GSIOnlySetup.C

Go to the documentation of this file.

#if !defined(__CINT__) 

#include "FrameDispatcher.h"

// Watchers

#include "WatcherClient.h"
#include "ADFWatchers.h"
#include "CrystalWatchers.h"
#include "PSAWatchers.h"
#include "TrackedWatchers.h"
#include "EventPSAWatchers.h"
#include "EventWatchers.h"
#include "MetaWatchers.h"
#include "RancLegnaroWatchers.h"
#include "DanteWatchers.h"
//#include "MyTree.h"
//#include "PrismaWatchers.h"

#include "WatchersConfig.h"

#include "ADFWatchers.h"

#ifdef HAS_PRESPEC
#include "GSIWatchers.h"
#include "GSIPrespecWatchers.h"
#endif

#include "MyTree.h"


using namespace Gw;
using namespace ADF;

const char *GetWN(const char *name, const char *ext)
{
        return Form("%s%s",name,ext);
}

void DoTSRateCollector(TTask *top_task, TSRateCollector *collector)
{
        TTask *task; FrameDispatcher *fd; TSRate *ts_rate;
        
        // loop on task to get FrameDispatchers
        TIter next(top_task->GetListOfTasks());
        while ( (task = (TTask *)next()) ) {
                if (  task == collector )
                        continue;
                fd = dynamic_cast<FrameDispatcher *> (task);
                if ( fd ) {                     
                        TIter next_w(fd->GetListOfTasks());
                        while ( (task = (TTask *)next_w()) ) {
                                ts_rate = dynamic_cast<TSRate *> (task);
                                if ( ts_rate ) {
                                        collector->AddHook(ts_rate,fd->GetName());
                                }
                        }
                }
        }
}

/*
        i
*/
Bool_t SetupWatchers(const char *df_type, FrameDispatcher *fd, const char *ext = "")
{
        Bool_t ok = false; TString DFtype = df_type;

// ANY KIND OF DATA FLOW
        // ADF ----------------------------------------------------------------
        // General to any kind of data flow, based on the key part of the frame
        if ( DFtype.Contains("ADF") ) {
                // Watchers on any kind of Agata Frame ... the trigger should not be changed (lowest agatakey version) !         
                AgataFrameTrigger  *trig = 
                        new AgataFrameTrigger("ADF");
                trig->Add(FactoryItem("Agata","agata",Version(1,0)),
                                  FactoryItem("Agata","agata",Version(0,0))); 
                trig->Universal(true);
                fd->SetTrigger(trig);
                
                // Just dump the frames in a file for decoding
                Watcher *dumper = new Dumper(); 
                dumper->SetActive(false);
                fd->Add(dumper);
                
                // frame length, message type, event number of time stamp
                fd->Add<AgataKeyWatcher>(GetWN("AgataKey",ext),"To check the keys on the Data Flow");
                fd->Add<TSRate>(GetWN("TSRate",ext),"To get rate form consecutive TS value");
                
                ok = true;
        }
        // ADF -----------------------------------------------------------------
        

        // RANC0 -----------------------------------------------------------------
        // output of the ancillary producer or Filter
        if ( DFtype.Contains("RANC0") ) {
                
                // define WatcherClient for a specific trigger
                // it defines a trigger on an ancilary frame
                AgataFrameTrigger *trig = 
                        AgataFrameTrigger::Build("RANC0", "data:ranc0");        
                fd->SetTrigger(trig);
                
                // to get all the raw spectra for ancillaries
                fd->Add<TSRate>(GetWN("TSRate",ext),"To get rate form consecutive TS value");
                
#ifdef HAS_PRESPEC
                fd->Add<MBSWatcher>(GetWN("MBSWatcher",ext),"To get the content of MBS Frame ");
//              fd->Add<LightLYCCAVertexBuilder>(GetWN("LightLYCCAVertexBuilder",ext),"To get the vertex from LYCCA ");
//              fd->Add<GlobalDC>(GetWN("LyccaVertex",ext),"To get the vertex given LYCCA ");

//              TTreeMaster *rootmaster = fd->Add<TTreeMaster>(GetWN("TreeMaster",ext),"Own the tree");
//              rootmaster->Add<Unpack>("Unpack","Branch on Unpack Data");
#endif                  
                ok = true;
        }
        // RANC0 -----------------------------------------------------------------
        
        if ( DFtype.Contains("MERGER") ) {

                AgataFrameTrigger *trig = 
                        AgataFrameTrigger::Build("Event", "event:data event:data:psa data:ranc0");

                // set the main trigger to coincidences between ancillary et gammas
                fd->SetTrigger(trig);

                fd->Add<TSCoinc>(GetWN("TSCoinc",ext),"TS distribution in events");
                fd->Add<MBSWatcher>(GetWN("MBSWatcher",ext),"RawData as produced by the MBS2ADF");

// Any kind of Watcher on event:data:psa, data:ranc1 or 
//              fd->Add<DisplayRancLegnaro>(GetWN("DisplayRanc",ext),"RawData as produced by the Ancillary Filter");
//              fd->Add<DisplayDante>(GetWN("DisplayDante",ext),"Display Raw and Calibrated Data for Dante");
                // watcher to keep rates 
                fd->Add<TSRate>(GetWN("TSRate",ext),"To get rate form consecutive TS value");
                
// Build and Fill TTrees
                // create a TreeMaster which takes care of the TTree part 
                // It opens a root file (TreeMaster.root), build a tree and call Fill in the Exec method

                TTreeMaster *rootmaster = fd->Add<TTreeMaster>(GetWN("TreeMaster",ext),"Own the tree");
                // Using this option, if one watcher does not pass the condition, the spectra of the following are not filled 
                rootmaster->SetDoSpectra(1);
                // to this tree, add a watcher which adds branches and takes cares to fill them
                rootmaster->Add<Unpack>(GetWN("Unpack",ext),"To Produce Tree with Unpack Data");
                rootmaster->Add<Sort>(GetWN("Sort",ext),"To Produce Tree with Unpack Data");
                rootmaster->Add<Calibr>(GetWN("Calibr",ext),"To Produce Tree with Unpack Data");
                rootmaster->Add<Anl>(GetWN("Anl",ext),"To Produce Tree with Unpack Data");
                rootmaster->AddWatcher<LightLYCCAVertexBuilder_1>(GetWN("VertexBuilder",ext),"To Compute a vertex from Anl");
                rootmaster->Add<DoMyHitTree>("HitTree","Branch on hits");

                fd->Add<GlobalDC>(GetWN("CheckDoppler",ext),"Check Doppler as computed by Anl");
                fd->Add<HitsSpectra>(GetWN("HitsSpectra",ext),"Gamma-ray spectra from Hits");

//DoMyCoincTree
                ok = true;
        }
        // TRACKING Level //
        if ( DFtype.Contains("TRACKING") ) {
                
                // a trigger on event with hits, tracked gammas and ancillary
                AgataFrameTrigger *trig = 
                        AgataFrameTrigger::Build("TRACKING", "event:data event:data:psa data:tracked"); 
                
                // set the main trigger to coincidences between ancillary et gammas
                fd->SetTrigger(trig);

                // specific to tracked frame
                // gamma-gamma matrix
                fd->Add<Coinc2D>(GetWN("GxG",ext),"Gamma Gamma coincidence");
                
// Build and Fill TTrees : add branches related to the tracking
                // create a TreeMaster which takes care of the TTree part 
                // It opens a root file (TreeMaster.root), build a tree and call Fill in the Exec method
                // TTreeMaster *rootmaster = fd->Add<TTreeMaster>(GetWN("TreeMaster",ext),"Own the tree");
                // to this tree, add a watcher which adds branches and takes cares to fill them
                // rootmaster->Add<DoMyRawAncillaryTree>("RawAncTree","Branch on ancillary");
                // rootmaster->Add<DoMyHitTree>("HitTree","Branch on hits");
                // rootmaster->Add<DoMyTrackTree>("TrackTree","Branch on track");       

                
                ok = true;
        }


        return ok;
}

#endif