3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * See cxx source for full Copyright notice */
6 //_________________________________________________________________________
7 // Class for PID selection with calorimeters
8 // The Output of the main method GetIdentifiedParticleType is a PDG number identifying the cluster,
9 // being kPhoton, kElectron, kPi0 ... as defined in the header file
10 // - GetIdentifiedParticleType(const AliVCluster * cluster)
11 // Assignes a PID tag to the cluster, right now there is the possibility to : use bayesian weights from reco,
12 // recalculate them (EMCAL) or use other procedures not used in reco.
13 // In order to recalculate Bayesian, it is necessary to load the EMCALUtils library
14 // and do SwitchOnBayesianRecalculation().
15 // To change the PID parameters from Low to High like the ones by default, use the constructor
17 // where flux is AliCaloPID::kLow or AliCaloPID::kHigh
18 // If it is necessary to change the parameters use the constructor
19 // AliCaloPID(AliEMCALPIDUtils *utils) and set the parameters before.
21 // - GetGetIdentifiedParticleTypeFromBayesian(const Double_t * pid, const Float_t energy)
22 // Reads the PID weights array of the ESDs and depending on its magnitude identifies the particle,
23 // executed when bayesian is ON by GetIdentifiedParticleType(const AliVCluster * cluster)
24 // - SetPIDBits: Simple PID, depending on the thresholds fLOCut fTOFCut and even the
25 // result of the PID bayesian a different PID bit is set.
28 //*-- Author: Gustavo Conesa (INFN-LNF)
30 // --- ROOT system ---
33 class TLorentzVector ;
38 //--- AliRoot system ---
41 class AliAODPWG4Particle;
42 class AliEMCALPIDUtils;
43 class AliCalorimeterUtils;
46 class AliCaloPID : public TObject {
50 AliCaloPID() ; // ctor
51 AliCaloPID(const Int_t particleFlux) ; // ctor, to be used when recalculating bayesian PID
52 AliCaloPID(const TNamed * emcalpid) ; // ctor, to be used when recalculating bayesian PID and need different parameters
53 virtual ~AliCaloPID() ;//virtual dtor
62 kNeutralHadron = 2112,
64 kNeutralUnknown = 130,
68 enum TagType {kPi0Decay, kEtaDecay, kOtherDecay, kConversion, kNoTag = -1};
72 TList * GetCreateOutputObjects();
74 void InitParameters();
76 Bool_t IsInPi0SplitAsymmetryRange(const Float_t energy, const Float_t asy, const Int_t nlm);
78 Bool_t IsInPi0SplitMassRange (const Float_t energy, const Float_t mass, const Int_t nlm);
80 Bool_t IsInPi0M02Range (const Float_t energy, const Float_t m02, const Int_t nlm);
81 Bool_t IsInEtaM02Range (const Float_t energy, const Float_t m02, const Int_t nlm);
82 Bool_t IsInConM02Range (const Float_t energy, const Float_t m02, const Int_t nlm);
85 Int_t GetIdentifiedParticleTypeFromBayesWeights(const Bool_t isEMCAL, const Double_t * pid, const Float_t energy) ;
87 Int_t GetIdentifiedParticleTypeFromClusterSplitting(AliVCluster * cluster, AliVCaloCells* cells,
88 AliCalorimeterUtils * caloutils,
90 Int_t & nLocMax, Double_t & mass, Double_t & angle,
91 TLorentzVector & l1 , TLorentzVector & l2,
92 Int_t & absId1, Int_t & absId2,
93 Float_t & distbad1, Float_t & distbad2,
94 Bool_t & fidcut1, Bool_t & fidcut2 ) ;
96 Int_t GetIdentifiedParticleType(const AliVCluster * cluster) ;
98 TString GetPIDParametersList();
100 Bool_t IsTrackMatched(AliVCluster * cluster, AliCalorimeterUtils* cu, AliVEvent* event) const ;
102 void SetPIDBits(AliVCluster * cluster, AliAODPWG4Particle *aodph,
103 AliCalorimeterUtils* cu, AliVEvent* event);
105 void Print(const Option_t * opt)const;
107 void PrintClusterPIDWeights(const Double_t * pid) const;
109 //Check if cluster photon-like. Uses photon cluster parameterization in real pp data
110 //Returns distance in sigmas. Recommended cut 2.5
111 Float_t TestPHOSDispersion(const Double_t pt, const Double_t m20, const Double_t m02) const ;
112 //Checks distance to the closest track. Takes into account
113 //non-perpendicular incidence of tracks.
114 Float_t TestPHOSChargedVeto(const Double_t dx, const Double_t dz, const Double_t ptTrack,
115 const Int_t chargeTrack, const Double_t mf) const ;
119 void SetDebug(Int_t deb) { fDebug = deb ; }
120 Int_t GetDebug() const { return fDebug ; }
122 enum eventType{kLow,kHigh};
123 void SetLowParticleFlux() { fParticleFlux = kLow ; }
124 void SetHighParticleFlux() { fParticleFlux = kHigh ; }
125 // not really used, only for bayesian recalculation in EMCAL, but could be useful in future
129 void SwitchOnBayesian() { fUseBayesianWeights = kTRUE ; }
130 void SwitchOffBayesian() { fUseBayesianWeights = kFALSE; }
131 void SwitchOnBayesianRecalculation() { fRecalculateBayesian = kTRUE ; fUseBayesianWeights = kTRUE ;} // EMCAL
132 void SwitchOffBayesianRecalculation() { fRecalculateBayesian = kFALSE; } // EMCAL
134 AliEMCALPIDUtils * GetEMCALPIDUtils() ;
137 Float_t GetEMCALPhotonWeight() const { return fEMCALPhotonWeight ; }
138 Float_t GetEMCALPi0Weight() const { return fEMCALPi0Weight ; }
139 Float_t GetEMCALElectronWeight() const { return fEMCALElectronWeight ; }
140 Float_t GetEMCALChargeWeight() const { return fEMCALChargeWeight ; }
141 Float_t GetEMCALNeutralWeight() const { return fEMCALNeutralWeight ; }
142 Float_t GetPHOSPhotonWeight() const { return fPHOSPhotonWeight ; }
143 Float_t GetPHOSPi0Weight() const { return fPHOSPi0Weight ; }
144 Float_t GetPHOSElectronWeight() const { return fPHOSElectronWeight ; }
145 Float_t GetPHOSChargeWeight() const { return fPHOSChargeWeight ; }
146 Float_t GetPHOSNeutralWeight() const { return fPHOSNeutralWeight ; }
148 Bool_t IsPHOSPIDWeightFormulaOn() const { return fPHOSWeightFormula ; }
150 TFormula * GetPHOSPhotonWeightFormula() {
151 if(!fPHOSPhotonWeightFormula)
152 fPHOSPhotonWeightFormula = new TFormula("phos_photon_weight",
153 fPHOSPhotonWeightFormulaExpression);
154 return fPHOSPhotonWeightFormula ; }
156 TFormula * GetPHOSPi0WeightFormula() {
157 if(!fPHOSPi0WeightFormula)
158 fPHOSPi0WeightFormula = new TFormula("phos_pi0_weight",
159 fPHOSPi0WeightFormulaExpression);
160 return fPHOSPi0WeightFormula ; }
162 TString GetPHOSPhotonWeightFormulaExpression() const { return fPHOSPhotonWeightFormulaExpression ; }
163 TString GetPHOSPi0WeightFormulaExpression() const { return fPHOSPi0WeightFormulaExpression ; }
166 void SetEMCALPhotonWeight (Float_t w) { fEMCALPhotonWeight = w ; }
167 void SetEMCALPi0Weight (Float_t w) { fEMCALPi0Weight = w ; }
168 void SetEMCALElectronWeight(Float_t w) { fEMCALElectronWeight = w ; }
169 void SetEMCALChargeWeight (Float_t w) { fEMCALChargeWeight = w ; }
170 void SetEMCALNeutralWeight (Float_t w) { fEMCALNeutralWeight = w ; }
171 void SetPHOSPhotonWeight (Float_t w) { fPHOSPhotonWeight = w ; }
172 void SetPHOSPi0Weight (Float_t w) { fPHOSPi0Weight = w ; }
173 void SetPHOSElectronWeight (Float_t w) { fPHOSElectronWeight = w ; }
174 void SetPHOSChargeWeight (Float_t w) { fPHOSChargeWeight = w ; }
175 void SetPHOSNeutralWeight (Float_t w) { fPHOSNeutralWeight = w ; }
177 void UsePHOSPIDWeightFormula (Bool_t ok ) { fPHOSWeightFormula = ok ; }
178 void SetPHOSPhotonWeightFormulaExpression(TString ph) { fPHOSPhotonWeightFormulaExpression = ph ; }
179 void SetPHOSPi0WeightFormulaExpression (TString pi) { fPHOSPi0WeightFormulaExpression = pi ; }
183 void SetEMCALLambda0CutMax(Float_t lcut ) { fEMCALL0CutMax = lcut ; }
184 Float_t GetEMCALLambda0CutMax() const { return fEMCALL0CutMax ; }
186 void SetEMCALLambda0CutMin(Float_t lcut ) { fEMCALL0CutMin = lcut ; }
187 Float_t GetEMCALLambda0CutMin() const { return fEMCALL0CutMin ; }
189 void SetEMCALDEtaCut(Float_t dcut ) { fEMCALDEtaCut = dcut ; }
190 Float_t GetEMCALDEtaCut() const { return fEMCALDEtaCut ; }
192 void SetEMCALDPhiCut(Float_t dcut ) { fEMCALDPhiCut = dcut ; }
193 Float_t GetEMCALDPhiCut() const { return fEMCALDPhiCut ; }
195 void SetTOFCut(Float_t tcut ) { fTOFCut = tcut ; }
196 Float_t GetTOFCut() const { return fTOFCut ; }
198 void SetPHOSRCut(Float_t rcut ) { fPHOSRCut = rcut ; }
199 Float_t GetPHOSRCut() const { return fPHOSRCut ; }
201 void SetPHOSDispersionCut(Float_t dcut ) { fPHOSDispersionCut = dcut ; }
202 Float_t GetPHOSDispersionCut() const { return fPHOSDispersionCut ; }
204 // Cluster splitting analysis
206 void SwitchOnClusterSplittingPID() { fDoClusterSplitting = kTRUE ; }
207 void SwitchOffClusterplittingPID() { fDoClusterSplitting = kFALSE ; }
209 void SwitchOnSimpleSplitMassCut() { fUseSimpleMassCut = kTRUE ; }
210 void SwitchOffSimpleSplitMassCut() { fUseSimpleMassCut = kFALSE ; }
212 void SwitchOnSimpleSplitM02Cut() { fUseSimpleM02Cut = kTRUE ; }
213 void SwitchOffSimpleSplitM02Cut() { fUseSimpleM02Cut = kFALSE ; }
215 void SwitchOnSplitAsymmetryCut() { fUseSplitAsyCut = kTRUE ; }
216 void SwitchOffSplitAsymmetryCut() { fUseSplitAsyCut = kFALSE ; }
217 Bool_t IsSplitAsymmetryCutOn() { return fUseSplitAsyCut ; }
219 void SwitchOnSplitShowerShapeCut() { fUseSplitSSCut = kTRUE ; }
220 void SwitchOffSplitShowerShapeCut() { fUseSplitSSCut = kFALSE ; }
221 Bool_t IsSplitShowerShapeCutOn() { return fUseSplitSSCut ; }
223 void SetClusterSplittingM02Cut(Float_t min=0, Float_t max=100)
224 { fSplitM02MinCut = min ; fSplitM02MaxCut = max ; }
226 void SetClusterSplittingMinNCells(Int_t c) { fSplitMinNCells = c ; }
227 Int_t GetClusterSplittingMinNCells() const { return fSplitMinNCells ; }
229 void SetSplitEnergyFractionMinimum(Int_t i, Float_t min){ if (i < 3 && i >=0 ) fSplitEFracMin[i] = min ; }
230 Float_t GetSplitEnergyFractionMinimum(Int_t i) const { if( i < 3 && i >=0 ) return fSplitEFracMin[i] ; else return 0 ; }
232 Float_t GetPi0MinMass() const { return fMassPi0Min ; } // Simple cut case
233 Float_t GetEtaMinMass() const { return fMassEtaMin ; } // Simple cut case
234 Float_t GetPhotonMinMass() const { return fMassPhoMin ; }
235 Float_t GetPi0MaxMass() const { return fMassPi0Max ; }
236 Float_t GetEtaMaxMass() const { return fMassEtaMax ; }
237 Float_t GetPhotonMaxMass() const { return fMassPhoMax ; }
239 void SetSplitWidthSigma(Float_t s) { fSplitWidthSigma = s ; }
241 void SetPi0MassShiftHighECell(Float_t s) { s = fMassShiftHighECell ; }
242 void SetPi0MassWidthSelectionParameters (Int_t inlm, Int_t iparam, Float_t param)
243 { if(iparam < 7 ) fMassWidthPi0Param[inlm][iparam] = param ; }
244 void SetM02MaximumSelectionParameters (Int_t inlm, Int_t iparam, Float_t param)
245 { if(iparam < 7 && inlm < 2) fM02MaxParam[inlm][iparam] = param ; }
246 void SetM02MinimumSelectionParameters (Int_t inlm, Int_t iparam, Float_t param)
247 { if(iparam < 7 && inlm < 2) fM02MinParam[inlm][iparam] = param ; }
248 void SetAsymmetryMinimumSelectionParameters(Int_t inlm, Int_t iparam, Float_t param)
249 { if(iparam < 4 && inlm < 2) fAsyMinParam[inlm][iparam] = param ; }
251 void SetPi0MassRange(Float_t min, Float_t max) { fMassPi0Min = min ; fMassPi0Max = max ; } // Simple case
252 void SetEtaMassRange(Float_t min, Float_t max) { fMassEtaMin = min ; fMassEtaMax = max ; }
253 void SetPhotonMassRange(Float_t min, Float_t max) { fMassPhoMin = min ; fMassPhoMax = max ; }
257 Int_t fDebug; // Debug level
258 Int_t fParticleFlux; // Particle flux for setting PID parameters
261 AliEMCALPIDUtils * fEMCALPIDUtils; // Pointer to EMCALPID to redo the PID Bayesian calculation
262 Bool_t fUseBayesianWeights; // Select clusters based on weights calculated in reconstruction
263 Bool_t fRecalculateBayesian; // Recalculate PID bayesian or use simple PID?
265 Float_t fEMCALPhotonWeight; // Bayesian PID weight for photons in EMCAL
266 Float_t fEMCALPi0Weight; // Bayesian PID weight for pi0 in EMCAL
267 Float_t fEMCALElectronWeight; // Bayesian PID weight for electrons in EMCAL
268 Float_t fEMCALChargeWeight; // Bayesian PID weight for charged hadrons in EMCAL
269 Float_t fEMCALNeutralWeight; // Bayesian PID weight for neutral hadrons in EMCAL
270 Float_t fPHOSPhotonWeight; // Bayesian PID weight for photons in PHOS
271 Float_t fPHOSPi0Weight; // Bayesian PID weight for pi0 in PHOS
272 Float_t fPHOSElectronWeight; // Bayesian PID weight for electrons in PHOS
273 Float_t fPHOSChargeWeight; // Bayesian PID weight for charged hadrons in PHOS
274 Float_t fPHOSNeutralWeight; // Bayesian PID weight for neutral hadrons in PHOS
276 Bool_t fPHOSWeightFormula ; // Use parametrized weight threshold, function of energy
277 TFormula *fPHOSPhotonWeightFormula ; // Formula for photon weight
278 TFormula *fPHOSPi0WeightFormula ; // Formula for pi0 weight
279 TString fPHOSPhotonWeightFormulaExpression; // Photon weight formula in string
280 TString fPHOSPi0WeightFormulaExpression; // Pi0 weight formula in string
283 Float_t fEMCALL0CutMax; // Max Cut on shower shape lambda0, used in PID evaluation, only EMCAL
284 Float_t fEMCALL0CutMin; // Min Cut on shower shape lambda0, used in PID evaluation, only EMCAL
285 Float_t fEMCALDEtaCut; // Track matching cut on Dz
286 Float_t fEMCALDPhiCut; // Track matching cut on Dx
288 Float_t fTOFCut; // Cut on TOF, used in PID evaluation
290 Float_t fPHOSDispersionCut; // Shower shape elipse radious cut
291 Float_t fPHOSRCut; // Track-Cluster distance cut for track matching in PHOS
293 // Cluster splitting mass ranges
294 Bool_t fDoClusterSplitting; // Cluster splitting analysis
295 Bool_t fUseSimpleMassCut; // Use simple min-max pi0 mass cut
296 Bool_t fUseSimpleM02Cut; // Use simple min-max M02 cut
297 Bool_t fUseSplitAsyCut ; // Remove splitted clusters with too large asymmetry
298 Bool_t fUseSplitSSCut ; // Remove splitted clusters out of shower shape band
299 Float_t fSplitM02MaxCut ; // Study clusters with l0 smaller than cut
300 Float_t fSplitM02MinCut ; // Study clusters with l0 larger than cut // simple case
301 Int_t fSplitMinNCells ; // Study clusters with ncells larger than cut
302 Float_t fMassEtaMin ; // Min Eta mass
303 Float_t fMassEtaMax ; // Max Eta mass
304 Float_t fMassPi0Min ; // Min Pi0 mass // simple cut case
305 Float_t fMassPi0Max ; // Min Pi0 mass // simple cut case
306 Float_t fMassPhoMin ; // Min Photon mass
307 Float_t fMassPhoMax ; // Min Photon mass
308 Float_t fMassWidthPi0Param[2][7] ; // 2+1 param for pol1 fit on width, 2+1 param for mass position pi0 selection
309 Float_t fM02MinParam[2][7] ; // 5 param for expo + pol fit on M02 minimum for pi0 selection (maximum for conversions)
310 Float_t fM02MaxParam[2][7] ; // 5 param for expo + pol fit on M02 maximum for pi0 selection
311 Float_t fAsyMinParam[2][4] ; // 2 param for fit on asymmetry minimum, for 2 cases, NLM=1 and NLM>=2
312 Float_t fSplitEFracMin[3] ; // Do not use clusters with too large energy in cluster compared
313 // to energy in splitted clusters, depeding on NLM
314 Float_t fSplitWidthSigma; // Cut on mass+-width*fSplitWidthSigma
315 Float_t fMassShiftHighECell; // Shift cuts 5 MeV for Ecell > 150 MeV, default Ecell > 50 MeV
317 AliCaloPID & operator = (const AliCaloPID & cpid) ; // cpy assignment
318 AliCaloPID( const AliCaloPID & cpid) ; // cpy ctor
320 ClassDef(AliCaloPID,19)
325 #endif //ALICALOPID_H