AliPhysics/vAN-20180109/_ali_calo_track_reader_8h_source.html

 #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 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 0x0                    ; }

   // 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() ;

   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   ; }


   // 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  *          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;


   AliCaloTrackReader(              const AliCaloTrackReader & r) ;


   AliCaloTrackReader & operator = (const AliCaloTrackReader & r) ;


   ClassDef(AliCaloTrackReader,79) ;


 } ;


 #endif //ALICALOTRACKREADER_H


AliCaloTrackReader::IsPileUpFromSPD
Bool_t IsPileUpFromSPD() const
Definition: AliCaloTrackReader.cxx:1189

AliCaloTrackReader::GetDebug
virtual Int_t GetDebug() const
Definition: AliCaloTrackReader.h:79

AliCaloTrackReader::GetZvertexCut
virtual Float_t GetZvertexCut() const
Definition: AliCaloTrackReader.h:567

AliCaloTrackReader::IsBadMaxCellTriggerEvent
Bool_t IsBadMaxCellTriggerEvent() const
Definition: AliCaloTrackReader.h:358

AliCaloTrackReader::SwitchOnLEDEventsRemoval
void SwitchOnLEDEventsRemoval(Int_t opt=1)
Definition: AliCaloTrackReader.h:326

AliCaloTrackReader::fEventWeight
Double_t fEventWeight
Weight assigned to the event when filling histograms.
Definition: AliCaloTrackReader.h:872

AliFiducialCut::kPHOS
Definition: AliFiducialCut.h:126

AliCaloTrackReader::fUseTrackDCACut
Bool_t fUseTrackDCACut
Do DCA selection.
Definition: AliCaloTrackReader.h:793

AliCaloTrackReader::SwitchOnAODTrackSharedClusterSelection
virtual void SwitchOnAODTrackSharedClusterSelection()
Definition: AliCaloTrackReader.h:535

AliCaloTrackReader::SetDebug
virtual void SetDebug(Int_t d)
Definition: AliCaloTrackReader.h:80

AliCaloTrackReader::GetTaskName
TString GetTaskName() const
Definition: AliCaloTrackReader.h:90

AliCaloTrackReader::SwitchOffConstrainTrackToVertex
virtual void SwitchOffConstrainTrackToVertex()
Definition: AliCaloTrackReader.h:550

TTree
Definition: External.C:140

AliCaloTrackReader::SetLastCaloMixedEvent
void SetLastCaloMixedEvent(Int_t e)
Definition: AliCaloTrackReader.h:618

AliAnaWeights.h

AliCaloTrackReader::GetTriggerPatches
TArrayI GetTriggerPatches(Int_t tmin, Int_t tmax)
Definition: AliCaloTrackReader.cxx:2542

AliCaloTrackReader::FillInputVZERO
virtual void FillInputVZERO()
Definition: AliCaloTrackReader.cxx:2442

AliCaloTrackReader::GetMC
virtual AliMCEvent * GetMC() const
Definition: AliCaloTrackReader.h:669

AliCaloTrackReader::fV0ADC
Int_t fV0ADC[2]
Integrated V0 signal.
Definition: AliCaloTrackReader.h:885

AliCaloTrackReader::fComparePtHardAndClusterPt
Bool_t fComparePtHardAndClusterPt
In MonteCarlo, jet events, reject events with too large cluster energy.
Definition: AliCaloTrackReader.h:766

AliCaloTrackReader::kESD
Definition: AliCaloTrackReader.h:82

AliCaloTrackReader::fWeightUtils
AliAnaWeights * fWeightUtils
Pointer to AliAnaWeights.
Definition: AliCaloTrackReader.h:871

AliCaloTrackReader::SetShowerShapeSmearWidth
void SetShowerShapeSmearWidth(Float_t w)
Definition: AliCaloTrackReader.h:274

AliCaloTrackReader::GetNPileUpClusters
Int_t GetNPileUpClusters()
Definition: AliCaloTrackReader.h:478

AliCaloTrackReader::fTimeStampEventCTPBCCorrMax
Double_t fTimeStampEventCTPBCCorrMax
Maximum value of time stamp corrected by CTP in run.
Definition: AliCaloTrackReader.h:932

AliCaloTrackReader::GetCaloUtils
AliCalorimeterUtils * GetCaloUtils() const
Definition: AliCaloTrackReader.h:633

AliCaloTrackReader::fTimeStampEventFracMin
Float_t fTimeStampEventFracMin
Minimum value of time stamp fraction event.
Definition: AliCaloTrackReader.h:925

AliCaloTrackReader::AnalyzeOnlyEventsOfType
void AnalyzeOnlyEventsOfType(Int_t specie)
Definition: AliCaloTrackReader.h:556

AliCaloTrackReader::SwitchOffUseEMCALTimeCut
void SwitchOffUseEMCALTimeCut()
Definition: AliCaloTrackReader.h:212

Double_t
double Double_t
Definition: External.C:58

AliCaloTrackReader::FillInputNonStandardJets
virtual void FillInputNonStandardJets()
Definition: AliCaloTrackReader.cxx:2475

AliCaloTrackReader::fEMCALTimeCutMax
Double_t fEMCALTimeCutMax
Remove clusters/cells with time larger than this value, in ns.
Definition: AliCaloTrackReader.h:787

AliCaloTrackReader::SetInputBackgroundJetBranchName
virtual void SetInputBackgroundJetBranchName(TString name)
Definition: AliCaloTrackReader.h:752

AliCaloTrackReader::kNoSmearing
Definition: AliCaloTrackReader.h:125

AliCaloTrackReader::SetEMCALPtMax
void SetEMCALPtMax(Float_t pt)
Definition: AliCaloTrackReader.h:139

AliCaloTrackReader::fBitEJE
Int_t fBitEJE
Trigger bit on VCaloTrigger for EJE.
Definition: AliCaloTrackReader.h:863

AliCaloTrackReader::SwitchOffUnMatchedTriggerEventsRemoval
void SwitchOffUnMatchedTriggerEventsRemoval()
Definition: AliCaloTrackReader.h:381

AliCaloTrackReader::GetListWithMixedEventsForTracks
TList * GetListWithMixedEventsForTracks(Int_t bi) const
Definition: AliCaloTrackReader.h:610

AliCaloTrackReader::fMomentum
TLorentzVector fMomentum
! Temporal TLorentzVector container, avoid declaration of TLorentzVectors per event.
Definition: AliCaloTrackReader.h:970

AliCaloTrackReader::SwitchOffBackgroundJets
void SwitchOffBackgroundJets()
Definition: AliCaloTrackReader.h:743

AliCaloTrackReader::fTimeStampRunMin
Double_t fTimeStampRunMin
Minimum value of time stamp in run.
Definition: AliCaloTrackReader.h:927

AliCaloTrackReader::fDoPileUpEventRejection
Bool_t fDoPileUpEventRejection
Select pile-up events by SPD.
Definition: AliCaloTrackReader.h:917

AliCaloTrackReader::GetNonStandardJets
virtual TClonesArray * GetNonStandardJets() const
Definition: AliCaloTrackReader.h:746

AliCaloTrackReader::GetEMCALCellsListName
TString GetEMCALCellsListName() const
Definition: AliCaloTrackReader.h:296

AliCaloTrackReader::fPHOSClusters
TObjArray * fPHOSClusters
Temporal array with PHOS CaloClusters.
Definition: AliCaloTrackReader.h:809

AliCaloTrackReader::GetGeneratorNameAndIndex
TString GetGeneratorNameAndIndex(Int_t index, Int_t &genIndex) const
Definition: AliCaloTrackReader.cxx:369

AliCaloTrackReader::fTrackDCACut
Double_t fTrackDCACut[3]
Remove tracks with DCA larger than cut, parameters of function stored here.
Definition: AliCaloTrackReader.h:794

AliCaloTrackReader::kAOD
Definition: AliCaloTrackReader.h:82

TH2F
Definition: External.C:236

AliFiducialCut::kDCAL
Definition: AliFiducialCut.h:126

AliCaloTrackReader::SwitchOnStatusSelection
virtual void SwitchOnStatusSelection()
Definition: AliCaloTrackReader.h:723

AliCaloTrackReader::fUseEventsWithPrimaryVertex
Bool_t fUseEventsWithPrimaryVertex
Select events with primary vertex.
Definition: AliCaloTrackReader.h:921

AliCaloTrackReader::SwitchOnFiducialCut
virtual void SwitchOnFiducialCut()
Definition: AliCaloTrackReader.h:224

AliCaloTrackReader::GetPHOSCells
virtual AliVCaloCells * GetPHOSCells() const
Definition: AliCaloTrackReader.h:305

AliCaloTrackReader::fIsBadCellEvent
Bool_t fIsBadCellEvent
Bad cell triggered event flag, any cell in cluster is bad.
Definition: AliCaloTrackReader.h:909

AliCaloTrackReader::fEventTrigEMCALL1Gamma1
Bool_t fEventTrigEMCALL1Gamma1
Event is L1-Gamma, threshold 1 on its name, it should correspond kEMCEGA.
Definition: AliCaloTrackReader.h:857

AliCaloTrackReader::SwitchOnRejectNoTrackEvents
void SwitchOnRejectNoTrackEvents()
Definition: AliCaloTrackReader.h:426

AliCaloTrackReader::AddStatusArray
virtual void AddStatusArray(TArrayI &)
Definition: AliCaloTrackReader.h:719

AliCaloTrackReader::GetHeader
virtual AliHeader * GetHeader() const
Definition: AliCaloTrackReader.cxx:916

AliCaloTrackReader::SwitchOffPi0Decay
virtual void SwitchOffPi0Decay()
Definition: AliCaloTrackReader.h:722

AliCaloTrackReader::CheckEventTriggers
Bool_t CheckEventTriggers()
Definition: AliCaloTrackReader.cxx:439

AliCaloTrackReader::IsEventEMCALL1Jet1
Bool_t IsEventEMCALL1Jet1() const
Definition: AliCaloTrackReader.h:399

AliCaloTrackReader::SetTriggerPatchTimeWindow
void SetTriggerPatchTimeWindow(Int_t min, Int_t max)
Definition: AliCaloTrackReader.h:373

AliCaloTrackReader::SetPHOSPtMax
void SetPHOSPtMax(Float_t pt)
Definition: AliCaloTrackReader.h:140

AliCaloTrackReader::IsEventEMCALL1Gamma1
Bool_t IsEventEMCALL1Gamma1() const
Definition: AliCaloTrackReader.h:397

AliCaloTrackReader::SwitchOnAODHybridTrackSelection
virtual void SwitchOnAODHybridTrackSelection()
Definition: AliCaloTrackReader.h:529

AliCaloTrackReader::GetNumberOfMCGeneratorsToAccept
virtual Int_t GetNumberOfMCGeneratorsToAccept() const
Definition: AliCaloTrackReader.h:699

AliCaloTrackReader::SwitchOnEMCALEventRejectionWith2Thresholds
void SwitchOnEMCALEventRejectionWith2Thresholds()
Definition: AliCaloTrackReader.h:405

AliCaloTrackReader::fRemoveLEDEvents
Int_t fRemoveLEDEvents
Remove events where LED was wrongly firing - only EMCAL LHC11a for this equal to 1, generalized to any SM for larger.
Definition: AliCaloTrackReader.h:895

AliCaloTrackReader::SetCentralityBin
virtual void SetCentralityBin(Int_t min, Int_t max)
Definition: AliCaloTrackReader.h:590

AliCaloTrackReader::SetPHOSPtMin
void SetPHOSPtMin(Float_t pt)
Definition: AliCaloTrackReader.h:137

AliCaloTrackReader::SwitchOnV0ANDSelection
void SwitchOnV0ANDSelection()
Definition: AliCaloTrackReader.h:414

AliCaloTrackReader::SwitchOffCTS
void SwitchOffCTS()
Definition: AliCaloTrackReader.h:232

AliCaloTrackReader::AreBadTriggerEventsRemoved
Bool_t AreBadTriggerEventsRemoved() const
Definition: AliCaloTrackReader.h:376

AliCaloTrackReader::SetEMCALTriggerThresholds
void SetEMCALTriggerThresholds()
Definition: AliCaloTrackReader.cxx:2985

AliCaloTrackReader::GetEventTimeStampFractionMax
Float_t GetEventTimeStampFractionMax() const
Definition: AliCaloTrackReader.h:439

AliCaloTrackReader::SwitchOffClusterRecalculation
void SwitchOffClusterRecalculation()
Definition: AliCaloTrackReader.h:256

AliCaloTrackReader::fSmearNLMMin
Int_t fSmearNLMMin
Do smearing for clusters with at least this value.
Definition: AliCaloTrackReader.h:832

AliCaloTrackReader::SwitchOffExcludeEventTimeCTPBCCorrStamp
void SwitchOffExcludeEventTimeCTPBCCorrStamp()
Definition: AliCaloTrackReader.h:459

AliCaloTrackReader::SetEMCALParametrizedMinTimeCut
void SetEMCALParametrizedMinTimeCut(Int_t i, Float_t par)
Definition: AliCaloTrackReader.h:208

AliCaloTrackReader::GetBField
virtual Double_t GetBField() const
Definition: AliCaloTrackReader.h:641

AliCaloTrackReader::SetMC
virtual void SetMC(AliMCEvent *const mc)
Definition: AliCaloTrackReader.h:99

AliCaloTrackReader::SetPHOSOverlapAngle
virtual void SetPHOSOverlapAngle(Float_t)
Definition: AliCaloTrackReader.h:731

AliCaloTrackReader::fEventPlaneMethod
TString fEventPlaneMethod
Name of event plane method, by default "Q".
Definition: AliCaloTrackReader.h:955

AliCaloTrackReader::GetNameOfMCEventHederGeneratorToAccept
virtual TString GetNameOfMCEventHederGeneratorToAccept() const
Definition: AliCaloTrackReader.h:713

AliCaloTrackReader::fTrackBCEventCut
Int_t fTrackBCEventCut[19]
Fill one entry per event if there is a track in a given BC, depend on track pT, acceptance cut...
Definition: AliCaloTrackReader.h:946

AliCaloTrackReader::SwitchOffClusterELinearityCorrection
void SwitchOffClusterELinearityCorrection()
Definition: AliCaloTrackReader.h:259

AliCaloTrackReader::GetEMCALClusters
virtual TObjArray * GetEMCALClusters() const
Definition: AliCaloTrackReader.h:301

AliCaloTrackReader::SetCTSPtMax
void SetCTSPtMax(Float_t pt)
Definition: AliCaloTrackReader.h:141

AliCaloTrackReader::fDoVertexBCEventSelection
Bool_t fDoVertexBCEventSelection
Select events with vertex on BC=0 or -100.
Definition: AliCaloTrackReader.h:919

AliCaloTrackReader::GetCTSPtMax
Float_t GetCTSPtMax() const
Definition: AliCaloTrackReader.h:134

AliCaloTrackReader::kCTS
Definition: AliCaloTrackReader.h:121

AliCaloTrackReader::SetInputOutputMCEvent
virtual void SetInputOutputMCEvent(AliVEvent *, AliAODEvent *, AliMCEvent *)
Definition: AliCaloTrackReader.h:100

AliCaloTrackReader::WriteDeltaAODToFile
Bool_t WriteDeltaAODToFile() const
Definition: AliCaloTrackReader.h:109

AliCaloTrackReader::SetListWithMixedEventsForTracks
void SetListWithMixedEventsForTracks(TList **l)
Definition: AliCaloTrackReader.h:625

AliCaloTrackReader::fhEMCALClusterTimeE
TH2F * fhEMCALClusterTimeE
! Control histogram on EMCAL timing
Definition: AliCaloTrackReader.h:976

AliCaloTrackReader::GetListWithMixedEventsForCalo
TList * GetListWithMixedEventsForCalo(Int_t bi) const
Definition: AliCaloTrackReader.h:609

AliCaloTrackReader::fMixedEvent
AliMixedEvent * fMixedEvent
! Mixed event object. This class is not the owner.
Definition: AliCaloTrackReader.h:874

AliCaloTrackReader::GetInputEvent
virtual AliVEvent * GetInputEvent() const
Definition: AliCaloTrackReader.h:666

AliCaloTrackReader::SwitchOnPileUpEventRejection
void SwitchOnPileUpEventRejection()
Definition: AliCaloTrackReader.h:410

AliCaloTrackReader::SwitchOnOnlyGeneratorParticles
virtual void SwitchOnOnlyGeneratorParticles()
Definition: AliCaloTrackReader.h:727

AliCaloTrackReader::SetSmearingFunction
void SetSmearingFunction(Int_t smfu)
Definition: AliCaloTrackReader.h:267

AliCaloTrackReader::IsPileUpFromSPDAndNotEMCal
Bool_t IsPileUpFromSPDAndNotEMCal() const
Check if event is from pile-up determined by SPD and not by EMCal.
Definition: AliCaloTrackReader.cxx:1226

AliCaloTrackReader::IsEventEMCALL1
Bool_t IsEventEMCALL1() const
Definition: AliCaloTrackReader.h:403

AliCaloTrackReader::IsTriggerPatchMatchedToCluster
Bool_t IsTriggerPatchMatchedToCluster() const
Definition: AliCaloTrackReader.h:384

AliCaloTrackReader::SwitchOnPHOS
void SwitchOnPHOS()
Definition: AliCaloTrackReader.h:243

AliCaloTrackReader::GetIndexOfMCGeneratorsToAccept
virtual Int_t GetIndexOfMCGeneratorsToAccept(Int_t ig) const
Definition: AliCaloTrackReader.h:706

AliCaloTrackReader::fPtHardAndClusterPtFactor
Float_t fPtHardAndClusterPtFactor
Factor between ptHard and cluster pT to reject/accept event.
Definition: AliCaloTrackReader.h:767

AliCaloTrackReader::fAcceptFastCluster
Bool_t fAcceptFastCluster
Accept events from fast cluster, exclude these events for LHC11a.
Definition: AliCaloTrackReader.h:894

AliCaloTrackReader::SetTrackComplementaryCuts
virtual void SetTrackComplementaryCuts(AliESDtrackCuts *)
Definition: AliCaloTrackReader.h:547

AliCaloTrackReader::fTrackTimeCutMin
Double_t fTrackTimeCutMin
Remove tracks with time smaller than this value, in ns.
Definition: AliCaloTrackReader.h:790

energy
energy
Definition: HFPtSpectrum.C:44

AliCaloTrackReader::SwitchOffUseTrackDCACut
void SwitchOffUseTrackDCACut()
Definition: AliCaloTrackReader.h:181

AliCaloTrackReader::IsPrimaryVertexSelectionDone
Bool_t IsPrimaryVertexSelectionDone() const
Definition: AliCaloTrackReader.h:424

AliCaloTrackReader::SetEMCALEMin
void SetEMCALEMin(Float_t en)
Definition: AliCaloTrackReader.h:148

AliCaloTrackReader::GetEMCALBadChannelMinDist
Float_t GetEMCALBadChannelMinDist() const
Definition: AliCaloTrackReader.h:157

AliCaloTrackReader::SwitchOffPHOSCells
void SwitchOffPHOSCells()
Definition: AliCaloTrackReader.h:252

AliCaloTrackReader::GetV0Signal
Int_t GetV0Signal(Int_t i) const
Definition: AliCaloTrackReader.h:289

AliCaloTrackReader::fSmearShowerShape
Bool_t fSmearShowerShape
Smear shower shape (use in MC).
Definition: AliCaloTrackReader.h:828

AliCaloTrackReader::SetTrackDCACut
void SetTrackDCACut(Int_t i, Float_t cut)
Definition: AliCaloTrackReader.h:177

AliCaloTrackReader::fInputEvent
AliVEvent * fInputEvent
! pointer to esd or aod input.
Definition: AliCaloTrackReader.h:814

AliCaloTrackReader::IsEventSemiCentral
Bool_t IsEventSemiCentral() const
Definition: AliCaloTrackReader.h:395

AliAnaWeights
Calculate the weight to the event to be applied when filling histograms.
Definition: AliAnaWeights.h:34

AliCaloTrackReader::SetInputEvent
virtual void SetInputEvent(AliVEvent *input)
Definition: AliCaloTrackReader.cxx:3404

AliCaloTrackReader::SetPileUpParamForEMCal
void SetPileUpParamForEMCal(Int_t param)
Definition: AliCaloTrackReader.h:476

AliCaloTrackReader::fTrackTimeCutMax
Double_t fTrackTimeCutMax
Remove tracks with time larger than this value, in ns.
Definition: AliCaloTrackReader.h:791

AliCaloTrackReader::AddNeutralParticlesArray
virtual void AddNeutralParticlesArray(TArrayI &)
Definition: AliCaloTrackReader.h:717

AliCaloTrackReader::fTriggerClusterBC
Int_t fTriggerClusterBC
Event triggered by a cluster in BC -5 0 to 5.
Definition: AliCaloTrackReader.h:905

AliCaloTrackReader::SwitchOnTriggerPatchMatching
void SwitchOnTriggerPatchMatching()
Definition: AliCaloTrackReader.h:386

AliCaloTrackReader::GetMultSelCen
virtual AliMultSelection * GetMultSelCen() const
Definition: AliCaloTrackReader.h:578

AliCaloTrackReader::fEMCALClustersListName
TString fEMCALClustersListName
Alternative list of clusters produced elsewhere and not from InputEvent.
Definition: AliCaloTrackReader.h:888

AliCaloTrackReader::GetTrackStatus
ULong_t GetTrackStatus() const
Definition: AliCaloTrackReader.h:498

AliCaloTrackReader::fPHOSBadChMinDist
Float_t fPHOSBadChMinDist
Minimal distance to bad channel to accept cluster in PHOS, cm.
Definition: AliCaloTrackReader.h:777

AliCaloTrackReader::kSmearingLandauShift
Definition: AliCaloTrackReader.h:125

AliCaloTrackReader::GetRunTimeStampMin
Double_t GetRunTimeStampMin() const
Definition: AliCaloTrackReader.h:432

AliFiducialCut::kEMCAL
Definition: AliFiducialCut.h:126

AliCaloTrackReader::fWriteOutputDeltaAOD
Bool_t fWriteOutputDeltaAOD
Write the created delta AOD objects into file.
Definition: AliCaloTrackReader.h:883

AliCaloTrackReader::SwitchOnNonStandardJets
void SwitchOnNonStandardJets()
Definition: AliCaloTrackReader.h:738

AliCaloTrackReader::SwitchOnStack
void SwitchOnStack()
Definition: AliCaloTrackReader.h:673

AliCaloTrackReader::SetNameOfMCEventHederGeneratorToAccept
virtual void SetNameOfMCEventHederGeneratorToAccept(TString name)
Definition: AliCaloTrackReader.h:712

AliCaloTrackReader::GetFiredTriggerClassName
TString GetFiredTriggerClassName() const
Definition: AliCaloTrackReader.h:332

AliCaloTrackReader::fV0Mul
Int_t fV0Mul[2]
Integrated V0 Multiplicity.
Definition: AliCaloTrackReader.h:886

AliCaloTrackReader::fEMCALPtMin
Float_t fEMCALPtMin
pT Threshold on emcal clusters.
Definition: AliCaloTrackReader.h:770

AliCaloTrackReader::SwitchOnEMCAL
void SwitchOnEMCAL()
Definition: AliCaloTrackReader.h:235

AliCaloTrackReader::fTriggerClusterTimeRecal
Bool_t fTriggerClusterTimeRecal
In case cluster already calibrated, do not try to recalibrate even if recalib on in AliEMCALRecoUtils...
Definition: AliCaloTrackReader.h:913

AliCaloTrackReader::fVertex
Double_t ** fVertex
! Vertex array 3 dim for each mixed event buffer.
Definition: AliCaloTrackReader.h:876

AliCaloTrackReader::RejectLEDEvents
Bool_t RejectLEDEvents()
Definition: AliCaloTrackReader.cxx:3099

AliCaloTrackReader::fhCTSTrackCutsPt
TH1F * fhCTSTrackCutsPt[6]
! Control histogram on the different CTS tracks selection cuts, pT
Definition: AliCaloTrackReader.h:979

AliCaloTrackReader::SwitchOnAODMCParticles
void SwitchOnAODMCParticles()
Definition: AliCaloTrackReader.h:675

AliCaloTrackReader::IsEventWithNoTrackRejectionDone
Bool_t IsEventWithNoTrackRejectionDone() const
Definition: AliCaloTrackReader.h:428

AliFiducialCut.h

AliCaloTrackReader::fEventTriggerMask
UInt_t fEventTriggerMask
Select this triggerered event.
Definition: AliCaloTrackReader.h:849

AliCaloTrackReader::GetEventCentrality
virtual Int_t GetEventCentrality() const
Definition: AliCaloTrackReader.cxx:1519

AliCaloTrackReader::GetEMCALTimeCutMax
Double_t GetEMCALTimeCutMax() const
Definition: AliCaloTrackReader.h:201

AliCaloTrackReader::GetSmearingFunction
Int_t GetSmearingFunction() const
Definition: AliCaloTrackReader.h:268

AliCaloTrackReader::SetTPCSharedClusterFraction
virtual void SetTPCSharedClusterFraction(Float_t)
Definition: AliCaloTrackReader.h:538

AliCaloTrackReader::GetCentrality
virtual AliCentrality * GetCentrality() const
Definition: AliCaloTrackReader.h:574

AliCaloTrackReader::fPHOSCells
AliVCaloCells * fPHOSCells
! Temporal array with PHOS AliVCaloCells.
Definition: AliCaloTrackReader.h:812

AliCaloTrackReader::fOutputContainer
TList * fOutputContainer
! Output container with cut control histograms.
Definition: AliCaloTrackReader.h:974

AliCaloTrackReader::IsEventEMCALL1Gamma2
Bool_t IsEventEMCALL1Gamma2() const
Definition: AliCaloTrackReader.h:398

AliCaloTrackReader::GetMixedEvent
virtual AliMixedEvent * GetMixedEvent() const
Definition: AliCaloTrackReader.h:670

AliCaloTrackReader::kEMCAL
Definition: AliCaloTrackReader.h:120

AliCaloTrackReader::fEnergyHistogramNbins
Int_t fEnergyHistogramNbins
Binning of the control histograms, min and max window.
Definition: AliCaloTrackReader.h:982

AliCaloTrackReader::fFillInputBackgroundJetBranch
Bool_t fFillInputBackgroundJetBranch
Flag to use data from background jets.
Definition: AliCaloTrackReader.h:961

AliCaloTrackReader::SetTrackEventBC
void SetTrackEventBC(Int_t bc)
Definition: AliCaloTrackReader.h:487

AliCaloTrackReader::ComparePtHardAndClusterPt
virtual Bool_t ComparePtHardAndClusterPt()
Definition: AliCaloTrackReader.cxx:689

AliCaloTrackReader::fAODBranchList
TList * fAODBranchList
List with AOD branches created and needed in analysis.
Definition: AliCaloTrackReader.h:797

AliCaloTrackReader::SwitchOffStatusSelection
virtual void SwitchOffStatusSelection()
Definition: AliCaloTrackReader.h:724

AliCaloTrackReader::IsTriggerMatchedOpenCuts
Bool_t IsTriggerMatchedOpenCuts(Int_t i) const
Definition: AliCaloTrackReader.h:360

AliCaloTrackReader::GetTrackMultiplicityPtCut
Float_t GetTrackMultiplicityPtCut(Int_t cut=0) const
Definition: AliCaloTrackReader.h:515

AliCaloTrackReader::RemapMCLabelForAODs
void RemapMCLabelForAODs(Int_t &label)
Definition: AliCaloTrackReader.cxx:3161

AliCaloTrackReader::GetEMCALEMin
Float_t GetEMCALEMin() const
Definition: AliCaloTrackReader.h:143

AliCaloTrackReader::fEventTrigSemiCentral
Bool_t fEventTrigSemiCentral
Event is AliVEvent::kSemiCentral on its name, it should correspond to PbPb.
Definition: AliCaloTrackReader.h:855

AliCaloTrackReader::SwitchOffPileUpEventRejection
void SwitchOffPileUpEventRejection()
Definition: AliCaloTrackReader.h:411

AliCaloTrackReader::fRandom
TRandom3 fRandom
! Random generator.
Definition: AliCaloTrackReader.h:830

AliCaloTrackReader::AcceptDCA
Bool_t AcceptDCA(Float_t pt, Float_t dca)
Definition: AliCaloTrackReader.cxx:236

AliCaloTrackReader::IsPileUpFromNotSPDAndNotEMCal
Bool_t IsPileUpFromNotSPDAndNotEMCal() const
Check if event not from pile-up determined neither by SPD nor by EMCal.
Definition: AliCaloTrackReader.cxx:1244

AliCaloTrackReader::GetPtHardAndJetFactor
virtual Float_t GetPtHardAndJetFactor() const
Definition: AliCaloTrackReader.h:685

AliCaloTrackReader::fFillCTS
Bool_t fFillCTS
Use data from CTS.
Definition: AliCaloTrackReader.h:818

AliCaloTrackReader::GetGenEventHeader
virtual AliGenEventHeader * GetGenEventHeader() const
Definition: AliCaloTrackReader.h:658

AliCaloTrackReader::SetTrackFilterMaskComplementary
virtual void SetTrackFilterMaskComplementary(ULong_t)
Definition: AliCaloTrackReader.h:527

AliCaloTrackReader::InitParameters
virtual void InitParameters()
Initialize the parameters with default.
Definition: AliCaloTrackReader.cxx:1030

AliCaloTrackReader::GetEMCALEMax
Float_t GetEMCALEMax() const
Definition: AliCaloTrackReader.h:145

AliCaloTrackReader::GetVertex
virtual void GetVertex(Double_t v[3]) const
Definition: AliCaloTrackReader.cxx:1598

AliCaloTrackReader::SwitchOffV0ANDSelection
void SwitchOffV0ANDSelection()
Definition: AliCaloTrackReader.h:415

AliCaloTrackReader::SetPtHardAndJetPtComparison
virtual void SetPtHardAndJetPtComparison(Bool_t compare)
Definition: AliCaloTrackReader.h:684

AliCaloTrackReader::SwitchOnEmbeddedClustersSelection
void SwitchOnEmbeddedClustersSelection()
Definition: AliCaloTrackReader.h:262

AliCaloTrackReader::fTrackMult
Int_t fTrackMult[10]
Track multiplicity, count for different pT cuts.
Definition: AliCaloTrackReader.h:839

AliCaloTrackReader::IsTriggerClusterTimeRecal
Bool_t IsTriggerClusterTimeRecal() const
Definition: AliCaloTrackReader.h:388

AliCaloTrackReader::SwitchOffOverlapCheck
virtual void SwitchOffOverlapCheck()
Definition: AliCaloTrackReader.h:726

AliCaloTrackReader::FillInputEvent
virtual Bool_t FillInputEvent(Int_t iEntry, const char *currentFileName)
Definition: AliCaloTrackReader.cxx:1259

AliCaloTrackReader::SetSmearingNLMRange
void SetSmearingNLMRange(Int_t mi, Int_t ma)
Definition: AliCaloTrackReader.h:276

AliCaloTrackReader::IsBackgroundJetsSwitchedOn
Bool_t IsBackgroundJetsSwitchedOn() const
Definition: AliCaloTrackReader.h:741

AliCaloTrackReader::SwitchOnWriteDeltaAOD
void SwitchOnWriteDeltaAOD()
Definition: AliCaloTrackReader.h:107

AliCaloTrackReader::detector
detector
Definition: AliCaloTrackReader.h:120

AliCaloTrackReader::SetTrackMultiplicityNPtCut
void SetTrackMultiplicityNPtCut(Float_t ncut)
Definition: AliCaloTrackReader.h:511

AliCaloTrackReader::fPHOSPtMin
Float_t fPHOSPtMin
pT Threshold on phos clusters.
Definition: AliCaloTrackReader.h:771

AliCaloTrackReader::SwitchOffEMCALCells
void SwitchOffEMCALCells()
Definition: AliCaloTrackReader.h:248

AliCaloTrackReader::fSelectEmbeddedClusters
Bool_t fSelectEmbeddedClusters
Use only simulated clusters that come from embedding.
Definition: AliCaloTrackReader.h:826

AliCaloTrackReader::fEventTrigMinBias
Bool_t fEventTrigMinBias
Event is min bias on its name, it should correspond to AliVEvent::kMB, AliVEvent::kAnyInt.
Definition: AliCaloTrackReader.h:853

AliCaloTrackReader::fEMCALParamTimeCutMin
Float_t fEMCALParamTimeCutMin[4]
Remove clusters/cells with time smaller than parametrized value, in ns.
Definition: AliCaloTrackReader.h:788

AliCaloTrackReader::fEventNumber
Int_t fEventNumber
Event number.
Definition: AliCaloTrackReader.h:757

AliCaloTrackReader::SwitchOffAODMCParticles
void SwitchOffAODMCParticles()
Definition: AliCaloTrackReader.h:676

AliCaloTrackReader::fTaskName
TString fTaskName
Name of task that executes the analysis.
Definition: AliCaloTrackReader.h:867

AliCaloTrackReader::SwitchOffEventTriggerAtSE
void SwitchOffEventTriggerAtSE()
Definition: AliCaloTrackReader.h:346

AliCaloTrackReader::SetCTSPtMin
void SetCTSPtMin(Float_t pt)
Definition: AliCaloTrackReader.h:138

AliCaloTrackReader::fRemoveBadTriggerEvents
Bool_t fRemoveBadTriggerEvents
Remove triggered events because trigger was exotic, bad, or out of BC.
Definition: AliCaloTrackReader.h:897

AliCaloTrackReader::fTrackMultPtCut
Float_t fTrackMultPtCut[10]
Track multiplicity and sum pt cuts list.
Definition: AliCaloTrackReader.h:842

AliCaloTrackReader::IsPileUpFromSPDOrEMCal
Bool_t IsPileUpFromSPDOrEMCal() const
Check if event is from pile-up determined by SPD or EMCal.
Definition: AliCaloTrackReader.cxx:1217

AliCaloTrackReader::IsPileUpFromEMCalAndNotSPD
Bool_t IsPileUpFromEMCalAndNotSPD() const
Check if event is from pile-up determined by EMCal, not by SPD.
Definition: AliCaloTrackReader.cxx:1235

AliCaloTrackReader::fEventTrigEMCALL1Gamma2
Bool_t fEventTrigEMCALL1Gamma2
Event is L1-Gamma, threshold 2 on its name, it should correspond kEMCEGA.
Definition: AliCaloTrackReader.h:858

AliCaloTrackReader::GetCentralityBin
virtual Float_t GetCentralityBin(Int_t i) const
Definition: AliCaloTrackReader.h:593

AliCaloTrackReader::SwitchOnUseTrackDCACut
void SwitchOnUseTrackDCACut()
Definition: AliCaloTrackReader.h:180

AliCaloTrackReader::SetEventTriggerMask
void SetEventTriggerMask(UInt_t evtTrig=AliVEvent::kAny)
Definition: AliCaloTrackReader.h:339

AliCaloTrackReader::GetRunTimeStampMax
Double_t GetRunTimeStampMax() const
Definition: AliCaloTrackReader.h:433

AliCaloTrackReader::fEventTrigEMCALL1Jet1
Bool_t fEventTrigEMCALL1Jet1
Event is L1-Gamma, threshold 1 on its name, it should correspond kEMCEGA.
Definition: AliCaloTrackReader.h:859

AliCaloTrackReader::SetEMCALParametrizedMaxTimeCut
void SetEMCALParametrizedMaxTimeCut(Int_t i, Float_t par)
Definition: AliCaloTrackReader.h:209

AliCaloTrackReader::GetEventNumber
virtual Int_t GetEventNumber() const
Definition: AliCaloTrackReader.h:86

AliCaloTrackReader::fTimeStampEventCTPBCCorrMin
Double_t fTimeStampEventCTPBCCorrMin
Minimum value of time stamp corrected by CTP in run.
Definition: AliCaloTrackReader.h:931

AliCaloTrackReader::fFillEMCALCells
Bool_t fFillEMCALCells
Use data from EMCAL.
Definition: AliCaloTrackReader.h:822

AliCaloTrackReader::SwitchOffVertexBCEventSelection
void SwitchOffVertexBCEventSelection()
Definition: AliCaloTrackReader.h:419

AliCaloTrackReader::SetPtHardAndClusterPtFactor
virtual void SetPtHardAndClusterPtFactor(Float_t factor)
Definition: AliCaloTrackReader.h:692

AliCaloTrackReader::fEnergyHistogramLimit
Float_t fEnergyHistogramLimit[2]
Binning of the control histograms, number of bins.
Definition: AliCaloTrackReader.h:981

AliCaloTrackReader::fTriggerClusterId
Int_t fTriggerClusterId
Id of trigger cluster (cluster->GetID()).
Definition: AliCaloTrackReader.h:907

AliCaloTrackReader::fPHOSNCellsCut
Int_t fPHOSNCellsCut
Accept for the analysis PHOS clusters with more than fNCellsCut cells.
Definition: AliCaloTrackReader.h:780

AliCaloTrackReader::fCTSPtMax
Float_t fCTSPtMax
pT Threshold on charged particles.
Definition: AliCaloTrackReader.h:772

AliCaloTrackReader::DeletePointers
void DeletePointers()
Definition: AliCaloTrackReader.cxx:160

AliCaloTrackReader::SetTaskName
void SetTaskName(TString name)
Definition: AliCaloTrackReader.h:91

AliCaloTrackReader::GetCocktailGeneratorAndIndex
Int_t GetCocktailGeneratorAndIndex(Int_t index, TString &nameGen) const
Definition: AliCaloTrackReader.cxx:309

AliCaloTrackReader::fEMCALParamTimeCutMax
Double_t fEMCALParamTimeCutMax[4]
Remove clusters/cells with time larger than parametrized value, in ns.
Definition: AliCaloTrackReader.h:789

AliCaloTrackReader::GetTimeStampEventCTPBCCorrMin
Double_t GetTimeStampEventCTPBCCorrMin() const
Definition: AliCaloTrackReader.h:451

AliCaloTrackReader::FillInputEMCALCells
virtual void FillInputEMCALCells()
Connects the array with EMCAL cells and the pointer.
Definition: AliCaloTrackReader.cxx:2422

AliCaloTrackReader::fFillPHOSCells
Bool_t fFillPHOSCells
Use data from PHOS.
Definition: AliCaloTrackReader.h:823

AliCaloTrackReader::GetEMCALCells
virtual AliVCaloCells * GetEMCALCells() const
Definition: AliCaloTrackReader.h:304

AliCaloTrackReader::fhEMCALClusterEtaPhi
TH2F * fhEMCALClusterEtaPhi
! Control histogram on EMCAL clusters acceptance, before fiducial cuts
Definition: AliCaloTrackReader.h:975

AliCaloTrackReader::SwitchOffStack
void SwitchOffStack()
Definition: AliCaloTrackReader.h:674

AliCaloTrackReader::GetPHOSNCellsCut
Int_t GetPHOSNCellsCut() const
Definition: AliCaloTrackReader.h:166

AliCaloTrackReader::GetPtHardAndClusterFactor
virtual Float_t GetPtHardAndClusterFactor() const
Definition: AliCaloTrackReader.h:691

AliCaloTrackReader::GetTrackFilterMaskComplementary
virtual ULong_t GetTrackFilterMaskComplementary() const
Definition: AliCaloTrackReader.h:526

AliCaloTrackReader::IsDCACutOn
Bool_t IsDCACutOn() const
Definition: AliCaloTrackReader.h:182

AliCaloTrackReader::SetListWithMixedEventsForCalo
void SetListWithMixedEventsForCalo(TList **l)
Definition: AliCaloTrackReader.h:621

AliCaloTrackReader::GetFiducialCut
virtual AliFiducialCut * GetFiducialCut()
Definition: AliCaloTrackReader.h:219

AliCaloTrackReader::SetCentralityOpt
virtual void SetCentralityOpt(Int_t opt)
Definition: AliCaloTrackReader.h:586

AliCaloTrackReader::fIsBadMaxCellEvent
Bool_t fIsBadMaxCellEvent
Bad cell triggered event flag, only max energy cell is bad.
Definition: AliCaloTrackReader.h:910

Int_t
int Int_t
Definition: External.C:63

AliCaloTrackReader::fSelectSPDHitTracks
Bool_t fSelectSPDHitTracks
Ensure that track hits SPD layers.
Definition: AliCaloTrackReader.h:837

AliCaloTrackReader::GetEventTriggerL0Threshold
Float_t GetEventTriggerL0Threshold() const
Definition: AliCaloTrackReader.h:366

AliCaloTrackReader::fFiredTriggerClassName
TString fFiredTriggerClassName
Name of trigger event type used to do the analysis.
Definition: AliCaloTrackReader.h:846

AliCaloTrackReader::GetPHOSEMin
Float_t GetPHOSEMin() const
Definition: AliCaloTrackReader.h:144

AliCaloTrackReader::GetAODMCParticles
virtual TClonesArray * GetAODMCParticles() const
Definition: AliCaloTrackReader.cxx:933

TH1I
Definition: External.C:204

AliCaloTrackReader::GetTrackMultiplicity
Int_t GetTrackMultiplicity(Int_t cut=0) const
Definition: AliCaloTrackReader.h:506

AliCaloTrackReader::GetFiredTriggerClasses
TString GetFiredTriggerClasses() const
Definition: AliCaloTrackReader.h:333

AliCaloTrackReader::SwitchOffAODPrimaryTrackSelection
virtual void SwitchOffAODPrimaryTrackSelection()
Definition: AliCaloTrackReader.h:533

UInt_t
unsigned int UInt_t
Definition: External.C:33

AliCaloTrackReader::fEMCALClusters
TObjArray * fEMCALClusters
Temporal array with EMCAL CaloClusters.
Definition: AliCaloTrackReader.h:803

AliCaloTrackReader::GetPHOSBadChannelMinDist
Float_t GetPHOSBadChannelMinDist() const
Definition: AliCaloTrackReader.h:158

AliCaloTrackReader::IsEventEMCALL1Jet
Bool_t IsEventEMCALL1Jet() const
Definition: AliCaloTrackReader.h:402

AliCaloTrackReader::GetPHOSEMax
Float_t GetPHOSEMax() const
Definition: AliCaloTrackReader.h:146

AliCaloTrackReader::fPHOSPtMax
Float_t fPHOSPtMax
pT Threshold on phos clusters.
Definition: AliCaloTrackReader.h:774

AliCaloTrackReader::GetAODBranchList
virtual TList * GetAODBranchList() const
Definition: AliCaloTrackReader.h:104

AliCaloTrackReader::SwitchOffShowerShapeSmearing
void SwitchOffShowerShapeSmearing()
Definition: AliCaloTrackReader.h:272

AliCaloTrackReader::fAccessTrackTOF
Bool_t fAccessTrackTOF
Access the track TOF, in case of problems when accessing GetTOFBunchCrossing.
Definition: AliCaloTrackReader.h:785

Float_t
float Float_t
Definition: External.C:68

AliCaloTrackReader::GetInputNonStandardJetBranchName
virtual TString GetInputNonStandardJetBranchName()
Definition: AliCaloTrackReader.h:748

AliCaloTrackReader::SetTrackStatus
void SetTrackStatus(ULong_t bit)
Definition: AliCaloTrackReader.h:499

AliCaloTrackReader::SwitchOnUseEMCALTimeCut
void SwitchOnUseEMCALTimeCut()
Definition: AliCaloTrackReader.h:211

AliCaloTrackReader::IsTriggerMatched
Bool_t IsTriggerMatched() const
Definition: AliCaloTrackReader.h:359

AliCaloTrackReader::IsPileUpEventRejectionDone
Bool_t IsPileUpEventRejectionDone() const
Definition: AliCaloTrackReader.h:412

AliCaloTrackReader::CheckForPrimaryVertex
virtual Bool_t CheckForPrimaryVertex() const
Definition: AliCaloTrackReader.h:566

AliCaloTrackReader::SwitchOffDCAL
void SwitchOffDCAL()
Definition: AliCaloTrackReader.h:240

AliCaloTrackReader::fEMCalBCEvent
Int_t fEMCalBCEvent[19]
Fill one entry per event if there is a cluster in a given BC.
Definition: AliCaloTrackReader.h:943

AliCaloTrackReader::SetOutputEvent
virtual void SetOutputEvent(AliAODEvent *aod)
Definition: AliCaloTrackReader.h:98

AliCaloTrackReader::fInputBackgroundJetBranchName
TString fInputBackgroundJetBranchName
Name of background jet branch.
Definition: AliCaloTrackReader.h:963

AliCaloTrackReader::SetLastTracksMixedEvent
void SetLastTracksMixedEvent(Int_t e)
Definition: AliCaloTrackReader.h:619

AliCaloTrackReader::GetEventPlane
virtual AliEventplane * GetEventPlane() const
Definition: AliCaloTrackReader.h:596

AliCaloTrackReader::fEventTriggerAtSE
Bool_t fEventTriggerAtSE
Select triggered event at SE base task or here.
Definition: AliCaloTrackReader.h:851

AliCaloTrackReader::IsLEDEventRemoved
Bool_t IsLEDEventRemoved() const
Definition: AliCaloTrackReader.h:328

AliCaloTrackReader::fNMCGenerToAccept
Int_t fNMCGenerToAccept
Number of MC generators that should not be included in analysis.
Definition: AliCaloTrackReader.h:987

AliCaloTrackReader::SetControlHistogramEnergyBinning
void SetControlHistogramEnergyBinning(Int_t nBins, Float_t emin, Float_t emax)
Definition: AliCaloTrackReader.h:112

AliCaloTrackReader::fEMCALPtMax
Float_t fEMCALPtMax
pT Threshold on emcal clusters.
Definition: AliCaloTrackReader.h:773

AliCaloTrackReader::SetNumberOfMCGeneratorsToAccept
virtual void SetNumberOfMCGeneratorsToAccept(Int_t nGen)
Definition: AliCaloTrackReader.h:695

AliCaloTrackReader::fEventType
Int_t fEventType
Set the event species: 7 physics, 0 MC, 8 LED (not useful now)
Definition: AliCaloTrackReader.h:865

AliCaloTrackReader::kDCAL
Definition: AliCaloTrackReader.h:121

AliCaloTrackReader::ComparePtHardAndJetPt
virtual Bool_t ComparePtHardAndJetPt()
Definition: AliCaloTrackReader.cxx:631

AliCaloTrackReader::IsEventCentral
Bool_t IsEventCentral() const
Definition: AliCaloTrackReader.h:394

AliCaloTrackReader::SwitchOffPHOS
void SwitchOffPHOS()
Definition: AliCaloTrackReader.h:244

AliCaloTrackReader::SetEMCALBadChannelMinDist
void SetEMCALBadChannelMinDist(Float_t di)
Definition: AliCaloTrackReader.h:160

AliCaloTrackReader::GetCentralityOpt
virtual Int_t GetCentralityOpt() const
Definition: AliCaloTrackReader.h:588

AliCaloTrackReader::GetOutputEvent
virtual AliAODEvent * GetOutputEvent() const
Definition: AliCaloTrackReader.h:668

AliCaloTrackReader::fEventTrigCentral
Bool_t fEventTrigCentral
Event is AliVEvent::kCentral on its name, it should correspond to PbPb.
Definition: AliCaloTrackReader.h:854

AliCaloTrackReader::SwitchOnTriggerClusterTimeRecal
void SwitchOnTriggerClusterTimeRecal()
Definition: AliCaloTrackReader.h:389

AliCaloTrackReader::SwitchOnCTS
void SwitchOnCTS()
Definition: AliCaloTrackReader.h:231

AliCaloTrackReader::IsPHOSSwitchedOn
Bool_t IsPHOSSwitchedOn() const
Definition: AliCaloTrackReader.h:242

AliCaloTrackReader::GetListOfParameters
virtual TObjString * GetListOfParameters()
Save parameters used for analysis in a string.
Definition: AliCaloTrackReader.cxx:829

AliCaloTrackReader::fTrackMultEtaCut
Float_t fTrackMultEtaCut
Track multiplicity eta cut.
Definition: AliCaloTrackReader.h:843

AliCaloTrackReader::SetEMCALNCellsCut
void SetEMCALNCellsCut(Int_t nc)
Definition: AliCaloTrackReader.h:168

AliCaloTrackReader::SwitchOnUnMatchedTriggerEventsRemoval
void SwitchOnUnMatchedTriggerEventsRemoval()
Definition: AliCaloTrackReader.h:382

AliCaloTrackReader::IsExcludeEventTimeStampCTPBCCorrOn
Bool_t IsExcludeEventTimeStampCTPBCCorrOn()
Definition: AliCaloTrackReader.h:461

AliCaloTrackReader::fMCGenerToAccept
TString fMCGenerToAccept[5]
List with name of generators that should not be included.
Definition: AliCaloTrackReader.h:988

AliCaloTrackReader::SetPtHardAndClusterPtComparison
virtual void SetPtHardAndClusterPtComparison(Bool_t compare)
Definition: AliCaloTrackReader.h:690

AliCaloTrackReader::IsFastClusterAccepted
Bool_t IsFastClusterAccepted() const
Definition: AliCaloTrackReader.h:313

AliCaloTrackReader::SetPHOSNCellsCut
void SetPHOSNCellsCut(Int_t nc)
Definition: AliCaloTrackReader.h:169

AliCaloTrackReader::fCaloUtils
AliCalorimeterUtils * fCaloUtils
Pointer to AliCalorimeterUtils.
Definition: AliCaloTrackReader.h:869

AliCaloTrackReader::AcceptFastClusterEvents
void AcceptFastClusterEvents()
Definition: AliCaloTrackReader.h:311

AliCaloTrackReader::fCentralityBin
Int_t fCentralityBin[2]
Minimum and maximum value of the centrality for the analysis.
Definition: AliCaloTrackReader.h:954

AliCaloTrackReader::SwitchOffTriggerClusterTimeRecal
void SwitchOffTriggerClusterTimeRecal()
Definition: AliCaloTrackReader.h:390

AliCaloTrackReader::FillInputPHOSCells
virtual void FillInputPHOSCells()
Connects the array with PHOS cells and the pointer.
Definition: AliCaloTrackReader.cxx:2433

AliCaloTrackReader::SetAcceptEventsWithBit
void SetAcceptEventsWithBit(UInt_t bit)
Definition: AliCaloTrackReader.h:317

AliCaloTrackReader::kSmearingLandau
Definition: AliCaloTrackReader.h:125

AliCaloTrackReader
Base class for event, clusters and tracks filtering and preparation for the analysis.
Definition: AliCaloTrackReader.h:59

AliCaloTrackReader::GetEMCALNCellsCut
Int_t GetEMCALNCellsCut() const
Definition: AliCaloTrackReader.h:165

AliCaloTrackReader::SwitchOffBadTriggerEventsRemoval
void SwitchOffBadTriggerEventsRemoval()
Definition: AliCaloTrackReader.h:377

AliCaloTrackReader::fDCALClusters
TObjArray * fDCALClusters
Temporal array with DCAL CaloClusters, not needed in the normal case, use just EMCal array with DCal ...
Definition: AliCaloTrackReader.h:806

AliCaloTrackReader::SetEMCALClusterListName
void SetEMCALClusterListName(TString &name)
Definition: AliCaloTrackReader.h:292

AliCaloTrackReader::RejectFastClusterEvents
void RejectFastClusterEvents()
Definition: AliCaloTrackReader.h:312

AliCaloTrackReader::GetTriggerClusterBC
Int_t GetTriggerClusterBC() const
Definition: AliCaloTrackReader.h:362

AliCaloTrackReader::fUseTrackTimeCut
Bool_t fUseTrackTimeCut
Do time cut selection.
Definition: AliCaloTrackReader.h:784

AliCaloTrackReader::operator=
AliCaloTrackReader & operator=(const AliCaloTrackReader &r)
Assignment operator not implemented.

AliCaloTrackReader::GetEventPlaneMethod
virtual TString GetEventPlaneMethod() const
Definition: AliCaloTrackReader.h:600

AliCaloTrackReader::GetTrackID
virtual Int_t GetTrackID(AliVTrack *track)
Definition: AliCaloTrackReader.cxx:1011

AliCaloTrackReader::GetEventWeight
Double_t GetEventWeight() const
Definition: AliCaloTrackReader.h:637

AliCaloTrackReader::SetEventTriggerL1Threshold
void SetEventTriggerL1Threshold(Float_t tr)
Definition: AliCaloTrackReader.h:369

AliCaloTrackReader::GetEventTriggerMask
UInt_t GetEventTriggerMask() const
Definition: AliCaloTrackReader.h:338

AliCaloTrackReader::AcceptEventWithTriggerBit
Bool_t AcceptEventWithTriggerBit()
Definition: AliCaloTrackReader.cxx:250

AliCaloTrackReader::fAcceptEventsWithBit
TArrayI fAcceptEventsWithBit
Accept events if trigger bit is on.
Definition: AliCaloTrackReader.h:965

AliCaloTrackReader::SwitchOffAODTrackSharedClusterSelection
virtual void SwitchOffAODTrackSharedClusterSelection()
Definition: AliCaloTrackReader.h:536

AliCaloTrackReader::SetEventTriggerL1Bit
void SetEventTriggerL1Bit(Int_t ega, Int_t eje)
Definition: AliCaloTrackReader.h:371

AliCaloTrackReader::SetTrackMultiplicityEtaCut
void SetTrackMultiplicityEtaCut(Float_t eta)
Definition: AliCaloTrackReader.h:519

AliCaloTrackReader::fLastMixedTracksEvent
Int_t fLastMixedTracksEvent
Temporary container with the last event added to the mixing list for tracks.
Definition: AliCaloTrackReader.h:880

ULong_t
unsigned long ULong_t
Definition: External.C:38

AliCaloTrackReader::fhEMCALClusterCutsE
TH1F * fhEMCALClusterCutsE[8]
! Control histogram on the different EMCal cluster selection cuts, E
Definition: AliCaloTrackReader.h:977

AliCaloTrackReader::GetTPCSharedClusterFraction
virtual Float_t GetTPCSharedClusterFraction() const
Definition: AliCaloTrackReader.h:539

AliCaloTrackReader::GetLastTracksMixedEvent
Int_t GetLastTracksMixedEvent() const
Definition: AliCaloTrackReader.h:607

AliCaloTrackReader::Print
virtual void Print(const Option_t *opt) const
Print some relevant parameters set for the analysis.
Definition: AliCaloTrackReader.cxx:3041

AliCaloTrackReader::MatchTriggerCluster
void MatchTriggerCluster(TArrayI patches)
Definition: AliCaloTrackReader.cxx:2659

AliCaloTrackReader::SetTrackMultiplicityPtCut
void SetTrackMultiplicityPtCut(Int_t cut, Float_t pt)
Definition: AliCaloTrackReader.h:514

AliCaloTrackReader::fTimeStampEventSelect
Bool_t fTimeStampEventSelect
Select events within a fraction of data taking time.
Definition: AliCaloTrackReader.h:924

AliCaloTrackReader::fTimeStampRunMax
Double_t fTimeStampRunMax
Maximum value of time stamp in run.
Definition: AliCaloTrackReader.h:928

AliCaloTrackReader::fListMixedTracksEvents
TList ** fListMixedTracksEvents
! Container for tracks stored for different events, used in case of own mixing, set in analysis class...
Definition: AliCaloTrackReader.h:878

AliCaloTrackReader::fEMCALTimeCutMin
Double_t fEMCALTimeCutMin
Remove clusters/cells with time smaller than this value, in ns.
Definition: AliCaloTrackReader.h:786

AliCaloTrackReader::SetTrackFilterMask
virtual void SetTrackFilterMask(ULong_t)
Definition: AliCaloTrackReader.h:524

AliCaloTrackReader::fEventTrigEMCALL1Jet2
Bool_t fEventTrigEMCALL1Jet2
Event is L1-Gamma, threshold 2 on its name, it should correspond kEMCEGA.
Definition: AliCaloTrackReader.h:860

AliCaloTrackReader::SetEMCalEventBCcut
void SetEMCalEventBCcut(Int_t bc)
Definition: AliCaloTrackReader.h:488

AliCaloTrackReader::GetInputBackgroundJetBranchName
virtual TString GetInputBackgroundJetBranchName()
Definition: AliCaloTrackReader.h:753

AliCaloTrackReader::SwitchOffUseTrackTimeCut
void SwitchOffUseTrackTimeCut()
Definition: AliCaloTrackReader.h:193

AliCaloTrackReader::fNPileUpClustersCut
Int_t fNPileUpClustersCut
Cut to select event as pile-up.
Definition: AliCaloTrackReader.h:942

AliCaloTrackReader::IsPtHardAndClusterPtComparisonSet
virtual Bool_t IsPtHardAndClusterPtComparisonSet() const
Definition: AliCaloTrackReader.h:689

AliCaloTrackReader::fDebug
Int_t fDebug
Debugging level.
Definition: AliCaloTrackReader.h:759

AliCaloTrackReader::IsEMCALSwitchedOn
Bool_t IsEMCALSwitchedOn() const
Definition: AliCaloTrackReader.h:234

AliCaloTrackReader::fCheckFidCut
Bool_t fCheckFidCut
Do analysis for clusters in defined region.
Definition: AliCaloTrackReader.h:761

AliCaloTrackReader::~AliCaloTrackReader
virtual ~AliCaloTrackReader()
Destructor.
Definition: AliCaloTrackReader.cxx:151

AliCaloTrackReader::GetTrackTimeCutMin
Double_t GetTrackTimeCutMin() const
Definition: AliCaloTrackReader.h:186

AliCaloTrackReader::fEventTrigEMCALL0
Bool_t fEventTrigEMCALL0
Event is EMCal L0 on its name, it should correspond to AliVEvent::kEMC7, AliVEvent::kEMC1.
Definition: AliCaloTrackReader.h:856

AliCaloTrackReader::SwitchOnPi0Decay
virtual void SwitchOnPi0Decay()
Definition: AliCaloTrackReader.h:721

AliCaloTrackReader::GetV0Multiplicity
Int_t GetV0Multiplicity(Int_t i) const
Definition: AliCaloTrackReader.h:290

AliCaloTrackReader::fTrackBCEvent
Int_t fTrackBCEvent[19]
Fill one entry per event if there is a track in a given BC.
Definition: AliCaloTrackReader.h:945

AliCaloTrackReader::AreUnMatchedTriggerEventsRemoved
Bool_t AreUnMatchedTriggerEventsRemoved() const
Definition: AliCaloTrackReader.h:380

AliCaloTrackReader::SwitchOffTriggerPatchMatching
void SwitchOffTriggerPatchMatching()
Definition: AliCaloTrackReader.h:385

AliCaloTrackReader::SetZvertexCut
virtual void SetZvertexCut(Float_t zcut=10.)
Definition: AliCaloTrackReader.h:568

AliCaloTrackReader::GetPHOSClusters
virtual TObjArray * GetPHOSClusters() const
Definition: AliCaloTrackReader.h:303

AliCaloTrackReader::GetEMCalEventBC
Int_t GetEMCalEventBC(Int_t bc) const
Definition: AliCaloTrackReader.h:481

AliCaloTrackReader::inputDataType
inputDataType
Definition: AliCaloTrackReader.h:82

AliCaloTrackReader::FillInputEMCALAlgorithm
virtual void FillInputEMCALAlgorithm(AliVCluster *clus, Int_t iclus)
Definition: AliCaloTrackReader.cxx:1860

AliCaloTrackReader::fComparePtHardAndJetPt
Bool_t fComparePtHardAndJetPt
In MonteCarlo, jet events, reject fake events with wrong jet energy.
Definition: AliCaloTrackReader.h:763

AliCaloTrackReader::SetRunTimeStamp
void SetRunTimeStamp(Double_t a, Double_t b)
Definition: AliCaloTrackReader.h:435

AliCaloTrackReader::SwitchOffRejectNoTrackEvents
void SwitchOffRejectNoTrackEvents()
Definition: AliCaloTrackReader.h:427

AliCaloTrackReader::fNNonPileUpClusters
Int_t fNNonPileUpClusters
Number of clusters with time below 20 ns.
Definition: AliCaloTrackReader.h:941

AliCaloTrackReader::GetVertex
virtual Double_t * GetVertex(Int_t evtIndex) const
Definition: AliCaloTrackReader.h:563

AliCaloTrackReader::SwitchOffEMCAL
void SwitchOffEMCAL()
Definition: AliCaloTrackReader.h:236

AliCaloTrackReader::fNMixedEvent
Int_t fNMixedEvent
Number of events in mixed event buffer.
Definition: AliCaloTrackReader.h:875

AliCaloTrackReader::GetTriggerClusterIndex
Int_t GetTriggerClusterIndex() const
Definition: AliCaloTrackReader.h:363

AliCaloTrackReader::IsPHOSCellsSwitchedOn
Bool_t IsPHOSCellsSwitchedOn() const
Definition: AliCaloTrackReader.h:250

AliCaloTrackReader::fCentralityOpt
Int_t fCentralityOpt
Option for the returned value of the centrality, possible options 5, 10, 100.
Definition: AliCaloTrackReader.h:953

AliCaloTrackReader::SwitchOnClusterRecalculation
void SwitchOnClusterRecalculation()
Definition: AliCaloTrackReader.h:255

AliCaloTrackReader::fZvtxCut
Float_t fZvtxCut
Cut on vertex position.
Definition: AliCaloTrackReader.h:893

AliCaloTrackReader::GetEMCALTimeCutMin
Double_t GetEMCALTimeCutMin() const
Definition: AliCaloTrackReader.h:200

AliCaloTrackReader::SwitchOnPrimaryVertexSelection
void SwitchOnPrimaryVertexSelection()
Definition: AliCaloTrackReader.h:422

AliCaloTrackReader::SwitchOnEMCALCells
void SwitchOnEMCALCells()
Definition: AliCaloTrackReader.h:247

AliCaloTrackReader::AliCaloTrackReader
AliCaloTrackReader()
Constructor. Initialize parameters.
Definition: AliCaloTrackReader.cxx:59

AliCaloTrackReader::SwitchOnAliCentrality
virtual void SwitchOnAliCentrality()
Definition: AliCaloTrackReader.h:582

AliCaloTrackReader::fTriggerPatchClusterMatch
Bool_t fTriggerPatchClusterMatch
Search for the trigger patch and check if associated cluster was the trigger.
Definition: AliCaloTrackReader.h:898

AliCaloTrackReader::SetEMCALOverlapAngle
virtual void SetEMCALOverlapAngle(Float_t)
Definition: AliCaloTrackReader.h:730

TObject
Definition: External.C:76

AliCaloTrackReader::fListMixedCaloEvents
TList ** fListMixedCaloEvents
! Container for photon stored for different events, used in case of own mixing, set in analysis class...
Definition: AliCaloTrackReader.h:879

AliCaloTrackReader::fUseParamTimeCut
Bool_t fUseParamTimeCut
Use simple or parametrized time cut.
Definition: AliCaloTrackReader.h:783

AliCaloTrackReader::SwitchOffNonStandardJets
void SwitchOffNonStandardJets()
Definition: AliCaloTrackReader.h:739

AliCaloTrackReader::SetPtHardAndJetPtFactor
virtual void SetPtHardAndJetPtFactor(Float_t factor)
Definition: AliCaloTrackReader.h:686

AliCaloTrackReader::fFiducialCut
AliFiducialCut * fFiducialCut
Acceptance cuts.
Definition: AliCaloTrackReader.h:760

AliCaloTrackReader::fRejectEMCalTriggerEventsWith2Tresholds
Bool_t fRejectEMCalTriggerEventsWith2Tresholds
Reject events EG2 also triggered by EG1 or EJ2 also triggered by EJ1.
Definition: AliCaloTrackReader.h:968

AliCaloTrackReader::SwitchOnVertexBCEventSelection
void SwitchOnVertexBCEventSelection()
Definition: AliCaloTrackReader.h:418

AliCaloTrackReader::SetCaloUtils
void SetCaloUtils(AliCalorimeterUtils *caloutils)
Definition: AliCaloTrackReader.h:634

AliCaloTrackReader::SetTimeStampEventCTPBCCorrRange
void SetTimeStampEventCTPBCCorrRange(Double_t a, Double_t b)
Definition: AliCaloTrackReader.h:454

AliCaloTrackReader::fhPHOSClusterCutsE
TH1F * fhPHOSClusterCutsE[7]
! Control histogram on the different PHOS cluster selection cuts, E
Definition: AliCaloTrackReader.h:978

AliCaloTrackReader::SetEventPlaneMethod
virtual void SetEventPlaneMethod(TString m)
Definition: AliCaloTrackReader.h:599

AliCaloTrackReader::GetTimeStampEventCTPBCCorrMax
Double_t GetTimeStampEventCTPBCCorrMax() const
Definition: AliCaloTrackReader.h:452

AliCaloTrackReader::SetPHOSEMin
void SetPHOSEMin(Float_t en)
Definition: AliCaloTrackReader.h:149

AliCaloTrackReader::IsAccessToTrackTimeOn
Bool_t IsAccessToTrackTimeOn() const
Definition: AliCaloTrackReader.h:197

AliCaloTrackReader::GetTrackComplementaryCuts
virtual AliESDtrackCuts * GetTrackComplementaryCuts() const
Definition: AliCaloTrackReader.h:544

AliCaloTrackReader::IsSelectEventTimeStampOn
Bool_t IsSelectEventTimeStampOn()
Definition: AliCaloTrackReader.h:447

AliCaloTrackReader::GetCentralityClass
virtual TString GetCentralityClass() const
Definition: AliCaloTrackReader.h:587

AliCaloTrackReader::AreClustersRecalculated
Bool_t AreClustersRecalculated() const
Definition: AliCaloTrackReader.h:254

AliCaloTrackReader::FillInputEMCAL
virtual void FillInputEMCAL()
Definition: AliCaloTrackReader.cxx:2163

AliCaloTrackReader::fFillEMCAL
Bool_t fFillEMCAL
Use data from EMCAL.
Definition: AliCaloTrackReader.h:819

AliCaloTrackReader::fFillPHOS
Bool_t fFillPHOS
Use data from PHOS.
Definition: AliCaloTrackReader.h:821

AliCaloTrackReader::fEMCALCells
AliVCaloCells * fEMCALCells
! Temporal array with EMCAL AliVCaloCells.
Definition: AliCaloTrackReader.h:811

AliCaloTrackReader::IsEmbeddedClusterSelectionOn
Bool_t IsEmbeddedClusterSelectionOn() const
Definition: AliCaloTrackReader.h:261

AliAODEvent
Definition: External.C:335

AliCaloTrackReader::GetAODMCHeader
virtual AliAODMCHeader * GetAODMCHeader() const
Definition: AliCaloTrackReader.cxx:944

AliCaloTrackReader::SetEventTriggerBit
void SetEventTriggerBit()
Definition: AliCaloTrackReader.cxx:3221

AliCaloTrackReader::fEMCALNCellsCut
Int_t fEMCALNCellsCut
Accept for the analysis EMCAL clusters with more than fNCellsCut cells.
Definition: AliCaloTrackReader.h:779

AliCaloTrackReader::SetTrackCuts
virtual void SetTrackCuts(AliESDtrackCuts *)
Definition: AliCaloTrackReader.h:546

AliCaloTrackReader::GetPHOSPtMin
Float_t GetPHOSPtMin() const
Definition: AliCaloTrackReader.h:130

AliCaloTrackReader::GetLastCaloMixedEvent
Int_t GetLastCaloMixedEvent() const
Definition: AliCaloTrackReader.h:606

AliCaloTrackReader::kPHOS
Definition: AliCaloTrackReader.h:120

AliCaloTrackReader::fCTSPtMin
Float_t fCTSPtMin
pT Threshold on charged particles.
Definition: AliCaloTrackReader.h:769

AliCaloTrackReader::IsCTSSwitchedOn
Bool_t IsCTSSwitchedOn() const
Definition: AliCaloTrackReader.h:230

AliCaloTrackReader::SwitchOnBackgroundJets
void SwitchOnBackgroundJets()
Definition: AliCaloTrackReader.h:742

AliCaloTrackReader::GetMixEventTriggerMask
UInt_t GetMixEventTriggerMask() const
Definition: AliCaloTrackReader.h:341

AliCaloTrackReader::GetEMCALPtMin
Float_t GetEMCALPtMin() const
Definition: AliCaloTrackReader.h:129

AliCaloTrackReader::SetPileUpParamForSPD
void SetPileUpParamForSPD(Int_t i, Double_t param)
Definition: AliCaloTrackReader.h:474

AliCaloTrackReader::GetTrackCuts
virtual AliESDtrackCuts * GetTrackCuts() const
Definition: AliCaloTrackReader.h:543

AliCaloTrackReader::GetEventTriggerL1Threshold
Float_t GetEventTriggerL1Threshold() const
Definition: AliCaloTrackReader.h:368

AliCaloTrackReader::SwitchOffFiducialCut
virtual void SwitchOffFiducialCut()
Definition: AliCaloTrackReader.h:226

AliCaloTrackReader::fSmearNLMMax
Int_t fSmearNLMMax
Do smearing for clusters with at maximum this value.
Definition: AliCaloTrackReader.h:833

AliCaloTrackReader::GetBackgroundJets
virtual AliAODJetEventBackground * GetBackgroundJets() const
Definition: AliCaloTrackReader.h:751

AliCaloTrackReader::IsVertexBCEventSelectionDone
Bool_t IsVertexBCEventSelectionDone() const
Definition: AliCaloTrackReader.h:420

AliCaloTrackReader::SetCentralityClass
virtual void SetCentralityClass(TString name)
Definition: AliCaloTrackReader.h:585

AliCaloTrackReader::fTriggerL0EventThreshold
Float_t fTriggerL0EventThreshold
L0 Threshold to look for triggered events, set outside.
Definition: AliCaloTrackReader.h:901

AliCaloTrackReader::DegToRad
Float_t DegToRad(Float_t deg) const
Definition: AliCaloTrackReader.h:646

AliCaloTrackReader::fTimeStampEventFracMax
Float_t fTimeStampEventFracMax
Maximum value of time stamp fraction event.
Definition: AliCaloTrackReader.h:926

AliCaloTrackReader::SetEMCALPtMin
void SetEMCALPtMin(Float_t pt)
Definition: AliCaloTrackReader.h:136

AliCaloTrackReader::ResetLists
virtual void ResetLists()
Reset lists, called in AliAnaCaloTrackCorrMaker.
Definition: AliCaloTrackReader.cxx:3203

AliCaloTrackReader::SwitchOffTrackHitSPDSelection
void SwitchOffTrackHitSPDSelection()
Definition: AliCaloTrackReader.h:504

AliCaloTrackReader::SwitchOffWriteDeltaAOD
void SwitchOffWriteDeltaAOD()
Definition: AliCaloTrackReader.h:108

AliCaloTrackReader::fNPileUpClusters
Int_t fNPileUpClusters
Number of clusters with time avobe 20 ns.
Definition: AliCaloTrackReader.h:940

AliCaloTrackReader::SwitchOnBadTriggerEventsRemoval
void SwitchOnBadTriggerEventsRemoval()
Definition: AliCaloTrackReader.h:378

AliCaloTrackReader::IsNonStandardJetsSwitchedOn
Bool_t IsNonStandardJetsSwitchedOn() const
Definition: AliCaloTrackReader.h:737

AliCaloTrackReader::fOutputEvent
AliAODEvent * fOutputEvent
! pointer to aod output.
Definition: AliCaloTrackReader.h:815

AliCaloTrackReader::SetPHOSBadChannelMinDist
void SetPHOSBadChannelMinDist(Float_t di)
Definition: AliCaloTrackReader.h:161

AliCaloTrackReader::SwitchOnClusterELinearityCorrection
void SwitchOnClusterELinearityCorrection()
Definition: AliCaloTrackReader.h:258

AliCaloTrackReader::IsExoticEvent
Bool_t IsExoticEvent() const
Definition: AliCaloTrackReader.h:356

AliCaloTrackReader::GetTrackFilterMask
virtual ULong_t GetTrackFilterMask() const
Definition: AliCaloTrackReader.h:523

AliCaloTrackReader::GetEMCALPtMax
Float_t GetEMCALPtMax() const
Definition: AliCaloTrackReader.h:132

AliCaloTrackReader::AddChargedParticlesArray
virtual void AddChargedParticlesArray(TArrayI &)
Definition: AliCaloTrackReader.h:718

AliCaloTrackReader::SetTrackTimeCut
void SetTrackTimeCut(Double_t a, Double_t b)
Definition: AliCaloTrackReader.h:189

AliCaloTrackReader::fRecalculateClusters
Bool_t fRecalculateClusters
Correct clusters, recalculate them if recalibration parameters is given.
Definition: AliCaloTrackReader.h:824

AliCaloTrackReader::SetEMCALTimeCut
void SetEMCALTimeCut(Double_t a, Double_t b)
Definition: AliCaloTrackReader.h:205

AliCaloTrackReader::IsEventMinimumBias
Bool_t IsEventMinimumBias() const
Definition: AliCaloTrackReader.h:393

AliCaloTrackReader::fDoRejectNoTrackEvents
Bool_t fDoRejectNoTrackEvents
Reject events with no selected tracks in event.
Definition: AliCaloTrackReader.h:920

AliCaloTrackReader::IsEventEMCALL1Jet2
Bool_t IsEventEMCALL1Jet2() const
Definition: AliCaloTrackReader.h:400

AliCaloTrackReader::SwitchOnAccessTrackTimeCut
void SwitchOnAccessTrackTimeCut()
Definition: AliCaloTrackReader.h:195

AliCaloTrackReader::smearingFunction
smearingFunction
Smearing function enum.
Definition: AliCaloTrackReader.h:125

AliCaloTrackReader::SwitchOffSelectEventTimeStamp
void SwitchOffSelectEventTimeStamp()
Definition: AliCaloTrackReader.h:445

AliCaloTrackReader::fEMCALBadChMinDist
Float_t fEMCALBadChMinDist
Minimal distance to bad channel to accept cluster in EMCal, cell units.
Definition: AliCaloTrackReader.h:776

AliCaloTrackReader::fTimeStampEventCTPBCCorrExclude
Bool_t fTimeStampEventCTPBCCorrExclude
Activate event selection within a range of data taking time CTP corrected. ESD only.
Definition: AliCaloTrackReader.h:930

AliCaloTrackReader::fIsTriggerMatchOpenCut
Bool_t fIsTriggerMatchOpenCut[3]
Could not match the event to a trigger patch?, retry opening cuts.
Definition: AliCaloTrackReader.h:912

AliCaloTrackReader::fEMCALCellsListName
TString fEMCALCellsListName
Alternative list of cells produced elsewhere and not from InputEvent.
Definition: AliCaloTrackReader.h:889

AliCaloTrackReader::ListWithMixedEventsForCaloExists
Bool_t ListWithMixedEventsForCaloExists() const
Definition: AliCaloTrackReader.h:612

AliCaloTrackReader::fMixEventTriggerMask
UInt_t fMixEventTriggerMask
Select this triggerered event for mixing, tipically kMB or kAnyINT.
Definition: AliCaloTrackReader.h:850

AliCaloTrackReader::RadToDeg
Float_t RadToDeg(Float_t rad) const
Definition: AliCaloTrackReader.h:648

AliCaloTrackReader::IsEventTriggerAtSEOn
Bool_t IsEventTriggerAtSEOn() const
Definition: AliCaloTrackReader.h:344

AliCaloTrackReader::AnalyzeOnlyPhysicsEvents
void AnalyzeOnlyPhysicsEvents()
Definition: AliCaloTrackReader.h:555

AliCaloTrackReader::ListWithMixedEventsForTracksExists
Bool_t ListWithMixedEventsForTracksExists() const
Definition: AliCaloTrackReader.h:615

AliCaloTrackReader::kMC
Definition: AliCaloTrackReader.h:82

AliCaloTrackReader::SwitchOffRecalculateVertexBC
void SwitchOffRecalculateVertexBC()
Definition: AliCaloTrackReader.h:494

AliCaloTrackReader::SwitchOnUseParametrizedTimeCut
void SwitchOnUseParametrizedTimeCut()
Definition: AliCaloTrackReader.h:214

AliCaloTrackReader::FillVertexArray
virtual void FillVertexArray()
Definition: AliCaloTrackReader.cxx:1619

AliCaloTrackReader::IsInTimeWindow
Bool_t IsInTimeWindow(Double_t tof, Float_t energy) const
Definition: AliCaloTrackReader.cxx:1168

AliCaloTrackReader::fRemoveUnMatchedTriggers
Bool_t fRemoveUnMatchedTriggers
Analyze events where trigger patch and cluster where found or not.
Definition: AliCaloTrackReader.h:914

AliCaloTrackReader::SetEMCALCellsListName
void SetEMCALCellsListName(TString &name)
Definition: AliCaloTrackReader.h:295

AliCaloTrackReader::GetTrackMultiplicityEtaCut
Float_t GetTrackMultiplicityEtaCut() const
Definition: AliCaloTrackReader.h:518

AliCaloTrackReader::IsV0ANDEventSelectionDone
Bool_t IsV0ANDEventSelectionDone() const
Definition: AliCaloTrackReader.h:416

AliCaloTrackReader::GetEventPlaneAngle
virtual Double_t GetEventPlaneAngle() const
Definition: AliCaloTrackReader.cxx:1562

AliFiducialCut::kCTS
Definition: AliFiducialCut.h:126

AliCaloTrackReader::GetNNonPileUpClusters
Int_t GetNNonPileUpClusters()
Definition: AliCaloTrackReader.h:479

AliCaloTrackReader::SwitchOffEmbeddedClustersSelection
void SwitchOffEmbeddedClustersSelection()
Definition: AliCaloTrackReader.h:263

AliCaloTrackReader::SetRejectEventsWithBit
void SetRejectEventsWithBit(UInt_t bit)
Definition: AliCaloTrackReader.h:321

AliCaloTrackReader::fCTSTracks
TObjArray * fCTSTracks
Temporal array with tracks.
Definition: AliCaloTrackReader.h:800

AliCaloTrackReader::fTriggerPatchTimeWindow
Int_t fTriggerPatchTimeWindow[2]
Trigger patch selection window.
Definition: AliCaloTrackReader.h:899

AliCaloTrackReader::GetOriginalInputEvent
virtual AliVEvent * GetOriginalInputEvent() const
Definition: AliCaloTrackReader.h:667

AliCaloTrackReader::GetEventTimeStampFractionMin
Float_t GetEventTimeStampFractionMin() const
Definition: AliCaloTrackReader.h:438

AliCaloTrackReader::AcceptParticleMCLabel
Bool_t AcceptParticleMCLabel(Int_t mcLabel) const
Definition: AliCaloTrackReader.cxx:278

AliCaloTrackReader::fMC
AliMCEvent * fMC
! Monte Carlo Event Handler.
Definition: AliCaloTrackReader.h:816

AliCaloTrackReader::SwitchOnOverlapCheck
virtual void SwitchOnOverlapCheck()
Definition: AliCaloTrackReader.h:725

AliCaloTrackReader::fhNEventsAfterCut
TH1I * fhNEventsAfterCut
! Each bin represents number of events resulting after a given selection cut: vertex, trigger, ...
Definition: AliCaloTrackReader.h:984

AliCaloTrackReader::fPtHardAndJetPtFactor
Float_t fPtHardAndJetPtFactor
Factor between ptHard and jet pT to reject/accept event.
Definition: AliCaloTrackReader.h:764

AliCaloTrackReader::SetEMCALEMax
void SetEMCALEMax(Float_t en)
Definition: AliCaloTrackReader.h:150

AliCaloTrackReader::SwitchOnPHOSCells
void SwitchOnPHOSCells()
Definition: AliCaloTrackReader.h:251

AliCaloTrackReader::fMCGenerEventHeaderToAccept
TString fMCGenerEventHeaderToAccept
Accept events that contain at least this event header name.
Definition: AliCaloTrackReader.h:991

AliCaloTrackReader::SwitchOnAODPrimaryTrackSelection
virtual void SwitchOnAODPrimaryTrackSelection()
Definition: AliCaloTrackReader.h:532

AliCaloTrackReader::SetEventTriggerL0Threshold
void SetEventTriggerL0Threshold(Float_t tr)
Definition: AliCaloTrackReader.h:367

Option_t
const char Option_t
Definition: External.C:48

AliCaloTrackReader::IsPtHardAndJetPtComparisonSet
virtual Bool_t IsPtHardAndJetPtComparisonSet() const
Definition: AliCaloTrackReader.h:683

AliCaloTrackReader::SwitchOnUseTrackTimeCut
void SwitchOnUseTrackTimeCut()
Definition: AliCaloTrackReader.h:192

AliCaloTrackReader::SwitchOffAccessTrackTimeCut
void SwitchOffAccessTrackTimeCut()
Definition: AliCaloTrackReader.h:196

AliCaloTrackReader::GetTrackEventBC
Int_t GetTrackEventBC(Int_t bc) const
Definition: AliCaloTrackReader.h:482

AliCaloTrackReader::SwitchOnRecalculateVertexBC
void SwitchOnRecalculateVertexBC()
Definition: AliCaloTrackReader.h:493

AliCaloTrackReader::fPileUpParamSPD
Double_t fPileUpParamSPD[5]
Definition: AliCaloTrackReader.h:936

AliCaloTrackReader::fDeltaAODFileName
TString fDeltaAODFileName
Delta AOD file name.
Definition: AliCaloTrackReader.h:845

AliCaloTrackReader::GetDataType
virtual Int_t GetDataType() const
Definition: AliCaloTrackReader.h:83

AliCaloTrackReader::SwitchOffEMCALEventRejectionWith2Thresholds
void SwitchOffEMCALEventRejectionWith2Thresholds()
Definition: AliCaloTrackReader.h:406

AliCaloTrackReader::GetEMCALClusterListName
TString GetEMCALClusterListName() const
Definition: AliCaloTrackReader.h:293

AliCaloTrackReader::GetVertexBC
Int_t GetVertexBC() const
Definition: AliCaloTrackReader.h:492

AliCaloTrackReader::GetDeltaAODFileName
TString GetDeltaAODFileName() const
Definition: AliCaloTrackReader.h:106

AliCaloTrackReader::fTrackSumPt
Float_t fTrackSumPt[10]
Track sum pT, count for different pT cuts.
Definition: AliCaloTrackReader.h:840

AliCaloTrackReader::IsPileUpFromEMCal
Bool_t IsPileUpFromEMCal() const
Check if event is from pile-up determined by EMCal.
Definition: AliCaloTrackReader.cxx:1199

AliCaloTrackReader::fFillInputNonStandardJetBranch
Bool_t fFillInputNonStandardJetBranch
Flag to use data from non standard jets.
Definition: AliCaloTrackReader.h:958

AliCaloTrackReader::fNonStandardJets
TClonesArray * fNonStandardJets
! Temporal array with jets.
Definition: AliCaloTrackReader.h:959

AliCaloTrackReader::SwitchOnSelectEventTimeStamp
void SwitchOnSelectEventTimeStamp()
Definition: AliCaloTrackReader.h:444

AliCaloTrackReader::SetFiredTriggerClassName
void SetFiredTriggerClassName(TString name)
Definition: AliCaloTrackReader.h:331

AliCaloTrackReader::fEMCalBCEventCut
Int_t fEMCalBCEventCut[19]
Fill one entry per event if there is a cluster in a given BC, depend on cluster E, acceptance cut.
Definition: AliCaloTrackReader.h:944

AliCaloTrackReader::fTriggerClusterIndex
Int_t fTriggerClusterIndex
Index in clusters array of trigger cluster.
Definition: AliCaloTrackReader.h:906

AliCaloTrackReader::Init
virtual void Init()
Definition: AliCaloTrackReader.cxx:1020

AliCaloTrackReader::IsDCALSwitchedOn
Bool_t IsDCALSwitchedOn() const
Definition: AliCaloTrackReader.h:238

AliCaloTrackReader::fTriggerL1EventThresholdFix
Bool_t fTriggerL1EventThresholdFix
L1 Threshold is fix and set outside.
Definition: AliCaloTrackReader.h:903

Bool_t
bool Bool_t
Definition: External.C:53

AliCaloTrackReader::SwitchOnTrackHitSPDSelection
void SwitchOnTrackHitSPDSelection()
Definition: AliCaloTrackReader.h:503

AliCaloTrackReader::fSmearShowerShapeWidth
Float_t fSmearShowerShapeWidth
Smear shower shape landau function "width" (use in MC).
Definition: AliCaloTrackReader.h:829

AliCaloTrackReader::SetPHOSEMax
void SetPHOSEMax(Float_t en)
Definition: AliCaloTrackReader.h:151

AliCaloTrackReader::FillInputCTS
virtual void FillInputCTS()
Definition: AliCaloTrackReader.cxx:1683

TString
Definition: External.C:108

TObjArray
Definition: External.C:172

AliCalorimeterUtils
Class with utils specific to calorimeter clusters/cells.
Definition: AliCalorimeterUtils.h:44

AliCaloTrackReader::fBitEGA
Int_t fBitEGA
Trigger bit on VCaloTrigger for EGA.
Definition: AliCaloTrackReader.h:862

AliCaloTrackReader::fTrackMultNPtCut
Int_t fTrackMultNPtCut
Track multiplicty, number of pt cuts.
Definition: AliCaloTrackReader.h:841

AliCaloTrackReader::IsEventEMCALL1Gamma
Bool_t IsEventEMCALL1Gamma() const
Definition: AliCaloTrackReader.h:401

AliCaloTrackReader::SwitchOnShowerShapeSmearing
void SwitchOnShowerShapeSmearing()
Definition: AliCaloTrackReader.h:271

AliCaloTrackReader::GetTrackTimeCutMax
Double_t GetTrackTimeCutMax() const
Definition: AliCaloTrackReader.h:187

AliCaloTrackReader::GetTrackDCACut
Double_t GetTrackDCACut(Int_t i) const
Definition: AliCaloTrackReader.h:174

AliCaloTrackReader::RejectEventWithTriggerBit
Bool_t RejectEventWithTriggerBit()
Definition: AliCaloTrackReader.cxx:412

AliCaloTrackReader::FillInputBackgroundJets
virtual void FillInputBackgroundJets()
Definition: AliCaloTrackReader.cxx:2507

AliCaloTrackReader::GetNameOfMCGeneratorsToAccept
virtual TString GetNameOfMCGeneratorsToAccept(Int_t ig) const
Definition: AliCaloTrackReader.h:705

AliCaloTrackReader::AnalyzeOnlyLEDEvents
void AnalyzeOnlyLEDEvents()
Definition: AliCaloTrackReader.h:554

AliCaloTrackReader::SetIndexOfMCGeneratorsToAccept
virtual void SetIndexOfMCGeneratorsToAccept(Int_t ig, Int_t index)
Definition: AliCaloTrackReader.h:703

AliCaloTrackReader::fDoV0ANDEventSelection
Bool_t fDoV0ANDEventSelection
Select events depending on V0AND.
Definition: AliCaloTrackReader.h:918

AliCaloTrackReader::GetNMixedEvent
virtual Int_t GetNMixedEvent() const
Definition: AliCaloTrackReader.h:671

AliCaloTrackReader::SwitchOnConstrainTrackToVertex
virtual void SwitchOnConstrainTrackToVertex()
Definition: AliCaloTrackReader.h:549

AliCaloTrackReader::SwitchOffAliCentrality
virtual void SwitchOffAliCentrality()
Definition: AliCaloTrackReader.h:583

AliCaloTrackReader::SetNameOfMCGeneratorsToAccept
virtual void SetNameOfMCGeneratorsToAccept(Int_t ig, TString name)
Definition: AliCaloTrackReader.h:701

AliCaloTrackReader::fBackgroundJets
AliAODJetEventBackground * fBackgroundJets
! Background jets.
Definition: AliCaloTrackReader.h:962

AliCaloTrackReader::fCorrectELinearity
Bool_t fCorrectELinearity
Correct cluster linearity, always on.
Definition: AliCaloTrackReader.h:825

AliCaloTrackReader::SetMixEventTriggerMask
void SetMixEventTriggerMask(UInt_t evtTrig=AliVEvent::kAnyINT)
Definition: AliCaloTrackReader.h:342

AliCaloTrackReader::GetCreateControlHistograms
virtual TList * GetCreateControlHistograms()
Definition: AliCaloTrackReader.cxx:736

AliCaloTrackReader::fVertexBC
Int_t fVertexBC
Vertex BC.
Definition: AliCaloTrackReader.h:947

AliCaloTrackReader::IsFiducialCutOn
virtual Bool_t IsFiducialCutOn() const
Definition: AliCaloTrackReader.h:223

AliCaloTrackReader::SwitchOffPrimaryVertexSelection
void SwitchOffPrimaryVertexSelection()
Definition: AliCaloTrackReader.h:423

AliCaloTrackReader::SwitchOffOnlyGeneratorParticles
virtual void SwitchOffOnlyGeneratorParticles()
Definition: AliCaloTrackReader.h:728

AliCaloTrackReader::GetDCALClusters
virtual TObjArray * GetDCALClusters() const
Definition: AliCaloTrackReader.h:302

AliCaloTrackReader::GetWeightUtils
AliAnaWeights * GetWeightUtils()
Definition: AliCaloTrackReader.h:638

AliCaloTrackReader::SetInputNonStandardJetBranchName
virtual void SetInputNonStandardJetBranchName(TString name)
Definition: AliCaloTrackReader.h:747

AliCaloTrackReader::SetEventTimeStampFraction
void SetEventTimeStampFraction(Float_t a, Float_t b)
Definition: AliCaloTrackReader.h:441

AliCaloTrackReader::fIsExoticEvent
Bool_t fIsExoticEvent
Exotic trigger event flag.
Definition: AliCaloTrackReader.h:908

AliCaloTrackReader::fInputNonStandardJetBranchName
TString fInputNonStandardJetBranchName
Name of non standard jet branch.
Definition: AliCaloTrackReader.h:960

AliCaloTrackReader::GetEMCalEventBCcut
Int_t GetEMCalEventBCcut(Int_t bc) const
Definition: AliCaloTrackReader.h:483

AliCaloTrackReader::fRejectEventsWithBit
TArrayI fRejectEventsWithBit
Reject events if trigger bit is on.
Definition: AliCaloTrackReader.h:966

AliCaloTrackReader::fUseEMCALTimeCut
Bool_t fUseEMCALTimeCut
Do time cut selection.
Definition: AliCaloTrackReader.h:782

AliCaloTrackReader::IsBadCellTriggerEvent
Bool_t IsBadCellTriggerEvent() const
Definition: AliCaloTrackReader.h:357

AliCaloTrackReader::GetPhi
Float_t GetPhi(Float_t phi) const
Shift phi angle in case of negative value 360 degrees. Example TLorenzVector::Phi defined in -pi to p...
Definition: AliCaloTrackReader.h:644

AliCaloTrackReader::SwitchOnEventTriggerAtSE
void SwitchOnEventTriggerAtSE()
Definition: AliCaloTrackReader.h:345

AliFiducialCut
Store the acceptance cuts for clusters and tracks or particle objects.
Definition: AliFiducialCut.h:28

AliCaloTrackReader::fDataType
Int_t fDataType
Select MC: Kinematics, Data: ESD/AOD, MCData: Both.
Definition: AliCaloTrackReader.h:758

AliCaloTrackReader::SelectTrack
virtual Bool_t SelectTrack(AliVTrack *, Double_t *)
Definition: AliCaloTrackReader.h:501

AliCaloTrackReader::SetFiducialCut
virtual void SetFiducialCut(AliFiducialCut *fc)
Definition: AliCaloTrackReader.h:222

AliCaloTrackReader::fFillDCAL
Bool_t fFillDCAL
Use data from DCAL, not needed in the normal case, use just EMCal array with DCal limits...
Definition: AliCaloTrackReader.h:820

AliCaloTrackReader::IsEMCALCellsSwitchedOn
Bool_t IsEMCALCellsSwitchedOn() const
Definition: AliCaloTrackReader.h:246

AliCaloTrackReader::SetTrackEventBCcut
void SetTrackEventBCcut(Int_t bc)
Definition: AliCaloTrackReader.h:489

AliCaloTrackReader::SwitchOffUseParametrizedTimeCut
void SwitchOffUseParametrizedTimeCut()
Definition: AliCaloTrackReader.h:215

AliCaloTrackReader::SwitchOffLEDEventsRemoval
void SwitchOffLEDEventsRemoval()
Definition: AliCaloTrackReader.h:327

AliCaloTrackReader::IsShowerShapeSmeared
Bool_t IsShowerShapeSmeared() const
Definition: AliCaloTrackReader.h:270

AliCaloTrackReader::SwitchOnDCAL
void SwitchOnDCAL()
Definition: AliCaloTrackReader.h:239

AliCaloTrackReader::SetDataType
virtual void SetDataType(Int_t data)
Definition: AliCaloTrackReader.h:84

AliCaloTrackReader::GetTrackMultiplicityNPtCut
Int_t GetTrackMultiplicityNPtCut() const
Definition: AliCaloTrackReader.h:512

AliCaloTrackReader::GetPHOSPtMax
Float_t GetPHOSPtMax() const
Definition: AliCaloTrackReader.h:133

AliCaloTrackReader::fIsTriggerMatch
Bool_t fIsTriggerMatch
Could match the event to a trigger patch?
Definition: AliCaloTrackReader.h:911

AliCaloTrackReader::fTriggerL1EventThreshold
Float_t fTriggerL1EventThreshold
L1 Threshold to look for triggered events, set in data.
Definition: AliCaloTrackReader.h:902

AliCaloTrackReader::fCentralityClass
TString fCentralityClass
Name of selected centrality class.
Definition: AliCaloTrackReader.h:952

AliCaloTrackReader::fMCGenerIndexToAccept
Int_t fMCGenerIndexToAccept[5]
List with index of generators that should not be included.
Definition: AliCaloTrackReader.h:989

TList
Definition: External.C:164

AliCaloTrackReader::kDCALPHOS
Definition: AliCaloTrackReader.h:122

TArrayI
Definition: External.C:124

AliCaloTrackReader::GetTrackEventBCcut
Int_t GetTrackEventBCcut(Int_t bc) const
Definition: AliCaloTrackReader.h:484

AliCaloTrackReader::SwitchOnExcludeEventTimeCTPBCCorrStamp
void SwitchOnExcludeEventTimeCTPBCCorrStamp()
Definition: AliCaloTrackReader.h:458

AliCaloTrackReader::fTrackStatus
ULong_t fTrackStatus
Track selection bit, select tracks refitted in TPC, ITS ...
Definition: AliCaloTrackReader.h:836

AliCaloTrackReader::IsPileUpFromSPDAndEMCal
Bool_t IsPileUpFromSPDAndEMCal() const
Check if event is from pile-up determined by SPD and EMCal.
Definition: AliCaloTrackReader.cxx:1208

AliCaloTrackReader::GetTrackSumPt
Float_t GetTrackSumPt(Int_t cut=0) const
Definition: AliCaloTrackReader.h:508

AliCaloTrackReader::FillInputPHOS
virtual void FillInputPHOS()
Fill the array with PHOS filtered clusters.
Definition: AliCaloTrackReader.cxx:2303

AliFiducialCut::kDCALPHOS
Definition: AliFiducialCut.h:126

AliCaloTrackReader::fLastMixedCaloEvent
Int_t fLastMixedCaloEvent
Temporary container with the last event added to the mixing list for photons.
Definition: AliCaloTrackReader.h:881

AliCaloTrackReader::fUseAliCentrality
Bool_t fUseAliCentrality
Select as centrality estimator AliCentrality (Run1) or AliMultSelection (Run1 and Run2) ...
Definition: AliCaloTrackReader.h:951

AliCaloTrackReader::GetCTSTracks
virtual TObjArray * GetCTSTracks() const
Definition: AliCaloTrackReader.h:300

AliCaloTrackReader::fSmearingFunction
Int_t fSmearingFunction
Choice of smearing function. 0 no smearing. 1 smearing from Gustavo (Landau center at 0)...
Definition: AliCaloTrackReader.h:831

AliCaloTrackReader::fRecalculateVertexBC
Bool_t fRecalculateVertexBC
Recalculate vertex BC from tracks pointing to vertex.
Definition: AliCaloTrackReader.h:948

AliCaloTrackReader::SetEMCalEventBC
void SetEMCalEventBC(Int_t bc)
Definition: AliCaloTrackReader.h:486

AliCaloTrackReader::GetTriggerClusterId
Int_t GetTriggerClusterId() const
Definition: AliCaloTrackReader.h:364

AliCaloTrackReader::SwitchOffAODHybridTrackSelection
virtual void SwitchOffAODHybridTrackSelection()
Definition: AliCaloTrackReader.h:530

AliCaloTrackReader::SetDeltaAODFileName
void SetDeltaAODFileName(TString name)
Definition: AliCaloTrackReader.h:105

AliCaloTrackReader::IsEventEMCALL0
Bool_t IsEventEMCALL0() const
Definition: AliCaloTrackReader.h:396

AliCaloTrackReader::GetCTSPtMin
Float_t GetCTSPtMin() const
Definition: AliCaloTrackReader.h:131