//
//
// Author: Gustavo Conesa (LPSC- Grenoble)
+// Track matching part: Rongrong Ma (Yale)
+
///////////////////////////////////////////////////////////////////////////////
// --- standard c ---
#include <TGeoBBox.h>
// STEER includes
-#include "AliEMCALRecoUtils.h"
-#include "AliEMCALGeometry.h"
#include "AliVCluster.h"
#include "AliVCaloCells.h"
#include "AliVEvent.h"
#include "AliLog.h"
-#include "AliEMCALPIDUtils.h"
#include "AliPID.h"
#include "AliESDEvent.h"
#include "AliESDtrack.h"
+
+// EMCAL includes
+#include "AliEMCALRecoUtils.h"
+#include "AliEMCALGeometry.h"
#include "AliEMCALTrack.h"
#include "AliEMCALCalibTimeDepCorrection.h"
+#include "AliEMCALPIDUtils.h"
ClassImp(AliEMCALRecoUtils)
fRecalibration(kFALSE), fEMCALRecalibrationFactors(),
fRemoveBadChannels(kFALSE), fRecalDistToBadChannels(kFALSE), fEMCALBadChannelMap(),
fNCellsFromEMCALBorder(0), fNoEMCALBorderAtEta0(kTRUE),
- fMatchedClusterIndex(0x0), fResidualZ(0x0), fResidualR(0x0), fCutR(20), fCutZ(20),
+ fMatchedTrackIndex(0x0), fMatchedClusterIndex(0x0),
+ fResidualZ(0x0), fResidualR(0x0), fCutR(20), fCutZ(20),
fCutMinNClusterTPC(0), fCutMinNClusterITS(0), fCutMaxChi2PerClusterTPC(0), fCutMaxChi2PerClusterITS(0),
fCutRequireTPCRefit(0), fCutRequireITSRefit(0), fCutAcceptKinkDaughters(0),
fCutMaxDCAToVertexXY(0), fCutMaxDCAToVertexZ(0),fCutDCAToVertex2D(0),fPIDUtils(),
// during Reco algorithm execution
//
+ //Misalignment matrices
for(Int_t i = 0; i < 15 ; i++) {
fMisalTransShift[i] = 0.;
- fMisalRotShift[i] = 0.;
+ fMisalRotShift[i] = 0.;
}
+
+ //Non linearity
for(Int_t i = 0; i < 6 ; i++) fNonLinearityParams[i] = 0.;
//For kPi0GammaGamma case, but default is no correction
fNonLinearityParams[0] = 0.1457/0.1349766/1.038;
fNonLinearityParams[1] = -0.02024/0.1349766/1.038;
fNonLinearityParams[2] = 1.046;
+ //Track matching
+ fMatchedTrackIndex = new TArrayI();
fMatchedClusterIndex = new TArrayI();
- fResidualZ = new TArrayF();
- fResidualR = new TArrayF();
+ fResidualZ = new TArrayF();
+ fResidualR = new TArrayF();
- fPIDUtils = new AliEMCALPIDUtils();
-
InitTrackCuts();
+
+ fPIDUtils = new AliEMCALPIDUtils();
+
}
fRemoveBadChannels(reco.fRemoveBadChannels),fRecalDistToBadChannels(reco.fRecalDistToBadChannels),
fEMCALBadChannelMap(reco.fEMCALBadChannelMap),
fNCellsFromEMCALBorder(reco.fNCellsFromEMCALBorder),fNoEMCALBorderAtEta0(reco.fNoEMCALBorderAtEta0),
+ fMatchedTrackIndex(reco.fMatchedTrackIndex?new TArrayI(*reco.fMatchedTrackIndex):0x0),
fMatchedClusterIndex(reco.fMatchedClusterIndex?new TArrayI(*reco.fMatchedClusterIndex):0x0),
fResidualZ(reco.fResidualZ?new TArrayF(*reco.fResidualZ):0x0),
fResidualR(reco.fResidualR?new TArrayF(*reco.fResidualR):0x0),
fResidualZ = 0;
}
+ if(reco.fMatchedTrackIndex){
+ // assign or copy construct
+ if(fMatchedTrackIndex){
+ *fMatchedTrackIndex = *reco.fMatchedTrackIndex;
+ }
+ else fMatchedTrackIndex = new TArrayI(*reco.fMatchedTrackIndex);
+ }
+ else{
+ if(fMatchedTrackIndex)delete fMatchedTrackIndex;
+ fMatchedTrackIndex = 0;
+ }
if(reco.fMatchedClusterIndex){
// assign or copy construct
delete fEMCALBadChannelMap;
}
+ if(fMatchedTrackIndex) {delete fMatchedTrackIndex; fMatchedTrackIndex=0;}
if(fMatchedClusterIndex) {delete fMatchedClusterIndex; fMatchedClusterIndex=0;}
if(fResidualR) {delete fResidualR; fResidualR=0;}
if(fResidualZ) {delete fResidualZ; fResidualZ=0;}
}
-//__________________________________________________
-void AliEMCALRecoUtils::FindMatches(AliVEvent *event)
+//____________________________________________________________________________
+void AliEMCALRecoUtils::FindMatches(AliVEvent *event, TObjArray * clusterArr)
{
//This function should be called before the cluster loop
//Before call this function, please recalculate the cluster positions
//Store matched cluster indexes and residuals
//It only works with ESDs, not AODs
+ fMatchedTrackIndex ->Reset();
fMatchedClusterIndex->Reset();
- fResidualZ->Reset();
- fResidualR->Reset();
+ fResidualZ ->Reset();
+ fResidualR ->Reset();
+ fMatchedTrackIndex ->Set(100);
fMatchedClusterIndex->Set(100);
- fResidualZ->Set(100);
- fResidualR->Set(100);
+ fResidualZ ->Set(100);
+ fResidualR ->Set(100);
Int_t matched=0;
Float_t clsPos[3];
Float_t dRMax = fCutR, dZMax = fCutZ;
Int_t index = -1;
AliEMCALTrack *emctrack = new AliEMCALTrack(*track);
- for(Int_t icl=0; icl<event->GetNumberOfCaloClusters(); icl++)
- {
- AliVCluster *cluster = (AliVCluster*) event->GetCaloCluster(icl);
- if(!cluster->IsEMCAL()) continue;
- cluster->GetPosition(clsPos); //Has been recalculated
- if(!emctrack->PropagateToGlobal(clsPos[0],clsPos[1],clsPos[2],0.,0.) ) continue;
- emctrack->GetXYZ(trkPos);
- Float_t tmpR = TMath::Sqrt( TMath::Power(clsPos[0]-trkPos[0],2)+TMath::Power(clsPos[1]-trkPos[1],2)+TMath::Power(clsPos[2]-trkPos[2],2) );
- Float_t tmpZ = TMath::Abs(clsPos[2]-trkPos[2]);
+ if(!clusterArr){// get clusters from event
+ for(Int_t icl=0; icl<event->GetNumberOfCaloClusters(); icl++)
+ {
+ AliVCluster *cluster = (AliVCluster*) event->GetCaloCluster(icl);
+ if(!cluster->IsEMCAL()) continue;
+ cluster->GetPosition(clsPos); //Has been recalculated
+ if(!emctrack->PropagateToGlobal(clsPos[0],clsPos[1],clsPos[2],0.,0.) ) continue;
+ emctrack->GetXYZ(trkPos);
+ Float_t tmpR = TMath::Sqrt( TMath::Power(clsPos[0]-trkPos[0],2)+TMath::Power(clsPos[1]-trkPos[1],2)+TMath::Power(clsPos[2]-trkPos[2],2) );
+ Float_t tmpZ = TMath::Abs(clsPos[2]-trkPos[2]);
- if(tmpR<dRMax)
- {
- dRMax=tmpR;
- dZMax=tmpZ;
- index=icl;
- }
-
- }//cluser loop
-
+ if(tmpR<dRMax)
+ {
+ dRMax=tmpR;
+ dZMax=tmpZ;
+ index=icl;
+ }
+ }//cluster loop
+ } else { // external cluster array, not from ESD event
+ for(Int_t icl=0; icl<clusterArr->GetEntriesFast(); icl++)
+ {
+ AliVCluster *cluster = (AliVCluster*) clusterArr->At(icl);
+ if(!cluster->IsEMCAL()) continue;
+ cluster->GetPosition(clsPos); //Has been recalculated
+ if(!emctrack->PropagateToGlobal(clsPos[0],clsPos[1],clsPos[2],0.,0.) ) continue;
+ emctrack->GetXYZ(trkPos);
+ Float_t tmpR = TMath::Sqrt( TMath::Power(clsPos[0]-trkPos[0],2)+TMath::Power(clsPos[1]-trkPos[1],2)+TMath::Power(clsPos[2]-trkPos[2],2) );
+ Float_t tmpZ = TMath::Abs(clsPos[2]-trkPos[2]);
+
+ if(tmpR<dRMax)
+ {
+ dRMax=tmpR;
+ dZMax=tmpZ;
+ index=icl;
+ }
+ }//cluster loop
+ }// external list of clusters
+
if(index>-1)
{
+ fMatchedTrackIndex ->AddAt(itr,matched);
fMatchedClusterIndex->AddAt(index,matched);
- fResidualZ->AddAt(dZMax,matched);
- fResidualR->AddAt(dRMax,matched);
+ fResidualZ ->AddAt(dZMax,matched);
+ fResidualR ->AddAt(dRMax,matched);
matched++;
}
delete emctrack;
}//track loop
+
+ AliDebug(2,Form("Number of matched pairs = %d !\n",matched));
+
+ fMatchedTrackIndex ->Set(matched);
fMatchedClusterIndex->Set(matched);
- fResidualZ->Set(matched);
- fResidualR->Set(matched);
+ fResidualZ ->Set(matched);
+ fResidualR ->Set(matched);
//printf("Number of matched pairs: %d\n",matched);
}
-//__________________________________________________
+//________________________________________________________________________________
void AliEMCALRecoUtils::GetMatchedResiduals(Int_t index, Float_t &dR, Float_t &dZ)
{
//Given a cluster index as in AliESDEvent::GetCaloCluster(index)
//printf("dR %f, dZ %f\n",dR, dZ);
}
+//__________________________________________________________
+Int_t AliEMCALRecoUtils::GetMatchedTrackIndex(Int_t index)
+{
+ //Given a cluster index as in AliESDEvent::GetCaloCluster(index)
+ //Get the index of matched track for this cluster
+ //It only works with ESDs, not AODs
+
+ if(IsMatched(index))
+ return fMatchedTrackIndex->At(FindMatchedPos(index));
+ else
+ return -1;
+}
+
+
//__________________________________________________
Bool_t AliEMCALRecoUtils::IsMatched(Int_t index)
{
else
return kFALSE;
}
-//__________________________________________________
+//__________________________________________________________
UInt_t AliEMCALRecoUtils::FindMatchedPos(Int_t index) const
{
//Given a cluster index as in AliESDEvent::GetCaloCluster(index)
//Returns the position of the match in the fMatchedClusterIndex array
Float_t tmpR = fCutR;
UInt_t pos = 999;
-
+
for(Int_t i=0; i<fMatchedClusterIndex->GetSize(); i++)
+ {
+ if(fMatchedClusterIndex->At(i)==index && fResidualR->At(i)<tmpR)
{
- if(fMatchedClusterIndex->At(i)==index && fResidualR->At(i)<tmpR)
- {
- pos=i;
- tmpR=fResidualR->At(i);
- }
+ pos=i;
+ tmpR=fResidualR->At(i);
AliDebug(3,Form("Matched cluster pos: %d, index: %d, dR: %2.4f, dZ: %2.4f.\n",i,fMatchedClusterIndex->At(i),fResidualR->At(i),fResidualZ->At(i)));
}
+ }
return pos;
}
+//__________________________________________________________
Bool_t AliEMCALRecoUtils::IsAccepted(AliESDtrack *esdTrack)
{
// Given a esd track, return whether the track survive all the cuts
SetMinNClustersITS();
}
-//__________________________________________________
+//___________________________________________________
void AliEMCALRecoUtils::Print(const Option_t *) const
{
// Print Parameters
printf("MaxChi2TPC = %2.2f, MaxChi2ITS = %2.2f\n",fCutMaxChi2PerClusterTPC,fCutMaxChi2PerClusterITS);
printf("DCSToVertex2D = %d, MaxDCAToVertexXY = %2.2f, MaxDCAToVertexZ = %2.2f\n",fCutDCAToVertex2D,fCutMaxDCAToVertexXY,fCutMaxDCAToVertexZ);
-
}
-//__________________________________________________
+//_____________________________________________________________________
void AliEMCALRecoUtils::SetTimeDependentCorrections(Int_t runnumber){
//Get EMCAL time dependent corrections from file and put them in the recalibration histograms
//Do it only once and only if it is requested
//
//
// Author: Gustavo Conesa (LPSC- Grenoble)
+// Track matching part: Rongrong Ma (Yale)
///////////////////////////////////////////////////////////////////////////////
//Root includes
class AliVCaloCells;
class AliVEvent;
#include "AliLog.h"
+
+// EMCAL includes
class AliEMCALGeometry;
class AliEMCALPIDUtils;
class AliESDtrack;
AliEMCALRecoUtils();
AliEMCALRecoUtils(const AliEMCALRecoUtils&);
AliEMCALRecoUtils& operator=(const AliEMCALRecoUtils&);
- virtual ~AliEMCALRecoUtils() ;
-
+ virtual ~AliEMCALRecoUtils() ;
+ void Print(const Option_t*) const;
+
+ //enums
enum NonlinearityFunctions{kPi0MC=0,kPi0GammaGamma=1,kPi0GammaConversion=2,kNoCorrection=3,kBeamTest=4};
enum PositionAlgorithms{kUnchanged=-1,kPosTowerIndex=0, kPosTowerGlobal=1};
enum ParticleType{kPhoton=0, kElectron=1,kHadron =2, kUnknown=-1};
-
+ enum { kNCuts = 11 }; //track matching
+
+ //-----------------------------------------------------
//Position recalculation
+ //-----------------------------------------------------
+
void RecalculateClusterPosition(AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu);
void RecalculateClusterPositionFromTowerIndex (AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu);
void RecalculateClusterPositionFromTowerGlobal(AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu);
Float_t GetW0() const { return fW0 ;}
void SetW0(Float_t w0) { fW0 = w0 ;}
+ //-----------------------------------------------------
//Non Linearity
-
+ //-----------------------------------------------------
+
Float_t CorrectClusterEnergyLinearity(AliVCluster* clu);
Float_t GetNonLinearityParam(const Int_t i) const {
Int_t GetNonLinearityFunction() const { return fNonLinearityFunction ;}
void SetNonLinearityFunction(Int_t fun) { fNonLinearityFunction = fun ;}
-
- void Print(const Option_t*) const;
-
+
+ //-----------------------------------------------------
//Recalibration
+ //-----------------------------------------------------
+
void RecalibrateClusterEnergy(AliEMCALGeometry* geom, AliVCluster* cluster, AliVCaloCells * cells);
- Bool_t IsRecalibrationOn() const { return fRecalibration ; }
- void SwitchOnRecalibration() { fRecalibration = kTRUE ; if(!fEMCALRecalibrationFactors)InitEMCALRecalibrationFactors();}
- void SwitchOffRecalibration() { fRecalibration = kFALSE ; }
- void InitEMCALRecalibrationFactors() ;
+ Bool_t IsRecalibrationOn() const { return fRecalibration ; }
+ void SwitchOnRecalibration() { fRecalibration = kTRUE ; if(!fEMCALRecalibrationFactors)InitEMCALRecalibrationFactors();}
+ void SwitchOffRecalibration() { fRecalibration = kFALSE ; }
+ void InitEMCALRecalibrationFactors() ;
//Recalibrate channels with time dependent corrections
- void SwitchOnTimeDepCorrection() { fUseTimeCorrectionFactors = kTRUE ; SwitchOnRecalibration();}
- void SwitchOffTimeDepCorrection() { fUseTimeCorrectionFactors = kFALSE;}
+ void SwitchOnTimeDepCorrection() { fUseTimeCorrectionFactors = kTRUE ; SwitchOnRecalibration();}
+ void SwitchOffTimeDepCorrection() { fUseTimeCorrectionFactors = kFALSE;}
void SetTimeDependentCorrections(Int_t runnumber);
Float_t GetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow) const {
void SetEMCALChannelRecalibrationFactors(TObjArray *map) { fEMCALRecalibrationFactors = map ;}
void SetEMCALChannelRecalibrationFactors(Int_t iSM , TH2F* h) { fEMCALRecalibrationFactors->AddAt(h,iSM) ;}
+ //-----------------------------------------------------
//Modules fiducial region, remove clusters in borders
+ //-----------------------------------------------------
+
Bool_t CheckCellFiducialRegion(AliEMCALGeometry* geom, AliVCluster* cluster, AliVCaloCells* cells) ;
void SetNumberOfCellsFromEMCALBorder(Int_t n) { fNCellsFromEMCALBorder = n ;}
Int_t GetNumberOfCellsFromEMCALBorder() const { return fNCellsFromEMCALBorder ;}
void SwitchOffNoFiducialBorderInEMCALEta0() { fNoEMCALBorderAtEta0 = kFALSE ;}
Bool_t IsEMCALNoBorderAtEta0() { return fNoEMCALBorderAtEta0 ;}
+ //-----------------------------------------------------
// Bad channels
- Bool_t IsBadChannelsRemovalSwitchedOn() const { return fRemoveBadChannels ;}
- void SwitchOnBadChannelsRemoval () { fRemoveBadChannels = kTRUE ; if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap();}
- void SwitchOffBadChannelsRemoval() { fRemoveBadChannels = kFALSE ;}
+ //-----------------------------------------------------
+
+ Bool_t IsBadChannelsRemovalSwitchedOn() const { return fRemoveBadChannels ;}
+ void SwitchOnBadChannelsRemoval () { fRemoveBadChannels = kTRUE ; if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap();}
+ void SwitchOffBadChannelsRemoval() { fRemoveBadChannels = kFALSE ;}
- Bool_t IsDistanceToBadChannelRecalculated() const { return fRecalDistToBadChannels;}
- void SwitchOnDistToBadChannelRecalculation() { fRecalDistToBadChannels = kTRUE ; if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap();}
- void SwitchOffDistToBadChannelRecalculation() { fRecalDistToBadChannels = kFALSE ;}
+ Bool_t IsDistanceToBadChannelRecalculated() const { return fRecalDistToBadChannels ;}
+ void SwitchOnDistToBadChannelRecalculation() { fRecalDistToBadChannels = kTRUE ; if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap();}
+ void SwitchOffDistToBadChannelRecalculation() { fRecalDistToBadChannels = kFALSE ;}
void InitEMCALBadChannelStatusMap() ;
Bool_t ClusterContainsBadChannel(AliEMCALGeometry* geom, UShort_t* cellList, Int_t nCells);
- //Recalculate other cluster parameters
+ //-----------------------------------------------------
+ // Recalculate other cluster parameters
+ //-----------------------------------------------------
+
void RecalculateClusterDistanceToBadChannel(AliEMCALGeometry * geom, AliVCaloCells* cells, AliVCluster * cluster);
void RecalculateClusterPID(AliVCluster * cluster);
void RecalculateClusterShowerShapeParameters(AliEMCALGeometry * geom, AliVCaloCells* cells, AliVCluster * cluster);
- //Track matching
- void FindMatches(AliVEvent *event);
- void GetMatchedResiduals(Int_t index, Float_t &dR, Float_t &dZ);
- Bool_t IsMatched(Int_t index);
- UInt_t FindMatchedPos(Int_t index) const;
+ //----------------------------------------------------
+ // Track matching
+ //----------------------------------------------------
- Float_t GetCutR() const { return fCutR ;}
- Float_t GetCutZ() const { return fCutZ ;}
- void SetCutR(Float_t cutR) { fCutR=cutR ;}
- void SetCutZ(Float_t cutZ) { fCutZ=cutZ ;}
+ void FindMatches(AliVEvent *event, TObjArray * clusterArr=0x0);
+ void GetMatchedResiduals(Int_t index, Float_t &dR, Float_t &dZ);
+ Int_t GetMatchedTrackIndex(Int_t index);
+ Bool_t IsMatched(Int_t index);
+ UInt_t FindMatchedPos(Int_t index) const;
+
+ Float_t GetCutR() const { return fCutR ;}
+ Float_t GetCutZ() const { return fCutZ ;}
+ void SetCutR(Float_t cutR) { fCutR=cutR ;}
+ void SetCutZ(Float_t cutZ) { fCutZ=cutZ ;}
//Track Cuts
- Bool_t IsAccepted(AliESDtrack *track);
- void InitTrackCuts();
+ Bool_t IsAccepted(AliESDtrack *track);
+ void InitTrackCuts();
// track quality cut setters
- void SetMinNClustersTPC(Int_t min=-1) {fCutMinNClusterTPC = min ;}
- void SetMinNClustersITS(Int_t min=-1) {fCutMinNClusterITS = min ;}
- void SetMaxChi2PerClusterTPC(Float_t max=1e10) {fCutMaxChi2PerClusterTPC = max ;}
- void SetMaxChi2PerClusterITS(Float_t max=1e10) {fCutMaxChi2PerClusterITS = max ;}
- void SetRequireTPCRefit(Bool_t b=kFALSE) {fCutRequireTPCRefit = b ;}
- void SetRequireITSRefit(Bool_t b=kFALSE) {fCutRequireITSRefit = b ;}
- void SetAcceptKinkDaughters(Bool_t b=kTRUE) {fCutAcceptKinkDaughters = b ;}
- 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 SetMinNClustersTPC(Int_t min=-1) { fCutMinNClusterTPC = min ;}
+ void SetMinNClustersITS(Int_t min=-1) { fCutMinNClusterITS = min ;}
+ void SetMaxChi2PerClusterTPC(Float_t max=1e10) { fCutMaxChi2PerClusterTPC = max ;}
+ void SetMaxChi2PerClusterITS(Float_t max=1e10) { fCutMaxChi2PerClusterITS = max ;}
+ void SetRequireTPCRefit(Bool_t b=kFALSE) { fCutRequireTPCRefit = b ;}
+ void SetRequireITSRefit(Bool_t b=kFALSE) { fCutRequireITSRefit = b ;}
+ void SetAcceptKinkDaughters(Bool_t b=kTRUE) { fCutAcceptKinkDaughters = b ;}
+ void SetMaxDCAToVertexXY(Float_t dist=1e10) { fCutMaxDCAToVertexXY = dist ;}
+ void SetMaxDCAToVertexZ(Float_t dist=1e10) { fCutMaxDCAToVertexZ = dist ;}
+ void SetDCAToVertex2D(Bool_t b=kFALSE) { fCutDCAToVertex2D = b ;}
// getters
-
- Int_t GetMinNClusterTPC() const { return fCutMinNClusterTPC;}
- Int_t GetMinNClustersITS() const { return fCutMinNClusterITS;}
- Float_t GetMaxChi2PerClusterTPC() const { return fCutMaxChi2PerClusterTPC;}
- Float_t GetMaxChi2PerClusterITS() const { return fCutMaxChi2PerClusterITS;}
- Bool_t GetRequireTPCRefit() const { return fCutRequireTPCRefit;}
- Bool_t GetRequireITSRefit() const { return fCutRequireITSRefit;}
- Bool_t GetAcceptKinkDaughters() const { return fCutAcceptKinkDaughters;}
- Float_t GetMaxDCAToVertexXY() const { return fCutMaxDCAToVertexXY;}
- Float_t GetMaxDCAToVertexZ() const { return fCutMaxDCAToVertexZ;}
- Bool_t GetDCAToVertex2D() const { return fCutDCAToVertex2D;}
+ Int_t GetMinNClusterTPC() const { return fCutMinNClusterTPC ;}
+ Int_t GetMinNClustersITS() const { return fCutMinNClusterITS ;}
+ Float_t GetMaxChi2PerClusterTPC() const { return fCutMaxChi2PerClusterTPC ;}
+ Float_t GetMaxChi2PerClusterITS() const { return fCutMaxChi2PerClusterITS ;}
+ Bool_t GetRequireTPCRefit() const { return fCutRequireTPCRefit ;}
+ Bool_t GetRequireITSRefit() const { return fCutRequireITSRefit ;}
+ Bool_t GetAcceptKinkDaughters() const { return fCutAcceptKinkDaughters ;}
+ Float_t GetMaxDCAToVertexXY() const { return fCutMaxDCAToVertexXY ;}
+ Float_t GetMaxDCAToVertexZ() const { return fCutMaxDCAToVertexZ ;}
+ Bool_t GetDCAToVertex2D() const { return fCutDCAToVertex2D ;}
private:
+ //Position recalculation
Float_t fMisalTransShift[15]; // Shift parameters
Float_t fMisalRotShift[15]; // Shift parameters
Int_t fNonLinearityFunction; // Non linearity function choice
Int_t fPosAlgo; // Position recalculation algorithm
Float_t fW0; // Weight0
+ // Recalibration
Bool_t fRecalibration; // Switch on or off the recalibration
TObjArray* fEMCALRecalibrationFactors; // Array of histograms with map of recalibration factors, EMCAL
+
+ // Bad Channels
Bool_t fRemoveBadChannels; // Check the channel status provided and remove clusters with bad channels
Bool_t fRecalDistToBadChannels; // Calculate distance from highest energy tower of cluster to closes bad channel
TObjArray* fEMCALBadChannelMap; // Array of histograms with map of bad channels, EMCAL
+
+ // Border cells
Int_t fNCellsFromEMCALBorder; // Number of cells from EMCAL border the cell with maximum amplitude has to be.
Bool_t fNoEMCALBorderAtEta0; // Do fiducial cut in EMCAL region eta = 0?
-
+
+ //Track matching
+ TArrayI * fMatchedTrackIndex; // Array that stores indexes of matched tracks
TArrayI * fMatchedClusterIndex; // Array that stores indexes of matched clusters
TArrayF * fResidualZ; // Array that stores the residual z
TArrayF * fResidualR; // Array that stores the residual r
Float_t fCutR; // dR cut on matching
Float_t fCutZ; // dZ cut on matching
-
- enum { kNCuts = 11 };
+
Int_t fCutMinNClusterTPC; // Min number of tpc clusters
Int_t fCutMinNClusterITS; // Min number of its clusters
Float_t fCutMaxChi2PerClusterTPC; // Max tpc fit chi2 per tpc cluster
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. Tracks are accepted if sqrt((DCAXY / fCutMaxDCAToVertexXY)^2 + (DCAZ / fCutMaxDCAToVertexZ)^2) < 1 AND sqrt((DCAXY / fCutMinDCAToVertexXY)^2 + (DCAZ / fCutMinDCAToVertexZ)^2) > 1
+ //PID
AliEMCALPIDUtils * fPIDUtils; // Recalculate PID parameters
//Time Correction
Bool_t fUseTimeCorrectionFactors; // Use Time Dependent Correction
Bool_t fTimeCorrectionFactorsSet; // Time Correction set at leat once
- ClassDef(AliEMCALRecoUtils, 6)
+ ClassDef(AliEMCALRecoUtils, 7)
};
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff