PWG4/PartCorrBase/AliCaloTrackReader.h

   1 #ifndef ALICALOTRACKREADER_H
   2 #define ALICALOTRACKREADER_H
   3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice     */
   5 /* $Id:  $ */
   6
   7 //_________________________________________________________________________
   8 // Base class for reading data: MonteCarlo, ESD or AOD, of PHOS EMCAL and
   9 // Central Barrel Tracking detectors.
  10 // Not all MC particles/tracks/clusters are kept, some kinematical restrictions are done.
  11 // Mother class of : AliCaloTrackESDReader: Fills ESD data in 3 TObjArrays (PHOS, EMCAL, CTS)
  12 //                 : AliCaloTrackMCReader: Fills Kinematics data in 3 TObjArrays (PHOS, EMCAL, CTS)
  13 //                 : AliCaloTrackAODReader: Fills AOD data in 3 TObjArrays (PHOS, EMCAL, CTS)
  14 //
  15 // This part is commented: Mixing analysis can be done, input AOD with events
  16 // is opened in the AliCaloTrackReader::Init()
  17
  18 // -- Author: Gustavo Conesa (INFN-LNF)
  19
  20 // --- ROOT system ---
  21 #include "TObject.h"
  22 #include "TString.h"
  23 #include "TRandom3.h"
  24 class TObjArray ;
  25 class TTree ;
  26
  27 //--- ANALYSIS system ---
  28 #include "AliVCaloCells.h"
  29 class AliStack ;
  30 class AliHeader ;
  31 class AliGenEventHeader ;
  32 class AliVEvent;
  33 class AliAODEvent;
  34 class AliMCEvent;
  35 class AliMixedEvent;
  36 class AliAODMCHeader;
  37 class AliESDtrackCuts;
  38 class AliCentrality;
  39 class AliTriggerAnalysis;
  40
  41 // --- PartCorr
  42 #include "AliCalorimeterUtils.h"
  43 #include "AliFiducialCut.h"
  44
  45 class AliCaloTrackReader : public TObject {
  46
  47 public:
  48   AliCaloTrackReader() ; // ctor
  49   virtual ~AliCaloTrackReader() ;//virtual dtor
  50 private:
  51   AliCaloTrackReader(const AliCaloTrackReader & g) ; // cpy ctor
  52   AliCaloTrackReader & operator = (const AliCaloTrackReader & g) ;//cpy assignment
  53
  54 public:
  55
  56   //--------------------------------
  57   // General methods
  58   //--------------------------------
  59
  60   virtual void    Init();
  61   virtual void    InitParameters();
  62   virtual void    Print(const Option_t * opt) const;
  63   virtual void    ResetLists();
  64
  65   virtual Int_t   GetDebug()           const { return fDebug          ; }
  66   virtual void    SetDebug(Int_t d)          { fDebug = d             ; }
  67
  68   enum inputDataType {kESD, kAOD, kMC};
  69   virtual Int_t   GetDataType()        const { return fDataType       ; }
  70   virtual void    SetDataType(Int_t data )   { fDataType = data       ; }
  71
  72   virtual Int_t   GetEventNumber()     const {return fEventNumber     ; }
  73   //virtual TString GetCurrentFileName() const {return fCurrentFileName ; }
  74
  75   TString         GetTaskName()        const {return fTaskName        ; }
  76   void            SetTaskName(TString name)  {fTaskName = name        ; }
  77
  78
  79   //---------------------------------------
  80   //Input/output event setters and getters
  81   //---------------------------------------
  82   virtual void    SetInputEvent(AliVEvent* const input) ;
  83   virtual void    SetOutputEvent(AliAODEvent* const aod) {fOutputEvent = aod;}
  84   virtual void    SetMC(AliMCEvent* const mc)            {fMC  = mc;}
  85   virtual void    SetInputOutputMCEvent(AliVEvent* /*esd*/, AliAODEvent* /*aod*/, AliMCEvent* /*mc*/) {;}
  86
  87   // Delta AODs
  88   virtual TList * GetAODBranchList()      const { return fAODBranchList        ; }
  89   void    SetDeltaAODFileName(TString name )    { fDeltaAODFileName = name     ; }
  90   TString GetDeltaAODFileName()           const { return fDeltaAODFileName     ; }
  91   void    SwitchOnWriteDeltaAOD()               { fWriteOutputDeltaAOD = kTRUE ; }
  92   void    SwitchOffWriteDeltaAOD()              { fWriteOutputDeltaAOD = kFALSE; }
  93   Bool_t  WriteDeltaAODToFile()           const { return fWriteOutputDeltaAOD  ; }
  94
  95   //------------------------------------------------------------
  96   //Clusters/Tracks arrays filtering/filling methods and switchs
  97   //------------------------------------------------------------
  98
  99   //Minimum pt setters and getters
 100   virtual Float_t  GetEMCALPtMin()      const { return fEMCALPtMin ; }
 101   virtual Float_t  GetPHOSPtMin()       const { return fPHOSPtMin  ; }
 102   virtual Float_t  GetCTSPtMin()        const { return fCTSPtMin   ; }
 103
 104   virtual void     SetEMCALPtMin(Float_t  pt) { fEMCALPtMin = pt   ; }
 105   virtual void     SetPHOSPtMin(Float_t  pt)  { fPHOSPtMin  = pt   ; }
 106   virtual void     SetCTSPtMin(Float_t  pt)   { fCTSPtMin   = pt   ; }
 107
 108   // Fidutial cuts
 109   virtual AliFiducialCut * GetFiducialCut()   {if(!fFiducialCut) fFiducialCut = new AliFiducialCut();
 110     return  fFiducialCut ;}
 111   virtual void SetFiducialCut(AliFiducialCut * const fc) { fFiducialCut = fc ;}
 112   virtual Bool_t IsFiducialCutOn()     const  { return fCheckFidCut ; }
 113   virtual void SwitchOnFiducialCut()          { fCheckFidCut = kTRUE;  fFiducialCut = new AliFiducialCut();}
 114   virtual void SwitchOffFiducialCut()         { fCheckFidCut = kFALSE;}
 115
 116   // Cluster origin
 117   Bool_t IsEMCALCluster(AliVCluster *clus) const;
 118   Bool_t IsPHOSCluster (AliVCluster *clus) const;
 119   //Patch for cluster origin for Old AODs implementation
 120   void   SwitchOnOldAODs()         { fOldAOD = kTRUE     ; }
 121   void   SwitchOffOldAODs()        { fOldAOD = kFALSE    ; }
 122
 123   // Cluster/track/cells switchs
 124   Bool_t IsCTSSwitchedOn()   const { return fFillCTS     ; }
 125   void   SwitchOnCTS()             { fFillCTS = kTRUE    ; }
 126   void   SwitchOffCTS()            { fFillCTS = kFALSE   ; }
 127
 128   Bool_t IsEMCALSwitchedOn() const { return fFillEMCAL   ; }
 129   void   SwitchOnEMCAL()           { fFillEMCAL = kTRUE  ; }
 130   void   SwitchOffEMCAL()          { fFillEMCAL = kFALSE ; }
 131
 132   Bool_t IsPHOSSwitchedOn()  const { return fFillPHOS    ; }
 133   void   SwitchOnPHOS()            { fFillPHOS = kTRUE   ; }
 134   void   SwitchOffPHOS()           { fFillPHOS = kFALSE  ; }
 135
 136   Bool_t IsEMCALCellsSwitchedOn() const { return fFillEMCALCells   ; }
 137   void   SwitchOnEMCALCells()           { fFillEMCALCells = kTRUE  ; }
 138   void   SwitchOffEMCALCells()          { fFillEMCALCells = kFALSE ; }
 139
 140   Bool_t IsPHOSCellsSwitchedOn()  const { return fFillPHOSCells   ; }
 141   void   SwitchOnPHOSCells()            { fFillPHOSCells = kTRUE  ; }
 142   void   SwitchOffPHOSCells()           { fFillPHOSCells = kFALSE ; }
 143
 144   // Filling/ filtering methods
 145   virtual Bool_t FillInputEvent(const Int_t iEntry, const char *currentFileName)  ;
 146   virtual void   FillInputCTS() ;
 147   virtual void   FillInputEMCAL() ;
 148   virtual void   FillInputEMCALAlgorithm(AliVCluster * clus, const Int_t iclus) ;
 149   virtual void   FillInputPHOS() ;
 150   virtual void   FillInputEMCALCells() ;
 151   virtual void   FillInputPHOSCells() ;
 152   void           SetEMCALClusterListName(TString &name) {fEMCALClustersListName = name ; }
 153
 154   // Arrayes with clusters/track/cells access methods
 155   //FIXME CHANGE NAMES, remove AOD, now they are VClusters, VTracks ...
 156   virtual TObjArray*     GetAODCTS()      const { return fAODCTS     ; }
 157   virtual TObjArray*     GetAODEMCAL()    const { return fAODEMCAL   ; }
 158   virtual TObjArray*     GetAODPHOS()     const { return fAODPHOS    ; }
 159   virtual AliVCaloCells* GetEMCALCells()  const { return fEMCALCells ; }
 160   virtual AliVCaloCells* GetPHOSCells()   const { return fPHOSCells  ; }
 161
 162   //Methods for mixing with external input file (AOD)
 163   //virtual TTree* GetSecondInputAODTree() const {return  fSecondInputAODTree ; }
 164   //virtual void SetSecondInputAODTree(TTree * tree) {fSecondInputAODTree = tree ;
 165   //                                                                                              fSecondInputAODEvent->ReadFromTree(tree);}//Connect tree and AOD event.
 166
 167   //virtual AliAODEvent* GetSecondInputAODEvent() const { return fSecondInputAODEvent ; }
 168
 169   //TString GetSecondInputFileName() const    {return fSecondInputFileName ; }
 170   //void SetSecondInputFileName(TString name) { fSecondInputFileName = name ; }
 171
 172   //Int_t GetSecondInputFirstEvent() const    {return fSecondInputFirstEvent ; }
 173   //void SetSecondInputFirstEvent(Int_t iEvent0) { fSecondInputFirstEvent = iEvent0 ; }
 174
 175 //  Int_t GetAODCTSNormalInputEntries()   {if(!fSecondInputAODTree) { fAODCTSNormalInputEntries   = fAODCTS->GetEntriesFast()  ;}
 176 //                                                                               return fAODCTSNormalInputEntries ; }
 177 //  Int_t GetAODEMCALNormalInputEntries() {if(!fSecondInputAODTree) { fAODEMCALNormalInputEntries = fAODEMCAL->GetEntriesFast();}
 178 //                                                                               return fAODEMCALNormalInputEntries ; }
 179 //  Int_t GetAODPHOSNormalInputEntries()  {if(!fSecondInputAODTree) { fAODPHOSNormalInputEntries  = fAODPHOS->GetEntriesFast() ;}
 180 //                                                                               return fAODPHOSNormalInputEntries ; }
 181
 182
 183   //-------------------------------------
 184   // Event/track selection methods
 185   //-------------------------------------
 186
 187   void    SetFiredTriggerClassName(TString name ) { fFiredTriggerClassName = name ; }
 188   TString GetFiredTriggerClassName()        const { return fFiredTriggerClassName ; }
 189   virtual TString GetFiredTriggerClasses()        { return ""                     ; } // look the ESD/AOD reader
 190
 191   void    SwitchOnEventSelection()                { fDoEventSelection = kTRUE  ; }
 192   void    SwitchOffEventSelection()               { fDoEventSelection = kFALSE ; }
 193   Bool_t  IsEventSelectionDone()            const { return fDoEventSelection   ; }
 194
 195   void    SwitchOnV0ANDSelection()                { fDoV0ANDEventSelection = kTRUE  ; }
 196   void    SwitchOffV0ANDSelection()               { fDoV0ANDEventSelection = kFALSE ; }
 197   Bool_t  IsV0ANDEventSelectionDone()       const { return fDoV0ANDEventSelection   ; }
 198
 199   // Track selection
 200   ULong_t GetTrackStatus()                  const {return fTrackStatus      ; }
 201   void    SetTrackStatus(ULong_t bit)             { fTrackStatus = bit      ; }
 202
 203   AliESDtrackCuts* GetTrackCuts()           const { return fESDtrackCuts    ; }
 204   void    SetTrackCuts(AliESDtrackCuts * cuts)    { fESDtrackCuts = cuts    ; }
 205   Int_t   GetTrackMultiplicity()            const { return fTrackMult       ; }
 206   Float_t GetTrackMultiplicityEtaCut()      const { return fTrackMultEtaCut ; }
 207   void    SetTrackMultiplicityEtaCut(Float_t eta) { fTrackMultEtaCut = eta  ; }
 208
 209   // Calorimeter specific and patches
 210   void    AnalyzeOnlyLED()                        {fAnaLED = kTRUE  ; }
 211   void    AnalyzeOnlyPhysics()                    {fAnaLED = kFALSE ; }
 212
 213   void    SwitchOnCaloFilterPatch()               {fCaloFilterPatch = kTRUE ; fFillCTS = kFALSE    ; }
 214   void    SwitchOffCaloFilterPatch()              {fCaloFilterPatch = kFALSE                       ; }
 215   Bool_t  IsCaloFilterPatchOn()             const {if(fDataType == kAOD) { return fCaloFilterPatch ; }
 216                                                    else                  { return kFALSE           ; } }
 217
 218   //-------------------------------
 219   //Vertex methods
 220   //-------------------------------
 221   virtual void      GetVertex(Double_t v[3])        const ;
 222   virtual Double_t* GetVertex(const Int_t evtIndex) const {return fVertex[evtIndex];}
 223   virtual void      GetVertex(Double_t vertex[3],   const Int_t evtIndex) const ;
 224   virtual void      FillVertexArray();
 225   virtual Bool_t    CheckForPrimaryVertex();
 226  // virtual void       GetSecondInputAODVertex(Double_t *) const {;}
 227   virtual Float_t   GetZvertexCut()                 const {return fZvtxCut ;} //cut on vertex position
 228   virtual void      SetZvertexCut(Float_t zcut=10.)       {fZvtxCut=zcut   ;} //cut on vertex position
 229
 230   //------------------------
 231   // Centrality
 232   //------------------------
 233   virtual AliCentrality* GetCentrality() const {return 0x0;} //Actual method to recover the pointer is in the ESD/AODReader
 234   void    SetCentralityClass(TString name)     { fCentralityClass   = name       ;}
 235   void    SetCentralityOpt(Int_t opt)          { fCentralityOpt     = opt        ;}
 236   TString GetCentralityClass()           const { return fCentralityClass         ;}
 237   Int_t   GetCentralityOpt()             const { return fCentralityOpt           ;}
 238   Int_t   GetEventCentrality()           const ;
 239   void    SetCentralityBin(Int_t min, Int_t max) //Set the centrality bin to select the event. If used, then need to get percentile
 240                                                {fCentralityBin[0]=min; fCentralityBin[1]=max;
 241                                                 if(min>=0 && max > 0) fCentralityOpt = 100 ; }
 242   Float_t GetCentralityBin(Int_t i)     const  { if(i < 0 || i > 1) return 0 ;
 243                                                 else return fCentralityBin[i]   ; }
 244
 245   //-------------------------------------
 246   // Other methods
 247   //-------------------------------------
 248   AliCalorimeterUtils * GetCaloUtils()            const { return fCaloUtils      ; }
 249   void   SetCaloUtils(AliCalorimeterUtils * caloutils)  { fCaloUtils = caloutils ; }
 250
 251   void   SwitchOnSuspiciousClustersRemoval()            { fRemoveSuspiciousClusters = kTRUE ;  }
 252   void   SwitchOffSuspiciousClustersRemoval()           { fRemoveSuspiciousClusters = kFALSE ; }
 253   Bool_t IsSuspiciousClustersRemovalOn()          const { return fRemoveSuspiciousClusters   ; }
 254
 255   //Use only for MC
 256   void    SwitchOnClusterEnergySmearing()               { fSmearClusterEnergy = kTRUE    ; }
 257   void    SwitchOffClusterEnergySmearing()              { fSmearClusterEnergy = kFALSE   ; }
 258   Bool_t  IsClusterEnergySmeared()                const { return fSmearClusterEnergy     ; }
 259   void    SetSmearingParameters(Int_t i, Float_t param) { if(i < 3)fSmearClusterParam[i] = param  ; }
 260
 261   virtual void FillInputVZERO()                         { ; } // done in the AOD/ESD reader
 262   Int_t   GetV0Signal(Int_t i)                    const { return fV0ADC[i] ; }
 263   Int_t   GetV0Multiplicity(Int_t i)              const { return fV0Mul[i] ; }
 264
 265   virtual Double_t GetBField()                    const { return 0.        ; } // get in the AOD/ESD reader
 266
 267   //------------------------------------------------
 268   // MC analysis specific methods
 269   //-------------------------------------------------
 270
 271   //Kinematics and galice.root available
 272   virtual AliStack*          GetStack()          const ;
 273   virtual AliHeader*         GetHeader()         const ;
 274   virtual AliGenEventHeader* GetGenEventHeader() const ;
 275
 276   //Filtered kinematics in AOD
 277   virtual TClonesArray*     GetAODMCParticles(Int_t input = 0) const ;
 278   virtual AliAODMCHeader*   GetAODMCHeader(Int_t input = 0)    const ;
 279
 280   virtual AliVEvent*        GetInputEvent()  const { return fInputEvent  ; }
 281   virtual AliAODEvent*      GetOutputEvent() const { return fOutputEvent ; }
 282   virtual AliMCEvent*       GetMC()          const { return fMC          ; }
 283   virtual AliMixedEvent*    GetMixedEvent()  const { return fMixedEvent  ; }
 284   virtual Int_t             GetNMixedEvent() const { return fNMixedEvent ; }
 285
 286   void   SwitchOnStack()                           { fReadStack          = kTRUE  ; }
 287   void   SwitchOffStack()                          { fReadStack          = kFALSE ; }
 288   void   SwitchOnAODMCParticles()                  { fReadAODMCParticles = kTRUE  ; }
 289   void   SwitchOffAODMCParticles()                 { fReadAODMCParticles = kFALSE ; }
 290   Bool_t ReadStack()                         const { return fReadStack            ; }
 291   Bool_t ReadAODMCParticles()                const { return fReadAODMCParticles   ; }
 292
 293   //Select generated events, depending on comparison of pT hard and jets.
 294   virtual Bool_t  ComparePtHardAndJetPt() ;
 295   virtual Bool_t  IsPtHardAndJetPtComparisonSet()       const { return  fComparePtHardAndJetPt   ; }
 296   virtual void    SetPtHardAndJetPtComparison(Bool_t compare) { fComparePtHardAndJetPt = compare ; }
 297   virtual Float_t GetPtHardAndJetFactor()               const { return  fPtHardAndJetPtFactor    ; }
 298   virtual void    SetPtHardAndJetPtFactor(Float_t factor)     { fPtHardAndJetPtFactor = factor   ; }
 299
 300   //MC reader methods, declared there to allow compilation, they are only used in the MC reader:
 301
 302   virtual void AddNeutralParticlesArray(TArrayI & /*array*/)  { ; }
 303   virtual void AddChargedParticlesArray(TArrayI & /*array*/)  { ; }
 304   virtual void AddStatusArray(TArrayI & /*array*/)            { ; }
 305
 306   virtual void SwitchOnPi0Decay()                             { ; }
 307   virtual void SwitchOffPi0Decay()                            { ; }
 308   virtual void SwitchOnStatusSelection()                      { ; }
 309   virtual void SwitchOffStatusSelection()                     { ; }
 310   virtual void SwitchOnOverlapCheck()                         { ; }
 311   virtual void SwitchOffOverlapCheck()                        { ; }
 312
 313   virtual void SetEMCALOverlapAngle(Float_t /*angle*/)        { ; }
 314   virtual void SetPHOSOverlapAngle(Float_t /*angle*/)         { ; }
 315
 316
 317  protected:
 318   Int_t            fEventNumber;    // Event number
 319   //TString          fCurrentFileName;// Current file name under analysis
 320   Int_t            fDataType ;      // Select MC:Kinematics, Data:ESD/AOD, MCData:Both
 321   Int_t            fDebug;          // Debugging level
 322   AliFiducialCut * fFiducialCut;    //! Acceptance cuts
 323   Bool_t           fCheckFidCut ;   // Do analysis for clusters in defined region
 324
 325   Bool_t           fComparePtHardAndJetPt;  // In MonteCarlo, jet events, reject fake events with wrong jet energy.
 326   Float_t          fPtHardAndJetPtFactor;   // Factor between ptHard and jet pT to reject/accept event.
 327
 328   Float_t          fCTSPtMin;       // pT Threshold on charged particles
 329   Float_t          fEMCALPtMin;     // pT Threshold on emcal clusters
 330   Float_t          fPHOSPtMin;      // pT Threshold on phos clusters
 331
 332   TList          * fAODBranchList ; //! List with AOD branches created and needed in analysis
 333   //FIXME CHANGE NAMES, remove AOD, now they are VClusters, VTracks ...
 334   TObjArray      * fAODCTS ;        //! temporal referenced array with tracks
 335   TObjArray      * fAODEMCAL ;      //! temporal referenced array with EMCAL CaloClusters
 336   TObjArray      * fAODPHOS ;       //! temporal referenced array with PHOS CaloClusters
 337   AliVCaloCells  * fEMCALCells ;    //! temporal array with EMCAL CaloCells, ESD or AOD
 338   AliVCaloCells  * fPHOSCells ;     //! temporal array with PHOS CaloCells, ESD or AOD
 339
 340   AliVEvent      * fInputEvent;     //! pointer to esd or aod input
 341   AliAODEvent    * fOutputEvent;    //! pointer to aod output
 342   AliMCEvent     * fMC;             //! Monte Carlo Event Handler
 343
 344   Bool_t           fFillCTS;        // use data from CTS
 345   Bool_t           fFillEMCAL;      // use data from EMCAL
 346   Bool_t           fFillPHOS;       // use data from PHOS
 347   Bool_t           fFillEMCALCells; // use data from EMCAL
 348   Bool_t           fFillPHOSCells;  // use data from PHOS
 349   Bool_t           fRemoveSuspiciousClusters; // Remove high energy clusters with low number of cells
 350   Bool_t           fSmearClusterEnergy;       // Smear cluster energy, to be done only for simulated data to match real data
 351   Float_t          fSmearClusterParam[3];     // Smearing parameters
 352   TRandom3         fRandom;                   // Random generator
 353
 354 //  TTree *        fSecondInputAODTree;    // Tree with second input AOD, for mixing analysis.
 355 //  AliAODEvent*   fSecondInputAODEvent;   //! pointer to second input AOD event.
 356 //  TString        fSecondInputFileName;   // File with AOD data to mix with normal stream of data.
 357 //  Int_t          fSecondInputFirstEvent; // First event to be considered in the mixing.
 358 //
 359 //  Int_t          fAODCTSNormalInputEntries;   // Number of entries in CTS   in case of standard input, larger with mixing.
 360 //  Int_t          fAODEMCALNormalInputEntries; // Number of entries in EMCAL in case of standard input, larger with mixing.
 361 //  Int_t          fAODPHOSNormalInputEntries;  // Number of entries in PHOS  in case of standard input, larger with mixing.
 362
 363   ULong_t          fTrackStatus        ; // Track selection bit, select tracks refitted in TPC, ITS ...
 364   AliESDtrackCuts *fESDtrackCuts       ; // Track cut
 365   Int_t            fTrackMult          ; // Track multiplicity
 366   Float_t          fTrackMultEtaCut    ; // Track multiplicity eta cut
 367   Bool_t           fReadStack          ; // Access kine information from stack
 368   Bool_t                 fReadAODMCParticles ; // Access kine information from filtered AOD MC particles
 369
 370   TString          fDeltaAODFileName   ; // Delta AOD file name
 371   TString          fFiredTriggerClassName; // Name of trigger event type used to do the analysis
 372
 373   Bool_t           fAnaLED;             // Analyze LED data only.
 374
 375   TString          fTaskName;           // Name of task that executes the analysis
 376
 377   AliCalorimeterUtils * fCaloUtils ;    //  Pointer to CalorimeterUtils
 378
 379   AliMixedEvent  * fMixedEvent  ;       //! mixed event object. This class is not the owner
 380   Int_t            fNMixedEvent ;       // number of events in mixed event buffer
 381   Double_t      ** fVertex      ;       //! vertex array 3 dim for each mixed event buffer
 382
 383   Bool_t           fWriteOutputDeltaAOD;// Write the created delta AOD objects into file
 384         Bool_t           fOldAOD;             // Old AODs, before revision 4.20
 385
 386   Int_t            fV0ADC[2]    ;       // Integrated V0 signal
 387   Int_t            fV0Mul[2]    ;       // Integrated V0 Multiplicity
 388
 389   Bool_t           fCaloFilterPatch;    // CaloFilter patch
 390   TString          fEMCALClustersListName; //Alternative list of clusters produced elsewhere and not from InputEvent
 391   Float_t          fZvtxCut ;              // Cut on vertex position
 392   Bool_t           fDoEventSelection;    // Select events depending on V0, pileup, vertex well reconstructed, at least 1 track ...
 393   Bool_t           fDoV0ANDEventSelection; // Select events depending on V0, fDoEventSelection should be on
 394   AliTriggerAnalysis* fTriggerAnalysis;  // Access to trigger selection algorithm for V0AND calculation
 395
 396   //Centrality
 397   TString          fCentralityClass;    // Name of selected centrality class
 398   Int_t            fCentralityOpt;      // Option for the returned value of the centrality, possible options 5, 10, 100
 399   Int_t            fCentralityBin[2];   // Minimum and maximum value of the centrality for the analysis
 400
 401   ClassDef(AliCaloTrackReader,26)
 402 } ;
 403
 404
 405 #endif //ALICALOTRACKREADER_H
 406
 407
 408