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