AliCaloTrackReader.h

Go to the documentation of this file.

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

//_________________________________________________________________________
//_________________________________________________________________________

// --- 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 AliHeader; 
class AliGenEventHeader; 
class AliGenPythiaEventHeader; 
class AliAODEvent;
class AliMCEvent;
class AliMixedEvent;
class AliAODMCHeader;
class AliCentrality;
class AliMultSelection;
class AliESDtrackCuts;
//class AliTriggerAnalysis;
class AliEventplane;
class AliVCluster;
#include "AliLog.h"

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

// 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           ; }
  
  virtual TObjString *  GetListOfParameters() ;
  
  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   ; } 
  
  virtual TList * GetCreateControlHistograms() ;
  void            SetControlHistogramEnergyBinning(Int_t nBins, Float_t emin, Float_t emax)
  { fEnergyHistogramNbins = nBins ; fEnergyHistogramLimit[0] = emin; fEnergyHistogramLimit[1] = emax ; }
  
  //------------------------------------------------------------
  // 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 } ;
  
  enum smearingFunction     { kNoSmearing, kSmearingLandau, kSmearingLandauShift           } ;

  // 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  en)              { SetEMCALPtMin(en)             ; }
  void             SetPHOSEMin  (Float_t  en)              { SetPHOSPtMin (en)             ; }
  void             SetEMCALEMax (Float_t  en)              { SetEMCALPtMax(en)             ; }
  void             SetPHOSEMax  (Float_t  en)              { SetPHOSPtMax (en)             ; }
  
  virtual Int_t    GetTrackID(AliVTrack* track) ;
  
  // Distance to bad channels cut
  
  Float_t          GetEMCALBadChannelMinDist()       const { return fEMCALBadChMinDist     ; }
  Float_t          GetPHOSBadChannelMinDist()        const { return fPHOSBadChMinDist      ; }

  void             SetEMCALBadChannelMinDist(Float_t di)   { fEMCALBadChMinDist = di       ; }
  void             SetPHOSBadChannelMinDist (Float_t di)   { fPHOSBadChMinDist  = di       ; }

  // Number of cells in cluster cut
  
  Int_t            GetEMCALNCellsCut()               const { return fEMCALNCellsCut       ; }
  Int_t            GetPHOSNCellsCut()                const { return fPHOSNCellsCut        ; }
    
  void             SetEMCALNCellsCut(Int_t nc)             { fEMCALNCellsCut = nc         ; }
  void             SetPHOSNCellsCut (Int_t nc)             { fPHOSNCellsCut  = nc         ; }
  
  // 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           IsEmbeddedClusterSelectionOn()    const { return fSelectEmbeddedClusters   ; }
  void             SwitchOnEmbeddedClustersSelection()     { fSelectEmbeddedClusters = kTRUE  ; }
  void             SwitchOffEmbeddedClustersSelection()    { fSelectEmbeddedClusters = kFALSE ; }

  // Shower shape smearing function
  
  void             SetSmearingFunction(Int_t smfu)         { fSmearingFunction = smfu      ; }
  Int_t            GetSmearingFunction()             const { return fSmearingFunction      ; }
  
  Bool_t           IsShowerShapeSmeared()            const { return fSmearShowerShape      ; }
  void             SwitchOnShowerShapeSmearing()           { fSmearShowerShape = kTRUE     ; }
  void             SwitchOffShowerShapeSmearing()          { fSmearShowerShape = kFALSE    ; }
  
  void             SetShowerShapeSmearWidth(Float_t w )    { fSmearShowerShapeWidth = w    ; }
  
  void             SetSmearingNLMRange(Int_t mi, Int_t ma) { fSmearNLMMin = mi ; fSmearNLMMax = ma ; }
  
  // 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  ; }

  void             SetEMCALCellsListName(TString &name)    { fEMCALCellsListName = name     ; }
  TString          GetEMCALCellsListName()           const { return fEMCALCellsListName     ; }
  
  // 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(Int_t opt = 1) { fRemoveLEDEvents       = opt    ; }
  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);
  void             SetEMCALTriggerThresholds();
  
  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   ; }

  // Time Stamp CTP corrected
    
  Double_t         GetTimeStampEventCTPBCCorrMin()   const { return fTimeStampEventCTPBCCorrMin ; }
  Double_t         GetTimeStampEventCTPBCCorrMax()   const { return fTimeStampEventCTPBCCorrMax ; }
  
  void             SetTimeStampEventCTPBCCorrRange(Double_t a, Double_t b) { 
                                                             fTimeStampEventCTPBCCorrMin = a    ;
                                                             fTimeStampEventCTPBCCorrMax = b    ; } // seconds
  
  void             SwitchOnExcludeEventTimeCTPBCCorrStamp() { fTimeStampEventCTPBCCorrExclude = kTRUE   ; }
  void             SwitchOffExcludeEventTimeCTPBCCorrStamp(){ fTimeStampEventCTPBCCorrExclude = kFALSE  ; }
  
  Bool_t           IsExcludeEventTimeStampCTPBCCorrOn()     { return  fTimeStampEventCTPBCCorrExclude ; }

  
  // 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(Int_t cut=0) const 
  {  if(cut < 10)  return fTrackMult [cut] ; else return 0 ; }
  Float_t          GetTrackSumPt(Int_t cut=0) const 
  {  if(cut < 10)  return fTrackSumPt[cut] ; else return 0 ; }

  void             SetTrackMultiplicityNPtCut(Float_t ncut){ fTrackMultNPtCut = ncut      ; }
  Int_t            GetTrackMultiplicityNPtCut() const      { return fTrackMultNPtCut      ; }

  void             SetTrackMultiplicityPtCut(Int_t cut, Float_t  pt) {  if(cut < 10)  fTrackMultPtCut[cut] = pt; }
  Float_t          GetTrackMultiplicityPtCut(Int_t cut=0) const 
  {  if(cut < 10)  return fTrackMultPtCut[cut] ;  else return 0 ; }
 
  Float_t          GetTrackMultiplicityEtaCut()      const { return fTrackMultEtaCut      ; }
  void             SetTrackMultiplicityEtaCut(Float_t eta) { fTrackMultEtaCut = eta       ; }   
  
  // Virtual for AliCaloTrackAODReader
  
  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 AliCaloTrackESDReader
  
  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()       { ; }

  // Events species selection
  
  void             AnalyzeOnlyLEDEvents()                  { fEventType  = 8      ; }
  void             AnalyzeOnlyPhysicsEvents()              { fEventType  = 7      ; }
  void             AnalyzeOnlyEventsOfType(Int_t specie)   { fEventType  = specie ; }
  
  //-------------------------------
  // 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 AliMultSelection* GetMultSelCen()          const { 
    if(fDataType!=kMC) return (AliMultSelection * ) fInputEvent->FindListObject("MultSelection") ; 
    else               return 0x0                                                                ; } 

  virtual void     SwitchOnAliCentrality ()                { fUseAliCentrality  = kTRUE          ; }
  virtual void     SwitchOffAliCentrality()                { fUseAliCentrality  = kFALSE         ; }
  
  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                  ; }
    
  Double_t              GetEventWeight()             const { return fEventWeight                     ; }
  AliAnaWeights       * GetWeightUtils()                   { if ( !fWeightUtils ) fWeightUtils = new AliAnaWeights() ;
                                                             return               fWeightUtils       ; }

  virtual Double_t      GetBField()                  const { return fInputEvent->GetMagneticField()  ; }
  
  Float_t               GetPhi  (Float_t phi)        const { if ( phi < 0 ) phi += TMath::TwoPi() ; return phi ; }
  
  Float_t               DegToRad(Float_t deg)        const { deg *= TMath::DegToRad(); return deg ; }
  
  Float_t               RadToDeg(Float_t rad)        const { rad *= TMath::RadToDeg(); return rad ; }

  
  //------------------------------------------------
  // MC analysis specific methods
  //-------------------------------------------------
  
  // Kinematics and galice.root available
  
  virtual AliHeader*         GetHeader()            const ;
  virtual AliGenEventHeader* GetGenEventHeader()    const { return fGenEventHeader       ; }
  virtual AliGenPythiaEventHeader* GetGenPythiaEventHeader() 
                                                    const { return fGenPythiaEventHeader ; }
  // See implementation in AOD and ESD readers
  
  // 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()                         { AliError("Obsolete, remove this setting in AddTask") ; }
  void             SwitchOffStack()                        { AliError("Obsolete, remove this setting in AddTask") ; }
  void             SwitchOnAODMCParticles()                { AliError("Obsolete, remove this setting in AddTask") ; }
  void             SwitchOffAODMCParticles()               { AliError("Obsolete, remove this setting in AddTask") ; }

  void             RemapMCLabelForAODs(Int_t &label);
  
  // Select generated events, depending on comparison of pT hard and jets
    
  virtual Bool_t   ComparePtHardAndJetPt(Int_t process, TString processName) ;
  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(Int_t process, TString processName) ;
  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   ; }   
  
  // Select particles or clusters depending on generator
  virtual void     SetNumberOfMCGeneratorsToAccept(Int_t nGen) 
  { fNMCGenerToAccept = nGen ; 
    if      ( nGen > 5 ) fNMCGenerToAccept = 5 ; 
    else if ( nGen < 0 ) fNMCGenerToAccept = 0 ; }
  virtual Int_t    GetNumberOfMCGeneratorsToAccept()         const { return fNMCGenerToAccept ; } 
  
  virtual void     SetNameOfMCGeneratorsToAccept(Int_t ig, TString name) 
  { if ( ig < 5 && ig >= 0 ) fMCGenerToAccept[ig] = name ; }  
  virtual void     SetIndexOfMCGeneratorsToAccept(Int_t ig, Int_t index) 
  { if ( ig < 5 && ig >= 0 ) fMCGenerIndexToAccept[ig] = index ; }  
  virtual TString GetNameOfMCGeneratorsToAccept(Int_t ig)   const { return fMCGenerToAccept[ig] ; }
  virtual Int_t   GetIndexOfMCGeneratorsToAccept(Int_t ig)  const { return fMCGenerIndexToAccept[ig] ; }
  
  Bool_t           AcceptParticleMCLabel(Int_t mcLabel)     const ;
  Int_t            GetCocktailGeneratorAndIndex(Int_t index, TString & nameGen) const ;
  TString          GetGeneratorNameAndIndex(Int_t index, Int_t & genIndex) const ;

  virtual void     SetNameOfMCEventHederGeneratorToAccept(TString name) { fMCGenerEventHeaderToAccept = name ; }
  virtual TString  GetNameOfMCEventHederGeneratorToAccept()       const { return fMCGenerEventHeaderToAccept ; }
  
  
  
  // 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;                   
  Int_t            fDataType ;                     
  Int_t            fDebug;                         
  AliFiducialCut * fFiducialCut;                   
  Bool_t           fCheckFidCut ;                  

  Bool_t           fComparePtHardAndJetPt;         
  Float_t          fPtHardAndJetPtFactor;          

  Bool_t           fComparePtHardAndClusterPt;     
  Float_t          fPtHardAndClusterPtFactor;      
  
  Float_t          fCTSPtMin;                      
  Float_t          fEMCALPtMin;                    
  Float_t          fPHOSPtMin;                     
  Float_t          fCTSPtMax;                      
  Float_t          fEMCALPtMax;                    
  Float_t          fPHOSPtMax;                     
  
  Float_t          fEMCALBadChMinDist ;            
  Float_t          fPHOSBadChMinDist ;             

  Int_t            fEMCALNCellsCut ;               
  Int_t            fPHOSNCellsCut ;                
  
  Bool_t           fUseEMCALTimeCut;               
  Bool_t           fUseParamTimeCut;               
  Bool_t           fUseTrackTimeCut;               
  Bool_t           fAccessTrackTOF;                
  Double_t         fEMCALTimeCutMin;               
  Double_t         fEMCALTimeCutMax;               
  Float_t          fEMCALParamTimeCutMin[4];       
  Double_t         fEMCALParamTimeCutMax[4];       
  Double_t         fTrackTimeCutMin;               
  Double_t         fTrackTimeCutMax;               
  
  Bool_t           fUseTrackDCACut;                
  Double_t         fTrackDCACut[3];                

  TList          * fAODBranchList ;                //-> 
  
  TObjArray      * fCTSTracks ;                    //-> 
  
  TObjArray      * fEMCALClusters ;                //-> 

  TObjArray      * fDCALClusters ;                 //-> 
  
  TObjArray      * fPHOSClusters ;                 //-> 
  
  AliVCaloCells  * fEMCALCells ;                   
  AliVCaloCells  * fPHOSCells ;                    

  AliVEvent      * fInputEvent;                    
  AliAODEvent    * fOutputEvent;                   
  AliMCEvent     * fMC;                            

  Bool_t           fFillCTS;                       
  Bool_t           fFillEMCAL;                     
  Bool_t           fFillDCAL;                      
  Bool_t           fFillPHOS;                      
  Bool_t           fFillEMCALCells;                
  Bool_t           fFillPHOSCells;                 
  Bool_t           fRecalculateClusters;           
  Bool_t           fCorrectELinearity;             
  Bool_t           fSelectEmbeddedClusters;        
  
  Bool_t           fSmearShowerShape;              
  Float_t          fSmearShowerShapeWidth;         
  TRandom3         fRandom ;                       
  Int_t            fSmearingFunction;              
  Int_t            fSmearNLMMin ;                  
  Int_t            fSmearNLMMax ;                  
  
  // Track selection and counting
  ULong_t          fTrackStatus        ;           
  Bool_t           fSelectSPDHitTracks ;           
  
  Int_t            fTrackMult[10]      ;           
  Float_t          fTrackSumPt[10]     ;           
  Int_t            fTrackMultNPtCut    ;           
  Float_t          fTrackMultPtCut[10] ;           
  Float_t          fTrackMultEtaCut    ;           
    
  TString          fDeltaAODFileName   ;           
  TString          fFiredTriggerClassName;         

  // Trigger bit
  UInt_t           fEventTriggerMask ;             
  UInt_t           fMixEventTriggerMask ;          
  Bool_t           fEventTriggerAtSE;              
  
  Bool_t           fEventTrigMinBias ;             
  Bool_t           fEventTrigCentral ;             
  Bool_t           fEventTrigSemiCentral ;         
  Bool_t           fEventTrigEMCALL0 ;             
  Bool_t           fEventTrigEMCALL1Gamma1 ;       
  Bool_t           fEventTrigEMCALL1Gamma2 ;       
  Bool_t           fEventTrigEMCALL1Jet1 ;         
  Bool_t           fEventTrigEMCALL1Jet2 ;         
  
  Int_t            fBitEGA;                        
  Int_t            fBitEJE;                        
  
  Int_t            fEventType;                     

  TString          fTaskName;                      
  
  AliCalorimeterUtils * fCaloUtils ;               

  AliAnaWeights  * fWeightUtils ;                  
  Double_t         fEventWeight ;                  
    
  AliMixedEvent  * fMixedEvent  ;                  
  Int_t            fNMixedEvent ;                  
  Double_t      ** fVertex      ;                  
  
  TList **         fListMixedTracksEvents;         
  TList **         fListMixedCaloEvents  ;         
  Int_t            fLastMixedTracksEvent ;         
  Int_t            fLastMixedCaloEvent   ;         
   
  Bool_t           fWriteOutputDeltaAOD;           
  
  Int_t            fV0ADC[2]    ;                  
  Int_t            fV0Mul[2]    ;                  

  TString          fEMCALClustersListName;         
  TString          fEMCALCellsListName;            
  
  //  Event selection
  
  Float_t          fZvtxCut ;                      
  Bool_t           fAcceptFastCluster;             
  Int_t            fRemoveLEDEvents;               
  
  Bool_t           fRemoveBadTriggerEvents;        
  Bool_t           fTriggerPatchClusterMatch;      
  Int_t            fTriggerPatchTimeWindow[2];     
  
  Float_t          fTriggerL0EventThreshold;       
  Float_t          fTriggerL1EventThreshold;       
  Bool_t           fTriggerL1EventThresholdFix;    
  
  Int_t            fTriggerClusterBC;              
  Int_t            fTriggerClusterIndex;           
  Int_t            fTriggerClusterId;              
  Bool_t           fIsExoticEvent;                 
  Bool_t           fIsBadCellEvent;                
  Bool_t           fIsBadMaxCellEvent;             
  Bool_t           fIsTriggerMatch;                
  Bool_t           fIsTriggerMatchOpenCut[3];      
  Bool_t           fTriggerClusterTimeRecal;       
  Bool_t           fRemoveUnMatchedTriggers;       
  
  
  Bool_t           fDoPileUpEventRejection;        
  Bool_t           fDoV0ANDEventSelection;         
  Bool_t           fDoVertexBCEventSelection;      
  Bool_t           fDoRejectNoTrackEvents;         
  Bool_t           fUseEventsWithPrimaryVertex ;   
//AliTriggerAnalysis* fTriggerAnalysis;            ///<  Access to trigger selection algorithm for V0AND calculation.
  
  Bool_t           fTimeStampEventSelect;          
  Float_t          fTimeStampEventFracMin;         
  Float_t          fTimeStampEventFracMax;         
  Double_t         fTimeStampRunMin;               
  Double_t         fTimeStampRunMax;               
  
  Bool_t           fTimeStampEventCTPBCCorrExclude; 
  Double_t         fTimeStampEventCTPBCCorrMin;    
  Double_t         fTimeStampEventCTPBCCorrMax;    
  
  Double_t         fPileUpParamSPD[5];
    
  // Pile-up in EMCal
  
  Int_t            fNPileUpClusters;               
  Int_t            fNNonPileUpClusters;            
  Int_t            fNPileUpClustersCut;            
  Int_t            fEMCalBCEvent[19];              
  Int_t            fEMCalBCEventCut[19];           
  Int_t            fTrackBCEvent[19];              
  Int_t            fTrackBCEventCut[19];           
  Int_t            fVertexBC;                      
  Bool_t           fRecalculateVertexBC;           
  
  // Centrality/Event plane
  Bool_t           fUseAliCentrality;              
  TString          fCentralityClass;               
  Int_t            fCentralityOpt;                 
  Int_t            fCentralityBin[2];              
  TString          fEventPlaneMethod;              

  // Jets
  Bool_t           fFillInputNonStandardJetBranch; 
  TClonesArray *   fNonStandardJets;               
  TString          fInputNonStandardJetBranchName; 
  Bool_t           fFillInputBackgroundJetBranch;  
  AliAODJetEventBackground * fBackgroundJets;      
  TString          fInputBackgroundJetBranchName;  

  TArrayI          fAcceptEventsWithBit;           
  TArrayI          fRejectEventsWithBit;           

  Bool_t           fRejectEMCalTriggerEventsWith2Tresholds; 
  
  TLorentzVector   fMomentum;                      
    
  // cut control histograms
  
  TList *          fOutputContainer;               
  TH2F  *          fhEMCALClusterEtaPhi;           
  TH2F  *          fhEMCALClusterEtaPhiFidCut;     
  TH2F  *          fhEMCALClusterTimeE;            
  TH1F  *          fhEMCALClusterCutsE[8];         
  TH1F  *          fhPHOSClusterCutsE [7];         
  TH1F  *          fhCTSTrackCutsPt   [6];         
 
  Float_t          fEnergyHistogramLimit[2];       
  Int_t            fEnergyHistogramNbins ;         
  
  TH1I  *          fhNEventsAfterCut;              

  // MC labels to accept
  Int_t            fNMCGenerToAccept;              
  TString          fMCGenerToAccept[5];            
  Int_t            fMCGenerIndexToAccept[5];       

  TString          fMCGenerEventHeaderToAccept;    
  
  
  AliGenEventHeader       * fGenEventHeader;       
  AliGenPythiaEventHeader * fGenPythiaEventHeader; 
  
  AliCaloTrackReader(              const AliCaloTrackReader & r) ; 
  
  AliCaloTrackReader & operator = (const AliCaloTrackReader & r) ; 
  
  ClassDef(AliCaloTrackReader,80) ;

} ;

#endif //ALICALOTRACKREADER_H