DoExTracking.C

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2010 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   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 "WatchersConfig.h"

#include "AGAPROConfig.h" // defines for your system is set there by cmake

// Gw and Watchers
#include "RootAFP.h"
#include "FrameDispatcher.h"

#include "EmulatorControl.h"
#include "Emulator.h"
#include "GSIOnlySetup.C"

 #include "DEmulator.h"


#include "TrackingFilterOFT.h"

#include "ExTracking.h"
#include "ExTracking.C"

using namespace Gw;
using namespace ADF;

/*
        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)
 
        Of course one can define everything in a single macro like it is done in DoMyTree.
 
 @author O.Stezowski 
 
*/
void DoExTracking(TFile *file = 0x0)
{
        // MainDir is the top dir to organise histograms in subdirectories 
        // each one being attached to a given task.
        // Warning, a Watcher creates a new root directory (in the constructor) in the current directory
        // if you want to keep the same tree structures as for directories,
        // before allocating a new Watcher, think to set correctly its parent directory
        // see for instance mainADF->GetDirectory()->cd();
        TDirectory *MainDir = gROOT;
        if ( file ) 
                MainDir = file;

        // Emulator is a chain of a NOMADFile, a NOMADFilter and a FrameDispacher to which Watchers are attached 
        DEmulator *emulator = new DEmulator();
        
        emulator->SetGlobal ( NamedItem<Short_t>("Generation",0) );     
        
        // customization of the emulator
        emulator->Add<RootAFP>("-","Producer");
        //
        emulator->SetGlobal ( NamedItem<UInt_t>("SizeDataBlockC",aMByte) );
        emulator->Add<ExTracking>("Producer","Calib");
        //
        emulator->SetGlobal ( NamedItem<UInt_t>("SizeDataBlockC",5*aMByte) );
        //   emulator.Add<BlackHole>("Calib","Watchers");  
        emulator->Add<FrameDispatcher>("Calib","Watchers");
        // Create all actors in the topology
        emulator->Init() ;

        FrameDispatcher *d = 
        emulator->GetActorByName<FrameDispatcher>("Watchers");
        d->SetDirectory(MainDir, MainDir);

        // chain a producer a filter and a consume which is a FrameDispacher to which Watchers are attached 
        /*
//      EmulatorPFC<RootAFP,TrackingFilterOFT,FrameDispatcher> emulator("./");
//      EmulatorPFC<RootAFP,ExTracking,FrameDispatcher> emulator("./");
        EmulatorPFC<RootAFP,ExTracking,FrameDispatcher> emulator("./");
        
        if ( ! emulator.Init() ) {
                std::cout << "Cannot Init emulator" << std::endl; 
                return;
        }
        else 
                emulator.GetConsumer()->SetDirectory(MainDir,MainDir); */
        
        // add watchers to the dispatcher
        // watchers on the key part
        SetupWatchers("ADF",d);
        // watcher on track
        // SetupWatchers("TRACKING",emulator.GetConsumer());
        
        // run 
        emulator->Run();                
        // displays statistics and keeps all histograms 
        d->GetFrameIO().Print();

        // write all the spectra produced by the different watchers in a root file
        MainDir->Write();
}

#if !defined(__CINT__) 
int main(int argc, char **argv)
{               
        // a new root file is created
        TFile f("Offline.root","RECREATE");
        // run your analysis on it
        DoExTracking(&f);
        
        return 1;
}
#endif