// Input/output event setters and getters
//---------------------------------------
- virtual void SetInputEvent(AliVEvent* const input) ;
- virtual void SetOutputEvent(AliAODEvent* const aod) { fOutputEvent = aod ; }
+ 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*/) { ; }
// Track DCA cut
- Bool_t AcceptDCA(const Float_t pt, const Float_t dca);
+ 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 ; }
Double_t GetEMCALTimeCutMin() const { return fEMCALTimeCutMin ; }
Double_t GetEMCALTimeCutMax() const { return fEMCALTimeCutMax ; }
- Bool_t IsInTimeWindow(const Double_t tof, const Float_t energy) const ;
+ Bool_t IsInTimeWindow(Double_t tof, Float_t energy) const ;
void SetEMCALTimeCut(Double_t a, Double_t b) { fEMCALTimeCutMin = a ;
fEMCALTimeCutMax = b ; } // ns
virtual AliFiducialCut * GetFiducialCut() {
if(!fFiducialCut) fFiducialCut = new AliFiducialCut();
return fFiducialCut ; }
- virtual void SetFiducialCut(AliFiducialCut * const fc) { fFiducialCut = fc ; }
+ virtual void SetFiducialCut(AliFiducialCut * fc) { fFiducialCut = fc ; }
virtual Bool_t IsFiducialCutOn() const { return fCheckFidCut ; }
virtual void SwitchOnFiducialCut() { fCheckFidCut = kTRUE ;
fFiducialCut = new AliFiducialCut() ; }
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 ; }
// Filling/ filtering / detector information access methods
- virtual Bool_t FillInputEvent(const Int_t iEntry, const char *currentFileName) ;
+ virtual Bool_t FillInputEvent(Int_t iEntry, const char *currentFileName) ;
virtual void FillInputCTS() ;
virtual void FillInputEMCAL() ;
- virtual void FillInputEMCALAlgorithm(AliVCluster * clus, const Int_t iclus) ;
+ virtual void FillInputEMCALAlgorithm(AliVCluster * clus, Int_t iclus) ;
virtual void FillInputPHOS() ;
virtual void FillInputEMCALCells() ;
virtual void FillInputPHOSCells() ;
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 ; }
void SwitchOffBadTriggerEventsRemoval() { fRemoveBadTriggerEvents = kFALSE ; }
void SwitchOnBadTriggerEventsRemoval() { fRemoveBadTriggerEvents = kTRUE ; }
+ void SwitchOffUnMatchedTriggerEventsRemoval(){ fRemoveUnMatchedTriggers = kFALSE ; }
+ void SwitchOnUnMatchedTriggerEventsRemoval() { fRemoveUnMatchedTriggers = kTRUE ; }
+
void SwitchOffTriggerPatchMatching() { fTriggerPatchClusterMatch = kFALSE ; }
void SwitchOnTriggerPatchMatching() { fTriggerPatchClusterMatch = kTRUE ; }
+ void SwitchOnTriggerClusterTimeRecal () { fTriggerClusterTimeRecal = kTRUE ; }
+ void SwitchOffTriggerClusterTimeRecal() { fTriggerClusterTimeRecal = kFALSE ; }
+
UInt_t GetMixEventTriggerMask() const { return fMixEventTriggerMask ; }
void SetMixEventTriggerMask(UInt_t evtTrig = AliVEvent::kAnyINT)
{ fMixEventTriggerMask = evtTrig ; }
ULong_t GetTrackStatus() const { return fTrackStatus ; }
void SetTrackStatus(ULong_t bit) { fTrackStatus = bit ; }
- ULong_t GetTrackFilterMask() const {return fTrackFilterMask ; }
- void SetTrackFilterMask(ULong_t bit) { fTrackFilterMask = bit ; }
+ ULong_t GetTrackFilterMask() const { return fTrackFilterMask ; }
+ void SetTrackFilterMask(ULong_t bit) { fTrackFilterMask = bit ; }
+
+ ULong_t GetTrackFilterMaskComplementary() const { return fTrackFilterMaskComplementary ; }
+ void SetTrackFilterMaskComplementary(ULong_t bit) { fTrackFilterMaskComplementary = bit ; }
AliESDtrackCuts* GetTrackCuts() const { return fESDtrackCuts ; }
void SetTrackCuts(AliESDtrackCuts * cuts) ;
void SwitchOnAODHybridTrackSelection() { fSelectHybridTracks = kTRUE ; }
void SwitchOffAODHybridTrackSelection() { fSelectHybridTracks = kFALSE ; }
+
+ void SwitchOnAODPrimaryTrackSelection() { fSelectPrimaryTracks = kTRUE ; }
+ void SwitchOffAODPrimaryTrackSelection() { fSelectPrimaryTracks = kFALSE ; }
void SwitchOnTrackHitSPDSelection() { fSelectSPDHitTracks = kTRUE ; }
void SwitchOffTrackHitSPDSelection() { fSelectSPDHitTracks = kFALSE ; }
+
+ void SwitchOnAODTrackSharedClusterSelection() { fSelectFractionTPCSharedClusters = kTRUE ; }
+ void SwitchOffAODTrackSharedClusterSelection(){ fSelectFractionTPCSharedClusters = kFALSE ; }
+
+ void SetTPCSharedClusterFraction(Float_t fr) { fCutTPCSharedClustersFraction = fr ; }
+ Float_t GetTPCSharedClusterFraction() const { return fCutTPCSharedClustersFraction ; }
Int_t GetTrackMultiplicity() const { return fTrackMult ; }
Float_t GetTrackMultiplicityEtaCut() const { return fTrackMultEtaCut ; }
//-------------------------------
virtual void GetVertex(Double_t v[3]) const ;
- virtual Double_t* GetVertex(const Int_t evtIndex) const { return fVertex[evtIndex] ; }
+ 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();
virtual Double_t GetBField() const { return fInputEvent->GetMagneticField() ; }
- void SetImportGeometryFromFile(Bool_t import,
- TString path = "") {
- fImportGeometryFromFile = import ;
- fImportGeometryFilePath = path ; }
-
//------------------------------------------------
// MC analysis specific methods
//-------------------------------------------------
virtual Float_t GetPtHardAndClusterFactor() const { return fPtHardAndClusterPtFactor ; }
virtual void SetPtHardAndClusterPtFactor(Float_t factor) { fPtHardAndClusterPtFactor = factor ; }
- virtual Bool_t IsHIJINGLabel(const Int_t label);
+ virtual Bool_t IsHIJINGLabel(Int_t label);
void SetGeneratorMinMaxParticles();
void SwitchOnAcceptOnlyHIJINGLabels() { fAcceptOnlyHIJINGLabels = kTRUE ; }
void SwitchOffAcceptOnlyHIJINGLabels() { fAcceptOnlyHIJINGLabels = kFALSE ; }
Bool_t fFillEMCALCells; // use data from EMCAL
Bool_t fFillPHOSCells; // use data from PHOS
Bool_t fRecalculateClusters; // Correct clusters, recalculate them if recalibration parameters is given
+ Bool_t fCorrectELinearity; // Correct cluster linearity, always on
Bool_t fSelectEmbeddedClusters; // Use only simulated clusters that come from embedding.
ULong_t fTrackStatus ; // Track selection bit, select tracks refitted in TPC, ITS ...
ULong_t fTrackFilterMask ; // Track selection bit, for AODs (any difference with track status?)
+ ULong_t fTrackFilterMaskComplementary; // Complementary Track selection bit, for AODs in case hybrid option selected
AliESDtrackCuts *fESDtrackCuts ; // Track cut
AliESDtrackCuts *fESDtrackComplementaryCuts; // Track cut, complementary cuts for hybrids
Bool_t fConstrainTrack ; // Constrain Track to vertex
Bool_t fSelectHybridTracks ; // Select CTS tracks of type hybrid (only for AODs)
+ Bool_t fSelectPrimaryTracks ; // Select CTS tracks of type hybrid (only for AODs)
Bool_t fSelectSPDHitTracks ; // Ensure that track hits SPD layers
+ Bool_t fSelectFractionTPCSharedClusters; // Accept only TPC tracks with over a given fraction of shared clusters
+ Float_t fCutTPCSharedClustersFraction; // Fraction of TPC shared clusters to be accepted.
Int_t fTrackMult ; // Track multiplicity
Float_t fTrackMultEtaCut ; // Track multiplicity eta cut
Bool_t fReadStack ; // Access kine information from stack
Bool_t fIsBadMaxCellEvent; // Bad cell triggered event flag, only max energy cell is bad
Bool_t fIsTriggerMatch; // Could match the event to a trigger patch?
Bool_t fIsTriggerMatchOpenCut[3]; // Could not match the event to a trigger patch?, retry opening cuts
-
+ Bool_t fTriggerClusterTimeRecal; // In case cluster already calibrated, do not try to recalibrate even if recalib on in RecoUtils.
+ Bool_t fRemoveUnMatchedTriggers; // Analyze events where trigger patch and cluster where found or not
+
Bool_t fDoEventSelection; // Select events depending on V0, pileup, vertex well reconstructed, at least 1 track ...
Bool_t fDoV0ANDEventSelection; // Select events depending on V0, fDoEventSelection should be on
Int_t fCentralityOpt; // Option for the returned value of the centrality, possible options 5, 10, 100
Int_t fCentralityBin[2]; // Minimum and maximum value of the centrality for the analysis
TString fEventPlaneMethod; // Name of event plane method, by default "Q"
-
- Bool_t fImportGeometryFromFile; // Import geometry settings in geometry.root file
- TString fImportGeometryFilePath; // path fo geometry.root file
Bool_t fAcceptOnlyHIJINGLabels; // Select clusters or tracks that where generated by HIJING, reject other generators in case of cocktail
Int_t fNMCProducedMin; // In case of cocktail, select particles in the list with label from this value
Int_t fNMCProducedMax; // In case of cocktail, select particles in the list with label up to this value
// jets
-
Bool_t fFillInputNonStandardJetBranch; // Flag to use data from non standard jets
TClonesArray * fNonStandardJets; //! temporal array with jets
TString fInputNonStandardJetBranchName; // Name of non standard jet branch
+ TArrayI fAcceptEventsWithBit; // Accept events if trigger bit is on
+ TArrayI fRejectEventsWithBit; // Reject events if trigger bit is on
+
AliCaloTrackReader( const AliCaloTrackReader & r) ; // cpy ctor
AliCaloTrackReader & operator = (const AliCaloTrackReader & r) ; // cpy assignment
- ClassDef(AliCaloTrackReader,59)
+ ClassDef(AliCaloTrackReader,64)
} ;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff