ROOT logo
#ifndef ALICALOTRACKREADER_H
#define ALICALOTRACKREADER_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice     */

//_________________________________________________________________________
// Base class for reading data: MonteCarlo, ESD or AOD, of PHOS EMCAL and 
// Central Barrel Tracking detectors.
// Not all MC particles/tracks/clusters are kept, some kinematical restrictions are done.
// Mother class of : AliCaloTrackESDReader: Fills ESD data in 3 TObjArrays (PHOS, EMCAL, CTS)
//                 : AliCaloTrackMCReader : Fills Kinematics data in 3 TObjArrays (PHOS, EMCAL, CTS)
//                 : AliCaloTrackAODReader: Fills AOD data in 3 TObjArrays (PHOS, EMCAL, CTS)   
// -- Author: Gustavo Conesa (INFN-LNF)
//////////////////////////////////////////////////////////////////////////////

// --- ROOT system ---
#include <TObject.h> 
#include <TString.h>
class TObjArray ; 
class TTree ;
class TArrayI ;
#include <TRandom3.h>

//--- ANALYSIS system ---
#include "AliVEvent.h"
class AliVCaloCells;
class AliStack; 
class AliHeader; 
class AliGenEventHeader; 
class AliAODEvent;
class AliMCEvent;
class AliMixedEvent;
class AliAODMCHeader;
class AliCentrality;
class AliESDtrackCuts;
//class AliTriggerAnalysis;
class AliEventplane;
class AliVCluster;

// --- CaloTrackCorr / EMCAL ---
#include "AliFiducialCut.h"
class AliEMCALRecoUtils;
class AliCalorimeterUtils;

//jets
class AliAODJetEventBackground;

class AliCaloTrackReader : public TObject {

public: 
  
                  AliCaloTrackReader() ; // ctor
  virtual        ~AliCaloTrackReader() ; // virtual dtor
  void            DeletePointers();
  
  //--------------------------------
  // General methods
  //--------------------------------

  virtual void    Init();
    
  virtual void    InitParameters();
  
  virtual void    Print(const Option_t * opt) const;
  
  virtual void    ResetLists();

  virtual Int_t   GetDebug()                         const { return fDebug                 ; }
  virtual void    SetDebug(Int_t d)                        { fDebug = d                    ; }
  
  enum inputDataType {kESD, kAOD, kMC};
  virtual Int_t   GetDataType()                      const { return fDataType              ; }
  virtual void    SetDataType(Int_t data )                 { fDataType = data              ; }

  virtual Int_t   GetEventNumber()                   const { return fEventNumber           ; }
	
  TString         GetTaskName()                      const { return fTaskName              ; }
  void            SetTaskName(TString name)                { fTaskName = name              ; }
    
  //---------------------------------------
  // Input/output event setters and getters
  //---------------------------------------
  
  virtual void    SetInputEvent(AliVEvent* input) ;
  virtual void    SetOutputEvent(AliAODEvent*  aod)        { fOutputEvent = aod            ; }
  virtual void    SetMC(AliMCEvent* const mc)              { fMC          = mc             ; }
  virtual void    SetInputOutputMCEvent(AliVEvent* /*esd*/, AliAODEvent* /*aod*/, AliMCEvent* /*mc*/) { ; }
  
  // Delta AODs
  
  virtual TList * GetAODBranchList()                 const { return fAODBranchList         ; }
  void            SetDeltaAODFileName(TString name )       { fDeltaAODFileName = name      ; }
  TString         GetDeltaAODFileName()              const { return fDeltaAODFileName      ; }
  void            SwitchOnWriteDeltaAOD()                  { fWriteOutputDeltaAOD = kTRUE  ; }
  void            SwitchOffWriteDeltaAOD()                 { fWriteOutputDeltaAOD = kFALSE ; }
  Bool_t          WriteDeltaAODToFile()              const { return fWriteOutputDeltaAOD   ; } 
  
  //------------------------------------------------------------
  // Clusters/Tracks arrays filtering/filling methods and switchs 
  //------------------------------------------------------------
  
  // detector identificator enum, used here and in AliAnaCaloTrackBaseClass and derived classes
  enum detector { kEMCAL = AliFiducialCut::kEMCAL, kPHOS = AliFiducialCut::kPHOS,
                  kCTS   = AliFiducialCut::kCTS  , kDCAL = AliFiducialCut::kDCAL,
                  kDCALPHOS = AliFiducialCut::kDCALPHOS } ;

  // Minimum pt setters and getters
  
  Float_t          GetEMCALPtMin()                   const { return fEMCALPtMin            ; }
  Float_t          GetPHOSPtMin()                    const { return fPHOSPtMin             ; }
  Float_t          GetCTSPtMin()                     const { return fCTSPtMin              ; }
  Float_t          GetEMCALPtMax()                   const { return fEMCALPtMax            ; }
  Float_t          GetPHOSPtMax()                    const { return fPHOSPtMax             ; }
  Float_t          GetCTSPtMax()                     const { return fCTSPtMax              ; }
  
  void             SetEMCALPtMin(Float_t  pt)              { fEMCALPtMin = pt              ; }
  void             SetPHOSPtMin (Float_t  pt)              { fPHOSPtMin  = pt              ; }
  void             SetCTSPtMin  (Float_t  pt)              { fCTSPtMin   = pt              ; }  
  
  void             SetEMCALPtMax(Float_t  pt)              { fEMCALPtMax = pt              ; }
  void             SetPHOSPtMax (Float_t  pt)              { fPHOSPtMax  = pt              ; }
  void             SetCTSPtMax  (Float_t  pt)              { fCTSPtMax   = pt              ; }  
   
  Float_t          GetEMCALEMin()                    const { return GetEMCALPtMin()        ; }
  Float_t          GetPHOSEMin()                     const { return GetPHOSPtMin()         ; }
  Float_t          GetEMCALEMax()                    const { return GetEMCALPtMax()        ; }
  Float_t          GetPHOSEMax()                     const { return GetPHOSPtMax()         ; }
  
  void             SetEMCALEMin (Float_t  e)               { SetEMCALPtMin(e)              ; }
  void             SetPHOSEMin  (Float_t  e)               { SetPHOSPtMin (e)              ; }
  void             SetEMCALEMax (Float_t  e)               { SetEMCALPtMax(e)              ; }
  void             SetPHOSEMax  (Float_t  e)               { SetPHOSPtMax (e)              ; }
  
  // Track DCA cut
  
  Bool_t           AcceptDCA(Float_t pt, Float_t dca);
  Double_t         GetTrackDCACut(Int_t i)           const { if(i >= 0 && i < 3 ) return fTrackDCACut[i] ;
                                                             else return -999              ; }
  
  void             SetTrackDCACut(Int_t i, Float_t cut)    { if(i >= 0 && i < 3 )
                                                             fTrackDCACut[i] = cut         ; }
  
  void             SwitchOnUseTrackDCACut()                { fUseTrackDCACut = kTRUE       ; }
  void             SwitchOffUseTrackDCACut()               { fUseTrackDCACut = kFALSE      ; }
  Bool_t           IsDCACutOn()                      const { return fUseTrackDCACut        ; }
  
  // Time cut
  
  Double_t         GetTrackTimeCutMin()              const { return fTrackTimeCutMin       ; }
  Double_t         GetTrackTimeCutMax()              const { return fTrackTimeCutMax       ; }
  
  void             SetTrackTimeCut(Double_t a, Double_t b) { fTrackTimeCutMin = a ;
                                                             fTrackTimeCutMax = b          ; } // ns
  
  void             SwitchOnUseTrackTimeCut()               { fUseTrackTimeCut = kTRUE      ;  fAccessTrackTOF  = kTRUE ; }
  void             SwitchOffUseTrackTimeCut()              { fUseTrackTimeCut = kFALSE     ; }

  void             SwitchOnAccessTrackTimeCut()            { fAccessTrackTOF  = kTRUE      ; }
  void             SwitchOffAccessTrackTimeCut()           { fAccessTrackTOF  = kFALSE     ; }
  Bool_t           IsAccessToTrackTimeOn()           const { return fAccessTrackTOF        ; }

  
  Double_t         GetEMCALTimeCutMin()              const { return fEMCALTimeCutMin       ; }
  Double_t         GetEMCALTimeCutMax()              const { return fEMCALTimeCutMax       ; }	

  Bool_t           IsInTimeWindow(Double_t tof, Float_t energy)  const ;
  
  void             SetEMCALTimeCut(Double_t a, Double_t b) { fEMCALTimeCutMin = a ; 
                                                             fEMCALTimeCutMax = b          ; } // ns
  
  void             SetEMCALParametrizedMinTimeCut(Int_t i, Float_t par) { fEMCALParamTimeCutMin[i] = par ; } 
  void             SetEMCALParametrizedMaxTimeCut(Int_t i, Float_t par) { fEMCALParamTimeCutMax[i] = par ; }
  
  void             SwitchOnUseEMCALTimeCut()               { fUseEMCALTimeCut = kTRUE      ; }
  void             SwitchOffUseEMCALTimeCut()              { fUseEMCALTimeCut = kFALSE     ; }
  
  void             SwitchOnUseParametrizedTimeCut()        { fUseParamTimeCut = kTRUE      ; }
  void             SwitchOffUseParametrizedTimeCut()       { fUseParamTimeCut = kFALSE     ; }

  // Fidutial cuts
  
  virtual AliFiducialCut * GetFiducialCut()                { 
                    if(!fFiducialCut) fFiducialCut = new AliFiducialCut(); 
                    return  fFiducialCut                                                   ; }
  virtual void     SetFiducialCut(AliFiducialCut * fc)     { fFiducialCut = fc           ; }
  virtual Bool_t   IsFiducialCutOn()                 const { return fCheckFidCut           ; }
  virtual void     SwitchOnFiducialCut()                   { fCheckFidCut = kTRUE          ; 
                                                             fFiducialCut = new AliFiducialCut() ; }
  virtual void     SwitchOffFiducialCut()                  { fCheckFidCut = kFALSE         ; }
    
  // Cluster/track/cells switchs
  
  Bool_t           IsCTSSwitchedOn()                 const { return fFillCTS               ; }
  void             SwitchOnCTS()                           { fFillCTS = kTRUE              ; }
  void             SwitchOffCTS()                          { fFillCTS = kFALSE             ; }

  Bool_t           IsEMCALSwitchedOn()               const { return fFillEMCAL             ; }
  void             SwitchOnEMCAL()                         { fFillEMCAL = kTRUE            ; }
  void             SwitchOffEMCAL()                        { fFillEMCAL = kFALSE           ; }

  Bool_t           IsDCALSwitchedOn()                const { return fFillDCAL              ; }
  void             SwitchOnDCAL()                          { fFillDCAL = kTRUE             ; }
  void             SwitchOffDCAL()                         { fFillDCAL = kFALSE            ; }
  
  Bool_t           IsPHOSSwitchedOn()                const { return fFillPHOS              ; }
  void             SwitchOnPHOS()                          { fFillPHOS = kTRUE             ; }
  void             SwitchOffPHOS()                         { fFillPHOS = kFALSE            ; }

  Bool_t           IsEMCALCellsSwitchedOn()          const { return fFillEMCALCells        ; }
  void             SwitchOnEMCALCells()                    { fFillEMCALCells = kTRUE       ; }
  void             SwitchOffEMCALCells()                   { fFillEMCALCells = kFALSE      ; }

  Bool_t           IsPHOSCellsSwitchedOn()           const { return fFillPHOSCells         ; }
  void             SwitchOnPHOSCells()                     { fFillPHOSCells = kTRUE        ; }
  void             SwitchOffPHOSCells()                    { fFillPHOSCells = kFALSE       ; }

  Bool_t           AreClustersRecalculated()         const { return fRecalculateClusters   ; }
  void             SwitchOnClusterRecalculation()          { fRecalculateClusters = kTRUE  ; }
  void             SwitchOffClusterRecalculation()         { fRecalculateClusters = kFALSE ; }  

  void             SwitchOnClusterELinearityCorrection()   { fCorrectELinearity = kTRUE    ; }
  void             SwitchOffClusterELinearityCorrection()  { fCorrectELinearity = kFALSE   ; }

  Bool_t           IsShowerShapeSmeared()            const { return fSmearShowerShape      ; }
  void             SwitchOnShowerShapeSmearing()           { fSmearShowerShape = kTRUE     ; }
  void             SwitchOffShowerShapeSmearing()          { fSmearShowerShape = kFALSE    ; }
  
  void             SetShowerShapeSmearWidth(Float_t w )    { fSmearShowerShapeWidth = w    ; }

  Bool_t           IsEmbeddedClusterSelectionOn()    const { return fSelectEmbeddedClusters   ; }
  void             SwitchOnEmbeddedClustersSelection()     { fSelectEmbeddedClusters = kTRUE  ; }
  void             SwitchOffEmbeddedClustersSelection()    { fSelectEmbeddedClusters = kFALSE ; }
  
  // Filling/ filtering / detector information access methods
  
  virtual Bool_t   FillInputEvent(Int_t iEntry, const char *currentFileName)  ;
  virtual void     FillInputCTS() ;
  virtual void     FillInputEMCAL() ;
  virtual void     FillInputEMCALAlgorithm(AliVCluster * clus, Int_t iclus) ;
  virtual void     FillInputPHOS() ;
  virtual void     FillInputEMCALCells() ;
  virtual void     FillInputPHOSCells() ;
  virtual void     FillInputVZERO() ;  
  
  Int_t            GetV0Signal(Int_t i)              const { return fV0ADC[i]               ; }
  Int_t            GetV0Multiplicity(Int_t i)        const { return fV0Mul[i]               ; }
  
  void             SetEMCALClusterListName(TString &name)  { fEMCALClustersListName = name  ; }
  TString          GetEMCALClusterListName()         const { return fEMCALClustersListName  ; }

  // Arrays with clusters/track/cells access method
  
  virtual TObjArray*     GetCTSTracks()              const { return fCTSTracks              ; }
  virtual TObjArray*     GetEMCALClusters()          const { return fEMCALClusters          ; }
  virtual TObjArray*     GetDCALClusters()           const { return fDCALClusters           ; }
  virtual TObjArray*     GetPHOSClusters()           const { return fPHOSClusters           ; }
  virtual AliVCaloCells* GetEMCALCells()             const { return fEMCALCells             ; }
  virtual AliVCaloCells* GetPHOSCells()              const { return fPHOSCells              ; }
  
  //-------------------------------------
  // Event/track selection methods
  //-------------------------------------
  
  void             AcceptFastClusterEvents()               { fAcceptFastCluster     = kTRUE  ; } 
  void             RejectFastClusterEvents()               { fAcceptFastCluster     = kFALSE ; }  
  Bool_t           IsFastClusterAccepted()           const { return fAcceptFastCluster       ; }   
  
  Bool_t           AcceptEventWithTriggerBit();
  Bool_t           RejectEventWithTriggerBit();
  void             SetAcceptEventsWithBit(UInt_t bit)      { Int_t n = fAcceptEventsWithBit.GetSize();
                                                             fAcceptEventsWithBit.Set(n+1);
                                                             fAcceptEventsWithBit.AddAt(bit,n) ; }
  
  void             SetRejectEventsWithBit(UInt_t bit)      { Int_t n = fRejectEventsWithBit.GetSize();
                                                             fRejectEventsWithBit.Set(n+1);
                                                             fRejectEventsWithBit.AddAt(bit,n) ; }

  void             SwitchOnLEDEventsRemoval()              { fRemoveLEDEvents       = kTRUE  ; }
  void             SwitchOffLEDEventsRemoval()             { fRemoveLEDEvents       = kFALSE ; }
  Bool_t           IsLEDEventRemoved()               const { return fRemoveLEDEvents         ; }   
  Bool_t           RejectLEDEvents();
  
  void             SetFiredTriggerClassName(TString name ) { fFiredTriggerClassName = name   ; }
  TString          GetFiredTriggerClassName()        const { return fFiredTriggerClassName   ; }
  TString          GetFiredTriggerClasses()          const { return GetInputEvent()->GetFiredTriggerClasses() ; }
  
  
  // Event selection when mixed event is used
  
  UInt_t           GetEventTriggerMask()             const { return fEventTriggerMask        ; }
  void             SetEventTriggerMask(UInt_t evtTrig = AliVEvent::kAny) 
                                                           { fEventTriggerMask = evtTrig     ; }
  UInt_t           GetMixEventTriggerMask()          const { return fMixEventTriggerMask     ; }
  void             SetMixEventTriggerMask(UInt_t evtTrig = AliVEvent::kAnyINT)
                                                           { fMixEventTriggerMask = evtTrig  ; }
	Bool_t           IsEventTriggerAtSEOn()            const { return fEventTriggerAtSE        ; }
  void             SwitchOnEventTriggerAtSE()              { fEventTriggerAtSE      = kTRUE  ; }
  void             SwitchOffEventTriggerAtSE()             { fEventTriggerAtSE      = kFALSE ; }
		
  // EMCal Triggered events selection, studies
  
  TArrayI          GetTriggerPatches(Int_t tmin, Int_t tmax);
  void             MatchTriggerCluster(TArrayI patches);

  Bool_t           CheckEventTriggers();
  
  Bool_t           IsExoticEvent()                   const { return fIsExoticEvent           ; }
  Bool_t           IsBadCellTriggerEvent()           const { return fIsBadCellEvent          ; }
  Bool_t           IsBadMaxCellTriggerEvent()        const { return fIsBadMaxCellEvent       ; }
  Bool_t           IsTriggerMatched()                const { return fIsTriggerMatch          ; }
  Bool_t           IsTriggerMatchedOpenCuts(Int_t i) const { return fIsTriggerMatchOpenCut[i]; }
  
  Int_t            GetTriggerClusterBC()             const { return fTriggerClusterBC        ; }
  Int_t            GetTriggerClusterIndex()          const { return fTriggerClusterIndex     ; }
  Int_t            GetTriggerClusterId()             const { return fTriggerClusterId        ; }
  
  Float_t          GetEventTriggerL0Threshold()      const { return fTriggerL0EventThreshold ; }
  void             SetEventTriggerL0Threshold(Float_t tr)  { fTriggerL0EventThreshold   = tr ; }
  Float_t          GetEventTriggerL1Threshold()      const { return fTriggerL1EventThreshold ; }
  void             SetEventTriggerL1Threshold(Float_t tr)  { fTriggerL1EventThreshold   = tr ; fTriggerL1EventThresholdFix = kTRUE; }

  void             SetEventTriggerL1Bit(Int_t ega, Int_t eje) { fBitEGA   = ega ; fBitEJE = eje; }
  
  void             SetTriggerPatchTimeWindow(Int_t min, Int_t max) { fTriggerPatchTimeWindow[0] = min ;
                                                                     fTriggerPatchTimeWindow[1] = max ; }
  
  Bool_t           AreBadTriggerEventsRemoved()      const { return fRemoveBadTriggerEvents     ; }
  void             SwitchOffBadTriggerEventsRemoval()      { fRemoveBadTriggerEvents   = kFALSE ; }
  void             SwitchOnBadTriggerEventsRemoval()       { fRemoveBadTriggerEvents   = kTRUE  ; }

  Bool_t           AreUnMatchedTriggerEventsRemoved()const { return fRemoveUnMatchedTriggers    ; }
  void             SwitchOffUnMatchedTriggerEventsRemoval(){ fRemoveUnMatchedTriggers  = kFALSE ; }
  void             SwitchOnUnMatchedTriggerEventsRemoval() { fRemoveUnMatchedTriggers  = kTRUE  ; }
  
  Bool_t           IsTriggerPatchMatchedToCluster()  const { return fTriggerPatchClusterMatch   ; }
  void             SwitchOffTriggerPatchMatching()         { fTriggerPatchClusterMatch = kFALSE ; }
  void             SwitchOnTriggerPatchMatching()          { fTriggerPatchClusterMatch = kTRUE  ; }
  
  Bool_t           IsTriggerClusterTimeRecal()       const { return fTriggerClusterTimeRecal    ; }
  void             SwitchOnTriggerClusterTimeRecal ()      { fTriggerClusterTimeRecal  = kTRUE  ; }
  void             SwitchOffTriggerClusterTimeRecal()      { fTriggerClusterTimeRecal  = kFALSE ; }
  
	void             SetEventTriggerBit();
	Bool_t           IsEventMinimumBias()              const { return fEventTrigMinBias        ; }
	Bool_t           IsEventCentral()                  const { return fEventTrigCentral        ; }
	Bool_t           IsEventSemiCentral()              const { return fEventTrigSemiCentral    ; }
	Bool_t           IsEventEMCALL0()                  const { return fEventTrigEMCALL0        ; }
	Bool_t           IsEventEMCALL1Gamma1()            const { return fEventTrigEMCALL1Gamma1  ; }
	Bool_t           IsEventEMCALL1Gamma2()            const { return fEventTrigEMCALL1Gamma2  ; }
	Bool_t           IsEventEMCALL1Jet1()              const { return fEventTrigEMCALL1Jet1    ; }
	Bool_t           IsEventEMCALL1Jet2()              const { return fEventTrigEMCALL1Jet2    ; }
	Bool_t           IsEventEMCALL1Gamma()             const { return (fEventTrigEMCALL1Gamma1 || fEventTrigEMCALL1Gamma2) ; }
  Bool_t           IsEventEMCALL1Jet()               const { return (fEventTrigEMCALL1Jet1   || fEventTrigEMCALL1Jet2  ) ; }
	Bool_t           IsEventEMCALL1()                  const { return (IsEventEMCALL1Gamma()   || IsEventEMCALL1Jet()    ) ; }
	
  void             SwitchOnEMCALEventRejectionWith2Thresholds()  { fRejectEMCalTriggerEventsWith2Tresholds = kTRUE  ; }
  void             SwitchOffEMCALEventRejectionWith2Thresholds() { fRejectEMCalTriggerEventsWith2Tresholds = kFALSE ; }
	
  // Other event rejections criteria
  
  void             SwitchOnPileUpEventRejection()          { fDoPileUpEventRejection= kTRUE  ; }
  void             SwitchOffPileUpEventRejection()         { fDoPileUpEventRejection= kFALSE ; }
  Bool_t           IsPileUpEventRejectionDone()      const { return fDoPileUpEventRejection  ; }
  
  void             SwitchOnV0ANDSelection()                { fDoV0ANDEventSelection = kTRUE  ; }
  void             SwitchOffV0ANDSelection()               { fDoV0ANDEventSelection = kFALSE ; }
  Bool_t           IsV0ANDEventSelectionDone()       const { return fDoV0ANDEventSelection   ; } 

  void             SwitchOnVertexBCEventSelection()        { fDoVertexBCEventSelection = kTRUE  ; }
  void             SwitchOffVertexBCEventSelection()       { fDoVertexBCEventSelection = kFALSE ; }
  Bool_t           IsVertexBCEventSelectionDone()    const { return fDoVertexBCEventSelection   ; }
  
  void             SwitchOnPrimaryVertexSelection()        { fUseEventsWithPrimaryVertex = kTRUE  ; }
  void             SwitchOffPrimaryVertexSelection()       { fUseEventsWithPrimaryVertex = kFALSE ; }
  Bool_t           IsPrimaryVertexSelectionDone()    const { return fUseEventsWithPrimaryVertex   ; } 
  
  void             SwitchOnRejectNoTrackEvents()           { fDoRejectNoTrackEvents = kTRUE  ; }
  void             SwitchOffRejectNoTrackEvents()          { fDoRejectNoTrackEvents = kFALSE ; }
  Bool_t           IsEventWithNoTrackRejectionDone() const { return fDoRejectNoTrackEvents   ; }
  

  // Time Stamp
  
  Double_t         GetRunTimeStampMin()              const { return fTimeStampRunMin         ; }
  Double_t         GetRunTimeStampMax()              const { return fTimeStampRunMax         ; }
  
  void             SetRunTimeStamp(Double_t a, Double_t b) { fTimeStampRunMin = a            ;
                                                             fTimeStampRunMax = b            ; } // seconds
  
  Float_t          GetEventTimeStampFractionMin()    const { return fTimeStampEventFracMin   ; }
  Float_t          GetEventTimeStampFractionMax()    const { return fTimeStampEventFracMax   ; }
  
  void             SetEventTimeStampFraction(Float_t a, Float_t b) { fTimeStampEventFracMin = a ;
                                                                     fTimeStampEventFracMax = b ; }
  
  void             SwitchOnSelectEventTimeStamp()          { fTimeStampEventSelect = kTRUE   ; }
  void             SwitchOffSelectEventTimeStamp()         { fTimeStampEventSelect = kFALSE  ; }
  
  Bool_t           IsSelectEventTimeStampOn()              {return  fTimeStampEventSelect    ; }
  
  // Event tagging as pile-up
  
  Bool_t           IsPileUpFromSPD()               const ;
  Bool_t           IsPileUpFromEMCal()             const ;
  Bool_t           IsPileUpFromSPDAndEMCal()       const ;
  Bool_t           IsPileUpFromSPDOrEMCal()        const ;
  Bool_t           IsPileUpFromSPDAndNotEMCal()    const ;
  Bool_t           IsPileUpFromEMCalAndNotSPD()    const ;
  Bool_t           IsPileUpFromNotSPDAndNotEMCal() const ;

  void             SetPileUpParamForSPD  (Int_t i, Double_t param)
                                                           { fPileUpParamSPD[i]  = param  ; }
  void             SetPileUpParamForEMCal(Int_t param)     { fNPileUpClustersCut = param  ; }
  
  Int_t            GetNPileUpClusters()                    { return  fNPileUpClusters     ; }
  Int_t            GetNNonPileUpClusters()                 { return  fNNonPileUpClusters  ; }
  
  Int_t            GetEMCalEventBC(Int_t bc)     const     { if(bc >=0 && bc < 19) return  fEMCalBCEvent   [bc] ; else return 0 ; }
  Int_t            GetTrackEventBC(Int_t bc)     const     { if(bc >=0 && bc < 19) return  fTrackBCEvent   [bc] ; else return 0 ; }
  Int_t            GetEMCalEventBCcut(Int_t bc)  const     { if(bc >=0 && bc < 19) return  fEMCalBCEventCut[bc] ; else return 0 ; }
  Int_t            GetTrackEventBCcut(Int_t bc)  const     { if(bc >=0 && bc < 19) return  fTrackBCEventCut[bc] ; else return 0 ; }

  void             SetEMCalEventBC(Int_t bc)               { if(bc >=0 && bc < 19) fEMCalBCEvent   [bc] = 1 ; }
  void             SetTrackEventBC(Int_t bc)               { if(bc >=0 && bc < 19) fTrackBCEvent   [bc] = 1 ; }
  void             SetEMCalEventBCcut(Int_t bc)            { if(bc >=0 && bc < 19) fEMCalBCEventCut[bc] = 1 ; }
  void             SetTrackEventBCcut(Int_t bc)            { if(bc >=0 && bc < 19) fTrackBCEventCut[bc] = 1 ; }

  Int_t            GetVertexBC(const AliVVertex * vtx);
  Int_t            GetVertexBC()                  const    { return fVertexBC              ; }
  void             SwitchOnRecalculateVertexBC()           { fRecalculateVertexBC = kTRUE  ; fAccessTrackTOF  = kTRUE ; }
  void             SwitchOffRecalculateVertexBC()          { fRecalculateVertexBC = kFALSE ; }
  
  // Track selection
  
  ULong_t          GetTrackStatus()                  const { return fTrackStatus          ; }
  void             SetTrackStatus(ULong_t bit)             { fTrackStatus = bit           ; }

  virtual Bool_t   SelectTrack(AliVTrack* , Double_t*)     { return kFALSE                ; } // See AOD/ESD reader
  
  void             SwitchOnTrackHitSPDSelection()          { fSelectSPDHitTracks = kTRUE  ; }
  void             SwitchOffTrackHitSPDSelection()         { fSelectSPDHitTracks = kFALSE ; }
  
  Int_t            GetTrackMultiplicity()            const { return fTrackMult            ; }
  Float_t          GetTrackMultiplicityEtaCut()      const { return fTrackMultEtaCut      ; }
  void             SetTrackMultiplicityEtaCut(Float_t eta) { fTrackMultEtaCut = eta       ; }		
  
  // virtual for AODReader
  
  virtual ULong_t  GetTrackFilterMask()               const { return 0 ; }
  virtual void     SetTrackFilterMask(ULong_t)              { ; }
  
  virtual ULong_t  GetTrackFilterMaskComplementary()  const { return 0 ; }
  virtual void     SetTrackFilterMaskComplementary(ULong_t) { ; }
  
  virtual void     SwitchOnAODHybridTrackSelection()        { ; }
  virtual void     SwitchOffAODHybridTrackSelection()       { ; }
  
  virtual void     SwitchOnAODPrimaryTrackSelection()       { ; }
  virtual void     SwitchOffAODPrimaryTrackSelection()      { ; }
  
  virtual void     SwitchOnAODTrackSharedClusterSelection() { ; }
  virtual void     SwitchOffAODTrackSharedClusterSelection(){ ; }
  
  virtual void     SetTPCSharedClusterFraction(Float_t)     { ; }
  virtual Float_t  GetTPCSharedClusterFraction() const      { return 0 ; }

  // virtual for ESDReader
  
  virtual AliESDtrackCuts* GetTrackCuts()              const { return 0 ; }
  virtual AliESDtrackCuts* GetTrackComplementaryCuts() const { return 0 ; }
  
  virtual void     SetTrackCuts(AliESDtrackCuts *)               { ; }
  virtual void     SetTrackComplementaryCuts(AliESDtrackCuts *)  { ; }
  
  virtual void     SwitchOnConstrainTrackToVertex()  { ; }
  virtual void     SwitchOffConstrainTrackToVertex() { ; }

  // Calorimeter pure LED events selection
  void             AnalyzeOnlyLED()                        { fAnaLED             = kTRUE  ; }
  void             AnalyzeOnlyPhysics()                    { fAnaLED             = kFALSE ; }
  
  //-------------------------------
  // Vertex methods
  //-------------------------------

  virtual void      GetVertex(Double_t v[3])         const ;
  virtual Double_t* GetVertex(Int_t evtIndex)        const { return fVertex[evtIndex]            ; }
  virtual void      GetVertex(Double_t vertex[3],    const Int_t evtIndex) const ;
  virtual void      FillVertexArray();
  virtual Bool_t    CheckForPrimaryVertex()          const { return kTRUE                        ; } // algorithm in ESD/AOD Readers
  virtual Float_t   GetZvertexCut()                  const { return fZvtxCut                     ; } // cut on vertex position
  virtual void      SetZvertexCut(Float_t zcut=10.)        { fZvtxCut=zcut                       ; } // cut on vertex position

  //--------------------------
  // Centrality / Event Plane
  //--------------------------

  virtual AliCentrality* GetCentrality()             const { if(fDataType!=kMC) return fInputEvent->GetCentrality() ;
                                                             else               return 0x0       ; } 
  virtual void     SetCentralityClass(TString name)        { fCentralityClass   = name           ; }
  virtual void     SetCentralityOpt(Int_t opt)             { fCentralityOpt     = opt            ; }
  virtual TString  GetCentralityClass()              const { return fCentralityClass             ; }
  virtual Int_t    GetCentralityOpt()                const { return fCentralityOpt               ; }
  virtual Int_t    GetEventCentrality()              const ;
  virtual void     SetCentralityBin(Int_t min, Int_t max) //Set the centrality bin to select the event. If used, then need to get percentile
                                                           { fCentralityBin[0]=min; fCentralityBin[1]=max;  
                                                             if(min>=0 && max > 0) fCentralityOpt = 100 ; }
  virtual Float_t  GetCentralityBin(Int_t i)         const { if(i < 0 || i > 1) return 0 ; 
                                                             else return fCentralityBin[i]              ; }
  
  virtual AliEventplane* GetEventPlane()             const { if(fDataType!=kMC) return fInputEvent->GetEventplane() ;
                                                             else               return 0x0       ; }  
  virtual Double_t       GetEventPlaneAngle()        const ;          
  virtual void           SetEventPlaneMethod(TString m)    { fEventPlaneMethod = m               ; }
  virtual TString        GetEventPlaneMethod()       const { return fEventPlaneMethod            ; }

  //--------------------
  // Mixing
  //--------------------

  Int_t   GetLastCaloMixedEvent()                    const { return fLastMixedCaloEvent          ; }
  Int_t   GetLastTracksMixedEvent ()                 const { return fLastMixedTracksEvent        ; }
  
  TList * GetListWithMixedEventsForCalo  (Int_t bi)  const { if(fListMixedCaloEvents)   return fListMixedCaloEvents  [bi] ; else return 0 ; }
  TList * GetListWithMixedEventsForTracks(Int_t bi)  const { if(fListMixedTracksEvents) return fListMixedTracksEvents[bi] ; else return 0 ; }
   
  Bool_t  ListWithMixedEventsForCaloExists()         const { if(fListMixedCaloEvents) return kTRUE  ;
                                                             else                     return kFALSE ; }

  Bool_t  ListWithMixedEventsForTracksExists()       const { if(fListMixedTracksEvents) return kTRUE  ;
                                                             else                       return kFALSE ; }
  
  void    SetLastCaloMixedEvent  (Int_t e)                 { fLastMixedCaloEvent    = e          ; }
  void    SetLastTracksMixedEvent(Int_t e)                 { fLastMixedTracksEvent  = e          ; }
  
  void    SetListWithMixedEventsForCalo (TList ** l)       { 
            if(fListMixedCaloEvents) printf("AliCaloTrackReader::SetListWithMixedEventsForCalo() - Track Mixing event list already set, nothing done\n");
            else                        fListMixedCaloEvents    = l ; }
  
  void    SetListWithMixedEventsForTracks(TList ** l)      { 
            if(fListMixedTracksEvents)  printf("AliCaloTrackReader::SetListWithMixedEventsForTracks() - Calorimeter Mixing event list already set, nothing done\n");
            else                        fListMixedTracksEvents  = l ; }
  
  //-------------------------------------
  // Other methods
  //-------------------------------------
  
  AliCalorimeterUtils * GetCaloUtils()               const { return fCaloUtils                   ; }
  void             SetCaloUtils(AliCalorimeterUtils * caloutils)  { fCaloUtils = caloutils       ; }  
  
  virtual Double_t GetBField()                       const { return fInputEvent->GetMagneticField()  ; } 
  
  //------------------------------------------------
  // MC analysis specific methods
  //-------------------------------------------------
  
  // Kinematics and galice.root available
  
  virtual AliStack*          GetStack()              const ;
  virtual AliHeader*         GetHeader()             const ;
  virtual AliGenEventHeader* GetGenEventHeader()     const ;
  
  // Filtered kinematics in AOD
  
  virtual TClonesArray*     GetAODMCParticles()      const ;
  virtual AliAODMCHeader*   GetAODMCHeader   ()      const ;
  
  virtual AliVEvent*        GetInputEvent()          const { return fInputEvent            ; }
  virtual AliVEvent*        GetOriginalInputEvent()  const { return 0x0                    ; }
  virtual AliAODEvent*      GetOutputEvent()         const { return fOutputEvent           ; }
  virtual AliMCEvent*       GetMC()                  const { return fMC                    ; }
  virtual AliMixedEvent*    GetMixedEvent()          const { return fMixedEvent            ; }
  virtual Int_t             GetNMixedEvent()         const { return fNMixedEvent           ; } 
  
  void             SwitchOnStack()                         { fReadStack          = kTRUE   ; }
  void             SwitchOffStack()                        { fReadStack          = kFALSE  ; }
  void             SwitchOnAODMCParticles()                { fReadAODMCParticles = kTRUE   ; }
  void             SwitchOffAODMCParticles()               { fReadAODMCParticles = kFALSE  ; }
  Bool_t           ReadStack()                       const { return fReadStack             ; }
  Bool_t           ReadAODMCParticles()              const { return fReadAODMCParticles    ; }
	
  void             RemapMCLabelForAODs(Int_t &label);
  
  // Select generated events, depending on comparison of pT hard and jets
    
  virtual Bool_t   ComparePtHardAndJetPt() ;
  virtual Bool_t   IsPtHardAndJetPtComparisonSet()       const { return  fComparePtHardAndJetPt   ; }
  virtual void     SetPtHardAndJetPtComparison(Bool_t compare) { fComparePtHardAndJetPt = compare ; }	
  virtual Float_t  GetPtHardAndJetFactor()               const { return  fPtHardAndJetPtFactor    ; }
  virtual void     SetPtHardAndJetPtFactor(Float_t factor)     { fPtHardAndJetPtFactor = factor   ; }		
  
  virtual Bool_t   ComparePtHardAndClusterPt() ;
  virtual Bool_t   IsPtHardAndClusterPtComparisonSet()       const { return  fComparePtHardAndClusterPt   ; }
  virtual void     SetPtHardAndClusterPtComparison(Bool_t compare) { fComparePtHardAndClusterPt = compare ; }	
  virtual Float_t  GetPtHardAndClusterFactor()               const { return  fPtHardAndClusterPtFactor    ; }
  virtual void     SetPtHardAndClusterPtFactor(Float_t factor)     { fPtHardAndClusterPtFactor = factor   ; }		
  
  virtual Bool_t   IsHIJINGLabel(Int_t label);
  void             SetGeneratorMinMaxParticles();
  void             SwitchOnAcceptOnlyHIJINGLabels()          { fAcceptOnlyHIJINGLabels = kTRUE  ; }
  void             SwitchOffAcceptOnlyHIJINGLabels()         { fAcceptOnlyHIJINGLabels = kFALSE ; }
  Bool_t           AcceptOnlyHIJINGLabels()            const { return fAcceptOnlyHIJINGLabels   ; }
  
  // MC reader methods, declared there to allow compilation, they are only used in the MC reader
  
  virtual void AddNeutralParticlesArray(TArrayI & /*array*/) { ; }  
  virtual void AddChargedParticlesArray(TArrayI & /*array*/) { ; } 
  virtual void AddStatusArray(TArrayI & /*array*/)           { ; }
  
  virtual void SwitchOnPi0Decay()                            { ; } 
  virtual void SwitchOffPi0Decay()                           { ; } 
  virtual void SwitchOnStatusSelection()                     { ; }
  virtual void SwitchOffStatusSelection()                    { ; }
  virtual void SwitchOnOverlapCheck()                        { ; }
  virtual void SwitchOffOverlapCheck()                       { ; }
  virtual void SwitchOnOnlyGeneratorParticles()              { ; }
  virtual void SwitchOffOnlyGeneratorParticles()             { ; }

  virtual void SetEMCALOverlapAngle(Float_t /*angle*/)       { ; }
  virtual void SetPHOSOverlapAngle(Float_t /*angle*/)        { ; }

  //-------------
  // Jets
  //-------------
  Bool_t       IsNonStandardJetsSwitchedOn()           const { return fFillInputNonStandardJetBranch   ; }
  void         SwitchOnNonStandardJets()                     { fFillInputNonStandardJetBranch = kTRUE  ; }
  void         SwitchOffNonStandardJets()                    { fFillInputNonStandardJetBranch = kFALSE ; }
  
  Bool_t       IsBackgroundJetsSwitchedOn()           const { return fFillInputBackgroundJetBranch   ; }
  void         SwitchOnBackgroundJets()                     { fFillInputBackgroundJetBranch = kTRUE  ; }
  void         SwitchOffBackgroundJets()                    { fFillInputBackgroundJetBranch = kFALSE ; }

  virtual void FillInputNonStandardJets() ;
  virtual TClonesArray* GetNonStandardJets()            const { return fNonStandardJets                 ; }
  virtual void SetInputNonStandardJetBranchName(TString name) { fInputNonStandardJetBranchName   = name ; }
  virtual TString GetInputNonStandardJetBranchName()          { return fInputNonStandardJetBranchName   ; }
  
  virtual void FillInputBackgroundJets() ;
  virtual AliAODJetEventBackground* GetBackgroundJets() const { return fBackgroundJets                 ; }
  virtual void SetInputBackgroundJetBranchName(TString name) { fInputBackgroundJetBranchName   = name ; }
  virtual TString GetInputBackgroundJetBranchName()          { return fInputBackgroundJetBranchName   ; }

 protected:
  Int_t	           fEventNumber;               // Event number
  Int_t            fDataType ;                 // Select MC:Kinematics, Data:ESD/AOD, MCData:Both
  Int_t            fDebug;                     // Debugging level
  AliFiducialCut * fFiducialCut;               // Acceptance cuts
  Bool_t           fCheckFidCut ;              // Do analysis for clusters in defined region         

  Bool_t           fComparePtHardAndJetPt;     // In MonteCarlo, jet events, reject fake events with wrong jet energy.
  Float_t          fPtHardAndJetPtFactor;      // Factor between ptHard and jet pT to reject/accept event.

  Bool_t           fComparePtHardAndClusterPt; // In MonteCarlo, jet events, reject events with too large cluster energy
  Float_t          fPtHardAndClusterPtFactor;  // Factor between ptHard and cluster pT to reject/accept event.
  
  Float_t          fCTSPtMin;                  // pT Threshold on charged particles 
  Float_t          fEMCALPtMin;                // pT Threshold on emcal clusters
  Float_t          fPHOSPtMin;                 // pT Threshold on phos clusters
  Float_t          fCTSPtMax;                  // pT Threshold on charged particles 
  Float_t          fEMCALPtMax;                // pT Threshold on emcal clusters
  Float_t          fPHOSPtMax;                 // pT Threshold on phos clusters
  Bool_t           fUseEMCALTimeCut;           // Do time cut selection
  Bool_t           fUseParamTimeCut;           // Use simple or parametrized time cut
  Bool_t           fUseTrackTimeCut;           // Do time cut selection
  Bool_t           fAccessTrackTOF;            // Access the track TOF, in case of problems when accessing GetTOFBunchCrossing
  Double_t         fEMCALTimeCutMin;           // Remove clusters/cells with time smaller than this value, in ns
  Double_t         fEMCALTimeCutMax;           // Remove clusters/cells with time larger than this value, in ns
  Float_t          fEMCALParamTimeCutMin[4];   // Remove clusters/cells with time smaller than parametrized value, in ns
  Double_t         fEMCALParamTimeCutMax[4];   // Remove clusters/cells with time larger than parametrized value, in ns
  Double_t         fTrackTimeCutMin;           // Remove tracks with time smaller than this value, in ns
  Double_t         fTrackTimeCutMax;           // Remove tracks with time larger than this value, in ns
  Bool_t           fUseTrackDCACut;            // Do DCA selection
  Double_t         fTrackDCACut[3];            // Remove tracks with DCA larger than cut, parameters of function stored here

  TList          * fAODBranchList ;            //-> List with AOD branches created and needed in analysis
  TObjArray      * fCTSTracks ;                //-> temporal array with tracks
  TObjArray      * fEMCALClusters ;            //-> temporal array with EMCAL CaloClusters
  TObjArray      * fDCALClusters ;             //-> temporal array with DCAL CaloClusters, not needed in the normal case, use just EMCal array with DCal limits
  TObjArray      * fPHOSClusters ;             //-> temporal array with PHOS  CaloClusters
  AliVCaloCells  * fEMCALCells ;               //! temporal array with EMCAL CaloCells
  AliVCaloCells  * fPHOSCells ;                //! temporal array with PHOS  CaloCells

  AliVEvent      * fInputEvent;                //! pointer to esd or aod input
  AliAODEvent    * fOutputEvent;               //! pointer to aod output
  AliMCEvent     * fMC;                        //! Monte Carlo Event Handler  

  Bool_t           fFillCTS;                   // use data from CTS
  Bool_t           fFillEMCAL;                 // use data from EMCAL
  Bool_t           fFillDCAL;                  // use data from DCAL, not needed in the normal case, use just EMCal array with DCal limits
  Bool_t           fFillPHOS;                  // use data from PHOS
  Bool_t           fFillEMCALCells;            // use data from EMCAL
  Bool_t           fFillPHOSCells;             // use data from PHOS
  Bool_t           fRecalculateClusters;       // Correct clusters, recalculate them if recalibration parameters is given
  Bool_t           fCorrectELinearity;         // Correct cluster linearity, always on
  Bool_t           fSelectEmbeddedClusters;    // Use only simulated clusters that come from embedding.
  
  Bool_t           fSmearShowerShape;          // Smear shower shape (use in MC)
  Float_t          fSmearShowerShapeWidth;     // Smear shower shape landau function "width" (use in MC)
  TRandom3         fRandom ;                   //! Random generator
  
  ULong_t          fTrackStatus        ;       // Track selection bit, select tracks refitted in TPC, ITS ...
  Bool_t           fSelectSPDHitTracks ;       // Ensure that track hits SPD layers
  Int_t            fTrackMult          ;       // Track multiplicity
  Float_t          fTrackMultEtaCut    ;       // Track multiplicity eta cut
  
  Bool_t           fReadStack          ;       // Access kine information from stack
  Bool_t	         fReadAODMCParticles ;       // Access kine information from filtered AOD MC particles
	
  TString          fDeltaAODFileName   ;       // Delta AOD file name
  TString          fFiredTriggerClassName;     // Name of trigger event type used to do the analysis

	// Trigger bit
  UInt_t           fEventTriggerMask ;         // select this triggerered event
  UInt_t           fMixEventTriggerMask ;      // select this triggerered event for mixing, tipically kMB or kAnyINT
  Bool_t           fEventTriggerAtSE;          // select triggered event at SE base task or here
  
	Bool_t           fEventTrigMinBias ;         // Event is min bias on its name, it should correspond to AliVEvent::kMB, AliVEvent::kAnyInt
	Bool_t           fEventTrigCentral ;         // Event is AliVEvent::kCentral on its name,  it should correspond to PbPb
	Bool_t           fEventTrigSemiCentral ;     // Event is AliVEvent::kSemiCentral on its name,  it should correspond to PbPb 
	Bool_t           fEventTrigEMCALL0 ;         // Event is EMCal L0 on its name, it should correspond to AliVEvent::kEMC7, AliVEvent::kEMC1
	Bool_t           fEventTrigEMCALL1Gamma1 ;   // Event is L1-Gamma, threshold 1 on its name,  it should correspond kEMCEGA
	Bool_t           fEventTrigEMCALL1Gamma2 ;   // Event is L1-Gamma, threshold 2 on its name,  it should correspond kEMCEGA  
	Bool_t           fEventTrigEMCALL1Jet1 ;     // Event is L1-Gamma, threshold 1 on its name,  it should correspond kEMCEGA
	Bool_t           fEventTrigEMCALL1Jet2 ;     // Event is L1-Gamma, threshold 2 on its name,  it should correspond kEMCEGA  
	
	Int_t            fBitEGA;                    // Trigger bit on VCaloTrigger for EGA
	Int_t            fBitEJE;                    // Trigger bit on VCaloTrigger for EJE
	
  Bool_t           fAnaLED;                    // Analyze LED data only.

  TString          fTaskName;                  // Name of task that executes the analysis
	
  AliCalorimeterUtils * fCaloUtils ;           //  Pointer to CalorimeterUtils

  AliMixedEvent  * fMixedEvent  ;              //! mixed event object. This class is not the owner
  Int_t            fNMixedEvent ;              // number of events in mixed event buffer
  Double_t      ** fVertex      ;              //! vertex array 3 dim for each mixed event buffer
  
  TList **         fListMixedTracksEvents ;    //! Container for tracks stored for different events, used in case of own mixing, set in analysis class
  TList **         fListMixedCaloEvents;       //! Container for photon stored for different events, used in case of own mixing, set in analysis class
  Int_t            fLastMixedTracksEvent  ;    //  Temporary container with the last event added to the mixing list for tracks
  Int_t            fLastMixedCaloEvent ;       //  Temporary container with the last event added to the mixing list for photons
  
  Bool_t           fWriteOutputDeltaAOD;       // Write the created delta AOD objects into file  
  
  Int_t            fV0ADC[2]    ;              // Integrated V0 signal
  Int_t            fV0Mul[2]    ;              // Integrated V0 Multiplicity

  TString          fEMCALClustersListName;     // Alternative list of clusters produced elsewhere and not from InputEvent
  
  // Event selection
  Float_t          fZvtxCut ;	                   // Cut on vertex position
  Bool_t           fAcceptFastCluster;           // Accept events from fast cluster, exclude these events for LHC11a
  Bool_t           fRemoveLEDEvents;             // Remove events where LED was wrongly firing - EMCAL LHC11a
  
  Bool_t           fRemoveBadTriggerEvents;      // Remove triggered events because trigger was exotic, bad, or out of BC
  Bool_t           fTriggerPatchClusterMatch;    // Search for the trigger patch and check if associated cluster was the trigger
  Int_t            fTriggerPatchTimeWindow[2];   // Trigger patch selection window
  
  Float_t          fTriggerL0EventThreshold;     // L0 Threshold to look for triggered events, set outside
  Float_t          fTriggerL1EventThreshold;     // L1 Threshold to look for triggered events, set in data
  Bool_t           fTriggerL1EventThresholdFix;  // L1 Threshold is fix and set outside
  
  Int_t            fTriggerClusterBC;            // Event triggered by a cluster in BC -5 0 to 5
  Int_t            fTriggerClusterIndex;         // Index in clusters array of trigger cluster
  Int_t            fTriggerClusterId;            // Id of trigger cluster (cluster->GetID())
  Bool_t           fIsExoticEvent;               // Exotic trigger event flag
  Bool_t           fIsBadCellEvent;              // Bad cell triggered event flag, any cell in cluster is bad
  Bool_t           fIsBadMaxCellEvent;           // Bad cell triggered event flag, only max energy cell is bad
  Bool_t           fIsTriggerMatch;              // Could match the event to a trigger patch?
  Bool_t           fIsTriggerMatchOpenCut[3];    // Could not match the event to a trigger patch?, retry opening cuts
  Bool_t           fTriggerClusterTimeRecal;     // In case cluster already calibrated, do not try to recalibrate even if recalib on in RecoUtils.
  Bool_t           fRemoveUnMatchedTriggers;     // Analyze events where trigger patch and cluster where found or not
  
  
  Bool_t           fDoPileUpEventRejection;      // Select pile-up events by SPD
  Bool_t           fDoV0ANDEventSelection;       // Select events depending on V0AND
  Bool_t           fDoVertexBCEventSelection;    // Select events with vertex on BC=0 or -100
  Bool_t           fDoRejectNoTrackEvents;       // Reject events with no selected tracks in event
  Bool_t           fUseEventsWithPrimaryVertex ; // Select events with primary vertex
  //AliTriggerAnalysis* fTriggerAnalysis;          // Access to trigger selection algorithm for V0AND calculation
  
  Bool_t           fTimeStampEventSelect;        // Select events within a fraction of data taking time
  Float_t          fTimeStampEventFracMin;       // Minimum value of time stamp fraction event
  Float_t          fTimeStampEventFracMax;       // Maximum value of time stamp fraction event
  Double_t         fTimeStampRunMin;             // Minimum value of time stamp in run
  Double_t         fTimeStampRunMax;             // Maximum value of time stamp in run
  
  Double_t         fPileUpParamSPD[5];           // Parameters to pass to method IsPileupFromSPD: Int_t minContributors,
                                                 // Double_t minZdist, 
                                                 // Double_t nSigmaZdist, 
                                                 // Double_t nSigmaDiamXY, 
                                                 // Double_t nSigmaDiamZ)
  
  // Pile-up in EMCal
  Int_t            fNPileUpClusters;             // Number of clusters with time avobe 20 ns
  Int_t            fNNonPileUpClusters;          // Number of clusters with time below 20 ns
  Int_t            fNPileUpClustersCut;          // Cut to select event as pile-up
  Int_t            fEMCalBCEvent[19];            // Fill one entry per event if there is a cluster in a given BC
  Int_t            fEMCalBCEventCut[19];         // Fill one entry per event if there is a cluster in a given BC, depend on cluster E, acceptance cut
  Int_t            fTrackBCEvent[19];            // Fill one entry per event if there is a track in a given BC
  Int_t            fTrackBCEventCut[19];         // Fill one entry per event if there is a track in a given BC, depend on track pT, acceptance cut
  Int_t            fVertexBC;                    // Vertex BC
  Bool_t           fRecalculateVertexBC;         // Recalculate vertex BC from tracks pointing to vertex
  
  //Centrality/Event plane
  TString          fCentralityClass;            // Name of selected centrality class     
  Int_t            fCentralityOpt;              // Option for the returned value of the centrality, possible options 5, 10, 100
  Int_t            fCentralityBin[2];           // Minimum and maximum value of the centrality for the analysis
  TString          fEventPlaneMethod;           // Name of event plane method, by default "Q"

  Bool_t           fAcceptOnlyHIJINGLabels;     // Select clusters or tracks that where generated by HIJING, reject other generators in case of cocktail
  Int_t            fNMCProducedMin;             // In case of cocktail, select particles in the list with label from this value
  Int_t            fNMCProducedMax;             // In case of cocktail, select particles in the list with label up to this value
  
  // jets
  Bool_t           fFillInputNonStandardJetBranch;  // Flag to use data from non standard jets
  TClonesArray *   fNonStandardJets;                //! temporal array with jets
  TString          fInputNonStandardJetBranchName;  // Name of non standard jet branch
  Bool_t           fFillInputBackgroundJetBranch;   // Flag to use data from background jets
  AliAODJetEventBackground * fBackgroundJets;       //! background jets
  TString          fInputBackgroundJetBranchName;   // Name of background jet branch

  TArrayI          fAcceptEventsWithBit;           // Accept events if trigger bit is on
  TArrayI          fRejectEventsWithBit;           // Reject events if trigger bit is on

  Bool_t           fRejectEMCalTriggerEventsWith2Tresholds; // Reject events EG2 also triggered by EG1 or EJ2 also triggered by EJ1
  
  TLorentzVector   fMomentum;                    //! Temporal TLorentzVector container, avoid declaration of  TLorentzVectors per event
  
  AliCaloTrackReader(              const AliCaloTrackReader & r) ; // cpy ctor
  AliCaloTrackReader & operator = (const AliCaloTrackReader & r) ; // cpy assignment
  
  ClassDef(AliCaloTrackReader,69)
  
} ;


#endif //ALICALOTRACKREADER_H



 AliCaloTrackReader.h:1
 AliCaloTrackReader.h:2
 AliCaloTrackReader.h:3
 AliCaloTrackReader.h:4
 AliCaloTrackReader.h:5
 AliCaloTrackReader.h:6
 AliCaloTrackReader.h:7
 AliCaloTrackReader.h:8
 AliCaloTrackReader.h:9
 AliCaloTrackReader.h:10
 AliCaloTrackReader.h:11
 AliCaloTrackReader.h:12
 AliCaloTrackReader.h:13
 AliCaloTrackReader.h:14
 AliCaloTrackReader.h:15
 AliCaloTrackReader.h:16
 AliCaloTrackReader.h:17
 AliCaloTrackReader.h:18
 AliCaloTrackReader.h:19
 AliCaloTrackReader.h:20
 AliCaloTrackReader.h:21
 AliCaloTrackReader.h:22
 AliCaloTrackReader.h:23
 AliCaloTrackReader.h:24
 AliCaloTrackReader.h:25
 AliCaloTrackReader.h:26
 AliCaloTrackReader.h:27
 AliCaloTrackReader.h:28
 AliCaloTrackReader.h:29
 AliCaloTrackReader.h:30
 AliCaloTrackReader.h:31
 AliCaloTrackReader.h:32
 AliCaloTrackReader.h:33
 AliCaloTrackReader.h:34
 AliCaloTrackReader.h:35
 AliCaloTrackReader.h:36
 AliCaloTrackReader.h:37
 AliCaloTrackReader.h:38
 AliCaloTrackReader.h:39
 AliCaloTrackReader.h:40
 AliCaloTrackReader.h:41
 AliCaloTrackReader.h:42
 AliCaloTrackReader.h:43
 AliCaloTrackReader.h:44
 AliCaloTrackReader.h:45
 AliCaloTrackReader.h:46
 AliCaloTrackReader.h:47
 AliCaloTrackReader.h:48
 AliCaloTrackReader.h:49
 AliCaloTrackReader.h:50
 AliCaloTrackReader.h:51
 AliCaloTrackReader.h:52
 AliCaloTrackReader.h:53
 AliCaloTrackReader.h:54
 AliCaloTrackReader.h:55
 AliCaloTrackReader.h:56
 AliCaloTrackReader.h:57
 AliCaloTrackReader.h:58
 AliCaloTrackReader.h:59
 AliCaloTrackReader.h:60
 AliCaloTrackReader.h:61
 AliCaloTrackReader.h:62
 AliCaloTrackReader.h:63
 AliCaloTrackReader.h:64
 AliCaloTrackReader.h:65
 AliCaloTrackReader.h:66
 AliCaloTrackReader.h:67
 AliCaloTrackReader.h:68
 AliCaloTrackReader.h:69
 AliCaloTrackReader.h:70
 AliCaloTrackReader.h:71
 AliCaloTrackReader.h:72
 AliCaloTrackReader.h:73
 AliCaloTrackReader.h:74
 AliCaloTrackReader.h:75
 AliCaloTrackReader.h:76
 AliCaloTrackReader.h:77
 AliCaloTrackReader.h:78
 AliCaloTrackReader.h:79
 AliCaloTrackReader.h:80
 AliCaloTrackReader.h:81
 AliCaloTrackReader.h:82
 AliCaloTrackReader.h:83
 AliCaloTrackReader.h:84
 AliCaloTrackReader.h:85
 AliCaloTrackReader.h:86
 AliCaloTrackReader.h:87
 AliCaloTrackReader.h:88
 AliCaloTrackReader.h:89
 AliCaloTrackReader.h:90
 AliCaloTrackReader.h:91
 AliCaloTrackReader.h:92
 AliCaloTrackReader.h:93
 AliCaloTrackReader.h:94
 AliCaloTrackReader.h:95
 AliCaloTrackReader.h:96
 AliCaloTrackReader.h:97
 AliCaloTrackReader.h:98
 AliCaloTrackReader.h:99
 AliCaloTrackReader.h:100
 AliCaloTrackReader.h:101
 AliCaloTrackReader.h:102
 AliCaloTrackReader.h:103
 AliCaloTrackReader.h:104
 AliCaloTrackReader.h:105
 AliCaloTrackReader.h:106
 AliCaloTrackReader.h:107
 AliCaloTrackReader.h:108
 AliCaloTrackReader.h:109
 AliCaloTrackReader.h:110
 AliCaloTrackReader.h:111
 AliCaloTrackReader.h:112
 AliCaloTrackReader.h:113
 AliCaloTrackReader.h:114
 AliCaloTrackReader.h:115
 AliCaloTrackReader.h:116
 AliCaloTrackReader.h:117
 AliCaloTrackReader.h:118
 AliCaloTrackReader.h:119
 AliCaloTrackReader.h:120
 AliCaloTrackReader.h:121
 AliCaloTrackReader.h:122
 AliCaloTrackReader.h:123
 AliCaloTrackReader.h:124
 AliCaloTrackReader.h:125
 AliCaloTrackReader.h:126
 AliCaloTrackReader.h:127
 AliCaloTrackReader.h:128
 AliCaloTrackReader.h:129
 AliCaloTrackReader.h:130
 AliCaloTrackReader.h:131
 AliCaloTrackReader.h:132
 AliCaloTrackReader.h:133
 AliCaloTrackReader.h:134
 AliCaloTrackReader.h:135
 AliCaloTrackReader.h:136
 AliCaloTrackReader.h:137
 AliCaloTrackReader.h:138
 AliCaloTrackReader.h:139
 AliCaloTrackReader.h:140
 AliCaloTrackReader.h:141
 AliCaloTrackReader.h:142
 AliCaloTrackReader.h:143
 AliCaloTrackReader.h:144
 AliCaloTrackReader.h:145
 AliCaloTrackReader.h:146
 AliCaloTrackReader.h:147
 AliCaloTrackReader.h:148
 AliCaloTrackReader.h:149
 AliCaloTrackReader.h:150
 AliCaloTrackReader.h:151
 AliCaloTrackReader.h:152
 AliCaloTrackReader.h:153
 AliCaloTrackReader.h:154
 AliCaloTrackReader.h:155
 AliCaloTrackReader.h:156
 AliCaloTrackReader.h:157
 AliCaloTrackReader.h:158
 AliCaloTrackReader.h:159
 AliCaloTrackReader.h:160
 AliCaloTrackReader.h:161
 AliCaloTrackReader.h:162
 AliCaloTrackReader.h:163
 AliCaloTrackReader.h:164
 AliCaloTrackReader.h:165
 AliCaloTrackReader.h:166
 AliCaloTrackReader.h:167
 AliCaloTrackReader.h:168
 AliCaloTrackReader.h:169
 AliCaloTrackReader.h:170
 AliCaloTrackReader.h:171
 AliCaloTrackReader.h:172
 AliCaloTrackReader.h:173
 AliCaloTrackReader.h:174
 AliCaloTrackReader.h:175
 AliCaloTrackReader.h:176
 AliCaloTrackReader.h:177
 AliCaloTrackReader.h:178
 AliCaloTrackReader.h:179
 AliCaloTrackReader.h:180
 AliCaloTrackReader.h:181
 AliCaloTrackReader.h:182
 AliCaloTrackReader.h:183
 AliCaloTrackReader.h:184
 AliCaloTrackReader.h:185
 AliCaloTrackReader.h:186
 AliCaloTrackReader.h:187
 AliCaloTrackReader.h:188
 AliCaloTrackReader.h:189
 AliCaloTrackReader.h:190
 AliCaloTrackReader.h:191
 AliCaloTrackReader.h:192
 AliCaloTrackReader.h:193
 AliCaloTrackReader.h:194
 AliCaloTrackReader.h:195
 AliCaloTrackReader.h:196
 AliCaloTrackReader.h:197
 AliCaloTrackReader.h:198
 AliCaloTrackReader.h:199
 AliCaloTrackReader.h:200
 AliCaloTrackReader.h:201
 AliCaloTrackReader.h:202
 AliCaloTrackReader.h:203
 AliCaloTrackReader.h:204
 AliCaloTrackReader.h:205
 AliCaloTrackReader.h:206
 AliCaloTrackReader.h:207
 AliCaloTrackReader.h:208
 AliCaloTrackReader.h:209
 AliCaloTrackReader.h:210
 AliCaloTrackReader.h:211
 AliCaloTrackReader.h:212
 AliCaloTrackReader.h:213
 AliCaloTrackReader.h:214
 AliCaloTrackReader.h:215
 AliCaloTrackReader.h:216
 AliCaloTrackReader.h:217
 AliCaloTrackReader.h:218
 AliCaloTrackReader.h:219
 AliCaloTrackReader.h:220
 AliCaloTrackReader.h:221
 AliCaloTrackReader.h:222
 AliCaloTrackReader.h:223
 AliCaloTrackReader.h:224
 AliCaloTrackReader.h:225
 AliCaloTrackReader.h:226
 AliCaloTrackReader.h:227
 AliCaloTrackReader.h:228
 AliCaloTrackReader.h:229
 AliCaloTrackReader.h:230
 AliCaloTrackReader.h:231
 AliCaloTrackReader.h:232
 AliCaloTrackReader.h:233
 AliCaloTrackReader.h:234
 AliCaloTrackReader.h:235
 AliCaloTrackReader.h:236
 AliCaloTrackReader.h:237
 AliCaloTrackReader.h:238
 AliCaloTrackReader.h:239
 AliCaloTrackReader.h:240
 AliCaloTrackReader.h:241
 AliCaloTrackReader.h:242
 AliCaloTrackReader.h:243
 AliCaloTrackReader.h:244
 AliCaloTrackReader.h:245
 AliCaloTrackReader.h:246
 AliCaloTrackReader.h:247
 AliCaloTrackReader.h:248
 AliCaloTrackReader.h:249
 AliCaloTrackReader.h:250
 AliCaloTrackReader.h:251
 AliCaloTrackReader.h:252
 AliCaloTrackReader.h:253
 AliCaloTrackReader.h:254
 AliCaloTrackReader.h:255
 AliCaloTrackReader.h:256
 AliCaloTrackReader.h:257
 AliCaloTrackReader.h:258
 AliCaloTrackReader.h:259
 AliCaloTrackReader.h:260
 AliCaloTrackReader.h:261
 AliCaloTrackReader.h:262
 AliCaloTrackReader.h:263
 AliCaloTrackReader.h:264
 AliCaloTrackReader.h:265
 AliCaloTrackReader.h:266
 AliCaloTrackReader.h:267
 AliCaloTrackReader.h:268
 AliCaloTrackReader.h:269
 AliCaloTrackReader.h:270
 AliCaloTrackReader.h:271
 AliCaloTrackReader.h:272
 AliCaloTrackReader.h:273
 AliCaloTrackReader.h:274
 AliCaloTrackReader.h:275
 AliCaloTrackReader.h:276
 AliCaloTrackReader.h:277
 AliCaloTrackReader.h:278
 AliCaloTrackReader.h:279
 AliCaloTrackReader.h:280
 AliCaloTrackReader.h:281
 AliCaloTrackReader.h:282
 AliCaloTrackReader.h:283
 AliCaloTrackReader.h:284
 AliCaloTrackReader.h:285
 AliCaloTrackReader.h:286
 AliCaloTrackReader.h:287
 AliCaloTrackReader.h:288
 AliCaloTrackReader.h:289
 AliCaloTrackReader.h:290
 AliCaloTrackReader.h:291
 AliCaloTrackReader.h:292
 AliCaloTrackReader.h:293
 AliCaloTrackReader.h:294
 AliCaloTrackReader.h:295
 AliCaloTrackReader.h:296
 AliCaloTrackReader.h:297
 AliCaloTrackReader.h:298
 AliCaloTrackReader.h:299
 AliCaloTrackReader.h:300
 AliCaloTrackReader.h:301
 AliCaloTrackReader.h:302
 AliCaloTrackReader.h:303
 AliCaloTrackReader.h:304
 AliCaloTrackReader.h:305
 AliCaloTrackReader.h:306
 AliCaloTrackReader.h:307
 AliCaloTrackReader.h:308
 AliCaloTrackReader.h:309
 AliCaloTrackReader.h:310
 AliCaloTrackReader.h:311
 AliCaloTrackReader.h:312
 AliCaloTrackReader.h:313
 AliCaloTrackReader.h:314
 AliCaloTrackReader.h:315
 AliCaloTrackReader.h:316
 AliCaloTrackReader.h:317
 AliCaloTrackReader.h:318
 AliCaloTrackReader.h:319
 AliCaloTrackReader.h:320
 AliCaloTrackReader.h:321
 AliCaloTrackReader.h:322
 AliCaloTrackReader.h:323
 AliCaloTrackReader.h:324
 AliCaloTrackReader.h:325
 AliCaloTrackReader.h:326
 AliCaloTrackReader.h:327
 AliCaloTrackReader.h:328
 AliCaloTrackReader.h:329
 AliCaloTrackReader.h:330
 AliCaloTrackReader.h:331
 AliCaloTrackReader.h:332
 AliCaloTrackReader.h:333
 AliCaloTrackReader.h:334
 AliCaloTrackReader.h:335
 AliCaloTrackReader.h:336
 AliCaloTrackReader.h:337
 AliCaloTrackReader.h:338
 AliCaloTrackReader.h:339
 AliCaloTrackReader.h:340
 AliCaloTrackReader.h:341
 AliCaloTrackReader.h:342
 AliCaloTrackReader.h:343
 AliCaloTrackReader.h:344
 AliCaloTrackReader.h:345
 AliCaloTrackReader.h:346
 AliCaloTrackReader.h:347
 AliCaloTrackReader.h:348
 AliCaloTrackReader.h:349
 AliCaloTrackReader.h:350
 AliCaloTrackReader.h:351
 AliCaloTrackReader.h:352
 AliCaloTrackReader.h:353
 AliCaloTrackReader.h:354
 AliCaloTrackReader.h:355
 AliCaloTrackReader.h:356
 AliCaloTrackReader.h:357
 AliCaloTrackReader.h:358
 AliCaloTrackReader.h:359
 AliCaloTrackReader.h:360
 AliCaloTrackReader.h:361
 AliCaloTrackReader.h:362
 AliCaloTrackReader.h:363
 AliCaloTrackReader.h:364
 AliCaloTrackReader.h:365
 AliCaloTrackReader.h:366
 AliCaloTrackReader.h:367
 AliCaloTrackReader.h:368
 AliCaloTrackReader.h:369
 AliCaloTrackReader.h:370
 AliCaloTrackReader.h:371
 AliCaloTrackReader.h:372
 AliCaloTrackReader.h:373
 AliCaloTrackReader.h:374
 AliCaloTrackReader.h:375
 AliCaloTrackReader.h:376
 AliCaloTrackReader.h:377
 AliCaloTrackReader.h:378
 AliCaloTrackReader.h:379
 AliCaloTrackReader.h:380
 AliCaloTrackReader.h:381
 AliCaloTrackReader.h:382
 AliCaloTrackReader.h:383
 AliCaloTrackReader.h:384
 AliCaloTrackReader.h:385
 AliCaloTrackReader.h:386
 AliCaloTrackReader.h:387
 AliCaloTrackReader.h:388
 AliCaloTrackReader.h:389
 AliCaloTrackReader.h:390
 AliCaloTrackReader.h:391
 AliCaloTrackReader.h:392
 AliCaloTrackReader.h:393
 AliCaloTrackReader.h:394
 AliCaloTrackReader.h:395
 AliCaloTrackReader.h:396
 AliCaloTrackReader.h:397
 AliCaloTrackReader.h:398
 AliCaloTrackReader.h:399
 AliCaloTrackReader.h:400
 AliCaloTrackReader.h:401
 AliCaloTrackReader.h:402
 AliCaloTrackReader.h:403
 AliCaloTrackReader.h:404
 AliCaloTrackReader.h:405
 AliCaloTrackReader.h:406
 AliCaloTrackReader.h:407
 AliCaloTrackReader.h:408
 AliCaloTrackReader.h:409
 AliCaloTrackReader.h:410
 AliCaloTrackReader.h:411
 AliCaloTrackReader.h:412
 AliCaloTrackReader.h:413
 AliCaloTrackReader.h:414
 AliCaloTrackReader.h:415
 AliCaloTrackReader.h:416
 AliCaloTrackReader.h:417
 AliCaloTrackReader.h:418
 AliCaloTrackReader.h:419
 AliCaloTrackReader.h:420
 AliCaloTrackReader.h:421
 AliCaloTrackReader.h:422
 AliCaloTrackReader.h:423
 AliCaloTrackReader.h:424
 AliCaloTrackReader.h:425
 AliCaloTrackReader.h:426
 AliCaloTrackReader.h:427
 AliCaloTrackReader.h:428
 AliCaloTrackReader.h:429
 AliCaloTrackReader.h:430
 AliCaloTrackReader.h:431
 AliCaloTrackReader.h:432
 AliCaloTrackReader.h:433
 AliCaloTrackReader.h:434
 AliCaloTrackReader.h:435
 AliCaloTrackReader.h:436
 AliCaloTrackReader.h:437
 AliCaloTrackReader.h:438
 AliCaloTrackReader.h:439
 AliCaloTrackReader.h:440
 AliCaloTrackReader.h:441
 AliCaloTrackReader.h:442
 AliCaloTrackReader.h:443
 AliCaloTrackReader.h:444
 AliCaloTrackReader.h:445
 AliCaloTrackReader.h:446
 AliCaloTrackReader.h:447
 AliCaloTrackReader.h:448
 AliCaloTrackReader.h:449
 AliCaloTrackReader.h:450
 AliCaloTrackReader.h:451
 AliCaloTrackReader.h:452
 AliCaloTrackReader.h:453
 AliCaloTrackReader.h:454
 AliCaloTrackReader.h:455
 AliCaloTrackReader.h:456
 AliCaloTrackReader.h:457
 AliCaloTrackReader.h:458
 AliCaloTrackReader.h:459
 AliCaloTrackReader.h:460
 AliCaloTrackReader.h:461
 AliCaloTrackReader.h:462
 AliCaloTrackReader.h:463
 AliCaloTrackReader.h:464
 AliCaloTrackReader.h:465
 AliCaloTrackReader.h:466
 AliCaloTrackReader.h:467
 AliCaloTrackReader.h:468
 AliCaloTrackReader.h:469
 AliCaloTrackReader.h:470
 AliCaloTrackReader.h:471
 AliCaloTrackReader.h:472
 AliCaloTrackReader.h:473
 AliCaloTrackReader.h:474
 AliCaloTrackReader.h:475
 AliCaloTrackReader.h:476
 AliCaloTrackReader.h:477
 AliCaloTrackReader.h:478
 AliCaloTrackReader.h:479
 AliCaloTrackReader.h:480
 AliCaloTrackReader.h:481
 AliCaloTrackReader.h:482
 AliCaloTrackReader.h:483
 AliCaloTrackReader.h:484
 AliCaloTrackReader.h:485
 AliCaloTrackReader.h:486
 AliCaloTrackReader.h:487
 AliCaloTrackReader.h:488
 AliCaloTrackReader.h:489
 AliCaloTrackReader.h:490
 AliCaloTrackReader.h:491
 AliCaloTrackReader.h:492
 AliCaloTrackReader.h:493
 AliCaloTrackReader.h:494
 AliCaloTrackReader.h:495
 AliCaloTrackReader.h:496
 AliCaloTrackReader.h:497
 AliCaloTrackReader.h:498
 AliCaloTrackReader.h:499
 AliCaloTrackReader.h:500
 AliCaloTrackReader.h:501
 AliCaloTrackReader.h:502
 AliCaloTrackReader.h:503
 AliCaloTrackReader.h:504
 AliCaloTrackReader.h:505
 AliCaloTrackReader.h:506
 AliCaloTrackReader.h:507
 AliCaloTrackReader.h:508
 AliCaloTrackReader.h:509
 AliCaloTrackReader.h:510
 AliCaloTrackReader.h:511
 AliCaloTrackReader.h:512
 AliCaloTrackReader.h:513
 AliCaloTrackReader.h:514
 AliCaloTrackReader.h:515
 AliCaloTrackReader.h:516
 AliCaloTrackReader.h:517
 AliCaloTrackReader.h:518
 AliCaloTrackReader.h:519
 AliCaloTrackReader.h:520
 AliCaloTrackReader.h:521
 AliCaloTrackReader.h:522
 AliCaloTrackReader.h:523
 AliCaloTrackReader.h:524
 AliCaloTrackReader.h:525
 AliCaloTrackReader.h:526
 AliCaloTrackReader.h:527
 AliCaloTrackReader.h:528
 AliCaloTrackReader.h:529
 AliCaloTrackReader.h:530
 AliCaloTrackReader.h:531
 AliCaloTrackReader.h:532
 AliCaloTrackReader.h:533
 AliCaloTrackReader.h:534
 AliCaloTrackReader.h:535
 AliCaloTrackReader.h:536
 AliCaloTrackReader.h:537
 AliCaloTrackReader.h:538
 AliCaloTrackReader.h:539
 AliCaloTrackReader.h:540
 AliCaloTrackReader.h:541
 AliCaloTrackReader.h:542
 AliCaloTrackReader.h:543
 AliCaloTrackReader.h:544
 AliCaloTrackReader.h:545
 AliCaloTrackReader.h:546
 AliCaloTrackReader.h:547
 AliCaloTrackReader.h:548
 AliCaloTrackReader.h:549
 AliCaloTrackReader.h:550
 AliCaloTrackReader.h:551
 AliCaloTrackReader.h:552
 AliCaloTrackReader.h:553
 AliCaloTrackReader.h:554
 AliCaloTrackReader.h:555
 AliCaloTrackReader.h:556
 AliCaloTrackReader.h:557
 AliCaloTrackReader.h:558
 AliCaloTrackReader.h:559
 AliCaloTrackReader.h:560
 AliCaloTrackReader.h:561
 AliCaloTrackReader.h:562
 AliCaloTrackReader.h:563
 AliCaloTrackReader.h:564
 AliCaloTrackReader.h:565
 AliCaloTrackReader.h:566
 AliCaloTrackReader.h:567
 AliCaloTrackReader.h:568
 AliCaloTrackReader.h:569
 AliCaloTrackReader.h:570
 AliCaloTrackReader.h:571
 AliCaloTrackReader.h:572
 AliCaloTrackReader.h:573
 AliCaloTrackReader.h:574
 AliCaloTrackReader.h:575
 AliCaloTrackReader.h:576
 AliCaloTrackReader.h:577
 AliCaloTrackReader.h:578
 AliCaloTrackReader.h:579
 AliCaloTrackReader.h:580
 AliCaloTrackReader.h:581
 AliCaloTrackReader.h:582
 AliCaloTrackReader.h:583
 AliCaloTrackReader.h:584
 AliCaloTrackReader.h:585
 AliCaloTrackReader.h:586
 AliCaloTrackReader.h:587
 AliCaloTrackReader.h:588
 AliCaloTrackReader.h:589
 AliCaloTrackReader.h:590
 AliCaloTrackReader.h:591
 AliCaloTrackReader.h:592
 AliCaloTrackReader.h:593
 AliCaloTrackReader.h:594
 AliCaloTrackReader.h:595
 AliCaloTrackReader.h:596
 AliCaloTrackReader.h:597
 AliCaloTrackReader.h:598
 AliCaloTrackReader.h:599
 AliCaloTrackReader.h:600
 AliCaloTrackReader.h:601
 AliCaloTrackReader.h:602
 AliCaloTrackReader.h:603
 AliCaloTrackReader.h:604
 AliCaloTrackReader.h:605
 AliCaloTrackReader.h:606
 AliCaloTrackReader.h:607
 AliCaloTrackReader.h:608
 AliCaloTrackReader.h:609
 AliCaloTrackReader.h:610
 AliCaloTrackReader.h:611
 AliCaloTrackReader.h:612
 AliCaloTrackReader.h:613
 AliCaloTrackReader.h:614
 AliCaloTrackReader.h:615
 AliCaloTrackReader.h:616
 AliCaloTrackReader.h:617
 AliCaloTrackReader.h:618
 AliCaloTrackReader.h:619
 AliCaloTrackReader.h:620
 AliCaloTrackReader.h:621
 AliCaloTrackReader.h:622
 AliCaloTrackReader.h:623
 AliCaloTrackReader.h:624
 AliCaloTrackReader.h:625
 AliCaloTrackReader.h:626
 AliCaloTrackReader.h:627
 AliCaloTrackReader.h:628
 AliCaloTrackReader.h:629
 AliCaloTrackReader.h:630
 AliCaloTrackReader.h:631
 AliCaloTrackReader.h:632
 AliCaloTrackReader.h:633
 AliCaloTrackReader.h:634
 AliCaloTrackReader.h:635
 AliCaloTrackReader.h:636
 AliCaloTrackReader.h:637
 AliCaloTrackReader.h:638
 AliCaloTrackReader.h:639
 AliCaloTrackReader.h:640
 AliCaloTrackReader.h:641
 AliCaloTrackReader.h:642
 AliCaloTrackReader.h:643
 AliCaloTrackReader.h:644
 AliCaloTrackReader.h:645
 AliCaloTrackReader.h:646
 AliCaloTrackReader.h:647
 AliCaloTrackReader.h:648
 AliCaloTrackReader.h:649
 AliCaloTrackReader.h:650
 AliCaloTrackReader.h:651
 AliCaloTrackReader.h:652
 AliCaloTrackReader.h:653
 AliCaloTrackReader.h:654
 AliCaloTrackReader.h:655
 AliCaloTrackReader.h:656
 AliCaloTrackReader.h:657
 AliCaloTrackReader.h:658
 AliCaloTrackReader.h:659
 AliCaloTrackReader.h:660
 AliCaloTrackReader.h:661
 AliCaloTrackReader.h:662
 AliCaloTrackReader.h:663
 AliCaloTrackReader.h:664
 AliCaloTrackReader.h:665
 AliCaloTrackReader.h:666
 AliCaloTrackReader.h:667
 AliCaloTrackReader.h:668
 AliCaloTrackReader.h:669
 AliCaloTrackReader.h:670
 AliCaloTrackReader.h:671
 AliCaloTrackReader.h:672
 AliCaloTrackReader.h:673
 AliCaloTrackReader.h:674
 AliCaloTrackReader.h:675
 AliCaloTrackReader.h:676
 AliCaloTrackReader.h:677
 AliCaloTrackReader.h:678
 AliCaloTrackReader.h:679
 AliCaloTrackReader.h:680
 AliCaloTrackReader.h:681
 AliCaloTrackReader.h:682
 AliCaloTrackReader.h:683
 AliCaloTrackReader.h:684
 AliCaloTrackReader.h:685
 AliCaloTrackReader.h:686
 AliCaloTrackReader.h:687
 AliCaloTrackReader.h:688
 AliCaloTrackReader.h:689
 AliCaloTrackReader.h:690
 AliCaloTrackReader.h:691
 AliCaloTrackReader.h:692
 AliCaloTrackReader.h:693
 AliCaloTrackReader.h:694
 AliCaloTrackReader.h:695
 AliCaloTrackReader.h:696
 AliCaloTrackReader.h:697
 AliCaloTrackReader.h:698
 AliCaloTrackReader.h:699
 AliCaloTrackReader.h:700
 AliCaloTrackReader.h:701
 AliCaloTrackReader.h:702
 AliCaloTrackReader.h:703
 AliCaloTrackReader.h:704
 AliCaloTrackReader.h:705
 AliCaloTrackReader.h:706
 AliCaloTrackReader.h:707
 AliCaloTrackReader.h:708
 AliCaloTrackReader.h:709
 AliCaloTrackReader.h:710
 AliCaloTrackReader.h:711
 AliCaloTrackReader.h:712
 AliCaloTrackReader.h:713
 AliCaloTrackReader.h:714
 AliCaloTrackReader.h:715
 AliCaloTrackReader.h:716
 AliCaloTrackReader.h:717
 AliCaloTrackReader.h:718
 AliCaloTrackReader.h:719
 AliCaloTrackReader.h:720
 AliCaloTrackReader.h:721
 AliCaloTrackReader.h:722
 AliCaloTrackReader.h:723
 AliCaloTrackReader.h:724
 AliCaloTrackReader.h:725
 AliCaloTrackReader.h:726
 AliCaloTrackReader.h:727
 AliCaloTrackReader.h:728
 AliCaloTrackReader.h:729
 AliCaloTrackReader.h:730
 AliCaloTrackReader.h:731
 AliCaloTrackReader.h:732
 AliCaloTrackReader.h:733
 AliCaloTrackReader.h:734
 AliCaloTrackReader.h:735
 AliCaloTrackReader.h:736
 AliCaloTrackReader.h:737
 AliCaloTrackReader.h:738
 AliCaloTrackReader.h:739
 AliCaloTrackReader.h:740
 AliCaloTrackReader.h:741
 AliCaloTrackReader.h:742
 AliCaloTrackReader.h:743
 AliCaloTrackReader.h:744
 AliCaloTrackReader.h:745
 AliCaloTrackReader.h:746
 AliCaloTrackReader.h:747
 AliCaloTrackReader.h:748
 AliCaloTrackReader.h:749
 AliCaloTrackReader.h:750
 AliCaloTrackReader.h:751
 AliCaloTrackReader.h:752
 AliCaloTrackReader.h:753
 AliCaloTrackReader.h:754
 AliCaloTrackReader.h:755
 AliCaloTrackReader.h:756
 AliCaloTrackReader.h:757
 AliCaloTrackReader.h:758
 AliCaloTrackReader.h:759
 AliCaloTrackReader.h:760
 AliCaloTrackReader.h:761
 AliCaloTrackReader.h:762
 AliCaloTrackReader.h:763
 AliCaloTrackReader.h:764
 AliCaloTrackReader.h:765
 AliCaloTrackReader.h:766
 AliCaloTrackReader.h:767
 AliCaloTrackReader.h:768
 AliCaloTrackReader.h:769
 AliCaloTrackReader.h:770
 AliCaloTrackReader.h:771
 AliCaloTrackReader.h:772
 AliCaloTrackReader.h:773
 AliCaloTrackReader.h:774
 AliCaloTrackReader.h:775
 AliCaloTrackReader.h:776
 AliCaloTrackReader.h:777
 AliCaloTrackReader.h:778
 AliCaloTrackReader.h:779
 AliCaloTrackReader.h:780
 AliCaloTrackReader.h:781
 AliCaloTrackReader.h:782
 AliCaloTrackReader.h:783
 AliCaloTrackReader.h:784
 AliCaloTrackReader.h:785
 AliCaloTrackReader.h:786
 AliCaloTrackReader.h:787
 AliCaloTrackReader.h:788
 AliCaloTrackReader.h:789
 AliCaloTrackReader.h:790
 AliCaloTrackReader.h:791
 AliCaloTrackReader.h:792
 AliCaloTrackReader.h:793
 AliCaloTrackReader.h:794
 AliCaloTrackReader.h:795
 AliCaloTrackReader.h:796
 AliCaloTrackReader.h:797
 AliCaloTrackReader.h:798
 AliCaloTrackReader.h:799
 AliCaloTrackReader.h:800
 AliCaloTrackReader.h:801
 AliCaloTrackReader.h:802
 AliCaloTrackReader.h:803
 AliCaloTrackReader.h:804
 AliCaloTrackReader.h:805
 AliCaloTrackReader.h:806
 AliCaloTrackReader.h:807
 AliCaloTrackReader.h:808
 AliCaloTrackReader.h:809
 AliCaloTrackReader.h:810
 AliCaloTrackReader.h:811
 AliCaloTrackReader.h:812
 AliCaloTrackReader.h:813
 AliCaloTrackReader.h:814
 AliCaloTrackReader.h:815
 AliCaloTrackReader.h:816
 AliCaloTrackReader.h:817
 AliCaloTrackReader.h:818
 AliCaloTrackReader.h:819
 AliCaloTrackReader.h:820
 AliCaloTrackReader.h:821
 AliCaloTrackReader.h:822
 AliCaloTrackReader.h:823
 AliCaloTrackReader.h:824
 AliCaloTrackReader.h:825
 AliCaloTrackReader.h:826
 AliCaloTrackReader.h:827
 AliCaloTrackReader.h:828
 AliCaloTrackReader.h:829
 AliCaloTrackReader.h:830
 AliCaloTrackReader.h:831
 AliCaloTrackReader.h:832
 AliCaloTrackReader.h:833
 AliCaloTrackReader.h:834
 AliCaloTrackReader.h:835
 AliCaloTrackReader.h:836
 AliCaloTrackReader.h:837
 AliCaloTrackReader.h:838
 AliCaloTrackReader.h:839
 AliCaloTrackReader.h:840
 AliCaloTrackReader.h:841
 AliCaloTrackReader.h:842