ADF_to_Tree.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.             *
 ***************************************************************************/


void ADF_to_Tree(const Char_t *rootafpconf = "");
void ADF_to_Tree(Int_t Run,
                 const char *which_experiment = "/agatadisks/eagata/238u_comm_1/",
                 const char *which_adf_data = "/Out/Global/",
                 const char *run_name_pattern = "run",
                 const char *opt_adf_pattern = "*.adf",
                 const char *which_output_dir="");

#if !defined(__CINT__)

// gammaware/watchers includes
#include "WatchersConfig.h"
#include "FrameDispatcher.h"
#include "Trigger.h"
#include "TTreeWatchers.h"
#include "GANILWatchers.h"
#include "TSystemDirectory.h"
#include "ADTree.h"
#include "EmulatorControl.h"
#include "Emulator.h"
#include "RootAFP.h"

#include "BashColor.h"

// root/system includes
#include "TRegexp.h"
#include "TSystem.h"

namespace {
    TString PathToOut = "./Out";                            // path where to store TTrees
    TString PatternOfROOTFiles = "AGATA_VAMOS_Tree_";       // basename for ROOT files
    TString TTreeName  = "TreeMaster" ;                     // name of the Tree
    TString TTeeTilte = "GANIL Tree" ;                      // Title
    
    TString Run = "" ; // used to add run number by hand or automatically
    Int_t RunNr = -1;
    Bool_t OverWriteFile = false; // used to avoid to increment the output file name if already existing
    BashColor *fBashColor = new BashColor();
}

void PrintStats(BaseEmulatorChain *emulator);

//
void ADF_to_Tree_UserSetup( Gw::FrameDispatcher *fd)
{
    // Trigger means event:data with inside a data:tracked AND an event:data:pas AND an ancillary
    AgataFrameTrigger *trig = AgataFrameTrigger::Build("Event", "event:data data:tracked event:data:psa data:ranc0");
    fd->SetTrigger(trig);
    
    // ROOT Tree with Raw Branch and VAMOS one
    TTreeMaster *rootmaster = fd->AddTreeMaster(Form("%s%s",PatternOfROOTFiles.Data(),Run.Data()) , TTeeTilte.Data(), OverWriteFile);
    // This adds a VAMOS Watcher. The data containt depemds on the MODE
    VAMOSWatcher *vamosw = rootmaster->Add<VAMOSWatcher>("GVWInterface","Branch managed by the VAMOS librarie");
    vamosw->InitVAMOS(2,Form("%s/VAMOS_Spectra_%s.root",PathToOut.Data(),Run.Data()),RunNr,PathToOut.Data());
    // this compute from VAMOS the Doppler correction used in the branches/watcher following this
    rootmaster->AddWatcher<VAMOSVertexBuilder>("VAMOSVertexBuilder","To Compute a vertex from VAMOS library");
    //    // Tracked Part
    ADTrackTree *trackw = rootmaster->Add<ADTrackTree>("TrackTree","Branch on track");
    trackw->SetAgataOffset(0.);
    // Hit part
    rootmaster->Add<ADHitTree>("HitTree","Branch on hits");
}

void ADF_to_Tree(const Char_t *rootafpconf)
{
    EmulatorPC<RootAFP,FrameDispatcher> *emulator = new EmulatorPC<RootAFP,FrameDispatcher>("./");
    if ( ! emulator->Init(rootafpconf) ) {
        return;
    }
    // Setup i.e. attached the Watchers
    TTreeMaster::SetDefaultPathAndName(PathToOut.Data(),TTreeName.Data());
    ADF_to_Tree_UserSetup(emulator->GetConsumer());
    
    // loop
    emulator->Run();
    
    PrintStats(emulator);
    
    emulator->GetBaseConsumer()->GetFrameIO().Print();
}

void ADF_to_Tree(Int_t which_run, const char *which_experiment, const char *which_adf_data, const char *run_name_pattern, const char *opt_adf_pattern, const char *which_output_dir)
{
    EmulatorPC<RootAFP,FrameDispatcher> *emulator = new EmulatorPC<RootAFP,FrameDispatcher>("./");
    if ( ! emulator->Init(which_run,which_experiment,which_adf_data,run_name_pattern,opt_adf_pattern) ) {
        return;
    }
    Run = emulator->GetRunDir();
    RunNr =  which_run;
    if(which_output_dir != "")
        PathToOut = which_output_dir ;
    
    if(!gSystem->OpenDirectory(PathToOut.Data()))
        if(gSystem->mkdir(PathToOut.Data()) == -1)
        {
            fBashColor->SetErrorOut();
            cout << "ERROR : Could not create Output directory : " << PathToOut << endl;
            fBashColor->ResetColor();
            return ;
        }
        else
        {
            fBashColor->SetInfoOut();
            cout << "INFO : Creating new output directory : " << PathToOut << endl;
            fBashColor->ResetColor();
        }
        else
        {
            fBashColor->SetInfoOut();
            cout << "INFO : Writing in output directory : " << PathToOut << endl;
            fBashColor->ResetColor();
        }
    
    TTreeMaster::SetDefaultPathAndName(PathToOut.Data(),TTreeName.Data());
    
    
    ADF_to_Tree_UserSetup(emulator->GetConsumer());
    
    // loop
    emulator->Run();
    
    PrintStats(emulator);
    
    emulator->GetBaseConsumer()->GetFrameIO().Print();
}

void PrintStats(BaseEmulatorChain *emulator)
{
    fBashColor->SetInfoOut();
    
    std::cout<<"Watchers properties:"<<std::endl;
    
    FrameDispatcher *fd = dynamic_cast<FrameDispatcher *> (emulator->GetBaseConsumer()) ;
    
    const TList *ListOfWatchers = fd->GetListOfWatchers();
    TIter iter(ListOfWatchers);
    TObject *o;
    
    while( (o = iter.Next()) )
    {
        o->Print();
    }
    
    fBashColor->ResetColor();
}

/*
 void ADF_to_Tree(const Char_t *rootafpconf)
 {
 TString RootAFPConf = rootafpconf; Bool_t is_default_rootafp = false;
 //
 if ( RootAFPConf == "" ) { // just use standart RootAFP.conf file
 is_default_rootafp = true;
 }
 else { // use the one given in argument ... test if it exists !
 if ( gSystem->AccessPathName(rootafpconf)  ) {
 std::cout << " File " << rootafpconf << " does not exist ! - Cannot proceed " << std::endl; return;
 }
 // then keep current RootAFP and copy this one into RootAFP.conf just the time to initiate the emulator
 gSystem->Rename("RootAFP.conf",".RootAFP.conf.keep"); gSystem->CopyFile(rootafpconf,"RootAFP.conf");
 }
 
 // chain a producer and a FrameDispacher to which Watchers are attached
 EmulatorPC<RootAFP,FrameDispatcher> *emulator = new EmulatorPC<RootAFP,FrameDispatcher>("./");
 if ( ! emulator->Init() ) {
 if ( !is_default_rootafp )
 gSystem->Rename(".RootAFP.conf.keep","RootAFP.conf"); std::cout << "Cannot Init emulator" << std::endl;
 return;
 }
 else {
 if ( !is_default_rootafp )
 gSystem->Rename(".RootAFP.conf.keep","RootAFP.conf");
 // emulator->GetBaseConsumer()->SetName();
 }
 
 // Setup i.e. attached the Watchers
 TTreeMaster::SetDefaultPathAndName(PathToOut.Data(),TTreeName.Data());
 ADF_to_Tree_UserSetup(emulator->GetConsumer());
 
 // loop
 emulator->Run();
 emulator->GetBaseConsumer()->GetFrameIO().Print();
 }
 
 TString DoROOTAFPConf(Int_t which_run, const char *path, const char *which_adf_data,, const char *run_pat, Option_t *opt_adf_pattern, const char *tmp_rootafp_filename)
 {
 TString result = "", t_path = path, path_in_exp = which_adf_data, opt = opt_adf_pattern, run_pattern=run_pat; ; Bool_t ok_dir = false;
 if ( !t_path.EndsWith("/") )
 t_path += "/";
 
 // First it looks at the list of sub-directory in path to search from one containing the run number
 TString dir_name = ""; TSystemDirectory dir; dir.SetDirectory(t_path.Data());
 //
 TList *list = dir.GetListOfFiles();
 TIter iter(list);
 TObject *entry;
 //
 while ( (entry = iter()) )
 {
 if ( entry->InheritsFrom("TSystemDirectory") )
 {
 TString fname = entry->GetName();
 if ( fname.Contains(  Form("%s%4.4d",run_pattern,which_run) ) ) {
 dir_name = t_path.Data();
 dir_name += entry->GetName();
 if ( path_in_exp.Sizeof() ) {
 if ( !path_in_exp.BeginsWith("/") )
 dir_name += "/";
 dir_name += which_adf_data;
 if ( !path_in_exp.EndsWith("/") )
 dir_name += "/";
 }
 result = entry->GetName();
 ok_dir = true;
 
 break;
 }
 }
 }
 if ( !ok_dir ) {
 std::cout << " **** !! **** Run # " << which_run << " has not been found in path " << path << std::endl;
 return result;
 }
 else {
 if ( !dir_name.EndsWith("/") )
 dir_name += "/";
 std::cout << " Run # " << which_run << " has been found in path " << path << " - full directory is " << dir_name <<  std::endl;
 }
 
 TSystemDirectory dir_run; dir_run.SetDirectory(dir_name); TList list_of_final_file;
 //
 list = dir_run.GetListOfFiles();
 if ( list == 0x0 ) {
 result = "";
 std::cout << dir_name <<  " Is Empty " << std::endl;
 return result; // no files with such a run number
 }
 
 TIter iter_file(list); // start collecting .adf file
 //
 while ( (entry = iter_file()) )
 {
 TString fname = entry->GetName();
 
 Bool_t wildcard = false;
 if ( opt.Contains("*") )
 wildcard = true;
 TRegexp all("*",kTRUE), pattern(opt.Data(),wildcard);
 
 if ( pattern.Status() != TRegexp::kOK )
 {
 if ( gDebug > 0 )
 std::cerr << "pattern [*] intead of " << opt.Data()<< std::endl;
 pattern = all;
 }
 else
 {
 if ( gDebug > 0 ) std::cerr << "pattern " << opt.Data() << std::endl ;
 }
 if ( entry->InheritsFrom("TSystemFile") )
 {
 if ( fname.Contains( pattern ) ) {
 list_of_final_file.Add( new TNamed(dir_name.Data(),fname.Data()) );
 std::cout << " + ADD ADF " << fname.Data() << " file to the list of files to be read " <<  std::endl;
 }
 }
 }
 if ( list_of_final_file.GetEntries() ) {
 std::ofstream outputfile(tmp_rootafp_filename);
 std::cout << " A new file, " << tmp_rootafp_filename << ", suitable to configure the RootAFP producer, has been created " << std::endl;
 for ( Int_t i = 0; i < list_of_final_file.GetSize(); i++ )
 {
 outputfile << "l "     << list_of_final_file.At(i)->GetName() << list_of_final_file.At(i)->GetTitle() << std::endl;
 }
 outputfile.close();
 }
 else result = "";
 
 return result;
 }
 
 void ADF_to_Tree(Int_t which_run, const char *which_experiment, const char *which_adf_data, Option_t *opt_adf_pattern)
 {
 TString result = DoROOTAFPConf(which_run,which_experiment,which_adf_data,opt_adf_pattern,".RootAFP.conf.tmp");
 if ( result == ""  ) {
 return;
 }
 Run = result;
 
 ADF_to_Tree(".RootAFP.conf.tmp");
 }
 */
#endif