class AliVCluster;
class AliVCaloCells;
class AliVEvent;
-class AliESDEvent;
#include "AliLog.h"
// EMCAL includes
void Print(const Option_t*) const;
//enums
- enum NonlinearityFunctions{kPi0MC=0,kPi0GammaGamma=1,kPi0GammaConversion=2,kNoCorrection=3,kBeamTest=4,kBeamTestCorrected=5};
+ enum NonlinearityFunctions{kPi0MC=0,kPi0GammaGamma=1,kPi0GammaConversion=2,kNoCorrection=3,kBeamTest=4,kBeamTestCorrected=5,kPi0MCv2=6,kPi0MCv3=7,kBeamTestCorrectedv2=8};
enum PositionAlgorithms{kUnchanged=-1,kPosTowerIndex=0, kPosTowerGlobal=1};
enum ParticleType{kPhoton=0, kElectron=1,kHadron =2, kUnknown=-1};
- enum { kNCuts = 11 }; //track matching
- enum TrackCutsType{kTPCOnlyCut=0, kGlobalCut=1, kLooseCut=2};
+ enum { kNCuts = 12 }; //track matching Marcel
+ enum TrackCutsType{kTPCOnlyCut=0, kGlobalCut=1, kLooseCut=2, kITSStandAlone=3}; //Marcel
//-----------------------------------------------------
//Position recalculation
void RecalculateClusterPositionFromTowerIndex (const AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu);
void RecalculateClusterPositionFromTowerGlobal(const AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu);
- Float_t GetCellWeight(const Float_t eCell, const Float_t eCluster) const { return TMath::Max( 0., fW0 + TMath::Log( eCell / eCluster )) ; }
+ Float_t GetCellWeight(const Float_t eCell, const Float_t eCluster) const { if (eCell > 0 && eCluster > 0) return TMath::Max( 0., fW0 + TMath::Log( eCell / eCluster )) ;
+ else return 0. ; }
Float_t GetDepth(const Float_t eCluster, const Int_t iParticle, const Int_t iSM) const ;
Float_t CorrectClusterEnergyLinearity(AliVCluster* clu) ;
- Float_t GetNonLinearityParam(const Int_t i) const { if(i < 7 ){ return fNonLinearityParams[i] ; }
- else { AliInfo(Form("Index %d larger than 7, do nothing\n",i)) ;
+ Float_t GetNonLinearityParam(const Int_t i) const { if(i < 7 && i >=0 ){ return fNonLinearityParams[i] ; }
+ else { AliInfo(Form("Index %d larger than 6 or negative, do nothing\n",i)) ;
return 0. ; } }
void SetNonLinearityParam(const Int_t i, const Float_t param) {
- if(i < 7 ){fNonLinearityParams[i] = param ; }
- else { AliInfo(Form("Index %d larger than 7, do nothing\n",i)) ; } }
+ if(i < 7 && i >=0 ){ fNonLinearityParams[i] = param ; }
+ else { AliInfo(Form("Index %d larger than 6 or negative, do nothing\n",i)) ; } }
void InitNonLinearityParam();
Int_t GetNonLinearityFunction() const { return fNonLinearityFunction ; }
void SwitchOnRecalibration() { fRecalibration = kTRUE ;
if(!fEMCALRecalibrationFactors)InitEMCALRecalibrationFactors() ; }
void InitEMCALRecalibrationFactors() ;
+ TObjArray* GetEMCALRecalibrationFactorsArray() const { return fEMCALRecalibrationFactors ; }
TH2F * GetEMCALChannelRecalibrationFactors(Int_t iSM) const { return (TH2F*)fEMCALRecalibrationFactors->At(iSM) ; }
void SetEMCALChannelRecalibrationFactors(TObjArray *map) { fEMCALRecalibrationFactors = map ; }
((TH2F*)fEMCALRecalibrationFactors->At(iSM))->SetBinContent(iCol,iRow,c) ; }
//Recalibrate channels energy with run dependent corrections
+ Bool_t IsRunDepRecalibrationOn() const { return fUseRunCorrectionFactors ; }
+
void SwitchOffRunDepCorrection() { fUseRunCorrectionFactors = kFALSE ; }
void SwitchOnRunDepCorrection() { fUseRunCorrectionFactors = kTRUE ;
- SwitchOnRecalibration() ; }
- void SetRunDependentCorrections(Int_t runnumber);
-
+ SwitchOnRecalibration() ; }
// Time Recalibration
void RecalibrateCellTime(const Int_t absId, const Int_t bc, Double_t & time) const;
void SwitchOnTimeRecalibration() { fTimeRecalibration = kTRUE ;
if(!fEMCALTimeRecalibrationFactors)InitEMCALTimeRecalibrationFactors() ; }
void InitEMCALTimeRecalibrationFactors() ;
-
+ TObjArray* GetEMCALTimeRecalibrationFactorsArray() const { return fEMCALTimeRecalibrationFactors ; }
+
Float_t GetEMCALChannelTimeRecalibrationFactor(const Int_t bc, const Int_t absID) const {
if(fEMCALTimeRecalibrationFactors)
return (Float_t) ((TH1F*)fEMCALTimeRecalibrationFactors->At(bc))->GetBinContent(absID);
void SwitchOnDistToBadChannelRecalculation() { fRecalDistToBadChannels = kTRUE ;
if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap() ; }
+ TObjArray* GetEMCALBadChannelStatusMapArray() const { return fEMCALBadChannelMap ; }
void InitEMCALBadChannelStatusMap() ;
Int_t GetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow) const {
void RecalculateClusterDistanceToBadChannel (const AliEMCALGeometry * geom, AliVCaloCells* cells, AliVCluster * cluster);
void RecalculateClusterShowerShapeParameters(const AliEMCALGeometry * geom, AliVCaloCells* cells, AliVCluster * cluster);
+ void RecalculateClusterShowerShapeParameters(const AliEMCALGeometry * geom, AliVCaloCells* cells, AliVCluster * cluster,
+ Float_t & l0, Float_t & l1,
+ Float_t & disp, Float_t & dEta, Float_t & dPhi,
+ Float_t & sEta, Float_t & sPhi, Float_t & sEtaPhi);
+
void RecalculateClusterPID(AliVCluster * cluster);
AliEMCALPIDUtils * GetPIDUtils() { return fPIDUtils;}
void FindMatches(AliVEvent *event, TObjArray * clusterArr=0x0, const AliEMCALGeometry *geom=0x0);
Int_t FindMatchedClusterInEvent(const AliESDtrack *track, const AliVEvent *event,
const AliEMCALGeometry *geom, Float_t &dEta, Float_t &dPhi);
- Int_t FindMatchedClusterInClusterArr(AliExternalTrackParam *emcalParam, AliExternalTrackParam *trkParam,
- TObjArray * clusterArr, Float_t &dEta, Float_t &dPhi);
+ Int_t FindMatchedClusterInClusterArr(const AliExternalTrackParam *emcalParam,
+ AliExternalTrackParam *trkParam,
+ const TObjArray * clusterArr,
+ Float_t &dEta, Float_t &dPhi);
static Bool_t ExtrapolateTrackToEMCalSurface(AliExternalTrackParam *trkParam,
const Double_t emcalR, const Double_t mass, const Double_t step,
- Float_t &eta, Float_t &phi);
+ Float_t &eta, Float_t &phi, Float_t &pt);
static Bool_t ExtrapolateTrackToPosition(AliExternalTrackParam *trkParam, const Float_t *clsPos,
const Double_t mass, const Double_t step,
Float_t &tmpEta, Float_t &tmpPhi);
- static Bool_t ExtrapolateTrackToCluster (AliExternalTrackParam *trkParam, AliVCluster *cluster,
+ static Bool_t ExtrapolateTrackToCluster (AliExternalTrackParam *trkParam, const AliVCluster *cluster,
const Double_t mass, const Double_t step,
Float_t &tmpEta, Float_t &tmpPhi);
- Bool_t ExtrapolateTrackToCluster (AliExternalTrackParam *trkParam, AliVCluster *cluster,
+ Bool_t ExtrapolateTrackToCluster (AliExternalTrackParam *trkParam, const AliVCluster *cluster,
Float_t &tmpEta, Float_t &tmpPhi);
UInt_t FindMatchedPosForCluster(const Int_t clsIndex) const;
Bool_t IsClusterMatched(const Int_t clsIndex) const;
Bool_t IsTrackMatched (const Int_t trkIndex) const;
- void SetClusterMatchedToTrack (const AliESDEvent *event);
-
- void SetTracksMatchedToCluster(const AliESDEvent *event);
+ void SetClusterMatchedToTrack (const AliVEvent *event);
+ void SetTracksMatchedToCluster(const AliVEvent *event);
void SwitchOnCutEtaPhiSum() { fCutEtaPhiSum = kTRUE ;
fCutEtaPhiSeparate = kFALSE ; }
void SetCutPhi(Float_t cutPhi) { fCutPhi = cutPhi ; }
void SetClusterWindow(Double_t window) { fClusterWindow = window ; }
void SetCutZ(Float_t cutZ) { printf("Obsolete fucntion of cutZ=%1.1f\n",cutZ) ; } //Obsolete
+ void SetEMCalSurfaceDistance(Double_t d) { fEMCalSurfaceDistance = d ; }
Double_t GetMass() const { return fMass ; }
Double_t GetStep() const { return fStepCluster ; }
void SetStep(Double_t step) { fStepSurface = step ; }
void SetStepCluster(Double_t step) { fStepCluster = step ; }
+ void SetITSTrackSA(Bool_t isITS) { fITSTrackSA = isITS ; } //Special Handle of AliExternTrackParam
+
// Exotic cells / clusters
Bool_t IsExoticCell(const Int_t absId, AliVCaloCells* cells, const Int_t bc =-1) ;
void SwitchOnRejectExoticCell() { fRejectExoticCells = kTRUE ; }
void SwitchOffRejectExoticCell() { fRejectExoticCells = kFALSE ; }
+ Bool_t IsRejectExoticCell() const { return fRejectExoticCells ; }
+ Float_t GetECross(const Int_t absID, const Double_t tcell,
+ AliVCaloCells* cells, const Int_t bc);
+
+ Float_t GetExoticCellFractionCut() const { return fExoticCellFraction ; }
+ Float_t GetExoticCellDiffTimeCut() const { return fExoticCellDiffTime ; }
+ Float_t GetExoticCellMinAmplitudeCut() const { return fExoticCellMinAmplitude ; }
+
void SetExoticCellFractionCut(Float_t f) { fExoticCellFraction = f ; }
void SetExoticCellDiffTimeCut(Float_t dt) { fExoticCellDiffTime = dt ; }
void SetExoticCellMinAmplitudeCut(Float_t ma) { fExoticCellMinAmplitude = ma ; }
InitTrackCuts() ; }
Int_t GetTrackCutsType() const { return fTrackCutsType; }
- // track quality cut setters
+ // Define AOD track type for matching
+ void SwitchOffAODHybridTracksMatch() { fAODHybridTracks = kFALSE ; }
+ void SwitchOffAODTPCOnlyTracksMatch() { fAODTPCOnlyTracks = kFALSE ; }
+ void SwitchOnAODHybridTracksMatch() { fAODHybridTracks = kTRUE ; SwitchOffAODTPCOnlyTracksMatch() ; }
+ void SwitchOnAODTPCOnlyTracksMatch() { fAODTPCOnlyTracks = kTRUE ; SwitchOffAODHybridTracksMatch() ; }
+ void SetAODTrackFilterMask( UInt_t mask) { fAODFilterMask = mask ;
+ SwitchOffAODTPCOnlyTracksMatch() ; SwitchOffAODHybridTracksMatch() ; }
+
+ // track quality cut setters
void SetMinTrackPt(Double_t pt=0) { fCutMinTrackPt = pt ; }
void SetMinNClustersTPC(Int_t min=-1) { fCutMinNClusterTPC = min ; }
void SetMinNClustersITS(Int_t min=-1) { fCutMinNClusterITS = min ; }
void SetMaxDCAToVertexXY(Float_t dist=1e10) { fCutMaxDCAToVertexXY = dist ; }
void SetMaxDCAToVertexZ(Float_t dist=1e10) { fCutMaxDCAToVertexZ = dist ; }
void SetDCAToVertex2D(Bool_t b=kFALSE) { fCutDCAToVertex2D = b ; }
-
+ void SetRequireITSStandAlone(Bool_t b=kFALSE) {fCutRequireITSStandAlone = b;} //Marcel
+ void SetRequireITSPureStandAlone(Bool_t b=kFALSE){fCutRequireITSpureSA = b;}
+
// getters
Double_t GetMinTrackPt() const { return fCutMinTrackPt ; }
Int_t GetMinNClusterTPC() const { return fCutMinNClusterTPC ; }
Float_t GetMaxDCAToVertexXY() const { return fCutMaxDCAToVertexXY ; }
Float_t GetMaxDCAToVertexZ() const { return fCutMaxDCAToVertexZ ; }
Bool_t GetDCAToVertex2D() const { return fCutDCAToVertex2D ; }
-
+ Bool_t GetRequireITSStandAlone() const { return fCutRequireITSStandAlone ; } //Marcel
private:
//Position recalculation
// Recalibrate with run dependent corrections, energy
Bool_t fUseRunCorrectionFactors; // Use Run Dependent Correction
- Bool_t fRunCorrectionFactorsSet; // Run Correction set at leat once
// Bad Channels
Bool_t fRemoveBadChannels; // Check the channel status provided and remove clusters with bad channels
//Track matching
UInt_t fAODFilterMask; // Filter mask to select AOD tracks. Refer to $ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C
+ Bool_t fAODHybridTracks; // Match with hybrid
+ Bool_t fAODTPCOnlyTracks; // Match with TPC only tracks
+
TArrayI * fMatchedTrackIndex; // Array that stores indexes of matched tracks
TArrayI * fMatchedClusterIndex; // Array that stores indexes of matched clusters
TArrayF * fResidualEta; // Array that stores the residual eta
Double_t fMass; // Mass hypothesis of the track
Double_t fStepSurface; // Length of step to extrapolate tracks to EMCal surface
Double_t fStepCluster; // Length of step to extrapolate tracks to clusters
-
+ Bool_t fITSTrackSA; // If track matching is to be done with ITS tracks standing alone
+ Double_t fEMCalSurfaceDistance; // EMCal surface distance (= 430 by default, the last 10 cm are propagated on a cluster-track pair basis)
+
// Track cuts
Int_t fTrackCutsType; // Esd track cuts type for matching
Double_t fCutMinTrackPt; // Cut on track pT
Float_t fCutMaxDCAToVertexXY; // Track-to-vertex cut in max absolute distance in xy-plane
Float_t fCutMaxDCAToVertexZ; // Track-to-vertex cut in max absolute distance in z-plane
Bool_t fCutDCAToVertex2D; // If true a 2D DCA cut is made.
+ Bool_t fCutRequireITSStandAlone; // Require ITSStandAlone
+ Bool_t fCutRequireITSpureSA; // ITS pure standalone tracks
+
- ClassDef(AliEMCALRecoUtils, 17)
+ ClassDef(AliEMCALRecoUtils, 21)
};
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff