stogs/Watchers/SetupWatchers.C

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) IPNL, IN2P3, CNRS                                       *
 *   Contibutor(s) :                                                       *
 *      Olivier Stezowski stezow(AT)ipnl.in2p3.fr [2014]                   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/


#if !defined(__CINT__) 

#include "WatchersConfig.h"

// GW
#include "FrameDispatcher.h"

// Watchers
#include "WatcherClient.h"
#include "ADFWatchers.h"
#include "KeyWatchers.h"
#include "CrystalWatchers.h"
#include "PSAWatchers.h"
#include "TrackedWatchers.h"
#include "EventPSAWatchers.h"
#include "EventWatchers.h"
#include "MetaWatchers.h"
#include "ADTree.h"

#include "GANILWatchers.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());
                }
            }
        }
    }
}

AgataFrameTrigger *GetUniversalTrigger()
{
    AgataFrameTrigger  *trig = new AgataFrameTrigger("ADF");
    trig->Add(FactoryItem("Agata","agata",Version(4,0)), FactoryItem("Agata","agata",Version(0,0)));
    trig->Universal(true);

    return trig;
}

/*
    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") ) {

        AgataFrameTrigger  *trig = GetUniversalTrigger();
        fd->SetTrigger(trig);

        // Just dump the frames in a file for decoding ... not active by default !
        //fd->GetDirectory()->cd(); Watcher *dumper = new Dumper();
        //dumper->SetActive(false);
        //fd->Add(dumper);

        fd->Add<KeyWatcher>("AgataKey","AgataKeys Watcher using an universal trigger");

        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  *trig = AgataFrameTrigger::Build("Crystal", "data:crystal");
        // main trigger for the Dispatcher, delete by fd
        fd->SetTrigger(trig);

        // watcher to displays all signals
        fd->Add<CrystalSpectra>(GetWN("Crystal_Spectra_",ext),Form("Display the data for the %s crystal at the producer level",ext));

        fd->Add<KeyWatcher>(GetWN("Crystal_Keys_",ext),Form("AgataKeys Watcher for the %s crystal at the producer level",ext));


        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  *trig = AgataFrameTrigger::Build("CCrystal", "data:ccrystal");

        // main trigger for the Dispatcher, delete by fd
        fd->SetTrigger(trig);

        // watcher to displays all signals
        fd->Add<CCrystalSpectra>(GetWN("CCrystal_Spectra_",ext),Form("Display the calibrated data for the %s crystal at the preprocessing level",ext));

        fd->Add<KeyWatcher>(GetWN("CCrystal_Keys_",ext),Form("AgataKeys Watcher for the %s crystal at the preprocessing level",ext));

        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<PSACrystal>(GetWN("PsaHits_",ext),"Hits in a Crystal");

        fd->Add<KeyWatcher>(GetWN("Psa_Keys_",ext),Form("AgataKeys Watcher for the %s crystal at psa level",ext));

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

        // watcher to keep rates
        fd->Add<MFMWatcher>(GetWN("MFMWatcher",ext),"To check the MFM Content");
#ifdef HAS_VAMOS
        TTreeMaster *rootmaster = fd->Add<TTreeMaster>("TreeMaster","Own the tree");
        VAMOSWatcher *vw = rootmaster->Add<VAMOSWatcher>("GVWInterface","See Spectra in Out/VAMOS_Spectra.root");
        vw->InitVAMOS(0,"Out/VAMOS_Spectra.root");
#endif
        fd->Add<KeyWatcher>("Vamos_Keys","AgataKeys Watcher for the ancilary level");

        ok = true;
    }
    // RANC0 -----------------------------------------------------------------
    // 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);

        fd->Add<EBWatcher>(GetWN("EventBuilder",ext),"Display Agata spectra at the event builder level");

        //        fd->Add<HitsSpectra>(GetWN("HitsSpectra",ext),"Gamma-ray spectra from Hits");

        fd->Add<KeyWatcher>("EventBuilder_Keys","AgataKeys Watcher at the event builder level");

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

#ifdef HAS_GANIL
//        fd->Add<MFMWatcher>(GetWN("MFMWatcher",ext),"To check the MFM Content");

        TTreeMaster *rootmaster = fd->Add<TTreeMaster>("TreeMaster","Own the tree");
        rootmaster->Add<RawMFMTree>("RawMFMTree","Branch on Raw MFM");

        VAMOSWatcher *vw = rootmaster->Add<VAMOSWatcher>("GVWInterface","Branch managed by the VAMOS librarie");
         vw->InitVAMOS(0,Form("Out/VAMOS_Spectra.root"));

//        rootmaster->AddWatcher<VAMOSVertexBuilder>(GetWN("VAMOSVertexBuilder",ext),"To Compute a vertex from VAMOS library");

        fd->Add<VAMOSVertexBuilder>("VAMOSVertexBuilder","Check Doppler as computed by VAMOS");

        VertexBuilder *fVertexBuilder = VertexBuilder::theCurrentVertexBuilder();
        fVertexBuilder->SetVertex();
        fd->Add<GlobalDC>("CheckGlobalDoppler","Check Doppler as computed by VAMOS");

        fd->Add<AGATAVAMOSCoinc>("AGATAVAMOSCoinc","Check some coincidences spectra between VAMOS and AGATA");
#endif

        fd->Add<KeyWatcher>("Merger_Keys","AgataKeys Watcher at the merger level",trig);

        ok = true;
    }
    // TRACKING Level //
    if ( DFtype.Contains("TRACKING") ) {

        bool EventDataConfiguration = true;

        AgataFrameTrigger *TriggerEventBuilder = 0x0;
        AgataFrameTrigger *TriggerAncilary = 0x0;
        AgataFrameTrigger *TriggerTracking = 0x0;
        AgataFrameTrigger *UnivTrig = GetUniversalTrigger();


        if(EventDataConfiguration)
        {
            TriggerTracking =   AgataFrameTrigger::Build("TRACKING", "event:data data:ranc0 event:data:psa data:tracked");
            TriggerEventBuilder = TriggerTracking;
            TriggerAncilary = TriggerTracking;

        }
        else
        {
            TriggerTracking= AgataFrameTrigger::Build("TRACKING", "data:tracked");
            TriggerEventBuilder = AgataFrameTrigger::Build("TRACKING", "event:data:psa");
            TriggerAncilary = AgataFrameTrigger::Build("TRACKING", "data:ranc0");
        }

        fd->SetTrigger(TriggerTracking);

        fd->Add<EBWatcher>("EventBuilder","Display Agata spectra at the event builder level",TriggerEventBuilder);

        TTreeMaster *rootmaster = fd->Add<TTreeMaster>("EvtPsaHits","EvtPsaHits");
        rootmaster->Add<ADHitTree>("ADHitTree","ADHitTree");


#ifdef HAS_VAMOS
        fd->Add<AGATAVAMOSCoinc>("AGATAVAMOSCoinc","Check some coincidences spectra between VAMOS and AGATA");
#endif

        fd->Add<TrackingWatcher>("Tracking","Display Agata spectra at the tracking level",TriggerTracking);

        fd->Add<KeyWatcher>("Tracking_Keys_Univ","AgataKeys Watcher at the tracking level",UnivTrig);
        AgataFrameTrigger *VamosOnly = AgataFrameTrigger::Build("TRACKING", "event:data data:ranc0 !event:data:psa !data:tracked");
        AgataFrameTrigger *AgataOnly = AgataFrameTrigger::Build("TRACKING", "event:data !data:ranc0 event:data:psa data:tracked");
        AgataFrameTrigger *Normal = AgataFrameTrigger::Build("TRACKING", "event:data data:ranc0 event:data:psa data:tracked");
        fd->Add<KeyWatcher>("Tracking_Keys_Normal","AgataKeys Watcher at the tracking level",Normal);
        fd->Add<KeyWatcher>("Tracking_Keys_Vamos","AgataKeys Watcher at the tracking level",VamosOnly);
        fd->Add<KeyWatcher>("Tracking_Keys_AGATA","AgataKeys Watcher at the tracking level",AgataOnly);


        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