X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=EMCAL%2FAliEMCALRecoUtils.cxx;h=91bdf692691f2f73cf927afa1b649713686b085a;hb=aff917acadf17f97e8191d4b40f47b49bcbc078a;hp=4a4e5be2b038f125400e7e781fa3612c4cf7d800;hpb=7e0ecb89cfa7eac917a99e0b57a8f0a6c2dd6863;p=u%2Fmrichter%2FAliRoot.git diff --git a/EMCAL/AliEMCALRecoUtils.cxx b/EMCAL/AliEMCALRecoUtils.cxx index 4a4e5be2b03..91bdf692691 100644 --- a/EMCAL/AliEMCALRecoUtils.cxx +++ b/EMCAL/AliEMCALRecoUtils.cxx @@ -25,7 +25,6 @@ // Track matching part: Rongrong Ma (Yale) /////////////////////////////////////////////////////////////////////////////// - // --- standard c --- // standard C++ includes @@ -35,6 +34,10 @@ #include #include #include +#include +#include +#include +#include // STEER includes #include "AliVCluster.h" @@ -54,26 +57,30 @@ #include "AliEMCALRecoUtils.h" #include "AliEMCALGeometry.h" #include "AliEMCALTrack.h" -#include "AliEMCALCalibTimeDepCorrection.h" +#include "AliEMCALCalibTimeDepCorrection.h" // Run dependent #include "AliEMCALPIDUtils.h" ClassImp(AliEMCALRecoUtils) //______________________________________________ AliEMCALRecoUtils::AliEMCALRecoUtils(): - fNonLinearityFunction (kNoCorrection), fParticleType(kPhoton), - fPosAlgo(kUnchanged),fW0(4.), fNonLinearThreshold(30), - fRecalibration(kFALSE), fEMCALRecalibrationFactors(), - fRemoveBadChannels(kFALSE), fRecalDistToBadChannels(kFALSE), fEMCALBadChannelMap(), - fNCellsFromEMCALBorder(0), fNoEMCALBorderAtEta0(kTRUE), - fAODFilterMask(32), - fMatchedTrackIndex(0x0), fMatchedClusterIndex(0x0), - fResidualZ(0x0), fResidualR(0x0), fCutR(10), fCutZ(10), fMass(0.139), fStep(1), - fRejectExoticCluster(kFALSE), - fCutMinNClusterTPC(0), fCutMinNClusterITS(0), fCutMaxChi2PerClusterTPC(0), fCutMaxChi2PerClusterITS(0), - fCutRequireTPCRefit(0), fCutRequireITSRefit(0), fCutAcceptKinkDaughters(0), - fCutMaxDCAToVertexXY(0), fCutMaxDCAToVertexZ(0),fCutDCAToVertex2D(0),fPIDUtils(), - fUseTimeCorrectionFactors(kFALSE), fTimeCorrectionFactorsSet(kFALSE) + fParticleType(kPhoton), fPosAlgo(kUnchanged), fW0(4.), + fNonLinearityFunction(kNoCorrection), fNonLinearThreshold(30), + fSmearClusterEnergy(kFALSE), fRandom(), + fCellsRecalibrated(kFALSE), fRecalibration(kFALSE), fEMCALRecalibrationFactors(), + fTimeRecalibration(kFALSE), fEMCALTimeRecalibrationFactors(), + fUseRunCorrectionFactors(kFALSE), fRunCorrectionFactorsSet(kFALSE), + fRemoveBadChannels(kFALSE), fRecalDistToBadChannels(kFALSE), fEMCALBadChannelMap(), + fNCellsFromEMCALBorder(0), fNoEMCALBorderAtEta0(kTRUE), + fRejectExoticCluster(kFALSE), fPIDUtils(), fAODFilterMask(32), + fMatchedTrackIndex(0x0), fMatchedClusterIndex(0x0), + fResidualEta(0x0), fResidualPhi(0x0), fCutEtaPhiSum(kTRUE), fCutEtaPhiSeparate(kFALSE), + fCutR(0.1), fCutEta(0.025), fCutPhi(0.05), + fMass(0.139), fStep(10), + fTrackCutsType(kLooseCut), fCutMinTrackPt(0), fCutMinNClusterTPC(-1), + fCutMinNClusterITS(-1), fCutMaxChi2PerClusterTPC(1e10), fCutMaxChi2PerClusterITS(1e10), + fCutRequireTPCRefit(kFALSE), fCutRequireITSRefit(kFALSE), fCutAcceptKinkDaughters(kFALSE), + fCutMaxDCAToVertexXY(1e10), fCutMaxDCAToVertexZ(1e10), fCutDCAToVertex2D(kFALSE) { // // Constructor. @@ -104,49 +111,57 @@ AliEMCALRecoUtils::AliEMCALRecoUtils(): //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(); + //Cluster energy smearing + fSmearClusterEnergy = kFALSE; + fSmearClusterParam[0] = 0.07; // * sqrt E term + fSmearClusterParam[1] = 0.00; // * E term + fSmearClusterParam[2] = 0.00; // constant - InitTrackCuts(); - - fPIDUtils = new AliEMCALPIDUtils(); - + //Track matching + fMatchedTrackIndex = new TArrayI(); + fMatchedClusterIndex = new TArrayI(); + fResidualPhi = new TArrayF(); + fResidualEta = new TArrayF(); + fPIDUtils = new AliEMCALPIDUtils(); + InitTrackCuts(); } //______________________________________________________________________ AliEMCALRecoUtils::AliEMCALRecoUtils(const AliEMCALRecoUtils & reco) -: TNamed(reco), fNonLinearityFunction(reco.fNonLinearityFunction), - fParticleType(reco.fParticleType), fPosAlgo(reco.fPosAlgo), fW0(reco.fW0), fNonLinearThreshold(reco.fNonLinearThreshold), - fRecalibration(reco.fRecalibration),fEMCALRecalibrationFactors(reco.fEMCALRecalibrationFactors), - fRemoveBadChannels(reco.fRemoveBadChannels),fRecalDistToBadChannels(reco.fRecalDistToBadChannels), +: TNamed(reco), + fParticleType(reco.fParticleType), fPosAlgo(reco.fPosAlgo), fW0(reco.fW0), + fNonLinearityFunction(reco.fNonLinearityFunction), fNonLinearThreshold(reco.fNonLinearThreshold), + fSmearClusterEnergy(reco.fSmearClusterEnergy), fRandom(), + fCellsRecalibrated(reco.fCellsRecalibrated), + fRecalibration(reco.fRecalibration), fEMCALRecalibrationFactors(reco.fEMCALRecalibrationFactors), + fTimeRecalibration(reco.fTimeRecalibration), fEMCALTimeRecalibrationFactors(reco.fEMCALTimeRecalibrationFactors), + fUseRunCorrectionFactors(reco.fUseRunCorrectionFactors), fRunCorrectionFactorsSet(reco.fRunCorrectionFactorsSet), + fRemoveBadChannels(reco.fRemoveBadChannels), fRecalDistToBadChannels(reco.fRecalDistToBadChannels), fEMCALBadChannelMap(reco.fEMCALBadChannelMap), - fNCellsFromEMCALBorder(reco.fNCellsFromEMCALBorder),fNoEMCALBorderAtEta0(reco.fNoEMCALBorderAtEta0), + fNCellsFromEMCALBorder(reco.fNCellsFromEMCALBorder), fNoEMCALBorderAtEta0(reco.fNoEMCALBorderAtEta0), + fRejectExoticCluster(reco.fRejectExoticCluster), fPIDUtils(reco.fPIDUtils), fAODFilterMask(reco.fAODFilterMask), - fMatchedTrackIndex(reco.fMatchedTrackIndex?new TArrayI(*reco.fMatchedTrackIndex):0x0), + 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), - fCutR(reco.fCutR),fCutZ(reco.fCutZ),fMass(reco.fMass), fStep(reco.fStep), - fRejectExoticCluster(reco.fRejectExoticCluster), - fCutMinNClusterTPC(reco.fCutMinNClusterTPC), fCutMinNClusterITS(reco.fCutMinNClusterITS), - fCutMaxChi2PerClusterTPC(reco.fCutMaxChi2PerClusterTPC), fCutMaxChi2PerClusterITS(reco.fCutMaxChi2PerClusterITS), - fCutRequireTPCRefit(reco.fCutRequireTPCRefit), fCutRequireITSRefit(reco.fCutRequireITSRefit), - fCutAcceptKinkDaughters(reco.fCutAcceptKinkDaughters), - fCutMaxDCAToVertexXY(reco.fCutMaxDCAToVertexXY), fCutMaxDCAToVertexZ(reco.fCutMaxDCAToVertexZ),fCutDCAToVertex2D(reco.fCutDCAToVertex2D), - fPIDUtils(reco.fPIDUtils), - fUseTimeCorrectionFactors(reco.fUseTimeCorrectionFactors), fTimeCorrectionFactorsSet(reco.fTimeCorrectionFactorsSet) + fResidualEta( reco.fResidualEta? new TArrayF(*reco.fResidualEta):0x0), + fResidualPhi( reco.fResidualPhi? new TArrayF(*reco.fResidualPhi):0x0), + fCutEtaPhiSum(reco.fCutEtaPhiSum), fCutEtaPhiSeparate(reco.fCutEtaPhiSeparate), + fCutR(reco.fCutR), fCutEta(reco.fCutEta), fCutPhi(reco.fCutPhi), + fMass(reco.fMass), fStep(reco.fStep), + fTrackCutsType(reco.fTrackCutsType), fCutMinTrackPt(reco.fCutMinTrackPt), + fCutMinNClusterTPC(reco.fCutMinNClusterTPC), fCutMinNClusterITS(reco.fCutMinNClusterITS), + fCutMaxChi2PerClusterTPC(reco.fCutMaxChi2PerClusterTPC), fCutMaxChi2PerClusterITS(reco.fCutMaxChi2PerClusterITS), + fCutRequireTPCRefit(reco.fCutRequireTPCRefit), fCutRequireITSRefit(reco.fCutRequireITSRefit), + fCutAcceptKinkDaughters(reco.fCutAcceptKinkDaughters), fCutMaxDCAToVertexXY(reco.fCutMaxDCAToVertexXY), + fCutMaxDCAToVertexZ(reco.fCutMaxDCAToVertexZ), fCutDCAToVertex2D(reco.fCutDCAToVertex2D) { //Copy ctor - for(Int_t i = 0; i < 15 ; i++) { - fMisalRotShift[i] = reco.fMisalRotShift[i]; - fMisalTransShift[i] = reco.fMisalTransShift[i]; - } - for(Int_t i = 0; i < 7 ; i++) fNonLinearityParams[i] = reco.fNonLinearityParams[i]; + for(Int_t i = 0; i < 15 ; i++) { fMisalRotShift[i] = reco.fMisalRotShift[i] ; + fMisalTransShift[i] = reco.fMisalTransShift[i] ; } + for(Int_t i = 0; i < 7 ; i++) { fNonLinearityParams[i] = reco.fNonLinearityParams[i] ; } + for(Int_t i = 0; i < 3 ; i++) { fSmearClusterParam[i] = reco.fSmearClusterParam[i] ; } } @@ -159,31 +174,52 @@ AliEMCALRecoUtils & AliEMCALRecoUtils::operator = (const AliEMCALRecoUtils & rec if(this == &reco)return *this; ((TNamed *)this)->operator=(reco); - fNonLinearityFunction = reco.fNonLinearityFunction; + for(Int_t i = 0; i < 15 ; i++) { fMisalTransShift[i] = reco.fMisalTransShift[i] ; + fMisalRotShift[i] = reco.fMisalRotShift[i] ; } + for(Int_t i = 0; i < 7 ; i++) { fNonLinearityParams[i] = reco.fNonLinearityParams[i] ; } + for(Int_t i = 0; i < 3 ; i++) { fSmearClusterParam[i] = reco.fSmearClusterParam[i] ; } + fParticleType = reco.fParticleType; fPosAlgo = reco.fPosAlgo; fW0 = reco.fW0; + + fNonLinearityFunction = reco.fNonLinearityFunction; fNonLinearThreshold = reco.fNonLinearThreshold; + fSmearClusterEnergy = reco.fSmearClusterEnergy; + + fCellsRecalibrated = reco.fCellsRecalibrated; fRecalibration = reco.fRecalibration; fEMCALRecalibrationFactors = reco.fEMCALRecalibrationFactors; + + fTimeRecalibration = reco.fTimeRecalibration; + fEMCALTimeRecalibrationFactors = reco.fEMCALTimeRecalibrationFactors; + + fUseRunCorrectionFactors = reco.fUseRunCorrectionFactors; + fRunCorrectionFactorsSet = reco.fRunCorrectionFactorsSet; + fRemoveBadChannels = reco.fRemoveBadChannels; fRecalDistToBadChannels = reco.fRecalDistToBadChannels; fEMCALBadChannelMap = reco.fEMCALBadChannelMap; + fNCellsFromEMCALBorder = reco.fNCellsFromEMCALBorder; fNoEMCALBorderAtEta0 = reco.fNoEMCALBorderAtEta0; + fRejectExoticCluster = reco.fRejectExoticCluster; + fPIDUtils = reco.fPIDUtils; - for(Int_t i = 0; i < 15 ; i++) {fMisalTransShift[i] = reco.fMisalTransShift[i]; fMisalRotShift[i] = reco.fMisalRotShift[i];} - for(Int_t i = 0; i < 7 ; i++) fNonLinearityParams[i] = reco.fNonLinearityParams[i]; - - fAODFilterMask = reco.fAODFilterMask; + fAODFilterMask = reco.fAODFilterMask; + fCutEtaPhiSum = reco.fCutEtaPhiSum; + fCutEtaPhiSeparate = reco.fCutEtaPhiSeparate; fCutR = reco.fCutR; - fCutZ = reco.fCutZ; + fCutEta = reco.fCutEta; + fCutPhi = reco.fCutPhi; fMass = reco.fMass; fStep = reco.fStep; fRejectExoticCluster = reco.fRejectExoticCluster; + fTrackCutsType = reco.fTrackCutsType; + fCutMinTrackPt = reco.fCutMinTrackPt; fCutMinNClusterTPC = reco.fCutMinNClusterTPC; fCutMinNClusterITS = reco.fCutMinNClusterITS; fCutMaxChi2PerClusterTPC = reco.fCutMaxChi2PerClusterTPC; @@ -194,35 +230,29 @@ AliEMCALRecoUtils & AliEMCALRecoUtils::operator = (const AliEMCALRecoUtils & rec fCutMaxDCAToVertexXY = reco.fCutMaxDCAToVertexXY; fCutMaxDCAToVertexZ = reco.fCutMaxDCAToVertexZ; fCutDCAToVertex2D = reco.fCutDCAToVertex2D; - - fPIDUtils = reco.fPIDUtils; - fUseTimeCorrectionFactors = reco.fUseTimeCorrectionFactors; - fTimeCorrectionFactorsSet = reco.fTimeCorrectionFactorsSet; - - - if(reco.fResidualR){ + if(reco.fResidualEta){ // assign or copy construct - if(fResidualR){ - *fResidualR = *reco.fResidualR; + if(fResidualEta){ + *fResidualEta = *reco.fResidualEta; } - else fResidualR = new TArrayF(*reco.fResidualR); + else fResidualEta = new TArrayF(*reco.fResidualEta); } else{ - if(fResidualR)delete fResidualR; - fResidualR = 0; + if(fResidualEta)delete fResidualEta; + fResidualEta = 0; } - if(reco.fResidualZ){ + if(reco.fResidualPhi){ // assign or copy construct - if(fResidualZ){ - *fResidualZ = *reco.fResidualZ; + if(fResidualPhi){ + *fResidualPhi = *reco.fResidualPhi; } - else fResidualZ = new TArrayF(*reco.fResidualZ); + else fResidualPhi = new TArrayF(*reco.fResidualPhi); } else{ - if(fResidualZ)delete fResidualZ; - fResidualZ = 0; + if(fResidualPhi)delete fResidualPhi; + fResidualPhi = 0; } if(reco.fMatchedTrackIndex){ @@ -248,8 +278,7 @@ AliEMCALRecoUtils & AliEMCALRecoUtils::operator = (const AliEMCALRecoUtils & rec if(fMatchedClusterIndex)delete fMatchedClusterIndex; fMatchedClusterIndex = 0; } - - + return *this; } @@ -259,21 +288,28 @@ AliEMCALRecoUtils::~AliEMCALRecoUtils() { //Destructor. - if(fEMCALRecalibrationFactors) { - fEMCALRecalibrationFactors->Clear(); - delete fEMCALRecalibrationFactors; + if(fEMCALRecalibrationFactors) { + fEMCALRecalibrationFactors->Clear(); + delete fEMCALRecalibrationFactors; + } + + if(fEMCALTimeRecalibrationFactors) { + fEMCALTimeRecalibrationFactors->Clear(); + delete fEMCALTimeRecalibrationFactors; } if(fEMCALBadChannelMap) { - fEMCALBadChannelMap->Clear(); - delete fEMCALBadChannelMap; - } + fEMCALBadChannelMap->Clear(); + 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;} + delete fMatchedTrackIndex ; + delete fMatchedClusterIndex ; + delete fResidualEta ; + delete fResidualPhi ; + delete fPIDUtils ; + InitTrackCuts(); } //_______________________________________________________________ @@ -282,6 +318,11 @@ Bool_t AliEMCALRecoUtils::CheckCellFiducialRegion(AliEMCALGeometry* geom, AliVCl // Given the list of AbsId of the cluster, get the maximum cell and // check if there are fNCellsFromBorder from the calorimeter border + if(!cluster){ + AliInfo("Cluster pointer null!"); + return kFALSE; + } + //If the distance to the border is 0 or negative just exit accept all clusters if(cells->GetType()==AliVCaloCells::kEMCALCell && fNCellsFromEMCALBorder <= 0 ) return kTRUE; @@ -341,7 +382,7 @@ Bool_t AliEMCALRecoUtils::CheckCellFiducialRegion(AliEMCALGeometry* geom, AliVCl //_________________________________________________________________________________________________________ -Bool_t AliEMCALRecoUtils::ClusterContainsBadChannel(AliEMCALGeometry* geom, UShort_t* cellList, Int_t nCells){ +Bool_t AliEMCALRecoUtils::ClusterContainsBadChannel(AliEMCALGeometry* geom, UShort_t* cellList, const Int_t nCells){ // Check that in the cluster cells, there is no bad channel of those stored // in fEMCALBadChannelMap or fPHOSBadChannelMap @@ -370,20 +411,56 @@ Bool_t AliEMCALRecoUtils::ClusterContainsBadChannel(AliEMCALGeometry* geom, USho } //_________________________________________________ -Bool_t AliEMCALRecoUtils::IsExoticCluster(AliVCluster *cluster){ +Bool_t AliEMCALRecoUtils::IsExoticCluster(AliVCluster *cluster) const { // Check if the cluster has high energy but small number of cells // The criteria comes from Gustavo's study // - - if(cluster->GetNCells()<(1+cluster->E()/3.)) - return kTRUE; - else + + if(!cluster){ + AliInfo("Cluster pointer null!"); return kFALSE; + } + + Int_t nc = cluster->GetNCells() ; + + if ( nc > 8 ) return kFALSE ; // Good cluster, needed for 3x3 clusterizer + else if ( nc < 1 + cluster->E()/3. ) return kTRUE ; // Bad cluster + else return kFALSE ; // Good cluster + +} + +//__________________________________________________ +Float_t AliEMCALRecoUtils::SmearClusterEnergy(AliVCluster* cluster) { + + //In case of MC analysis, smear energy to match resolution/calibration in real data + + if(!cluster){ + AliInfo("Cluster pointer null!"); + return 0; + } + + Float_t energy = cluster->E() ; + Float_t rdmEnergy = energy ; + if(fSmearClusterEnergy){ + rdmEnergy = fRandom.Gaus(energy,fSmearClusterParam[0] * TMath::Sqrt(energy) + + fSmearClusterParam[1] * energy + + fSmearClusterParam[2] ); + AliDebug(2, Form("Energy: original %f, smeared %f\n", energy, rdmEnergy)); + } + + return rdmEnergy ; + } //__________________________________________________ Float_t AliEMCALRecoUtils::CorrectClusterEnergyLinearity(AliVCluster* cluster){ // Correct cluster energy from non linearity functions + + if(!cluster){ + AliInfo("Cluster pointer null!"); + return 0; + } + Float_t energy = cluster->E(); switch (fNonLinearityFunction) { @@ -588,7 +665,13 @@ void AliEMCALRecoUtils::GetMaxEnergyCell(AliEMCALGeometry *geom, AliVCaloCells* Int_t iIphi = -1; Int_t iIeta = -1; Int_t iSupMod0= -1; - //printf("---Max?\n"); + + if(!clu){ + AliInfo("Cluster pointer null!"); + absId=-1; iSupMod0=-1, ieta = -1; iphi = -1; shared = -1; + return; + } + for (Int_t iDig=0; iDig< clu->GetNCells(); iDig++) { cellAbsId = clu->GetCellAbsId(iDig); fraction = clu->GetCellAmplitudeFraction(iDig); @@ -648,6 +731,31 @@ void AliEMCALRecoUtils::InitEMCALRecalibrationFactors(){ TH1::AddDirectory(oldStatus); } +//________________________________________________________________ +void AliEMCALRecoUtils::InitEMCALTimeRecalibrationFactors(){ + //Init EMCAL recalibration factors + AliDebug(2,"AliCalorimeterUtils::InitEMCALRecalibrationFactors()"); + //In order to avoid rewriting the same histograms + Bool_t oldStatus = TH1::AddDirectoryStatus(); + TH1::AddDirectory(kFALSE); + + fEMCALTimeRecalibrationFactors = new TObjArray(4); + for (int i = 0; i < 4; i++) + fEMCALTimeRecalibrationFactors->Add(new TH1F(Form("hAllTimeAvBC%d",i), + Form("hAllTimeAvBC%d",i), + 48*24*10,0.,48*24*10) ); + //Init the histograms with 1 + for (Int_t bc = 0; bc < 4; bc++) { + for (Int_t i = 0; i < 48*24*10; i++) + SetEMCALChannelTimeRecalibrationFactor(bc,i,0.); + } + + fEMCALTimeRecalibrationFactors->SetOwner(kTRUE); + fEMCALTimeRecalibrationFactors->Compress(); + + //In order to avoid rewriting the same histograms + TH1::AddDirectory(oldStatus); +} //________________________________________________________________ void AliEMCALRecoUtils::InitEMCALBadChannelStatusMap(){ @@ -662,9 +770,7 @@ void AliEMCALRecoUtils::InitEMCALBadChannelStatusMap(){ for (int i = 0; i < 10; i++) { fEMCALBadChannelMap->Add(new TH2I(Form("EMCALBadChannelMap_Mod%d",i),Form("EMCALBadChannelMap_Mod%d",i), 48, 0, 48, 24, 0, 24)); } - - //delete hTemp; - + fEMCALBadChannelMap->SetOwner(kTRUE); fEMCALBadChannelMap->Compress(); @@ -673,9 +779,16 @@ void AliEMCALRecoUtils::InitEMCALBadChannelStatusMap(){ } //________________________________________________________________ -void AliEMCALRecoUtils::RecalibrateClusterEnergy(AliEMCALGeometry* geom, AliVCluster * cluster, AliVCaloCells * cells){ - // Recalibrate the cluster energy, considering the recalibration map and the energy of the cells that compose the cluster. +void AliEMCALRecoUtils::RecalibrateClusterEnergy(AliEMCALGeometry* geom, AliVCluster * cluster, AliVCaloCells * cells, const Int_t bc){ + // Recalibrate the cluster energy and Time, considering the recalibration map + // and the energy of the cells and time that compose the cluster. + // bc= bunch crossing number returned by esdevent->GetBunchCrossNumber(); + if(!cluster){ + AliInfo("Cluster pointer null!"); + return; + } + //Get the cluster number of cells and list of absId, check what kind of cluster do we have. UShort_t * index = cluster->GetCellsAbsId() ; Double_t * fraction = cluster->GetCellsAmplitudeFraction() ; @@ -683,39 +796,160 @@ void AliEMCALRecoUtils::RecalibrateClusterEnergy(AliEMCALGeometry* geom, AliVClu //Initialize some used variables Float_t energy = 0; - Int_t absId = -1; - Int_t icol = -1, irow = -1, imod=1; + Int_t absId =-1; + Int_t icol =-1, irow =-1, imod=1; Float_t factor = 1, frac = 0; - + Int_t absIdMax = -1; + Float_t emax = 0; + //Loop on the cells, get the cell amplitude and recalibration factor, multiply and and to the new energy for(Int_t icell = 0; icell < ncells; icell++){ absId = index[icell]; frac = fraction[icell]; if(frac < 1e-5) frac = 1; //in case of EMCAL, this is set as 0 since unfolding is off - Int_t iTower = -1, iIphi = -1, iIeta = -1; - geom->GetCellIndex(absId,imod,iTower,iIphi,iIeta); - if(fEMCALRecalibrationFactors->GetEntries() <= imod) continue; - geom->GetCellPhiEtaIndexInSModule(imod,iTower,iIphi, iIeta,irow,icol); - factor = GetEMCALChannelRecalibrationFactor(imod,icol,irow); - AliDebug(2,Form("AliEMCALRecoUtils::RecalibrateClusterEnergy - recalibrate cell: module %d, col %d, row %d, cell fraction %f,recalibration factor %f, cell energy %f\n", - imod,icol,irow,frac,factor,cells->GetCellAmplitude(absId))); - + + if(!fCellsRecalibrated && IsRecalibrationOn()){ + + // Energy + Int_t iTower = -1, iIphi = -1, iIeta = -1; + geom->GetCellIndex(absId,imod,iTower,iIphi,iIeta); + if(fEMCALRecalibrationFactors->GetEntries() <= imod) continue; + geom->GetCellPhiEtaIndexInSModule(imod,iTower,iIphi, iIeta,irow,icol); + factor = GetEMCALChannelRecalibrationFactor(imod,icol,irow); + + AliDebug(2,Form("AliEMCALRecoUtils::RecalibrateClusterEnergy - recalibrate cell: module %d, col %d, row %d, cell fraction %f,recalibration factor %f, cell energy %f\n", + imod,icol,irow,frac,factor,cells->GetCellAmplitude(absId))); + + } + energy += cells->GetCellAmplitude(absId)*factor*frac; + + if(emax < cells->GetCellAmplitude(absId)*factor*frac){ + emax = cells->GetCellAmplitude(absId)*factor*frac; + absIdMax = absId; + } + } - - AliDebug(2,Form("AliEMCALRecoUtils::RecalibrateClusterEnergy - Energy before %f, after %f\n",cluster->E(),energy)); - - cluster->SetE(energy); - + cluster->SetE(energy); + + AliDebug(2,Form("AliEMCALRecoUtils::RecalibrateClusterEnergy - Energy before %f, after %f\n",cluster->E(),energy)); + + // Recalculate time of cluster only for ESDs + if(!strcmp("AliESDCaloCluster",Form("%s",cluster->ClassName()))){ + + // Time + Double_t weightedTime = 0; + Double_t weight = 0; + Double_t weightTot = 0; + Double_t maxcellTime = 0; + for(Int_t icell = 0; icell < ncells; icell++){ + absId = index[icell]; + frac = fraction[icell]; + if(frac < 1e-5) frac = 1; //in case of EMCAL, this is set as 0 since unfolding is off + + Double_t celltime = cells->GetCellTime(absId); + RecalibrateCellTime(absId, bc, celltime); + if(absId == absIdMax) maxcellTime = celltime; + + if(!fCellsRecalibrated){ + + Int_t iTower = -1, iIphi = -1, iIeta = -1; + geom->GetCellIndex(absId,imod,iTower,iIphi,iIeta); + if(fEMCALRecalibrationFactors->GetEntries() <= imod) continue; + geom->GetCellPhiEtaIndexInSModule(imod,iTower,iIphi, iIeta,irow,icol); + factor = GetEMCALChannelRecalibrationFactor(imod,icol,irow); + + AliDebug(2,Form("AliEMCALRecoUtils::RecalibrateClusterEnergy - recalibrate cell: module %d, col %d, row %d, cell fraction %f,recalibration factor %f, cell energy %f\n", + imod,icol,irow,frac,factor,cells->GetCellTime(absId))); + + } + + weight = GetCellWeight(cells->GetCellAmplitude(absId)*factor*frac , energy ); + weightTot += weight; + weightedTime += celltime * weight; + + } + + if(weightTot > 0) + cluster->SetTOF(weightedTime/weightTot); + else + cluster->SetTOF(maxcellTime); + + } } +//________________________________________________________________ +void AliEMCALRecoUtils::RecalibrateCells(AliEMCALGeometry* geom, AliVCaloCells * cells, Int_t bc){ + // Recalibrate the cells time and energy, considering the recalibration map and the energy + // of the cells that compose the cluster. + // bc= bunch crossing number returned by esdevent->GetBunchCrossNumber(); -//__________________________________________________ + if(!IsRecalibrationOn() && !IsTimeRecalibrationOn()) return; + + if(!cells){ + AliInfo("Cells pointer null!"); + return; + } + + fCellsRecalibrated = kTRUE; + + Int_t absId =-1; + Int_t icol =-1, irow =-1, imod = 1; + Int_t iTower =-1, iIeta =-1, iIphi =-1; + + Int_t nEMcell = cells->GetNumberOfCells() ; + + for (Int_t iCell = 0; iCell < nEMcell; iCell++) { + + absId = cells->GetCellNumber(iCell); + + // Energy + Float_t factor = 1; + if(IsRecalibrationOn()){ + geom->GetCellIndex(absId,imod,iTower,iIphi,iIeta); + if(fEMCALRecalibrationFactors->GetEntries() <= imod) continue; + geom->GetCellPhiEtaIndexInSModule(imod,iTower,iIphi, iIeta,irow,icol); + factor = GetEMCALChannelRecalibrationFactor(imod,icol,irow); + } + + Float_t cellE = cells->GetAmplitude(iCell) * factor ; + + //Time + Double_t celltime = cells->GetCellTime(absId); + RecalibrateCellTime(absId, bc, celltime); + + //Set new values + cells->SetCell(iCell,cells->GetCellNumber(iCell),cellE, celltime); + + } + +} + +//_________________________________________________________________________________________________ +void AliEMCALRecoUtils::RecalibrateCellTime(const Int_t absId, const Int_t bc, Double_t & celltime) +{ + // Recalibrate time of cell with absID considering the recalibration map + // bc= bunch crossing number returned by esdevent->GetBunchCrossNumber(); + + if(!fCellsRecalibrated && IsTimeRecalibrationOn()){ + + celltime -= GetEMCALChannelTimeRecalibrationFactor(bc%4,absId)*1.e-9; ; + + } + +} + +//________________________________________________________________________________________________________________ void AliEMCALRecoUtils::RecalculateClusterPosition(AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu) { //For a given CaloCluster recalculates the position for a given set of misalignment shifts and puts it again in the CaloCluster. + if(!clu){ + AliInfo("Cluster pointer null!"); + return; + } + if (fPosAlgo==kPosTowerGlobal) RecalculateClusterPositionFromTowerGlobal( geom, cells, clu); else if(fPosAlgo==kPosTowerIndex) RecalculateClusterPositionFromTowerIndex ( geom, cells, clu); else AliDebug(2,"Algorithm to recalculate position not selected, do nothing."); @@ -747,20 +981,26 @@ void AliEMCALRecoUtils::RecalculateClusterPositionFromTowerGlobal(AliEMCALGeomet //printf("** Cluster energy %f, ncells %d, depth %f\n",clEnergy,clu->GetNCells(),depth); for (Int_t iDig=0; iDig< clu->GetNCells(); iDig++) { - absId = clu->GetCellAbsId(iDig); - fraction = clu->GetCellAmplitudeFraction(iDig); - if(fraction < 1e-4) fraction = 1.; // in case unfolding is off - geom->GetCellIndex(absId,iSM,iTower,iIphi,iIeta); - geom->GetCellPhiEtaIndexInSModule(iSM,iTower,iIphi, iIeta,iphi,ieta); - if(IsRecalibrationOn()) { - recalFactor = GetEMCALChannelRecalibrationFactor(iSM,ieta,iphi); + absId = clu->GetCellAbsId(iDig); + fraction = clu->GetCellAmplitudeFraction(iDig); + if(fraction < 1e-4) fraction = 1.; // in case unfolding is off + + if(!fCellsRecalibrated){ + + geom->GetCellIndex(absId,iSM,iTower,iIphi,iIeta); + geom->GetCellPhiEtaIndexInSModule(iSM,iTower,iIphi, iIeta,iphi,ieta); + + if(IsRecalibrationOn()) { + recalFactor = GetEMCALChannelRecalibrationFactor(iSM,ieta,iphi); + } } + eCell = cells->GetCellAmplitude(absId)*fraction*recalFactor; weight = GetCellWeight(eCell,clEnergy); - //printf("cell energy %f, weight %f\n",eCell,weight); totalWeight += weight; + geom->RelPosCellInSModule(absId,depth,pLocal[0],pLocal[1],pLocal[2]); //printf("pLocal (%f,%f,%f), SM %d, absId %d\n",pLocal[0],pLocal[1],pLocal[2],iSupModMax,absId); geom->GetGlobal(pLocal,pGlobal,iSupModMax); @@ -828,17 +1068,24 @@ void AliEMCALRecoUtils::RecalculateClusterPositionFromTowerIndex(AliEMCALGeometr absId = clu->GetCellAbsId(iDig); fraction = clu->GetCellAmplitudeFraction(iDig); if(fraction < 1e-4) fraction = 1.; // in case unfolding is off - geom->GetCellIndex(absId,iSupMod,iTower,iIphi,iIeta); - geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,iIphi, iIeta,iphi,ieta); - + if (iDig==0) startingSM = iSupMod; else if(iSupMod != startingSM) areInSameSM = kFALSE; eCell = cells->GetCellAmplitude(absId); - if(IsRecalibrationOn()) { - recalFactor = GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi); + geom->GetCellIndex(absId,iSupMod,iTower,iIphi,iIeta); + geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,iIphi, iIeta,iphi,ieta); + + if(!fCellsRecalibrated){ + + if(IsRecalibrationOn()) { + + recalFactor = GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi); + + } } + eCell = cells->GetCellAmplitude(absId)*fraction*recalFactor; weight = GetCellWeight(eCell,clEnergy); @@ -874,6 +1121,11 @@ void AliEMCALRecoUtils::RecalculateClusterDistanceToBadChannel(AliEMCALGeometry if(!fRecalDistToBadChannels) return; + if(!cluster){ + AliInfo("Cluster pointer null!"); + return; + } + //Get channels map of the supermodule where the cluster is. Int_t absIdMax = -1, iSupMod =-1, icolM = -1, irowM = -1; Bool_t shared = kFALSE; @@ -947,7 +1199,12 @@ void AliEMCALRecoUtils::RecalculateClusterDistanceToBadChannel(AliEMCALGeometry void AliEMCALRecoUtils::RecalculateClusterPID(AliVCluster * cluster){ //re-evaluate identification parameters with bayesian - + + if(!cluster){ + AliInfo("Cluster pointer null!"); + return; + } + if ( cluster->GetM02() != 0) fPIDUtils->ComputePID(cluster->E(),cluster->GetM02()); @@ -965,6 +1222,11 @@ void AliEMCALRecoUtils::RecalculateClusterShowerShapeParameters(AliEMCALGeometry // and tranfers into global ALICE coordinates // Calculates Dispersion and main axis + if(!cluster){ + AliInfo("Cluster pointer null!"); + return; + } + Int_t nstat = 0; Float_t wtot = 0. ; Double_t eCell = 0.; @@ -998,9 +1260,15 @@ void AliEMCALRecoUtils::RecalculateClusterShowerShapeParameters(AliEMCALGeometry //Get the cell energy, if recalibration is on, apply factors fraction = cluster->GetCellAmplitudeFraction(iDigit); if(fraction < 1e-4) fraction = 1.; // in case unfolding is off - if(IsRecalibrationOn()) { - recalFactor = GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi); + + if(!fCellsRecalibrated){ + + if(IsRecalibrationOn()) { + recalFactor = GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi); + } + } + eCell = cells->GetCellAmplitude(cluster->GetCellAbsId(iDigit))*fraction*recalFactor; if(cluster->E() > 0 && eCell > 0){ @@ -1090,121 +1358,160 @@ void AliEMCALRecoUtils::FindMatches(AliVEvent *event,TObjArray * clusterArr, Al //Before call this function, please recalculate the cluster positions //Given the input event, loop over all the tracks, select the closest cluster as matched with fCutR //Store matched cluster indexes and residuals - - fMatchedTrackIndex ->Reset(); + + fMatchedTrackIndex->Reset(); fMatchedClusterIndex->Reset(); - fResidualZ ->Reset(); - fResidualR ->Reset(); + fResidualPhi->Reset(); + fResidualEta->Reset(); - fMatchedTrackIndex ->Set(500); + fMatchedTrackIndex->Set(500); fMatchedClusterIndex->Set(500); - fResidualZ ->Set(500); - fResidualR ->Set(500); + fResidualPhi->Set(500); + fResidualEta->Set(500); AliESDEvent* esdevent = dynamic_cast (event); AliAODEvent* aodevent = dynamic_cast (event); - + Int_t matched=0; Double_t cv[21]; for (Int_t i=0; i<21;i++) cv[i]=0; for(Int_t itr=0; itrGetNumberOfTracks(); itr++) { - AliExternalTrackParam *trackParam=0; - + AliExternalTrackParam *trackParam = 0; + //If the input event is ESD, the starting point for extrapolation is TPCOut, if available, or TPCInner if(esdevent) - { - AliESDtrack *esdTrack = esdevent->GetTrack(itr); - if(!esdTrack || !IsAccepted(esdTrack)) continue; - const AliESDfriendTrack* friendTrack = esdTrack->GetFriendTrack(); - if(friendTrack && friendTrack->GetTPCOut()) - { - //Use TPC Out as starting point if it is available - trackParam= new AliExternalTrackParam(*friendTrack->GetTPCOut()); - } - else - { - //Otherwise use TPC inner - trackParam = new AliExternalTrackParam(*esdTrack->GetInnerParam()); - } - } + { + AliESDtrack *esdTrack = esdevent->GetTrack(itr); + if(!esdTrack || !IsAccepted(esdTrack)) continue; + if(esdTrack->Pt()(esdTrack->GetInnerParam()); + } //If the input event is AOD, the starting point for extrapolation is at vertex //AOD tracks are selected according to its bit. else if(aodevent) - { - AliAODTrack *aodTrack = aodevent->GetTrack(itr); - if(!aodTrack) continue; - if(!aodTrack->TestFilterMask(fAODFilterMask)) continue; //Select AOD tracks that fulfill GetStandardITSTPCTrackCuts2010() - Double_t pos[3],mom[3]; - aodTrack->GetXYZ(pos); - aodTrack->GetPxPyPz(mom); - AliDebug(5,Form("aod track: i=%d | pos=(%5.4f,%5.4f,%5.4f) | mom=(%5.4f,%5.4f,%5.4f) | charge=%d\n",itr,pos[0],pos[1],pos[2],mom[0],mom[1],mom[2],aodTrack->Charge())); - trackParam= new AliExternalTrackParam(pos,mom,cv,aodTrack->Charge()); - } + { + AliAODTrack *aodTrack = aodevent->GetTrack(itr); + if(!aodTrack) continue; + if(!aodTrack->TestFilterMask(fAODFilterMask)) continue; //Select AOD tracks that fulfill GetStandardITSTPCTrackCuts2010() + if(aodTrack->Pt()GetXYZ(pos); + aodTrack->GetPxPyPz(mom); + AliDebug(5,Form("aod track: i=%d | pos=(%5.4f,%5.4f,%5.4f) | mom=(%5.4f,%5.4f,%5.4f) | charge=%d\n",itr,pos[0],pos[1],pos[2],mom[0],mom[1],mom[2],aodTrack->Charge())); + trackParam= new AliExternalTrackParam(pos,mom,cv,aodTrack->Charge()); + } //Return if the input data is not "AOD" or "ESD" else - { - printf("Wrong input data type! Should be \"AOD\" or \"ESD\"\n"); - return; - } - + { + printf("Wrong input data type! Should be \"AOD\" or \"ESD\"\n"); + return; + } + if(!trackParam) continue; - - Float_t dRMax = fCutR, dZMax=fCutZ; + + Float_t dRMax = fCutR, dEtaMax=fCutEta, dPhiMax=fCutPhi; Int_t index = -1; if(!clusterArr){// get clusters from event for(Int_t icl=0; iclGetNumberOfCaloClusters(); icl++) { - AliExternalTrackParam *trkPamTmp = new AliExternalTrackParam(*trackParam);//Retrieve the starting point every time before the extrapolation AliVCluster *cluster = (AliVCluster*) event->GetCaloCluster(icl); - if(geom && !IsGoodCluster(cluster,geom,(AliVCaloCells*)event->GetEMCALCells())) continue; - Float_t tmpR=-1, tmpZ=-1; - if(!ExtrapolateTrackToCluster(trkPamTmp, cluster, tmpR, tmpZ)) continue; - if(tmpRGetEMCALCells())) continue; + AliExternalTrackParam trkPamTmp(*trackParam);//Retrieve the starting point every time before the extrapolation + Float_t tmpEta=-999, tmpPhi=-999; + if(!ExtrapolateTrackToCluster(&trkPamTmp, cluster, tmpEta, tmpPhi)) continue; + if(fCutEtaPhiSum) + { + Float_t tmpR=TMath::Sqrt(tmpEta*tmpEta + tmpPhi*tmpPhi); + if(tmpRGetEntriesFast(); icl++) { - AliExternalTrackParam *trkPamTmp = new AliExternalTrackParam(*trackParam);//Retrieve the starting point every time before the extrapolation - AliVCluster *cluster = (AliVCluster*) clusterArr->At(icl); + AliVCluster *cluster = dynamic_cast (clusterArr->At(icl)) ; + if(!cluster){ + AliInfo("Cluster not found!!!"); + continue; + } if(!cluster->IsEMCAL()) continue; - Float_t tmpR=-1, tmpZ=-1; - if(!ExtrapolateTrackToCluster(trkPamTmp, cluster, tmpR, tmpZ)) continue; - if(tmpR-1) { fMatchedTrackIndex ->AddAt(itr,matched); fMatchedClusterIndex->AddAt(index,matched); - fResidualZ ->AddAt(dZMax,matched); - fResidualR ->AddAt(dRMax,matched); + fResidualEta ->AddAt(dEtaMax,matched); + fResidualPhi ->AddAt(dPhiMax,matched); matched++; } - delete trackParam; + if(aodevent && trackParam) delete trackParam; }//track loop AliDebug(2,Form("Number of matched pairs = %d !\n",matched)); fMatchedTrackIndex ->Set(matched); fMatchedClusterIndex->Set(matched); - fResidualZ ->Set(matched); - fResidualR ->Set(matched); + fResidualPhi ->Set(matched); + fResidualEta ->Set(matched); } //________________________________________________________________________________ @@ -1212,39 +1519,55 @@ Int_t AliEMCALRecoUtils::FindMatchedCluster(AliESDtrack *track, AliVEvent *event { // // This function returns the index of matched cluster to input track - // Cut on match is dR<10cm by default. Returns -1 if no match is found - - - Float_t dRMax = fCutR; + // Returns -1 if no match is found + + + Float_t dRMax = fCutR, dEtaMax = fCutEta, dPhiMax = fCutPhi; Int_t index = -1; - - AliExternalTrackParam *trackParam=0; - const AliESDfriendTrack* friendTrack = track->GetFriendTrack(); - if(friendTrack && friendTrack->GetTPCOut()) - trackParam= const_cast(friendTrack->GetTPCOut()); - else - trackParam = const_cast(track->GetInnerParam()); - + + AliExternalTrackParam *trackParam = const_cast(track->GetInnerParam()); + if(!trackParam) return index; for(Int_t icl=0; iclGetNumberOfCaloClusters(); icl++) + { + AliVCluster *cluster = (AliVCluster*) event->GetCaloCluster(icl); + if(geom && !IsGoodCluster(cluster,geom,(AliVCaloCells*)event->GetEMCALCells())) continue; + AliExternalTrackParam trkPamTmp (*trackParam);//Retrieve the starting point every time before the extrapolation + Float_t tmpEta=-999, tmpPhi=-999; + if(!ExtrapolateTrackToCluster(&trkPamTmp, cluster, tmpEta, tmpPhi)) continue; + if(fCutEtaPhiSum) { - AliExternalTrackParam *trkPamTmp = new AliExternalTrackParam(*trackParam);//Retrieve the starting point every time before the extrapolation - AliVCluster *cluster = (AliVCluster*) event->GetCaloCluster(icl); - if(geom && !IsGoodCluster(cluster,geom,(AliVCaloCells*)event->GetEMCALCells())) continue; - Float_t tmpR=-1, tmpZ=-1; - if(!ExtrapolateTrackToCluster(trkPamTmp, cluster, tmpR, tmpZ)) continue; - if(tmpR>-1 && tmpRRotate(alpha); //Rotate the track to the same local extrapolation system - if(!AliTrackerBase::PropagateTrackToBxByBz(trkParam, vec.X(), fMass, fStep,kFALSE)) return kFALSE; + if(!AliTrackerBase::PropagateTrackToBxByBz(trkParam, vec.X(), fMass, fStep,kTRUE, 0.8, -1)) return kFALSE; trkParam->GetXYZ(trkPos); //Get the extrapolated global position - tmpR = TMath::Sqrt( TMath::Power(clsPos[0]-trkPos[0],2)+TMath::Power(clsPos[1]-trkPos[1],2)+TMath::Power(clsPos[2]-trkPos[2],2) ); - tmpZ = clsPos[2]-trkPos[2]; + + TVector3 clsPosVec(clsPos[0],clsPos[1],clsPos[2]); + TVector3 trkPosVec(trkPos[0],trkPos[1],trkPos[2]); + + // track cluster matching + tmpPhi = clsPosVec.DeltaPhi(trkPosVec); // tmpPhi is between -pi and pi + tmpEta = clsPosVec.Eta()-trkPosVec.Eta(); // track cluster matching + return kTRUE; } //________________________________________________________________________________ -void AliEMCALRecoUtils::GetMatchedResiduals(Int_t clsIndex, Float_t &dR, Float_t &dZ) +void AliEMCALRecoUtils::GetMatchedResiduals(Int_t clsIndex, Float_t &dEta, Float_t &dPhi) { //Given a cluster index as in AliESDEvent::GetCaloCluster(clsIndex) - //Get the residuals dR and dZ for this cluster to the closest track + //Get the residuals dEta and dPhi for this cluster to the closest track //Works with ESDs and AODs if( FindMatchedPosForCluster(clsIndex) >= 999 ) { AliDebug(2,"No matched tracks found!\n"); - dR=999.; - dZ=999.; + dEta=999.; + dPhi=999.; return; } - dR = fResidualR->At(FindMatchedPosForCluster(clsIndex)); - dZ = fResidualZ->At(FindMatchedPosForCluster(clsIndex)); + dEta = fResidualEta->At(FindMatchedPosForCluster(clsIndex)); + dPhi = fResidualPhi->At(FindMatchedPosForCluster(clsIndex)); } //________________________________________________________________________________ -void AliEMCALRecoUtils::GetMatchedClusterResiduals(Int_t trkIndex, Float_t &dR, Float_t &dZ) +void AliEMCALRecoUtils::GetMatchedClusterResiduals(Int_t trkIndex, Float_t &dEta, Float_t &dPhi) { //Given a track index as in AliESDEvent::GetTrack(trkIndex) - //Get the residuals dR and dZ for this track to the closest cluster + //Get the residuals dEta and dPhi for this track to the closest cluster //Works with ESDs and AODs if( FindMatchedPosForTrack(trkIndex) >= 999 ) { AliDebug(2,"No matched cluster found!\n"); - dR=999.; - dZ=999.; + dEta=999.; + dPhi=999.; return; } - dR = fResidualR->At(FindMatchedPosForTrack(trkIndex)); - dZ = fResidualZ->At(FindMatchedPosForTrack(trkIndex)); + dEta = fResidualEta->At(FindMatchedPosForTrack(trkIndex)); + dPhi = fResidualPhi->At(FindMatchedPosForTrack(trkIndex)); } //__________________________________________________________ @@ -1326,7 +1654,7 @@ Int_t AliEMCALRecoUtils::GetMatchedClusterIndex(Int_t trkIndex) } //__________________________________________________ -Bool_t AliEMCALRecoUtils::IsClusterMatched(Int_t clsIndex) +Bool_t AliEMCALRecoUtils::IsClusterMatched(Int_t clsIndex) const { //Given a cluster index as in AliESDEvent::GetCaloCluster(clsIndex) //Returns if the cluster has a match @@ -1337,7 +1665,7 @@ Bool_t AliEMCALRecoUtils::IsClusterMatched(Int_t clsIndex) } //__________________________________________________ -Bool_t AliEMCALRecoUtils::IsTrackMatched(Int_t trkIndex) +Bool_t AliEMCALRecoUtils::IsTrackMatched(Int_t trkIndex) const { //Given a track index as in AliESDEvent::GetTrack(trkIndex) //Returns if the track has a match @@ -1357,12 +1685,16 @@ UInt_t AliEMCALRecoUtils::FindMatchedPosForCluster(Int_t clsIndex) const for(Int_t i=0; iGetSize(); i++) { - if(fMatchedClusterIndex->At(i)==clsIndex && fResidualR->At(i)At(i); - AliDebug(3,Form("Matched cluster index: index: %d, dR: %2.4f, dZ: %2.4f.\n",fMatchedClusterIndex->At(i),fResidualR->At(i),fResidualZ->At(i))); - } + if(fMatchedClusterIndex->At(i)==clsIndex) + { + Float_t r = TMath::Sqrt(fResidualEta->At(i)*fResidualEta->At(i) + fResidualPhi->At(i)*fResidualPhi->At(i)); + if(rAt(i),fResidualEta->At(i),fResidualPhi->At(i))); + } + } } return pos; } @@ -1377,12 +1709,16 @@ UInt_t AliEMCALRecoUtils::FindMatchedPosForTrack(Int_t trkIndex) const for(Int_t i=0; iGetSize(); i++) { - if(fMatchedTrackIndex->At(i)==trkIndex && fResidualR->At(i)At(i); - AliDebug(3,Form("Matched track index: index: %d, dR: %2.4f, dZ: %2.4f.\n",fMatchedTrackIndex->At(i),fResidualR->At(i),fResidualZ->At(i))); - } + if(fMatchedTrackIndex->At(i)==trkIndex) + { + Float_t r = TMath::Sqrt(fResidualEta->At(i)*fResidualEta->At(i) + fResidualPhi->At(i)*fResidualPhi->At(i)); + if(rAt(i),fResidualEta->At(i),fResidualPhi->At(i))); + } + } } return pos; } @@ -1395,9 +1731,9 @@ Bool_t AliEMCALRecoUtils::IsGoodCluster(AliVCluster *cluster, AliEMCALGeometry * // Bool_t isGood=kTRUE; if(!cluster || !cluster->IsEMCAL()) return kFALSE; - if(ClusterContainsBadChannel(geom,cluster->GetCellsAbsId(),cluster->GetNCells())) isGood=kFALSE; - if(!CheckCellFiducialRegion(geom,cluster,cells)) isGood=kFALSE; - if(fRejectExoticCluster && IsExoticCluster(cluster)) isGood=kFALSE; + if(ClusterContainsBadChannel(geom,cluster->GetCellsAbsId(),cluster->GetNCells())) return kFALSE; + if(!CheckCellFiducialRegion(geom,cluster,cells)) return kFALSE; + if(fRejectExoticCluster && IsExoticCluster(cluster)) return kFALSE; return isGood; } @@ -1425,9 +1761,12 @@ Bool_t AliEMCALRecoUtils::IsAccepted(AliESDtrack *esdTrack) //DCA cuts - Float_t MaxDCAToVertexXYPtDep = 0.0182 + 0.0350/TMath::Power(esdTrack->Pt(),1.01); //This expression comes from AliESDtrackCuts::GetStandardITSTPCTrackCuts2010() - //AliDebug(3,Form("Track pT = %f, DCAtoVertexXY = %f",esdTrack->Pt(),MaxDCAToVertexXYPtDep)); - SetMaxDCAToVertexXY(MaxDCAToVertexXYPtDep); //Set pT dependent DCA cut to vertex in x-y plane + if(fTrackCutsType==kGlobalCut) + { + Float_t maxDCAToVertexXYPtDep = 0.0182 + 0.0350/TMath::Power(esdTrack->Pt(),1.01); //This expression comes from AliESDtrackCuts::GetStandardITSTPCTrackCuts2010() + //AliDebug(3,Form("Track pT = %f, DCAtoVertexXY = %f",esdTrack->Pt(),MaxDCAToVertexXYPtDep)); + SetMaxDCAToVertexXY(maxDCAToVertexXYPtDep); //Set pT dependent DCA cut to vertex in x-y plane + } Float_t b[2]; @@ -1474,12 +1813,15 @@ Bool_t AliEMCALRecoUtils::IsAccepted(AliESDtrack *esdTrack) if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexZ) > fCutMaxDCAToVertexZ) cuts[9] = kTRUE; - //Require at least one SPD point + anything else in ITS - if( (esdTrack->HasPointOnITSLayer(0) || esdTrack->HasPointOnITSLayer(1)) == kFALSE) - cuts[10] = kTRUE; + if(fTrackCutsType==kGlobalCut) + { + //Require at least one SPD point + anything else in ITS + if( (esdTrack->HasPointOnITSLayer(0) || esdTrack->HasPointOnITSLayer(1)) == kFALSE) + cuts[10] = kTRUE; + } Bool_t cut=kFALSE; - for (Int_t i=0; iReadRootInfo(Form("CorrectionFiles/Run%d_Correction.root",runnumber)); @@ -1563,6 +1959,6 @@ void AliEMCALRecoUtils::SetTimeDependentCorrections(Int_t runnumber){ } } } - fTimeCorrectionFactorsSet = kTRUE; + fRunCorrectionFactorsSet = kTRUE; }