adf/Macros/SetupWatchers.C

Go to the documentation of this file.

#if !defined(__CINT__) 

#include "WatchersConfig.h"

// GW
#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"

#ifdef HAS_PRISMA
#include "PrismaWatchers.h"
#endif

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 !   
                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
        //      fd->GetDirectory()->cd(); 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");
                
                ok = true;
        }
        // ADF -----------------------------------------------------------------
        
// LOCAL LEVEL PROCESSING
        // Crystal -------------------------------------------------------------
        // to analyse output data flow at the crystal level
        if ( DFtype.Contains("CRYSTAL") && ! DFtype.Contains("CCRYSTAL") ) {
                
                // It defines triggers on crystal frames
                AgataFrameTrigger  *trig1 = 
                        AgataFrameTrigger::Build("Crystal", "data:crystal");    
                
                // main trigger for the Dispatcher, delete by fd
                fd->SetTrigger(trig1);
                
                // watcher to displays all signals
                fd->Add<ShowSignals>(GetWN("RawSignals",ext),"Display the signals for one crystal",trig1);
                // watcher to keep rates 
                fd->Add<TSRate>(GetWN("TSRate",ext),"To get rate form consecutive TS value");

                ok = true;
        }
        // Crystal -------------------------------------------------------------
        // Calibrated Crystal --------------------------------------------------
        // to analyse output data flow at the pre-processing level
        if ( DFtype.Contains("CCRYSTAL") ) {
                
                // It defines triggers on crystal frames        
                AgataFrameTrigger  *trig2 =
                                AgataFrameTrigger::Build("CCrystal", "data:ccrystal");  
                
                // main trigger for the Dispatcher, delete by fd
                fd->SetTrigger(trig2);
                
                // watcher to displays all signals
                fd->Add<ShowSignals>(GetWN("CalibSignals",ext),"Display the calibrated signals for one crystal",trig2);
                // watcher to keep rates 
                fd->Add<TSRate>(GetWN("TSRate",ext),"To get rate form consecutive TS value");
                
                ok = true;
        }
        // Crystal -------------------------------------------------------------
        // PSA -----------------------------------------------------------------
        if ( DFtype.Contains("PSA") ) {
                
                // It defines a trigger on a psa frame
                AgataFrameTrigger  *trig = 
                        AgataFrameTrigger::Build("PSA", "data:psa");    
                // main trigger for the Dispatcher
                fd->SetTrigger(trig);
                
                // 3D view of Hits in a crystal
                fd->Add<PSACrystal3D>(GetWN("PSAHits",ext),"Hits in a Crystal");
                // watcher to keep rates 
                fd->Add<TSRate>(GetWN("TSRate",ext),"To get rate form consecutive TS value");
                
                ok = true;
        }
        // PSA -------------------------------------------------------------------
        // 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<DisplayRancLegnaro>(GetWN("DisplayRanc",ext),"RawData as produced by the Ancillary Filter");
                // watcher to keep rates 
                fd->Add<TSRate>(GetWN("TSRate",ext),"To get rate form consecutive TS value");
                
                ok = true;
        }
        // RANC0 -----------------------------------------------------------------
        // RANC1 -----------------------------------------------------------------
        // output of the ancillary producer or Filter
        if ( DFtype.Contains("RANC1") ) {
                
                // define WatcherClient for a specific trigger
                // it defines a trigger on an ancilary frame
                AgataFrameTrigger *trig = 
                        AgataFrameTrigger::Build("RANC1", "data:ranc1");        
                fd->SetTrigger(trig);
                
                // to get all the raw spectra for ancillaries
                fd->Add<DisplayRancLegnaro>(GetWN("DisplayRanc",ext),"RawData as produced by the Ancillary Filter");
                // watcher to keep rates 
                fd->Add<TSRate>(GetWN("TSRate",ext),"To get rate form consecutive TS value");
                
//Others        
                // to get Dante specific spectra (required Dante.conf)
                // fd->Add<DisplayDante>(GetWN("DisplayDante",ext),"Display Calibrated Data for Dante");
                
                ok = true;
        }
        // RANC1 -----------------------------------------------------------------
// END LOCAL LEVEL PROCESSING

// GLOBAL LEVEL PROCESSING
// EB Level //
        if ( DFtype.Contains("EB") ) {
                
                // It defines a trigger on an event:data:psa Frame
                AgataFrameTrigger *trig = 
                        AgataFrameTrigger::Build("EventPSA", "event:data:psa" );        
                fd->SetTrigger(trig);
                
                // Add a watcher that display the rate content
                fd->Add<RateDisplay>(GetWN("RateDisplay",ext),"To get the counting rates in each crystal");
                fd->Add<HitsSpectra>(GetWN("HitsSpectra",ext),"Gamma-ray spectra from Hits");
                // watcher to keep rates 
                fd->Add<TSRate>(GetWN("TSRate",ext),"To get rate form consecutive TS value");           
                ok = true;
        }
// MERGER Level //
        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<HitsSpectra>(GetWN("HitsSpectra",ext),"Gamma-ray spectra from Hits");

// 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");
                // 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");

                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 data:ranc1");      
                
                // set the main trigger to coincidences between ancillary et gammas
                fd->SetTrigger(trig);
                
#ifdef HAS_PRISMA
                // apply doppler correction from PRISMA if configuand check it
                DoPrismaDoppler *prisma_dop = fd->Add<DoPrismaDoppler>("DoDoppler","Set Doppler event by event"); 
                prisma_dop->Configure("Conf/PRISMA/manager.conf","Conf/PRISMA/lutPRISMA_WEEK49.txt");
                        
                fd->Add<GlobalDC>(GetWN("CheckDoppler",ext),"Doppler as delivered by Prisma"); 
                        
                // add a wacther on raw data
                DisplayPrisma *prisma_2 = fd->Add<DisplayPrisma>("DisplayPrima","Some usefull calibrated spectra for PRISMA "); 
                prisma_2->Configure("Conf/PRISMA/manager.conf","Conf/PRISMA/lutPRISMA_WEEK49.txt");
#endif
                
                // specific to tracked frame
                // gamma-gamma matrix
                fd->Add<Coinc2D>(GetWN("GxG",ext),"Gamma Gamma coincidence");
//              fd->Add<EveTrack>(GetWN("Eve",ext),"Gamma Gamma coincidence");
                
                // Any kind of Watcher on event:data:psa, data:ranc1 or 
                fd->Add<TSCoinc>(GetWN("TSCoinc",ext),"TS distribution in events");
                // watcher to keep rates 
                fd->Add<TSRate>(GetWN("TSRate",ext),"To get rate form consecutive TS value");
                
                // 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");
                
// 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");       
#ifdef HAS_PRISMA
                //      MyPrismaTree *prisma_tree = rootmaster->Add<MyPrismaTree>("Prisma","Branch on track");
                //      prisma_tree->Configure("Conf/PRISMA/manager.conf","Conf/PRISMA/lutPRISMA_WEEK49.txt"); 
#endif
                
                ok = true;
        }
        
        return ok;
}


// META -------------------------------------------------------------
// meta data frame 
/*
if ( DFtype.Contains("META") ) {
        
        // define WatcherClient for a specific trigger  
        AgataFrameTrigger *trig = AgataFrameTrigger::Build("Vertex", "meta:vertex" );   
        fd->SetTrigger(trig);
        
        // just to keep a global vertex frame.
        fd->Add<VertexWatcher>("GSource","To get a Global Vertex");
        // recoil velocity distribution
        fd->Add<GlobalDC>("GRecoil","Recoil velocity distribution");
        
        ok = true;
}
 */
// META ----------------------------------------------------------------

#endif