//____________________________________________________________________________
AliCaloTrackAODReader::AliCaloTrackAODReader() :
- AliCaloTrackReader(), fOrgInputEvent(0x0)
+ AliCaloTrackReader(), fOrgInputEvent(0x0),
+ fSelectHybridTracks(0), fSelectPrimaryTracks(0),
+ fTrackFilterMask(0), fTrackFilterMaskComplementary(0),
+ fSelectFractionTPCSharedClusters(0), fCutTPCSharedClustersFraction(0)
{
//Default Ctor
//Initialize parameters
- fDataType=kAOD;
+ fDataType = kAOD;
+
fReadStack = kTRUE;
fReadAODMCParticles = kFALSE;
+ fTrackFilterMask = 128;
+ fTrackFilterMaskComplementary = 0; // in case of hybrid tracks, without using the standard method
+
+ fSelectFractionTPCSharedClusters = kTRUE;
+ fCutTPCSharedClustersFraction = 0.4;
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliCaloTrackAODReader::SelectTrack(AliVTrack* track, Double_t pTrack[3])
+{
+ // Select AOD track using the AOD filter bits
+
+ AliAODTrack *aodtrack = dynamic_cast <AliAODTrack*>(track);
+
+ if(!aodtrack) return kFALSE;
+
+
+ if(fDebug > 2 ) printf("AliCaloTrackAODReader::FillInputCTS():AOD track type: %d (primary %d), hybrid? %d \n",
+ aodtrack->GetType(),AliAODTrack::kPrimary,
+ aodtrack->IsHybridGlobalConstrainedGlobal());
+
+ // Hybrid?
+ if (fSelectHybridTracks && fTrackFilterMaskComplementary == 0)
+ {
+ if (!aodtrack->IsHybridGlobalConstrainedGlobal()) return kFALSE ;
+ }
+ else // Filter Bit?
+ {
+ Bool_t accept = aodtrack->TestFilterBit(fTrackFilterMask);
+
+ if(!fSelectHybridTracks && !accept) return kFALSE ;
+
+ if(fSelectHybridTracks) // Second filter bit for hybrids?
+ {
+ Bool_t acceptcomplement = aodtrack->TestFilterBit(fTrackFilterMaskComplementary);
+ if (!accept && !acceptcomplement) return kFALSE ;
+ }
+ }
+
+ //
+ if(fSelectSPDHitTracks)
+ { // Not much sense to use with TPC only or Hybrid tracks
+ if(!aodtrack->HasPointOnITSLayer(0) && !aodtrack->HasPointOnITSLayer(1)) return kFALSE ;
+ }
+
+ //
+ if ( fSelectFractionTPCSharedClusters )
+ {
+ Double_t frac = Double_t(aodtrack->GetTPCnclsS()) / Double_t(aodtrack->GetTPCncls());
+ if (frac > fCutTPCSharedClustersFraction)
+ {
+ if (fDebug > 2 )printf("\t Reject track, shared cluster fraction %f > %f\n",frac, fCutTPCSharedClustersFraction);
+ return kFALSE ;
+ }
+ }
+
+ //
+ if ( fSelectPrimaryTracks )
+ {
+ if ( aodtrack->GetType()!= AliAODTrack::kPrimary )
+ {
+ if (fDebug > 2 ) printf("\t Remove not primary track\n");
+ return kFALSE ;
+ }
+ }
+
+ if (fDebug > 2 ) printf("\t accepted track! \n");
+
+ track->GetPxPyPz(pTrack) ;
+
+ return kTRUE;
+
}
+
//_________________________________________________________________
-void AliCaloTrackAODReader::SetInputOutputMCEvent(AliVEvent* input,
- AliAODEvent* aod,
- AliMCEvent* mc)
+void AliCaloTrackAODReader::SetInputOutputMCEvent(AliVEvent* input,
+ AliAODEvent* aod,
+ AliMCEvent* mc)
{
// Connect the data pointers
// If input is AOD, do analysis with input, if not, do analysis with the output aod.
public:
- AliCaloTrackAODReader() ; // ctor
+ AliCaloTrackAODReader() ; // ctor
- virtual ~AliCaloTrackAODReader() {;} // virtual dtor
-
- void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ;
+ virtual ~AliCaloTrackAODReader() {;} // virtual dtor
+
+ AliVEvent * GetOriginalInputEvent() const { return fOrgInputEvent; }
+
+ Bool_t SelectTrack(AliVTrack* track, Double_t* pTrack);
+
+ 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 ; }
+
+ void SwitchOnAODHybridTrackSelection() { fSelectHybridTracks = kTRUE ; }
+ void SwitchOffAODHybridTrackSelection() { fSelectHybridTracks = kFALSE ; }
+
+ void SwitchOnAODPrimaryTrackSelection() { fSelectPrimaryTracks = kTRUE ; }
+ void SwitchOffAODPrimaryTrackSelection() { fSelectPrimaryTracks = kFALSE ; }
+
+ void SwitchOnAODTrackSharedClusterSelection() { fSelectFractionTPCSharedClusters = kTRUE ; }
+ void SwitchOffAODTrackSharedClusterSelection(){ fSelectFractionTPCSharedClusters = kFALSE ; }
+
+ void SetTPCSharedClusterFraction(Float_t fr) { fCutTPCSharedClustersFraction = fr ; }
+ Float_t GetTPCSharedClusterFraction() const { return fCutTPCSharedClustersFraction ; }
+
+ void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ;
- AliVEvent* GetOriginalInputEvent() const { return fOrgInputEvent; }
-
private:
- AliVEvent *fOrgInputEvent; //! Original input event, not from filtering
+ AliVEvent * fOrgInputEvent; //! Original input event, not from filtering
+
+ Bool_t fSelectHybridTracks; // Select CTS tracks of type hybrid
+ Bool_t fSelectPrimaryTracks; // Select CTS tracks of type primary
+ 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
+ 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.
+
AliCaloTrackAODReader( const AliCaloTrackAODReader & r) ; // cpy ctor
AliCaloTrackAODReader & operator = (const AliCaloTrackAODReader & r) ; // cpy assignment
- ClassDef(AliCaloTrackAODReader,6)
+ ClassDef(AliCaloTrackAODReader,7)
} ;
#include "AliAnalysisManager.h"
#include "AliMixedEvent.h"
#include "AliESDEvent.h"
+#include "AliESDtrackCuts.h"
ClassImp(AliCaloTrackESDReader)
//______________________________________________
AliCaloTrackESDReader::AliCaloTrackESDReader() :
-AliCaloTrackReader()
+AliCaloTrackReader(), fConstrainTrack(0),
+fESDtrackCuts(0), fESDtrackComplementaryCuts(0)
{
//Default Ctor
//Initialize parameters
- fDataType=kESD;
+ fDataType = kESD;
fReadStack = kTRUE;
fReadAODMCParticles = kFALSE;
+ fConstrainTrack = kFALSE ; // constrain tracks to vertex
}
+//_____________________________________________
+AliCaloTrackESDReader::~AliCaloTrackESDReader()
+{
+ //Dtor
+
+ AliCaloTrackReader::~AliCaloTrackReader();
+
+ delete fESDtrackCuts;
+ delete fESDtrackComplementaryCuts;
+}
+
+//________________________________
+void AliCaloTrackESDReader::Init()
+{
+ //Init reader. Method to be called in AliAnaCaloTrackCorrMaker
+
+ AliCaloTrackReader::Init();
+
+ if(!fESDtrackCuts)
+ fESDtrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts(); //initialize with TPC only tracks
+}
+
+//_____________________________________________________________________________
+Bool_t AliCaloTrackESDReader::SelectTrack(AliVTrack* track, Double_t pTrack[3])
+{
+ // Select ESD track using the cuts declared in fESDtrackCuts
+ // in case of hybrid tracks, 2 different sets of cuts defined.
+
+ AliESDtrack* esdTrack = dynamic_cast<AliESDtrack*> (track);
+
+ if(!esdTrack) return kFALSE;
+
+ const AliExternalTrackParam* constrainParam = esdTrack->GetConstrainedParam();
+
+ if(fESDtrackCuts->AcceptTrack(esdTrack))
+ {
+ track->GetPxPyPz(pTrack) ;
+
+ if(fConstrainTrack)
+ {
+ if( !constrainParam ) return kFALSE;
+
+ esdTrack->Set(constrainParam->GetX(),constrainParam->GetAlpha(),constrainParam->GetParameter(),constrainParam->GetCovariance());
+ esdTrack->GetConstrainedPxPyPz(pTrack);
+
+ } // use constrained tracks
+
+ if(fSelectSPDHitTracks && !esdTrack->HasPointOnITSLayer(0) && !esdTrack->HasPointOnITSLayer(1))
+ return kFALSE ; // Not much sense to use with TPC only or Hybrid tracks
+ }
+
+ // Complementary track to global : Hybrids (make sure that the previous selection is for Global)
+ else if(fESDtrackComplementaryCuts && fESDtrackComplementaryCuts->AcceptTrack(esdTrack))
+ {
+ // constrain the track
+ if( !constrainParam ) return kFALSE;
+
+ esdTrack->Set(constrainParam->GetX(),constrainParam->GetAlpha(),constrainParam->GetParameter(),constrainParam->GetCovariance());
+ esdTrack->GetConstrainedPxPyPz(pTrack);
+
+ }
+ else return kFALSE;
+
+ return kTRUE;
+}
+
+//_______________________________________________________________
+void AliCaloTrackESDReader::SetTrackCuts(AliESDtrackCuts * cuts)
+{
+ // Set Track cuts
+
+ if(fESDtrackCuts) delete fESDtrackCuts ;
+
+ fESDtrackCuts = cuts ;
+
+}
+
+//____________________________________________________________________________
+void AliCaloTrackESDReader::SetTrackComplementaryCuts(AliESDtrackCuts * cuts)
+{
+ // Set Track cuts for complementary tracks (hybrids)
+
+ if(fESDtrackComplementaryCuts) delete fESDtrackComplementaryCuts ;
+
+ fESDtrackComplementaryCuts = cuts ;
+
+}
+
//_________________________________________________________________
-void AliCaloTrackESDReader::SetInputOutputMCEvent(AliVEvent* esd,
- AliAODEvent* aod,
+void AliCaloTrackESDReader::SetInputOutputMCEvent(AliVEvent* esd,
+ AliAODEvent* aod,
AliMCEvent* mc)
{
// Connect the data pointers
class AliCaloTrackESDReader : public AliCaloTrackReader {
- public:
+public:
- AliCaloTrackESDReader() ; // ctor
+ AliCaloTrackESDReader() ; // ctor
- virtual ~AliCaloTrackESDReader() {;} // virtual dtor
+ virtual ~AliCaloTrackESDReader() ; // virtual dtor
- void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ;
-
- ClassDef(AliCaloTrackESDReader,1)
+ void Init();
+
+ Bool_t SelectTrack(AliVTrack* track, Double_t* pTrack);
+
+ AliESDtrackCuts* GetTrackCuts() const { return fESDtrackCuts ; }
+ void SetTrackCuts(AliESDtrackCuts * cuts) ;
+
+ AliESDtrackCuts* GetTrackComplementaryCuts() const { return fESDtrackComplementaryCuts ; }
+ void SetTrackComplementaryCuts(AliESDtrackCuts * cuts) ;
+
+ void SwitchOnConstrainTrackToVertex() { fConstrainTrack = kTRUE ; }
+ void SwitchOffConstrainTrackToVertex() { fConstrainTrack = kFALSE ; }
+
+ void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ;
+
+private:
+
+ Bool_t fConstrainTrack; // Constrain Track to vertex
+ AliESDtrackCuts* fESDtrackCuts ; // Track cut
+ AliESDtrackCuts* fESDtrackComplementaryCuts; // Track cut, complementary cuts for hybrids
+
+ ClassDef(AliCaloTrackESDReader,2)
} ;
#include "AliVTrack.h"
#include "AliVParticle.h"
#include "AliMixedEvent.h"
-#include "AliESDtrack.h"
-#include "AliESDtrackCuts.h"
//#include "AliTriggerAnalysis.h"
#include "AliESDVZERO.h"
#include "AliVCaloCells.h"
fFillEMCALCells(0), fFillPHOSCells(0),
fRecalculateClusters(kFALSE),fCorrectELinearity(kTRUE),
fSelectEmbeddedClusters(kFALSE),
-fTrackStatus(0), fTrackFilterMask(0), fTrackFilterMaskComplementary(0),
-fESDtrackCuts(0), fESDtrackComplementaryCuts(0), fConstrainTrack(kFALSE),
-fSelectHybridTracks(0), fSelectPrimaryTracks(0),
-fSelectSPDHitTracks(0), fSelectFractionTPCSharedClusters(0), fCutTPCSharedClustersFraction(0),
+fTrackStatus(0), fSelectSPDHitTracks(0),
fTrackMult(0), fTrackMultEtaCut(0.9),
fReadStack(kFALSE), fReadAODMCParticles(kFALSE),
fDeltaAODFileName(""), fFiredTriggerClassName(""),
delete [] fVertex ;
}
- delete fESDtrackCuts;
- delete fESDtrackComplementaryCuts;
//delete fTriggerAnalysis;
if(fNonStandardJets)
//_____________________________
void AliCaloTrackReader::Init()
{
- //Init reader. Method to be called in AliAnaPartCorrMaker
-
- //printf(" AliCaloTrackReader::Init() %p \n",gGeoManager);
-
+ //Init reader. Method to be called in AliAnaCaloTrackCorrMaker
+
if(fReadStack && fReadAODMCParticles)
{
printf("AliCaloTrackReader::Init() - Cannot access stack and mcparticles at the same time, change them \n");
fReadStack = kFALSE;
fReadAODMCParticles = kFALSE;
}
-
- if(!fESDtrackCuts)
- fESDtrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts(); //initialize with TPC only tracks
-
}
//_______________________________________
//fTrackStatus=AliESDtrack::kTPCrefit;
//fTrackStatus|=AliESDtrack::kITSrefit;
fTrackStatus = 0;
- fTrackFilterMask = 128; //For AODs, but what is the difference between fTrackStatus and fTrackFilterMask?
- fTrackFilterMaskComplementary = 0; // in case of hybrid tracks, without using the standard method
-
- fSelectFractionTPCSharedClusters = kTRUE;
- fCutTPCSharedClustersFraction = 0.4,
-
- fESDtrackCuts = 0;
- fESDtrackComplementaryCuts = 0;
-
- fConstrainTrack = kFALSE ; // constrain tracks to vertex
fV0ADC[0] = 0; fV0ADC[1] = 0;
fV0Mul[0] = 0; fV0Mul[1] = 0;
nstatus++;
- Float_t dcaTPC =-999;
-
- if (fDataType==kESD)
- {
- AliESDtrack* esdTrack = dynamic_cast<AliESDtrack*> (track);
-
- if(esdTrack)
- {
- if(fESDtrackCuts->AcceptTrack(esdTrack))
- {
- track->GetPxPyPz(pTrack) ;
-
- if(fConstrainTrack)
- {
- if(esdTrack->GetConstrainedParam())
- {
- const AliExternalTrackParam* constrainParam = esdTrack->GetConstrainedParam();
- esdTrack->Set(constrainParam->GetX(),constrainParam->GetAlpha(),constrainParam->GetParameter(),constrainParam->GetCovariance());
- esdTrack->GetConstrainedPxPyPz(pTrack);
- }
- else continue;
-
- } // use constrained tracks
-
- if(fSelectSPDHitTracks)
- {//Not much sense to use with TPC only or Hybrid tracks
- if(!esdTrack->HasPointOnITSLayer(0) && !esdTrack->HasPointOnITSLayer(1)) continue ;
- }
- }
- // Complementary track to global : Hybrids (make sure that the previous selection is for Global)
- else if(fESDtrackComplementaryCuts && fESDtrackComplementaryCuts->AcceptTrack(esdTrack))
- {
- // constrain the track
- if(esdTrack->GetConstrainedParam())
- {
- esdTrack->Set(esdTrack->GetConstrainedParam()->GetX(),esdTrack->GetConstrainedParam()->GetAlpha(),esdTrack->GetConstrainedParam()->GetParameter(),esdTrack->GetConstrainedParam()->GetCovariance());
-
- track->GetPxPyPz(pTrack) ;
-
- }
- else continue;
- }
- else continue;
- }
- } // ESD
- else if(fDataType==kAOD)
- {
- AliAODTrack *aodtrack = dynamic_cast <AliAODTrack*>(track);
-
- if(aodtrack)
- {
- if(fDebug > 2 ) printf("AliCaloTrackReader::FillInputCTS():AOD track type: %d (primary %d), hybrid? %d \n",
- aodtrack->GetType(),AliAODTrack::kPrimary,
- aodtrack->IsHybridGlobalConstrainedGlobal());
-
- if (fSelectHybridTracks && fTrackFilterMaskComplementary == 0)
- {
- if (!aodtrack->IsHybridGlobalConstrainedGlobal()) continue ;
- }
- else
- {
- Bool_t accept = aodtrack->TestFilterBit(fTrackFilterMask);
-
- if(!fSelectHybridTracks && !accept) continue ;
-
- if(fSelectHybridTracks)
- {
- Bool_t acceptcomplement = aodtrack->TestFilterBit(fTrackFilterMaskComplementary);
- if (!accept && !acceptcomplement) continue ;
- }
- }
-
- if(fSelectSPDHitTracks)
- {//Not much sense to use with TPC only or Hybrid tracks
- if(!aodtrack->HasPointOnITSLayer(0) && !aodtrack->HasPointOnITSLayer(1)) continue ;
- }
-
- if ( fSelectFractionTPCSharedClusters )
- {
- Double_t frac = Double_t(aodtrack->GetTPCnclsS()) / Double_t(aodtrack->GetTPCncls());
- if (frac > fCutTPCSharedClustersFraction)
- {
- if (fDebug > 2 )printf("\t Reject track, shared cluster fraction %f > %f\n",frac, fCutTPCSharedClustersFraction);
- continue ;
- }
- }
-
- if ( fSelectPrimaryTracks )
- {
- if ( aodtrack->GetType()!= AliAODTrack::kPrimary )
- {
- if (fDebug > 2 ) printf("\t Remove not primary track\n");
- continue ;
- }
- }
-
- if (fDebug > 2 ) printf("\t accepted track! \n");
-
- //In case of AODs, TPC tracks cannot be propagated back to primary vertex,
- // info stored here
- dcaTPC = aodtrack->DCA();
-
- track->GetPxPyPz(pTrack) ;
-
- } // aod track exists
- else continue ;
-
- } // AOD
+ // Select the tracks depending on cuts of AOD or ESD
+ if(!SelectTrack(track, pTrack)) continue ;
// TOF cuts
Bool_t okTOF = ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) ;
// DCA cuts
if(fUseTrackDCACut)
- {
+ {
+ Float_t dcaTPC =-999;
+ //In case of AODs, TPC tracks cannot be propagated back to primary vertex,
+ if( fDataType == kAOD ) dcaTPC = ((AliAODTrack*) track)->DCA();
+
//normal way to get the dca, cut on dca_xy
if(dcaTPC==-999)
{
printf("Use EMCAL Cells = %d\n", fFillEMCALCells) ;
printf("Use PHOS Cells = %d\n", fFillPHOSCells) ;
printf("Track status = %d\n", (Int_t) fTrackStatus) ;
- printf("AODs Track filter mask = %d or hybrid %d (if filter bit comp %d), select : SPD hit %d, primary %d\n",
- (Int_t) fTrackFilterMask, fSelectHybridTracks, (Int_t) fTrackFilterMaskComplementary, fSelectSPDHitTracks,fSelectPrimaryTracks) ;
+ //printf("AODs Track filter mask = %d or hybrid %d (if filter bit comp %d), select : SPD hit %d, primary %d\n",
+ // (Int_t) fTrackFilterMask, fSelectHybridTracks, (Int_t) fTrackFilterMaskComplementary, fSelectSPDHitTracks,fSelectPrimaryTracks) ;
printf("Track Mult Eta Cut = %d\n", (Int_t) fTrackMultEtaCut) ;
printf("Write delta AOD = %d\n", fWriteOutputDeltaAOD) ;
printf("Recalculate Clusters = %d, E linearity = %d\n", fRecalculateClusters, fCorrectELinearity) ;
}
}
-//____________________________________________________________
-void AliCaloTrackReader::SetTrackCuts(AliESDtrackCuts * cuts)
-{
- // Set Track cuts
-
- if(fESDtrackCuts) delete fESDtrackCuts ;
-
- fESDtrackCuts = cuts ;
-
-}
-
-//_________________________________________________________________________
-void AliCaloTrackReader::SetTrackComplementaryCuts(AliESDtrackCuts * cuts)
-{
- // Set Track cuts for complementary tracks (hybrids)
-
- if(fESDtrackComplementaryCuts) delete fESDtrackComplementaryCuts ;
-
- fESDtrackComplementaryCuts = cuts ;
-
-}
-
class AliMCEvent;
class AliMixedEvent;
class AliAODMCHeader;
-class AliESDtrackCuts;
class AliCentrality;
+class AliESDtrackCuts;
//class AliTriggerAnalysis;
class AliEventplane;
class AliVCluster;
// Track selection
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 GetTrackFilterMaskComplementary() const { return fTrackFilterMaskComplementary ; }
- void SetTrackFilterMaskComplementary(ULong_t bit) { fTrackFilterMaskComplementary = bit ; }
-
- AliESDtrackCuts* GetTrackCuts() const { return fESDtrackCuts ; }
- void SetTrackCuts(AliESDtrackCuts * cuts) ;
-
- AliESDtrackCuts* GetTrackComplementaryCuts() const { return fESDtrackComplementaryCuts ; }
- void SetTrackComplementaryCuts(AliESDtrackCuts * cuts) ;
+ void SetTrackStatus(ULong_t bit) { fTrackStatus = bit ; }
-
- void SwitchOnConstrainTrackToVertex() { fConstrainTrack = kTRUE ; }
- void SwitchOffConstrainTrackToVertex() { fConstrainTrack = kFALSE ; }
-
- void SwitchOnAODHybridTrackSelection() { fSelectHybridTracks = kTRUE ; }
- void SwitchOffAODHybridTrackSelection() { fSelectHybridTracks = kFALSE ; }
-
- void SwitchOnAODPrimaryTrackSelection() { fSelectPrimaryTracks = kTRUE ; }
- void SwitchOffAODPrimaryTrackSelection() { fSelectPrimaryTracks = kFALSE ; }
+ virtual Bool_t SelectTrack(AliVTrack* , Double_t*) { return kFALSE ; } // See AOD/ESD reader
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 ; }
void SetTrackMultiplicityEtaCut(Float_t eta) { fTrackMultEtaCut = eta ; }
+ // virtual for AODReader
+
+ virtual ULong_t GetTrackFilterMask() const { return 0 ; }
+ virtual void SetTrackFilterMask(ULong_t) { ; }
+
+ virtual ULong_t GetTrackFilterMaskComplementary() const { return 0 ; }
+ virtual void SetTrackFilterMaskComplementary(ULong_t) { ; }
+
+ virtual void SwitchOnAODHybridTrackSelection() { ; }
+ virtual void SwitchOffAODHybridTrackSelection() { ; }
+
+ virtual void SwitchOnAODPrimaryTrackSelection() { ; }
+ virtual void SwitchOffAODPrimaryTrackSelection() { ; }
+
+ virtual void SwitchOnAODTrackSharedClusterSelection() { ; }
+ virtual void SwitchOffAODTrackSharedClusterSelection(){ ; }
+
+ virtual void SetTPCSharedClusterFraction(Float_t) { ; }
+ virtual Float_t GetTPCSharedClusterFraction() const { return 0 ; }
+
+ // virtual for ESDReader
+
+ virtual AliESDtrackCuts* GetTrackCuts() const { return 0 ; }
+ virtual AliESDtrackCuts* GetTrackComplementaryCuts() const { return 0 ; }
+
+ virtual void SetTrackCuts(AliESDtrackCuts *) { ; }
+ virtual void SetTrackComplementaryCuts(AliESDtrackCuts *) { ; }
+
+ virtual void SwitchOnConstrainTrackToVertex() { ; }
+ virtual void SwitchOffConstrainTrackToVertex() { ; }
+
// Calorimeter specific and patches
void AnalyzeOnlyLED() { fAnaLED = kTRUE ; }
void AnalyzeOnlyPhysics() { fAnaLED = kFALSE ; }
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 fReadAODMCParticles ; // Access kine information from filtered AOD MC particles
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff