adf/Macros/GANIL/OfflineWatchers.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"

// Gw and Watchers
#include "RootAFP.h"
#include "ReadMezzAFP.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 = "TRACKING";  // 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

//  Availables producer : RootAFP           ==> Used to read adf input files
//                        ReadMezzAFP       ==> Used to read cdat files produced by the mezzanines (only for ADF and CRYSTAL levels)
//                        ReadPSAHitsAFP    ==> Used to read Root files containing psa hits of a global event (only for Tracking watcher level)

    TString ProducerType = "RootAFP";
}

using namespace Gw;
using namespace ADF;

void OfflineWatchers(Int_t start = -1, TFile *file = 0x0 );
void OfflineWatchers(Int_t start, const Char_t *rootafp, TString EntryPoint,bool ReadCDAT);
void OfflineWatchers(Int_t which_run, const char *which_experiment, const char *which_adf_data,const char *run_patt, Option_t *opt_adf_pattern, Int_t start = -1);
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 OfflineWatchers(Int_t start, TFile *file)
{
    // 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 = DefineEmulatorType();
    FrameDispatcher *FDispatcher;

    if ( ! emulator->Init() ) {
        std::cout << "Cannot Init emulator" << std::endl; return;
    }
    else {
        FDispatcher = (FrameDispatcher*) emulator->GetBaseConsumer();
        if ( file )
            MainDir = file;
        if ( MainDir != gROOT )
            FDispatcher->SetDirectory(MainDir,MainDir);
    } 

    // 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>0 ) {
        control->Save();
    }
}

void OfflineWatchers(Int_t start, const Char_t *rootafp, TString EntryPoint, bool ReadCDAT)
{
    // MainDir is the top dir to organise histograms in subdirectories
    // each one being attached to a given task.
    TDirectory *MainDir = gROOT;

    if(EntryPoint!="") EntryPointInSetupWatchers = EntryPoint;
    if(ReadCDAT) ProducerType = "ReadMezzAFP";
    
    // 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);
    }
    
    // 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();
    }
}

void OfflineWatchers(Int_t which_run, const char *which_experiment, const char *which_adf_data, const char *run_patt, Option_t *opt_adf_pattern, Int_t start)
{
    TDirectory *MainDir = gROOT;
    
    // chain a producer and a FrameDispacher to which Watchers are attached
    BaseEmulatorChain *emulator = DefineEmulatorType();
    FrameDispatcher *FDispatcher;

    if ( ! emulator->Init(which_run,which_experiment,which_adf_data,run_patt,opt_adf_pattern) ) {
        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);
    }
    
    // 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 == "RootAFP")
        emulator = new EmulatorPC<RootAFP,FrameDispatcher>("./");
    else if(ProducerType == "ReadMezzAFP")
        emulator = new EmulatorPC<ReadMezzAFP,FrameDispatcher>("./");

    return emulator;
}