1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15 /* $Id: AliCaloPID.cxx 21839 2007-10-29 13:49:42Z gustavo $ */
17 //_________________________________________________________________________
18 // Class for PID selection with calorimeters
19 // The Output of the 2 main methods GetPdg is a PDG number identifying the cluster,
20 // being kPhoton, kElectron, kPi0 ... as defined in the header file
21 // - GetPdg(const TString calo, 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 // - GetPdg(const TString calo,const TLorentzVector mom, const AliAODCaloCluster * cluster)
24 // Recalcultes PID, the bayesian or any new one to be implemented in the future
25 // Right now only the possibility to recalculate EMCAL with bayesian and simple PID.
26 // In order to recalculate Bayesian, it is necessary to load the EMCALUtils library
27 // and do SwitchOnBayesianRecalculation().
28 // To change the PID parameters from Low to High like the ones by default, use the constructor
30 // where flux is AliCaloPID::kLow or AliCaloPID::kHigh
31 // If it is necessary to change the parameters use the constructor
32 // AliCaloPID(AliEMCALPIDUtils *utils) and set the parameters before.
33 // - SetPIDBits: Simple PID, depending on the thresholds fDispCut fTOFCut and even the
34 // result of the PID bayesian a different PID bit is set.
36 // All these methods can be called in the analysis you are interested.
38 //*-- Author: Gustavo Conesa (LNF-INFN)
39 //////////////////////////////////////////////////////////////////////////////
42 // --- ROOT system ---
45 //#include <TFormula.h>
47 //---- ANALYSIS system ----
48 #include "AliCaloPID.h"
49 #include "AliAODCaloCluster.h"
50 #include "AliAODPWG4Particle.h"
51 #include "AliEMCALPIDUtils.h"
55 //________________________________________________
56 AliCaloPID::AliCaloPID() :
57 TObject(), fEMCALPhotonWeight(0.), fEMCALPi0Weight(0.),
58 fEMCALElectronWeight(0.), fEMCALChargeWeight(0.),
59 fEMCALNeutralWeight(0.),
60 fPHOSPhotonWeight(0.), fPHOSPi0Weight(0.),
61 fPHOSElectronWeight(0.), fPHOSChargeWeight(0.) ,
62 fPHOSNeutralWeight(0.), //fPHOSWeightFormula(0),
63 //fPHOSPhotonWeightFormula(0x0), fPHOSPi0WeightFormula(0x0),
64 fDispCut(0.),fTOFCut(0.), fDebug(-1),
65 fRecalculateBayesian(kFALSE), fParticleFlux(kLow), fEMCALPIDUtils(new AliEMCALPIDUtils)
69 //Initialize parameters
73 //________________________________________________
74 AliCaloPID::AliCaloPID(const Int_t flux) :
75 TObject(), fEMCALPhotonWeight(0.), fEMCALPi0Weight(0.),
76 fEMCALElectronWeight(0.), fEMCALChargeWeight(0.),
77 fEMCALNeutralWeight(0.),
78 fPHOSPhotonWeight(0.), fPHOSPi0Weight(0.),
79 fPHOSElectronWeight(0.), fPHOSChargeWeight(0.) ,
80 fPHOSNeutralWeight(0.), //fPHOSWeightFormula(0),
81 //fPHOSPhotonWeightFormula(0x0), fPHOSPi0WeightFormula(0x0),
82 fDispCut(0.),fTOFCut(0.), fDebug(-1),
83 fRecalculateBayesian(kTRUE), fParticleFlux(flux), fEMCALPIDUtils(new AliEMCALPIDUtils)
87 //Initialize parameters
91 //________________________________________________
92 AliCaloPID::AliCaloPID(const TTask * emcalpid) :
93 TObject(), fEMCALPhotonWeight(0.), fEMCALPi0Weight(0.),
94 fEMCALElectronWeight(0.), fEMCALChargeWeight(0.),
95 fEMCALNeutralWeight(0.),
96 fPHOSPhotonWeight(0.), fPHOSPi0Weight(0.),
97 fPHOSElectronWeight(0.), fPHOSChargeWeight(0.) ,
98 fPHOSNeutralWeight(0.), //fPHOSWeightFormula(0),
99 //fPHOSPhotonWeightFormula(0x0), fPHOSPi0WeightFormula(0x0),
100 fDispCut(0.),fTOFCut(0.), fDebug(-1),
101 fRecalculateBayesian(kTRUE), fParticleFlux(-1), fEMCALPIDUtils( (AliEMCALPIDUtils*) emcalpid)
105 //Initialize parameters
109 //____________________________________________________________________________
110 AliCaloPID::AliCaloPID(const AliCaloPID & pid) :
111 TObject(pid), fEMCALPhotonWeight(pid.fEMCALPhotonWeight),
112 fEMCALPi0Weight(pid.fEMCALPi0Weight),
113 fEMCALElectronWeight(pid.fEMCALElectronWeight),
114 fEMCALChargeWeight(pid.fEMCALChargeWeight),
115 fEMCALNeutralWeight(pid.fEMCALNeutralWeight),
116 fPHOSPhotonWeight(pid.fPHOSPhotonWeight),
117 fPHOSPi0Weight(pid.fPHOSPi0Weight),
118 fPHOSElectronWeight(pid.fPHOSElectronWeight),
119 fPHOSChargeWeight(pid.fPHOSChargeWeight),
120 fPHOSNeutralWeight(pid.fPHOSNeutralWeight),
121 //fPHOSWeightFormula(pid.fPHOSWeightFormula),
122 //fPHOSPhotonWeightFormula(new TFormula(*pid.fPHOSPhotonWeightFormula)),
123 //fPHOSPi0WeightFormula (new TFormula(*pid.fPHOSPi0WeightFormula)),
124 fDispCut(pid.fDispCut),fTOFCut(pid.fTOFCut),
125 fDebug(pid.fDebug), fRecalculateBayesian(pid.fRecalculateBayesian),
126 fParticleFlux(pid.fParticleFlux),
127 fEMCALPIDUtils(new AliEMCALPIDUtils(*pid.fEMCALPIDUtils))
133 //_________________________________________________________________________
134 //AliCaloPID & AliCaloPID::operator = (const AliCaloPID & pid)
136 // // assignment operator
138 // if(&pid == this) return *this;
140 // fEMCALPhotonWeight = pid. fEMCALPhotonWeight ;
141 // fEMCALPi0Weight = pid.fEMCALPi0Weight ;
142 // fEMCALElectronWeight = pid.fEMCALElectronWeight;
143 // fEMCALChargeWeight = pid.fEMCALChargeWeight;
144 // fEMCALNeutralWeight = pid.fEMCALNeutralWeight;
146 // fPHOSPhotonWeight = pid.fPHOSPhotonWeight ;
147 // fPHOSPi0Weight = pid.fPHOSPi0Weight ;
148 // fPHOSElectronWeight = pid.fPHOSElectronWeight;
149 // fPHOSChargeWeight = pid.fPHOSChargeWeight;
150 // fPHOSNeutralWeight = pid.fPHOSNeutralWeight;
152 // fPHOSWeightFormula = pid.fPHOSWeightFormula;
153 // delete fPHOSPhotonWeightFormula; fPHOSPhotonWeightFormula = new TFormula(*pid.fPHOSPhotonWeightFormula);
154 // delete fPHOSPi0WeightFormula; fPHOSPi0WeightFormula = new TFormula(*pid.fPHOSPi0WeightFormula);
156 // fDispCut = pid.fDispCut;
157 // fTOFCut = pid.fTOFCut;
158 // fDebug = pid.fDebug;
160 // fRecalculateBayesian = pid.fRecalculateBayesian;
161 // fParticleFlux = pid.fParticleFlux;
163 // delete fEMCALPIDUtils; fEMCALPIDUtils = new AliEMCALPIDUtils(*pid.fEMCALPIDUtils);
169 //_________________________________
170 AliCaloPID::~AliCaloPID() {
173 // if(fPHOSPhotonWeightFormula) delete fPHOSPhotonWeightFormula ;
174 // if(fPHOSPi0WeightFormula) delete fPHOSPi0WeightFormula ;
175 if(fEMCALPIDUtils) delete fEMCALPIDUtils ;
179 //_______________________________________________________________
180 void AliCaloPID::InitParameters()
182 //Initialize the parameters of the PID.
184 fEMCALPhotonWeight = 0.5 ;
185 fEMCALPi0Weight = 0.5 ;
186 fEMCALElectronWeight = 0.5 ;
187 fEMCALChargeWeight = 0.5 ;
188 fEMCALNeutralWeight = 0.5 ;
190 fPHOSPhotonWeight = 0.5 ;
191 fPHOSPi0Weight = 0.5 ;
192 fPHOSElectronWeight = 0.5 ;
193 fPHOSChargeWeight = 0.5 ;
194 fPHOSNeutralWeight = 0.5 ;
196 //Formula to set the PID weight threshold for photon or pi0
197 //fPHOSWeightFormula = kTRUE;
198 //if(fPHOSPhotonWeightFormula) delete fPHOSPhotonWeightFormula;
199 //if(fPHOSPi0WeightFormula) delete fPHOSPi0WeightFormula;
200 //fPHOSPhotonWeightFormula =
201 //new TFormula("photonWeight","0.98*(x<40)+ 0.68*(x>=100)+(x>=40 && x<100)*(0.98+x*(6e-3)-x*x*(2e-04)+x*x*x*(1.1e-06))");
202 //fPHOSPi0WeightFormula =
203 //new TFormula("pi0Weight","0.98*(x<65)+ 0.915*(x>=100)+(x>=65 && x-x*(1.95e-3)-x*x*(4.31e-05)+x*x*x*(3.61e-07))");
209 if(fRecalculateBayesian){
210 if(fParticleFlux == kLow){
211 printf("AliCaloPID::Init() - SetLOWFluxParam\n");
212 fEMCALPIDUtils->SetLowFluxParam() ;
214 else if (fParticleFlux == kHigh){
215 printf("AliCaloPID::Init() - SetHIGHFluxParam\n");
216 fEMCALPIDUtils->SetHighFluxParam() ;
221 //_______________________________________________________________
222 Int_t AliCaloPID::GetPdg(const TString calo, const Double_t * pid, const Float_t energy) const {
223 //Return most probable identity of the particle.
226 printf("AliCaloPID::GetPdg() - pid pointer not initialized!!!\n");
230 Float_t wPh = fPHOSPhotonWeight ;
231 Float_t wPi0 = fPHOSPi0Weight ;
232 Float_t wE = fPHOSElectronWeight ;
233 Float_t wCh = fPHOSChargeWeight ;
234 Float_t wNe = fPHOSNeutralWeight ;
237 // if(calo == "PHOS" && fPHOSWeightFormula){
238 // wPh = fPHOSPhotonWeightFormula->Eval(energy) ;
239 // wPi0 = fPHOSPi0WeightFormula->Eval(energy);
244 wPh = fEMCALPhotonWeight ;
245 wPi0 = fEMCALPi0Weight ;
246 wE = fEMCALElectronWeight ;
247 wCh = fEMCALChargeWeight ;
248 wNe = fEMCALNeutralWeight ;
252 if(fDebug > 0) printf("AliCaloPID::GetPdg: calo %s, ph %0.2f, pi0 %0.2f, el %0.2f, conv el %0.2f, hadrons: pion %0.2f, kaon %0.2f, proton %0.2f , neutron %0.2f, kaon %0.2f \n",
253 calo.Data(),pid[AliVCluster::kPhoton], pid[AliVCluster::kPi0],
254 pid[AliVCluster::kElectron], pid[AliVCluster::kEleCon],
255 pid[AliVCluster::kPion], pid[AliVCluster::kKaon], pid[AliVCluster::kProton],
256 pid[AliVCluster::kNeutron], pid[AliVCluster::kKaon0]);
258 Int_t pdg = kNeutralUnknown ;
259 Float_t chargedHadronWeight = pid[AliVCluster::kProton]+pid[AliVCluster::kKaon]+
260 pid[AliVCluster::kPion]+pid[AliVCluster::kMuon];
261 Float_t neutralHadronWeight = pid[AliVCluster::kNeutron]+pid[AliVCluster::kKaon0];
262 Float_t allChargedWeight = pid[AliVCluster::kElectron]+pid[AliVCluster::kEleCon]+ chargedHadronWeight;
263 Float_t allNeutralWeight = pid[AliVCluster::kPhoton]+pid[AliVCluster::kPi0]+ neutralHadronWeight;
265 //Select most probable ID
267 if(pid[AliVCluster::kPhoton] > wPh) pdg = kPhoton ;
268 else if(pid[AliVCluster::kPi0] > wPi0) pdg = kPi0 ;
269 else if(pid[AliVCluster::kElectron] > wE) pdg = kElectron ;
270 else if(pid[AliVCluster::kEleCon] > wE) pdg = kEleCon ;
271 else if(chargedHadronWeight > wCh) pdg = kChargedHadron ;
272 else if(neutralHadronWeight > wNe) pdg = kNeutralHadron ;
273 else if(allChargedWeight > allNeutralWeight)
274 pdg = kChargedUnknown ;
276 pdg = kNeutralUnknown ;
280 if(pid[AliVCluster::kPhoton]+pid[AliVCluster::kElectron] > wPh) pdg = kPhoton ; //temporal sollution until track matching for electrons is considered
281 //if(pid[AliVCluster::kPhoton] > wPh) pdg = kPhoton ;
282 else if(pid[AliVCluster::kPi0] > wPi0) pdg = kPi0 ;
283 //else if(pid[AliVCluster::kElectron] > wE) pdg = kElectron ;
284 else if(chargedHadronWeight + neutralHadronWeight > wCh) pdg = kChargedHadron ;
285 else if(neutralHadronWeight + chargedHadronWeight > wNe) pdg = kNeutralHadron ;
286 else pdg = kNeutralUnknown ;
290 if(fDebug > 0)printf("AliCaloPID::GetPdg:Final Pdg: %d, cluster energy %2.2f \n", pdg,energy);
296 //_______________________________________________________________
297 Int_t AliCaloPID::GetPdg(const TString calo,const TLorentzVector mom, const AliAODCaloCluster * cluster) const {
298 //Recalculated PID with all parameters
299 Float_t lambda0 = cluster->GetM02();
300 Float_t energy = mom.E();
302 if(fDebug > 0) printf("AliCaloPID::GetPdg: Calorimeter %s, E %3.2f, l0 %3.2f, l1 %3.2f, disp %3.2f, tof %1.11f, distCPV %3.2f, distToBC %1.1f, NMax %d\n",
303 calo.Data(),energy,lambda0,cluster->GetM20(),cluster->GetDispersion(),cluster->GetTOF(),
304 cluster->GetEmcCpvDistance(), cluster->GetDistanceToBadChannel(),cluster->GetNExMax());
306 if(calo == "EMCAL") {
307 //Recalculate Bayesian
308 if(fRecalculateBayesian){
310 const Double_t *pid0 = cluster->GetPID();
311 printf("AliCaloPID::GetPdg: BEFORE calo %s, ph %0.2f, pi0 %0.2f, el %0.2f, conv el %0.2f, hadrons: pion %0.2f, kaon %0.2f, proton %0.2f , neutron %0.2f, kaon %0.2f \n",
312 calo.Data(),pid0[AliVCluster::kPhoton], pid0[AliVCluster::kPi0],
313 pid0[AliVCluster::kElectron], pid0[AliVCluster::kEleCon],
314 pid0[AliVCluster::kPion], pid0[AliVCluster::kKaon], pid0[AliVCluster::kProton],
315 pid0[AliVCluster::kNeutron], pid0[AliVCluster::kKaon0]);
318 fEMCALPIDUtils->ComputePID(energy, lambda0);
319 Double_t pid[AliPID::kSPECIESN];
320 for(Int_t i = 0; i < AliPID::kSPECIESN; i++) pid[i] = fEMCALPIDUtils->GetPIDFinal(i);
321 return GetPdg(calo, pid, energy);
326 // If no use of bayesian, simple PID
327 if(lambda0 < 0.25) return kPhoton ;
328 //else return kNeutralHadron ;
332 // if(calo == "PHOS") {
333 // if(cluster->GetM02()< 0.25) return kPhoton ;
334 // else return kNeutralHadron ;
337 return kNeutralHadron ;
341 //__________________________________________________
342 TString AliCaloPID::GetPIDParametersList() {
343 //Put data member values in string to keep in output container
345 TString parList ; //this will be list of parameters used for this analysis.
347 sprintf(onePar,"--- AliCaloPID ---\n") ;
349 sprintf(onePar,"fDispCut =%2.2f (Cut on dispersion, used in PID evaluation) \n",fDispCut) ;
351 sprintf(onePar,"fTOFCut =%e (Cut on TOF, used in PID evaluation) \n",fTOFCut) ;
353 sprintf(onePar,"fEMCALPhotonWeight =%2.2f (EMCAL bayesian weight for photons)\n",fEMCALPhotonWeight) ;
355 sprintf(onePar,"fEMCALPi0Weight =%2.2f (EMCAL bayesian weight for pi0)\n",fEMCALPi0Weight) ;
357 sprintf(onePar,"fEMCALElectronWeight =%2.2f(EMCAL bayesian weight for electrons)\n",fEMCALElectronWeight) ;
359 sprintf(onePar,"fEMCALChargeWeight =%2.2f (EMCAL bayesian weight for charged hadrons)\n",fEMCALChargeWeight) ;
361 sprintf(onePar,"fEMCALNeutralWeight =%2.2f (EMCAL bayesian weight for neutral hadrons)\n",fEMCALNeutralWeight) ;
363 sprintf(onePar,"fPHOSPhotonWeight =%2.2f (PHOS bayesian weight for photons)\n",fPHOSPhotonWeight) ;
365 sprintf(onePar,"fPHOSPi0Weight =%2.2f (PHOS bayesian weight for pi0)\n",fPHOSPi0Weight) ;
367 sprintf(onePar,"fPHOSElectronWeight =%2.2f(PHOS bayesian weight for electrons)\n",fPHOSElectronWeight) ;
369 sprintf(onePar,"fPHOSChargeWeight =%2.2f (PHOS bayesian weight for charged hadrons)\n",fPHOSChargeWeight) ;
371 sprintf(onePar,"fPHOSNeutralWeight =%2.2f (PHOS bayesian weight for neutral hadrons)\n",fPHOSNeutralWeight) ;
374 // if(fPHOSWeightFormula){
375 // sprintf(onePar,"PHOS Photon Weight Formula: %s\n",(fPHOSPhotonWeightFormula->GetExpFormula("p")).Data()) ;
377 // sprintf(onePar,"PHOS Pi0 Weight Formula: %s\n",(fPHOSPi0WeightFormula->GetExpFormula("p")).Data()) ;
385 //________________________________________________________________
386 void AliCaloPID::Print(const Option_t * opt) const
389 //Print some relevant parameters set for the analysis
393 printf("***** Print: %s %s ******\n", GetName(), GetTitle() ) ;
395 printf("PHOS PID weight , photon %0.2f, pi0 %0.2f, e %0.2f, charge %0.2f, neutral %0.2f \n",
396 fPHOSPhotonWeight, fPHOSPi0Weight,
397 fPHOSElectronWeight, fPHOSChargeWeight, fPHOSNeutralWeight) ;
398 printf("EMCAL PID weight, photon %0.2f, pi0 %0.2f, e %0.2f, charge %0.2f, neutral %0.2f\n",
399 fEMCALPhotonWeight, fEMCALPi0Weight,
400 fEMCALElectronWeight, fEMCALChargeWeight, fEMCALNeutralWeight) ;
402 // printf("PHOS Parametrized weight on? = %d\n", fPHOSWeightFormula) ;
403 // if(fPHOSWeightFormula){
404 // printf("Photon weight formula = %s\n", (fPHOSPhotonWeightFormula->GetExpFormula("p")).Data());
405 // printf("Pi0 weight formula = %s\n", (fPHOSPhotonWeightFormula->GetExpFormula("p")).Data());
408 printf("TOF cut = %e\n",fTOFCut);
409 printf("Dispersion cut = %2.2f\n",fDispCut);
410 printf("Debug level = %d\n",fDebug);
411 printf("Recalculate Bayesian? = %d\n",fRecalculateBayesian);
412 if(fRecalculateBayesian) printf("Particle Flux? = %d\n",fParticleFlux);
417 //_______________________________________________________________
418 void AliCaloPID::SetPIDBits(const TString calo, const AliAODCaloCluster * cluster, AliAODPWG4Particle * ph) {
419 //Set Bits for PID selection
422 Double_t disp=cluster->GetDispersion() ;
423 // Double_t m20=calo->GetM20() ;
424 // Double_t m02=calo->GetM02() ;
425 ph->SetDispBit(disp<fDispCut) ;
428 Double_t tof=cluster->GetTOF() ;
429 ph->SetTOFBit(TMath::Abs(tof)<fTOFCut) ;
432 // Double_t cpvR=calo->GetEmcCpvDistance() ;
433 Int_t ntr=cluster->GetNTracksMatched(); //number of track matched
434 ph->SetChargedBit(ntr>0) ; //Temporary cut, should we evaluate distance?
437 ph->SetPdg(GetPdg(calo,cluster->GetPID(),ph->E()));
440 printf("AliCaloPID::SetPIDBits: TOF %e, Dispersion %2.2f, NTracks %d\n",tof , disp, ntr);
441 printf("AliCaloPID::SetPIDBits: pdg %d, bits: TOF %d, Dispersion %d, Charge %d\n",
442 ph->GetPdg(), ph->GetTOFBit() , ph->GetDispBit() , ph->GetChargedBit());