da2991a5794d6a3859e6f3e31aaa3dcaa115c7a8
[u/mrichter/AliRoot.git] / PWG / CaloTrackCorrBase / 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 // -- Author: Gustavo Conesa (INFN-LNF)
15 //////////////////////////////////////////////////////////////////////////////
16
17 // --- ROOT system ---
18 #include <TObject.h> 
19 #include <TString.h>
20 class TObjArray ; 
21 class TTree ;
22 class TArrayI ;
23
24 //--- ANALYSIS system ---
25 class AliVCaloCells;
26 class AliStack; 
27 class AliHeader; 
28 class AliGenEventHeader; 
29 #include "AliVEvent.h"
30 class AliAODEvent;
31 class AliMCEvent;
32 class AliMixedEvent;
33 class AliAODMCHeader;
34 class AliESDtrackCuts;
35 class AliCentrality;
36 class AliTriggerAnalysis;
37 class AliEventplane;
38 class AliVCluster;
39
40 // --- PartCorr / EMCAL ---
41 class AliEMCALRecoUtils;
42 #include "AliFiducialCut.h"
43 class AliCalorimeterUtils;
44
45 class AliCaloTrackReader : public TObject {
46
47 public: 
48   
49   AliCaloTrackReader() ;          // ctor
50   virtual ~AliCaloTrackReader() ; // virtual dtor
51   
52   //--------------------------------
53   // General methods
54   //--------------------------------
55
56   virtual void    Init();
57     
58   virtual void    InitParameters();
59   
60   virtual void    Print(const Option_t * opt) const;
61   
62   virtual void    ResetLists();
63
64   virtual Int_t   GetDebug()                         const { return fDebug                 ; }
65   virtual void    SetDebug(Int_t d)                        { fDebug = d                    ; }
66   
67   enum inputDataType {kESD, kAOD, kMC};
68   virtual Int_t   GetDataType()                      const { return fDataType              ; }
69   virtual void    SetDataType(Int_t data )                 { fDataType = data              ; }
70
71   virtual Int_t   GetEventNumber()                   const { return fEventNumber           ; }
72         
73   TString         GetTaskName()                      const { return fTaskName              ; }
74   void            SetTaskName(TString name)                { fTaskName = name              ; }
75     
76   //---------------------------------------
77   //Input/output event setters and getters
78   //---------------------------------------
79   virtual void    SetInputEvent(AliVEvent* const input) ;
80   virtual void    SetOutputEvent(AliAODEvent* const aod)   { fOutputEvent = aod            ; }
81   virtual void    SetMC(AliMCEvent* const mc)              { fMC          = mc             ; }
82   virtual void    SetInputOutputMCEvent(AliVEvent* /*esd*/, AliAODEvent* /*aod*/, AliMCEvent* /*mc*/) { ; }
83   
84   // Delta AODs
85   virtual TList * GetAODBranchList()                 const { return fAODBranchList         ; }
86   void            SetDeltaAODFileName(TString name )       { fDeltaAODFileName = name      ; }
87   TString         GetDeltaAODFileName()              const { return fDeltaAODFileName      ; }
88   void            SwitchOnWriteDeltaAOD()                  { fWriteOutputDeltaAOD = kTRUE  ; }
89   void            SwitchOffWriteDeltaAOD()                 { fWriteOutputDeltaAOD = kFALSE ; }
90   Bool_t          WriteDeltaAODToFile()              const { return fWriteOutputDeltaAOD   ; } 
91   
92   //------------------------------------------------------------
93   //Clusters/Tracks arrays filtering/filling methods and switchs 
94   //------------------------------------------------------------
95   
96   //Minimum pt setters and getters 
97   Float_t          GetEMCALPtMin()                   const { return fEMCALPtMin            ; }
98   Float_t          GetPHOSPtMin()                    const { return fPHOSPtMin             ; }
99   Float_t          GetCTSPtMin()                     const { return fCTSPtMin              ; }
100   Float_t          GetEMCALPtMax()                   const { return fEMCALPtMax            ; }
101   Float_t          GetPHOSPtMax()                    const { return fPHOSPtMax             ; }
102   Float_t          GetCTSPtMax()                     const { return fCTSPtMax              ; }
103   
104   void             SetEMCALPtMin(Float_t  pt)              { fEMCALPtMin = pt              ; }
105   void             SetPHOSPtMin (Float_t  pt)              { fPHOSPtMin  = pt              ; }
106   void             SetCTSPtMin  (Float_t  pt)              { fCTSPtMin   = pt              ; }  
107   
108   void             SetEMCALPtMax(Float_t  pt)              { fEMCALPtMax = pt              ; }
109   void             SetPHOSPtMax (Float_t  pt)              { fPHOSPtMax  = pt              ; }
110   void             SetCTSPtMax  (Float_t  pt)              { fCTSPtMax   = pt              ; }  
111    
112   Float_t          GetEMCALEMin()                    const { return GetEMCALPtMin()        ; }
113   Float_t          GetPHOSEMin()                     const { return GetPHOSPtMin()         ; }
114   Float_t          GetEMCALEMax()                    const { return GetEMCALPtMax()        ; }
115   Float_t          GetPHOSEMax()                     const { return GetPHOSPtMax()         ; }
116   
117   void             SetEMCALEMin (Float_t  e)               { SetEMCALPtMin(e)              ; }
118   void             SetPHOSEMin  (Float_t  e)               { SetPHOSPtMin (e)              ; }
119   void             SetEMCALEMax (Float_t  e)               { SetEMCALPtMax(e)              ; }
120   void             SetPHOSEMax  (Float_t  e)               { SetPHOSPtMax (e)              ; }
121   
122   
123   // Fidutial cuts  
124   virtual AliFiducialCut * GetFiducialCut()                { 
125                     if(!fFiducialCut) fFiducialCut = new AliFiducialCut(); 
126                     return  fFiducialCut                                                   ; }
127   virtual void     SetFiducialCut(AliFiducialCut * const fc) { fFiducialCut = fc           ; }
128   virtual Bool_t   IsFiducialCutOn()                 const { return fCheckFidCut           ; }
129   virtual void     SwitchOnFiducialCut()                   { fCheckFidCut = kTRUE          ; 
130                                                              fFiducialCut = new AliFiducialCut() ; }
131   virtual void     SwitchOffFiducialCut()                  { fCheckFidCut = kFALSE         ; }
132   
133   // Cluster origin
134   Bool_t           IsEMCALCluster(AliVCluster *clus) const;
135   Bool_t           IsPHOSCluster (AliVCluster *clus) const;
136   //Patch for cluster origin for Old AODs implementation
137   void             SwitchOnOldAODs()                       { fOldAOD = kTRUE               ; }
138   void             SwitchOffOldAODs()                      { fOldAOD = kFALSE              ; }
139   
140   // Cluster/track/cells switchs
141   Bool_t           IsCTSSwitchedOn()                 const { return fFillCTS               ; }
142   void             SwitchOnCTS()                           { fFillCTS = kTRUE              ; }
143   void             SwitchOffCTS()                          { fFillCTS = kFALSE             ; }
144
145   Bool_t           IsEMCALSwitchedOn()               const { return fFillEMCAL             ; }
146   void             SwitchOnEMCAL()                         { fFillEMCAL = kTRUE            ; }
147   void             SwitchOffEMCAL()                        { fFillEMCAL = kFALSE           ; }
148
149   Bool_t           IsPHOSSwitchedOn()                const { return fFillPHOS              ; }
150   void             SwitchOnPHOS()                          { fFillPHOS = kTRUE             ; }
151   void             SwitchOffPHOS()                         { fFillPHOS = kFALSE            ; }
152
153   Bool_t           IsEMCALCellsSwitchedOn()          const { return fFillEMCALCells        ; }
154   void             SwitchOnEMCALCells()                    { fFillEMCALCells = kTRUE       ; }
155   void             SwitchOffEMCALCells()                   { fFillEMCALCells = kFALSE      ; }
156
157   Bool_t           IsPHOSCellsSwitchedOn()           const { return fFillPHOSCells         ; }
158   void             SwitchOnPHOSCells()                     { fFillPHOSCells = kTRUE        ; }
159   void             SwitchOffPHOSCells()                    { fFillPHOSCells = kFALSE       ; }
160
161   Bool_t           AreClustersRecalculated()         const { return fRecalculateClusters   ; }
162   void             SwitchOnClusterRecalculation()          { fRecalculateClusters = kTRUE  ; }
163   void             SwitchOffClusterRecalculation()         { fRecalculateClusters = kFALSE ; }  
164   
165   Bool_t           IsEmbeddedClusterSelectionOn()    const { return fSelectEmbeddedClusters   ; }
166   void             SwitchOnEmbeddedClustersSelection()     { fSelectEmbeddedClusters = kTRUE  ; }
167   void             SwitchOffEmbeddedClustersSelection()    { fSelectEmbeddedClusters = kFALSE ; }
168   
169   // Filling/ filtering / detector information access methods
170   virtual Bool_t   FillInputEvent(const Int_t iEntry, const char *currentFileName)  ;
171   virtual void     FillInputCTS() ;
172   virtual void     FillInputEMCAL() ;
173   virtual void     FillInputEMCALAlgorithm(AliVCluster * clus, const Int_t iclus) ;
174   virtual void     FillInputPHOS() ;
175   virtual void     FillInputEMCALCells() ;
176   virtual void     FillInputPHOSCells() ;
177   virtual void     FillInputVZERO() ;  
178   
179   Int_t            GetV0Signal(Int_t i)              const { return fV0ADC[i]              ; }
180   Int_t            GetV0Multiplicity(Int_t i)        const { return fV0Mul[i]              ; }
181   
182   void             SetEMCALClusterListName(TString &name)  { fEMCALClustersListName = name ; }
183   TString          GetEMCALClusterListName()         const { return fEMCALClustersListName ; }
184
185   // Arrayes with clusters/track/cells access method
186   virtual TObjArray*     GetCTSTracks()              const { return fCTSTracks             ; }
187   virtual TObjArray*     GetEMCALClusters()          const { return fEMCALClusters         ; }
188   virtual TObjArray*     GetPHOSClusters()           const { return fPHOSClusters          ; }
189   virtual AliVCaloCells* GetEMCALCells()             const { return fEMCALCells            ; }
190   virtual AliVCaloCells* GetPHOSCells()              const { return fPHOSCells             ; }
191    
192   //-------------------------------------
193   // Event/track selection methods
194   //-------------------------------------
195   
196   void             AcceptFastClusterEvents()               { fAcceptFastCluster     = kTRUE  ; } 
197   void             RejectFastClusterEvents()               { fAcceptFastCluster     = kFALSE ; }  
198   Bool_t           IsFastClusterAccepted()           const { return fAcceptFastCluster       ; }   
199   
200   void             SwitchOnLEDEventsRemoval()              { fRemoveLEDEvents       = kTRUE  ; }
201   void             SwitchOffLEDEventsRemoval()             { fRemoveLEDEvents       = kFALSE ; } 
202   Bool_t           IsLEDEventRemoved()               const { return fRemoveLEDEvents         ; }   
203
204   void             SetFiredTriggerClassName(TString name ) { fFiredTriggerClassName = name   ; }
205   TString          GetFiredTriggerClassName()        const { return fFiredTriggerClassName   ; }
206   TString          GetFiredTriggerClasses() ;               
207   
208   void             SwitchOnEventSelection()                { fDoEventSelection      = kTRUE  ; }
209   void             SwitchOffEventSelection()               { fDoEventSelection      = kFALSE ; }
210   Bool_t           IsEventSelectionDone()            const { return fDoEventSelection        ; } 
211   
212   void             SwitchOnV0ANDSelection()                { fDoV0ANDEventSelection = kTRUE  ; }
213   void             SwitchOffV0ANDSelection()               { fDoV0ANDEventSelection = kFALSE ; }
214   Bool_t           IsV0ANDEventSelectionDone()       const { return fDoV0ANDEventSelection   ; } 
215
216   void             SwitchOnPrimaryVertexSelection()        { fUseEventsWithPrimaryVertex = kTRUE  ; }
217   void             SwitchOffPrimaryVertexSelection()       { fUseEventsWithPrimaryVertex = kFALSE ; }
218   Bool_t           IsPrimaryVertexSelectionDone()    const { return fUseEventsWithPrimaryVertex   ; } 
219   
220   // Track selection
221   ULong_t          GetTrackStatus()                  const { return fTrackStatus       ; }
222   void             SetTrackStatus(ULong_t bit)             { fTrackStatus = bit        ; }              
223
224   ULong_t          GetTrackFilterMask()              const {return fTrackFilterMask    ; }
225   void             SetTrackFilterMask(ULong_t bit)         { fTrackFilterMask = bit    ; }              
226   
227   AliESDtrackCuts* GetTrackCuts()                    const { return fESDtrackCuts      ; }
228   void             SetTrackCuts(AliESDtrackCuts * cuts)    ;
229   
230   Int_t            GetTrackMultiplicity()            const { return fTrackMult         ; }
231   Float_t          GetTrackMultiplicityEtaCut()      const { return fTrackMultEtaCut   ; }
232   void             SetTrackMultiplicityEtaCut(Float_t eta) { fTrackMultEtaCut = eta    ; }              
233   
234   // Calorimeter specific and patches
235   void             AnalyzeOnlyLED()                        { fAnaLED = kTRUE           ; }
236   void             AnalyzeOnlyPhysics()                    { fAnaLED = kFALSE          ; }
237   
238   void             SwitchOnCaloFilterPatch()               { fCaloFilterPatch = kTRUE  ; 
239                                                              fFillCTS = kFALSE         ; }
240   void             SwitchOffCaloFilterPatch()              { fCaloFilterPatch = kFALSE ; }
241   Bool_t           IsCaloFilterPatchOn()             const { 
242                     if(fDataType == kAOD) { return fCaloFilterPatch ; } 
243                     else                  { return kFALSE           ; }                  }
244         
245   //-------------------------------
246   //Vertex methods
247   //-------------------------------
248   virtual void      GetVertex(Double_t v[3])         const ;
249   virtual Double_t* GetVertex(const Int_t evtIndex)  const { return fVertex[evtIndex]            ; }
250   virtual void      GetVertex(Double_t vertex[3],    const Int_t evtIndex) const ;
251   virtual void      FillVertexArray();
252   virtual Bool_t    CheckForPrimaryVertex();
253   virtual Float_t   GetZvertexCut()                  const { return fZvtxCut                     ; } //cut on vertex position  
254   virtual void      SetZvertexCut(Float_t zcut=10.)        { fZvtxCut=zcut                       ; } //cut on vertex position
255
256   //--------------------------
257   // Centrality / Event Plane
258   //--------------------------
259   virtual AliCentrality* GetCentrality()             const { return fInputEvent->GetCentrality() ; } //Look in AOD reader, different there
260   virtual void     SetCentralityClass(TString name)        { fCentralityClass   = name           ; }
261   virtual void     SetCentralityOpt(Int_t opt)             { fCentralityOpt     = opt            ; }
262   virtual TString  GetCentralityClass()              const { return fCentralityClass             ; }
263   virtual Int_t    GetCentralityOpt()                const { return fCentralityOpt               ; }
264   virtual Int_t    GetEventCentrality()              const ;
265   virtual void     SetCentralityBin(Int_t min, Int_t max) //Set the centrality bin to select the event. If used, then need to get percentile
266                                                            { fCentralityBin[0]=min; fCentralityBin[1]=max;  
267                                                              if(min>=0 && max > 0) fCentralityOpt = 100 ; }
268   virtual Float_t  GetCentralityBin(Int_t i)         const { if(i < 0 || i > 1) return 0 ; 
269                                                              else return fCentralityBin[i]              ; }
270   
271   virtual AliEventplane* GetEventPlane()             const { return fInputEvent->GetEventplane() ; }           
272   virtual void           SetEventPlaneMethod(TString m)    { fEventPlaneMethod = m               ; }
273   virtual TString        GetEventPlaneMethod()       const { return fEventPlaneMethod            ; }
274
275   //-------------------------------------
276   // Other methods
277   //-------------------------------------
278   AliCalorimeterUtils * GetCaloUtils()               const { return fCaloUtils                   ; }
279   void             SetCaloUtils(AliCalorimeterUtils * caloutils)  { fCaloUtils = caloutils       ; }  
280   
281   virtual Double_t GetBField()                       const { return fInputEvent->GetMagneticField()  ; } 
282   
283   void    SetImportGeometryFromFile(Bool_t import, 
284                                     TString path = ".")    { 
285                                                              fImportGeometryFromFile = import    ; 
286                                                              fImportGeometryFilePath = path      ; }      
287   
288   //------------------------------------------------
289   // MC analysis specific methods
290   //-------------------------------------------------
291   
292   //Kinematics and galice.root available 
293   virtual AliStack*          GetStack()              const ;
294   virtual AliHeader*         GetHeader()             const ;
295   virtual AliGenEventHeader* GetGenEventHeader()     const ;
296   
297   //Filtered kinematics in AOD  
298   virtual TClonesArray*     GetAODMCParticles(Int_t input = 0) const ;
299   virtual AliAODMCHeader*   GetAODMCHeader(Int_t input = 0)    const ;
300         
301   virtual AliVEvent*        GetInputEvent()          const { return fInputEvent            ; }
302   virtual AliVEvent*        GetOriginalInputEvent()  const { return 0x0                    ; }
303   virtual AliAODEvent*      GetOutputEvent()         const { return fOutputEvent           ; }
304   virtual AliMCEvent*       GetMC()                  const { return fMC                    ; }
305   virtual AliMixedEvent*    GetMixedEvent()          const { return fMixedEvent            ; }
306   virtual Int_t             GetNMixedEvent()         const { return fNMixedEvent           ; } 
307   
308   void             SwitchOnStack()                         { fReadStack          = kTRUE   ; }
309   void             SwitchOffStack()                        { fReadStack          = kFALSE  ; }
310   void             SwitchOnAODMCParticles()                { fReadAODMCParticles = kTRUE   ; }
311   void             SwitchOffAODMCParticles()               { fReadAODMCParticles = kFALSE  ; }
312   Bool_t           ReadStack()                       const { return fReadStack             ; }
313   Bool_t           ReadAODMCParticles()              const { return fReadAODMCParticles    ; }
314         
315   //Select generated events, depending on comparison of pT hard and jets.
316   virtual Bool_t   ComparePtHardAndJetPt() ;
317   virtual Bool_t   IsPtHardAndJetPtComparisonSet()       const { return  fComparePtHardAndJetPt   ; }
318   virtual void     SetPtHardAndJetPtComparison(Bool_t compare) { fComparePtHardAndJetPt = compare ; }   
319   virtual Float_t  GetPtHardAndJetFactor()               const { return  fPtHardAndJetPtFactor    ; }
320   virtual void     SetPtHardAndJetPtFactor(Float_t factor)     { fPtHardAndJetPtFactor = factor   ; }           
321   
322   //MC reader methods, declared there to allow compilation, they are only used in the MC reader:
323   
324   virtual void AddNeutralParticlesArray(TArrayI & /*array*/) { ; }  
325   virtual void AddChargedParticlesArray(TArrayI & /*array*/) { ; } 
326   virtual void AddStatusArray(TArrayI & /*array*/)           { ; }
327   
328   virtual void SwitchOnPi0Decay()                            { ; } 
329   virtual void SwitchOffPi0Decay()                           { ; } 
330   virtual void SwitchOnStatusSelection()                     { ; }
331   virtual void SwitchOffStatusSelection()                    { ; }
332   virtual void SwitchOnOverlapCheck()                        { ; }
333   virtual void SwitchOffOverlapCheck()                       { ; }
334   virtual void SwitchOnOnlyGeneratorParticles()              { ; }
335   virtual void SwitchOffOnlyGeneratorParticles()             { ; }
336
337   virtual void SetEMCALOverlapAngle(Float_t /*angle*/)       { ; }
338   virtual void SetPHOSOverlapAngle(Float_t /*angle*/)        { ; }
339
340   
341  protected:
342   Int_t            fEventNumber;    // Event number
343   Int_t            fDataType ;      // Select MC:Kinematics, Data:ESD/AOD, MCData:Both
344   Int_t            fDebug;          // Debugging level
345   AliFiducialCut * fFiducialCut;    //! Acceptance cuts
346   Bool_t           fCheckFidCut ;   // Do analysis for clusters in defined region         
347
348   Bool_t           fComparePtHardAndJetPt;  // In MonteCarlo, jet events, reject fake events with wrong jet energy.
349   Float_t          fPtHardAndJetPtFactor;   // Factor between ptHard and jet pT to reject/accept event.
350
351   Float_t          fCTSPtMin;       // pT Threshold on charged particles 
352   Float_t          fEMCALPtMin;     // pT Threshold on emcal clusters
353   Float_t          fPHOSPtMin;      // pT Threshold on phos clusters
354   Float_t          fCTSPtMax;       // pT Threshold on charged particles 
355   Float_t          fEMCALPtMax;     // pT Threshold on emcal clusters
356   Float_t          fPHOSPtMax;      // pT Threshold on phos clusters
357   
358   TList          * fAODBranchList ; //-> List with AOD branches created and needed in analysis  
359   TObjArray      * fCTSTracks ;     //-> temporal array with tracks
360   TObjArray      * fEMCALClusters ; //-> temporal array with EMCAL CaloClusters
361   TObjArray      * fPHOSClusters ;  //-> temporal array with PHOS  CaloClusters
362   AliVCaloCells  * fEMCALCells ;    //! temporal array with EMCAL CaloCells
363   AliVCaloCells  * fPHOSCells ;     //! temporal array with PHOS  CaloCells
364
365   AliVEvent      * fInputEvent;     //! pointer to esd or aod input
366   AliAODEvent    * fOutputEvent;    //! pointer to aod output
367   AliMCEvent     * fMC;             //! Monte Carlo Event Handler  
368
369   Bool_t           fFillCTS;        // use data from CTS
370   Bool_t           fFillEMCAL;      // use data from EMCAL
371   Bool_t           fFillPHOS;       // use data from PHOS
372   Bool_t           fFillEMCALCells; // use data from EMCAL
373   Bool_t           fFillPHOSCells;  // use data from PHOS
374   Bool_t           fRecalculateClusters;    // Correct clusters, recalculate them if recalibration parameters is given
375   Bool_t           fSelectEmbeddedClusters; // Use only simulated clusters that come from embedding.
376   
377   ULong_t          fTrackStatus        ; // Track selection bit, select tracks refitted in TPC, ITS ...
378   ULong_t          fTrackFilterMask    ; // Track selection bit, for AODs (any difference with track status?)
379   AliESDtrackCuts *fESDtrackCuts       ; // Track cut  
380   Int_t            fTrackMult          ; // Track multiplicity
381   Float_t          fTrackMultEtaCut    ; // Track multiplicity eta cut
382   Bool_t           fReadStack          ; // Access kine information from stack
383   Bool_t                 fReadAODMCParticles ; // Access kine information from filtered AOD MC particles
384         
385   TString          fDeltaAODFileName   ; // Delta AOD file name
386   TString          fFiredTriggerClassName; // Name of trigger event type used to do the analysis
387
388   Bool_t           fAnaLED;              // Analyze LED data only.
389
390   TString          fTaskName;            // Name of task that executes the analysis
391         
392   AliCalorimeterUtils * fCaloUtils ;     //  Pointer to CalorimeterUtils
393
394   AliMixedEvent  * fMixedEvent  ;        //! mixed event object. This class is not the owner
395   Int_t            fNMixedEvent ;        // number of events in mixed event buffer
396   Double_t      ** fVertex      ;        //! vertex array 3 dim for each mixed event buffer
397   
398   Bool_t           fWriteOutputDeltaAOD; // Write the created delta AOD objects into file  
399         Bool_t           fOldAOD;              // Old AODs, before revision 4.20
400   
401   Int_t            fV0ADC[2]    ;        // Integrated V0 signal
402   Int_t            fV0Mul[2]    ;        // Integrated V0 Multiplicity
403
404   Bool_t           fCaloFilterPatch;             // CaloFilter patch
405   TString          fEMCALClustersListName;       // Alternative list of clusters produced elsewhere and not from InputEvent
406   
407   // Event selection
408   Float_t          fZvtxCut ;                      // Cut on vertex position
409   Bool_t           fAcceptFastCluster;           // Accept events from fast cluster, exclude these events for LHC11a
410   Bool_t           fRemoveLEDEvents;             // Remove events where LED was wrongly firing - EMCAL LHC11a
411   Bool_t           fDoEventSelection;            // Select events depending on V0, pileup, vertex well reconstructed, at least 1 track ...
412   Bool_t           fDoV0ANDEventSelection;       // Select events depending on V0, fDoEventSelection should be on
413   Bool_t           fUseEventsWithPrimaryVertex ; // Select events with primary vertex
414   AliTriggerAnalysis* fTriggerAnalysis;          // Access to trigger selection algorithm for V0AND calculation
415   
416   //Centrality/Event plane
417   TString          fCentralityClass;     // Name of selected centrality class     
418   Int_t            fCentralityOpt;       // Option for the returned value of the centrality, possible options 5, 10, 100
419   Int_t            fCentralityBin[2];    // Minimum and maximum value of the centrality for the analysis
420   TString          fEventPlaneMethod;    // Name of event plane method, by default "Q"
421   
422   Bool_t           fImportGeometryFromFile; // Import geometry settings in geometry.root file
423   TString          fImportGeometryFilePath; // path fo geometry.root file
424
425   AliCaloTrackReader(const AliCaloTrackReader & g) ;               // cpy ctor
426   AliCaloTrackReader & operator = (const AliCaloTrackReader & g) ; // cpy assignment
427   
428   ClassDef(AliCaloTrackReader,35)
429   
430 } ;
431
432
433 #endif //ALICALOTRACKREADER_H
434
435
436