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