StogsWatchers.C

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) IPNL, IN2P3, CNRS                                       *
 *   Contibutor(s) :                                                       *
 *      Olivier Stezowski stezow(AT)ipnl.in2p3.fr [2014]                   *
 *      Jeremie Dudouet   j.dudouet(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.             *
 ***************************************************************************/

// ROOT includes
#include "TROOT.h"
#include "TBrowser.h"
#include "TSystem.h"

#include "StogsAFP.h"

#include "FrameDispatcher.h"
#include "EmulatorControl.h"
#include "Emulator.h"

// same include that for Online
#include "SetupWatchers.C"

namespace {
    // ADF CRYSTAL CCRYSTAL PSA RANC0 EB MERGER TRACKING
    TString EntryPointInSetupWatchers = "EB";  // selection in the SetupWatcher.C file
    TString PathToOut = "./Out";                // path where to store root files. It should exist !
    TString PatternOfROOTFiles = "";            // basename for ROOT files. If empty, files are not saved
    TString TTreeName  = "TreeMaster";          // name of the Tree
    TString TTeeTilte = "GANIL Tree" ;          // Title
    
    TString Run = "" ; // used to add run number by hand or automatically in case OfflineWatcher(run_number, ...) is called

    TString ProducerType = "StogsAFP";
    bool ADHitTreeMode = false;
}

using namespace Gw;
using namespace ADF;

void StogsWatchers(Int_t start = -1, const Char_t *rootafp = "");
BaseEmulatorChain *DefineEmulatorType();

/*
    An emulator is composed of producer that reads data from .adf files
    and send the buffer to an FrameDispatcher.

    Watchers, in which the analysis is done are attached to the FrameDispatcher.

    Watchers are added to the FrameDispacher using the SetupWatcher function
    that is in the SetupWtachers.C (in order to be shared with other macros see OnlineWatchers examples)

 @author O.Stezowski
 
*/

void StogsWatchers(Int_t start,const Char_t *rootafp)
{
    // MainDir is the top dir to organise histograms in subdirectories
    // each one being attached to a given task.
    TDirectory *MainDir = gROOT;
    
    // chain a producer and a FrameDispacher to which Watchers are attached
    BaseEmulatorChain *emulator;
    FrameDispatcher *FDispatcher;

    emulator = DefineEmulatorType();

    if ( ! emulator->Init(rootafp) ) {
        std::cout << "Cannot Init emulator" << std::endl; return;
    }
    else {
        FDispatcher = (FrameDispatcher*) emulator->GetBaseConsumer();
        TFile *tmp_rfile = 0x0;
        if ( PatternOfROOTFiles != "" ) {
            tmp_rfile = TFile::Open( Form("%s/%s.root",PathToOut.Data(),PatternOfROOTFiles.Data()) , "UPDATE" );
        }
        if ( tmp_rfile ) {
            MainDir = tmp_rfile;
        }
        if ( MainDir != gROOT )
            FDispatcher->SetDirectory(MainDir,MainDir);
    }

    if(ProducerType == "StogsAFP")
    {
        StogsAFP *prod = (StogsAFP*)emulator->GetBaseProducer();
        prod->SetADHitTreeMode(ADHitTreeMode);
    }

    // to have all watcher in the task folder
    EmulatorControl *control = new EmulatorControl(emulator);
    gROOT->GetListOfTasks()->Add( control );
    gROOT->GetListOfTasks()->Add( FDispatcher );
    
    TTreeMaster::SetDefaultPathAndName(PathToOut.Data(),TTreeName.Data());
    SetupWatchers(EntryPointInSetupWatchers.Data(),FDispatcher);
    
    if ( !gROOT->IsBatch() ) {
        TBrowser *b = (TBrowser*)gROOT->GetListOfBrowsers()->Last();
        
        TFolder *GwWatchersFolder = (TFolder*)gROOT->GetRootFolder()->FindObject("GwWatchers");
        if(GwWatchersFolder) b->Add(GwWatchersFolder);
        
        TFolder *RootFilesFolder = (TFolder*)gROOT->GetRootFolder()->FindObject("ROOT Files");
        if(RootFilesFolder) b->Add(RootFilesFolder);
    }
       
    // run
    if(start==-1)emulator->Run();
    else if(start>0)emulator->Run(start);
    
    // displays statistics and keeps all histograms
    // write all the spectra produced by the different watchers in a root file
    if ( MainDir != gROOT && start ) {
        control->Save();
    }
}

BaseEmulatorChain *DefineEmulatorType()
{
    BaseEmulatorChain *emulator = 0x0;

    if(ProducerType == "StogsAFP")
    {
        emulator = new EmulatorPC<StogsAFP,FrameDispatcher>("./");
    }

    return emulator;
}