#ifndef ALICALOTRACKREADER_H
#define ALICALOTRACKREADER_H
#include <TObject.h>
#include <TString.h>
class TObjArray ;
class TTree ;
class TArrayI ;
#include <TRandom3.h>
#include "AliVEvent.h"
class AliVCaloCells;
class AliStack;
class AliHeader;
class AliGenEventHeader;
class AliAODEvent;
class AliMCEvent;
class AliMixedEvent;
class AliAODMCHeader;
class AliCentrality;
class AliESDtrackCuts;
class AliEventplane;
class AliVCluster;
#include "AliFiducialCut.h"
class AliEMCALRecoUtils;
class AliCalorimeterUtils;
class AliAODJetEventBackground;
class AliCaloTrackReader : public TObject {
public:
AliCaloTrackReader() ;
virtual ~AliCaloTrackReader() ;
void DeletePointers();
virtual void Init();
virtual void InitParameters();
virtual void Print(const Option_t * opt) const;
virtual void ResetLists();
virtual Int_t GetDebug() const { return fDebug ; }
virtual void SetDebug(Int_t d) { fDebug = d ; }
enum inputDataType {kESD, kAOD, kMC};
virtual Int_t GetDataType() const { return fDataType ; }
virtual void SetDataType(Int_t data ) { fDataType = data ; }
virtual Int_t GetEventNumber() const { return fEventNumber ; }
TString GetTaskName() const { return fTaskName ; }
void SetTaskName(TString name) { fTaskName = name ; }
virtual void SetInputEvent(AliVEvent* input) ;
virtual void SetOutputEvent(AliAODEvent* aod) { fOutputEvent = aod ; }
virtual void SetMC(AliMCEvent* const mc) { fMC = mc ; }
virtual void SetInputOutputMCEvent(AliVEvent* , AliAODEvent* , AliMCEvent* ) { ; }
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 ; }
enum detector { kEMCAL = AliFiducialCut::kEMCAL, kPHOS = AliFiducialCut::kPHOS,
kCTS = AliFiducialCut::kCTS , kDCAL = AliFiducialCut::kDCAL,
kDCALPHOS = AliFiducialCut::kDCALPHOS } ;
Float_t GetEMCALPtMin() const { return fEMCALPtMin ; }
Float_t GetPHOSPtMin() const { return fPHOSPtMin ; }
Float_t GetCTSPtMin() const { return fCTSPtMin ; }
Float_t GetEMCALPtMax() const { return fEMCALPtMax ; }
Float_t GetPHOSPtMax() const { return fPHOSPtMax ; }
Float_t GetCTSPtMax() const { return fCTSPtMax ; }
void SetEMCALPtMin(Float_t pt) { fEMCALPtMin = pt ; }
void SetPHOSPtMin (Float_t pt) { fPHOSPtMin = pt ; }
void SetCTSPtMin (Float_t pt) { fCTSPtMin = pt ; }
void SetEMCALPtMax(Float_t pt) { fEMCALPtMax = pt ; }
void SetPHOSPtMax (Float_t pt) { fPHOSPtMax = pt ; }
void SetCTSPtMax (Float_t pt) { fCTSPtMax = pt ; }
Float_t GetEMCALEMin() const { return GetEMCALPtMin() ; }
Float_t GetPHOSEMin() const { return GetPHOSPtMin() ; }
Float_t GetEMCALEMax() const { return GetEMCALPtMax() ; }
Float_t GetPHOSEMax() const { return GetPHOSPtMax() ; }
void SetEMCALEMin (Float_t e) { SetEMCALPtMin(e) ; }
void SetPHOSEMin (Float_t e) { SetPHOSPtMin (e) ; }
void SetEMCALEMax (Float_t e) { SetEMCALPtMax(e) ; }
void SetPHOSEMax (Float_t e) { SetPHOSPtMax (e) ; }
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 ; }
Double_t GetTrackTimeCutMin() const { return fTrackTimeCutMin ; }
Double_t GetTrackTimeCutMax() const { return fTrackTimeCutMax ; }
void SetTrackTimeCut(Double_t a, Double_t b) { fTrackTimeCutMin = a ;
fTrackTimeCutMax = b ; }
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 ; }
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 ; }
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 ; }
Bool_t IsCTSSwitchedOn() const { return fFillCTS ; }
void SwitchOnCTS() { fFillCTS = kTRUE ; }
void SwitchOffCTS() { fFillCTS = kFALSE ; }
Bool_t IsEMCALSwitchedOn() const { return fFillEMCAL ; }
void SwitchOnEMCAL() { fFillEMCAL = kTRUE ; }
void SwitchOffEMCAL() { fFillEMCAL = kFALSE ; }
Bool_t IsDCALSwitchedOn() const { return fFillDCAL ; }
void SwitchOnDCAL() { fFillDCAL = kTRUE ; }
void SwitchOffDCAL() { fFillDCAL = kFALSE ; }
Bool_t IsPHOSSwitchedOn() const { return fFillPHOS ; }
void SwitchOnPHOS() { fFillPHOS = kTRUE ; }
void SwitchOffPHOS() { fFillPHOS = kFALSE ; }
Bool_t IsEMCALCellsSwitchedOn() const { return fFillEMCALCells ; }
void SwitchOnEMCALCells() { fFillEMCALCells = kTRUE ; }
void SwitchOffEMCALCells() { fFillEMCALCells = kFALSE ; }
Bool_t IsPHOSCellsSwitchedOn() const { return fFillPHOSCells ; }
void SwitchOnPHOSCells() { fFillPHOSCells = kTRUE ; }
void SwitchOffPHOSCells() { fFillPHOSCells = kFALSE ; }
Bool_t AreClustersRecalculated() const { return fRecalculateClusters ; }
void SwitchOnClusterRecalculation() { fRecalculateClusters = kTRUE ; }
void SwitchOffClusterRecalculation() { fRecalculateClusters = kFALSE ; }
void SwitchOnClusterELinearityCorrection() { fCorrectELinearity = kTRUE ; }
void SwitchOffClusterELinearityCorrection() { fCorrectELinearity = kFALSE ; }
Bool_t IsShowerShapeSmeared() const { return fSmearShowerShape ; }
void SwitchOnShowerShapeSmearing() { fSmearShowerShape = kTRUE ; }
void SwitchOffShowerShapeSmearing() { fSmearShowerShape = kFALSE ; }
void SetShowerShapeSmearWidth(Float_t w ) { fSmearShowerShapeWidth = w ; }
Bool_t IsEmbeddedClusterSelectionOn() const { return fSelectEmbeddedClusters ; }
void SwitchOnEmbeddedClustersSelection() { fSelectEmbeddedClusters = kTRUE ; }
void SwitchOffEmbeddedClustersSelection() { fSelectEmbeddedClusters = kFALSE ; }
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 ; }
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 ; }
void AcceptFastClusterEvents() { fAcceptFastCluster = kTRUE ; }
void RejectFastClusterEvents() { fAcceptFastCluster = kFALSE ; }
Bool_t IsFastClusterAccepted() const { return fAcceptFastCluster ; }
Bool_t AcceptEventWithTriggerBit();
Bool_t RejectEventWithTriggerBit();
void SetAcceptEventsWithBit(UInt_t bit) { Int_t n = fAcceptEventsWithBit.GetSize();
fAcceptEventsWithBit.Set(n+1);
fAcceptEventsWithBit.AddAt(bit,n) ; }
void SetRejectEventsWithBit(UInt_t bit) { Int_t n = fRejectEventsWithBit.GetSize();
fRejectEventsWithBit.Set(n+1);
fRejectEventsWithBit.AddAt(bit,n) ; }
void SwitchOnLEDEventsRemoval() { fRemoveLEDEvents = kTRUE ; }
void SwitchOffLEDEventsRemoval() { fRemoveLEDEvents = kFALSE ; }
Bool_t IsLEDEventRemoved() const { return fRemoveLEDEvents ; }
Bool_t RejectLEDEvents();
void SetFiredTriggerClassName(TString name ) { fFiredTriggerClassName = name ; }
TString GetFiredTriggerClassName() const { return fFiredTriggerClassName ; }
TString GetFiredTriggerClasses() const { return GetInputEvent()->GetFiredTriggerClasses() ; }
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 ; }
TArrayI GetTriggerPatches(Int_t tmin, Int_t tmax);
void MatchTriggerCluster(TArrayI patches);
Bool_t CheckEventTriggers();
Bool_t IsExoticEvent() const { return fIsExoticEvent ; }
Bool_t IsBadCellTriggerEvent() const { return fIsBadCellEvent ; }
Bool_t IsBadMaxCellTriggerEvent() const { return fIsBadMaxCellEvent ; }
Bool_t IsTriggerMatched() const { return fIsTriggerMatch ; }
Bool_t IsTriggerMatchedOpenCuts(Int_t i) const { return fIsTriggerMatchOpenCut[i]; }
Int_t GetTriggerClusterBC() const { return fTriggerClusterBC ; }
Int_t GetTriggerClusterIndex() const { return fTriggerClusterIndex ; }
Int_t GetTriggerClusterId() const { return fTriggerClusterId ; }
Float_t GetEventTriggerL0Threshold() const { return fTriggerL0EventThreshold ; }
void SetEventTriggerL0Threshold(Float_t tr) { fTriggerL0EventThreshold = tr ; }
Float_t GetEventTriggerL1Threshold() const { return fTriggerL1EventThreshold ; }
void SetEventTriggerL1Threshold(Float_t tr) { fTriggerL1EventThreshold = tr ; fTriggerL1EventThresholdFix = kTRUE; }
void SetEventTriggerL1Bit(Int_t ega, Int_t eje) { fBitEGA = ega ; fBitEJE = eje; }
void SetTriggerPatchTimeWindow(Int_t min, Int_t max) { fTriggerPatchTimeWindow[0] = min ;
fTriggerPatchTimeWindow[1] = max ; }
Bool_t AreBadTriggerEventsRemoved() const { return fRemoveBadTriggerEvents ; }
void SwitchOffBadTriggerEventsRemoval() { fRemoveBadTriggerEvents = kFALSE ; }
void SwitchOnBadTriggerEventsRemoval() { fRemoveBadTriggerEvents = kTRUE ; }
Bool_t AreUnMatchedTriggerEventsRemoved()const { return fRemoveUnMatchedTriggers ; }
void SwitchOffUnMatchedTriggerEventsRemoval(){ fRemoveUnMatchedTriggers = kFALSE ; }
void SwitchOnUnMatchedTriggerEventsRemoval() { fRemoveUnMatchedTriggers = kTRUE ; }
Bool_t IsTriggerPatchMatchedToCluster() const { return fTriggerPatchClusterMatch ; }
void SwitchOffTriggerPatchMatching() { fTriggerPatchClusterMatch = kFALSE ; }
void SwitchOnTriggerPatchMatching() { fTriggerPatchClusterMatch = kTRUE ; }
Bool_t IsTriggerClusterTimeRecal() const { return fTriggerClusterTimeRecal ; }
void SwitchOnTriggerClusterTimeRecal () { fTriggerClusterTimeRecal = kTRUE ; }
void SwitchOffTriggerClusterTimeRecal() { fTriggerClusterTimeRecal = kFALSE ; }
void SetEventTriggerBit();
Bool_t IsEventMinimumBias() const { return fEventTrigMinBias ; }
Bool_t IsEventCentral() const { return fEventTrigCentral ; }
Bool_t IsEventSemiCentral() const { return fEventTrigSemiCentral ; }
Bool_t IsEventEMCALL0() const { return fEventTrigEMCALL0 ; }
Bool_t IsEventEMCALL1Gamma1() const { return fEventTrigEMCALL1Gamma1 ; }
Bool_t IsEventEMCALL1Gamma2() const { return fEventTrigEMCALL1Gamma2 ; }
Bool_t IsEventEMCALL1Jet1() const { return fEventTrigEMCALL1Jet1 ; }
Bool_t IsEventEMCALL1Jet2() const { return fEventTrigEMCALL1Jet2 ; }
Bool_t IsEventEMCALL1Gamma() const { return (fEventTrigEMCALL1Gamma1 || fEventTrigEMCALL1Gamma2) ; }
Bool_t IsEventEMCALL1Jet() const { return (fEventTrigEMCALL1Jet1 || fEventTrigEMCALL1Jet2 ) ; }
Bool_t IsEventEMCALL1() const { return (IsEventEMCALL1Gamma() || IsEventEMCALL1Jet() ) ; }
void SwitchOnEMCALEventRejectionWith2Thresholds() { fRejectEMCalTriggerEventsWith2Tresholds = kTRUE ; }
void SwitchOffEMCALEventRejectionWith2Thresholds() { fRejectEMCalTriggerEventsWith2Tresholds = kFALSE ; }
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 ; }
Double_t GetRunTimeStampMin() const { return fTimeStampRunMin ; }
Double_t GetRunTimeStampMax() const { return fTimeStampRunMax ; }
void SetRunTimeStamp(Double_t a, Double_t b) { fTimeStampRunMin = a ;
fTimeStampRunMax = b ; }
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 ; }
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 ; }
ULong_t GetTrackStatus() const { return fTrackStatus ; }
void SetTrackStatus(ULong_t bit) { fTrackStatus = bit ; }
virtual Bool_t SelectTrack(AliVTrack* , Double_t*) { return kFALSE ; }
void SwitchOnTrackHitSPDSelection() { fSelectSPDHitTracks = kTRUE ; }
void SwitchOffTrackHitSPDSelection() { fSelectSPDHitTracks = kFALSE ; }
Int_t GetTrackMultiplicity() const { return fTrackMult ; }
Float_t GetTrackMultiplicityEtaCut() const { return fTrackMultEtaCut ; }
void SetTrackMultiplicityEtaCut(Float_t eta) { fTrackMultEtaCut = eta ; }
virtual 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 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() { ; }
void AnalyzeOnlyLED() { fAnaLED = kTRUE ; }
void AnalyzeOnlyPhysics() { fAnaLED = kFALSE ; }
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 ; }
virtual Float_t GetZvertexCut() const { return fZvtxCut ; }
virtual void SetZvertexCut(Float_t zcut=10.) { fZvtxCut=zcut ; }
virtual AliCentrality* GetCentrality() const { if(fDataType!=kMC) return fInputEvent->GetCentrality() ;
else return 0x0 ; }
virtual void SetCentralityClass(TString name) { fCentralityClass = name ; }
virtual void SetCentralityOpt(Int_t opt) { fCentralityOpt = opt ; }
virtual TString GetCentralityClass() const { return fCentralityClass ; }
virtual Int_t GetCentralityOpt() const { return fCentralityOpt ; }
virtual Int_t GetEventCentrality() const ;
virtual void SetCentralityBin(Int_t min, Int_t max)
{ 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 ; }
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 ; }
AliCalorimeterUtils * GetCaloUtils() const { return fCaloUtils ; }
void SetCaloUtils(AliCalorimeterUtils * caloutils) { fCaloUtils = caloutils ; }
virtual Double_t GetBField() const { return fInputEvent->GetMagneticField() ; }
virtual AliStack* GetStack() const ;
virtual AliHeader* GetHeader() const ;
virtual AliGenEventHeader* GetGenEventHeader() const ;
virtual TClonesArray* GetAODMCParticles() const ;
virtual AliAODMCHeader* GetAODMCHeader () const ;
virtual AliVEvent* GetInputEvent() const { return fInputEvent ; }
virtual AliVEvent* GetOriginalInputEvent() const { return 0x0 ; }
virtual AliAODEvent* GetOutputEvent() const { return fOutputEvent ; }
virtual AliMCEvent* GetMC() const { return fMC ; }
virtual AliMixedEvent* GetMixedEvent() const { return fMixedEvent ; }
virtual Int_t GetNMixedEvent() const { return fNMixedEvent ; }
void SwitchOnStack() { fReadStack = kTRUE ; }
void SwitchOffStack() { fReadStack = kFALSE ; }
void SwitchOnAODMCParticles() { fReadAODMCParticles = kTRUE ; }
void SwitchOffAODMCParticles() { fReadAODMCParticles = kFALSE ; }
Bool_t ReadStack() const { return fReadStack ; }
Bool_t ReadAODMCParticles() const { return fReadAODMCParticles ; }
void RemapMCLabelForAODs(Int_t &label);
virtual Bool_t ComparePtHardAndJetPt() ;
virtual Bool_t IsPtHardAndJetPtComparisonSet() const { return fComparePtHardAndJetPt ; }
virtual void SetPtHardAndJetPtComparison(Bool_t compare) { fComparePtHardAndJetPt = compare ; }
virtual Float_t GetPtHardAndJetFactor() const { return fPtHardAndJetPtFactor ; }
virtual void SetPtHardAndJetPtFactor(Float_t factor) { fPtHardAndJetPtFactor = factor ; }
virtual Bool_t ComparePtHardAndClusterPt() ;
virtual Bool_t IsPtHardAndClusterPtComparisonSet() const { return fComparePtHardAndClusterPt ; }
virtual void SetPtHardAndClusterPtComparison(Bool_t compare) { fComparePtHardAndClusterPt = compare ; }
virtual Float_t GetPtHardAndClusterFactor() const { return fPtHardAndClusterPtFactor ; }
virtual void SetPtHardAndClusterPtFactor(Float_t factor) { fPtHardAndClusterPtFactor = factor ; }
virtual Bool_t IsHIJINGLabel(Int_t label);
void SetGeneratorMinMaxParticles();
void SwitchOnAcceptOnlyHIJINGLabels() { fAcceptOnlyHIJINGLabels = kTRUE ; }
void SwitchOffAcceptOnlyHIJINGLabels() { fAcceptOnlyHIJINGLabels = kFALSE ; }
Bool_t AcceptOnlyHIJINGLabels() const { return fAcceptOnlyHIJINGLabels ; }
virtual void AddNeutralParticlesArray(TArrayI & ) { ; }
virtual void AddChargedParticlesArray(TArrayI & ) { ; }
virtual void AddStatusArray(TArrayI & ) { ; }
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 ) { ; }
virtual void SetPHOSOverlapAngle(Float_t ) { ; }
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;
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 ;
ULong_t fTrackStatus ;
Bool_t fSelectSPDHitTracks ;
Int_t fTrackMult ;
Float_t fTrackMultEtaCut ;
Bool_t fReadStack ;
Bool_t fReadAODMCParticles ;
TString fDeltaAODFileName ;
TString fFiredTriggerClassName;
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;
Bool_t fAnaLED;
TString fTaskName;
AliCalorimeterUtils * fCaloUtils ;
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;
Float_t fZvtxCut ;
Bool_t fAcceptFastCluster;
Bool_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 ;
Bool_t fTimeStampEventSelect;
Float_t fTimeStampEventFracMin;
Float_t fTimeStampEventFracMax;
Double_t fTimeStampRunMin;
Double_t fTimeStampRunMax;
Double_t fPileUpParamSPD[5];
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;
TString fCentralityClass;
Int_t fCentralityOpt;
Int_t fCentralityBin[2];
TString fEventPlaneMethod;
Bool_t fAcceptOnlyHIJINGLabels;
Int_t fNMCProducedMin;
Int_t fNMCProducedMax;
Bool_t fFillInputNonStandardJetBranch;
TClonesArray * fNonStandardJets;
TString fInputNonStandardJetBranchName;
Bool_t fFillInputBackgroundJetBranch;
AliAODJetEventBackground * fBackgroundJets;
TString fInputBackgroundJetBranchName;
TArrayI fAcceptEventsWithBit;
TArrayI fRejectEventsWithBit;
Bool_t fRejectEMCalTriggerEventsWith2Tresholds;
TLorentzVector fMomentum;
AliCaloTrackReader( const AliCaloTrackReader & r) ;
AliCaloTrackReader & operator = (const AliCaloTrackReader & r) ;
ClassDef(AliCaloTrackReader,69)
} ;
#endif //ALICALOTRACKREADER_H