change default thresholds for PID weights
[u/mrichter/AliRoot.git] / PWG4 / PartCorrBase / AliCaloPID.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
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 $ */
16
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 
29 //      AliCaloPID(flux)
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. 
35 //
36 //  All these methods can be called in the analysis you are interested.
37 //
38 //*-- Author: Gustavo Conesa (LNF-INFN) 
39 //////////////////////////////////////////////////////////////////////////////
40
41
42 // --- ROOT system ---
43 #include <TMath.h>
44 #include <TString.h>
45 #include <TFormula.h>
46
47 //---- ANALYSIS system ----
48 #include "AliCaloPID.h"
49 #include "AliAODCaloCluster.h"
50 #include "AliAODPWG4Particle.h"
51 #ifdef __EMCALUTIL__
52 #include "AliEMCALPIDUtils.h"
53 #endif
54 ClassImp(AliCaloPID)
55
56
57 //________________________________________________
58 AliCaloPID::AliCaloPID() : 
59 TObject(), fEMCALPhotonWeight(0.), fEMCALPi0Weight(0.),  
60 fEMCALElectronWeight(0.),  fEMCALChargeWeight(0.),
61 fEMCALNeutralWeight(0.),
62 fPHOSPhotonWeight(0.), fPHOSPi0Weight(0.),  
63 fPHOSElectronWeight(0.), fPHOSChargeWeight(0.) , 
64 fPHOSNeutralWeight(0.), fPHOSWeightFormula(0), 
65 fPHOSPhotonWeightFormula(0x0), fPHOSPi0WeightFormula(0x0),
66 fDispCut(0.),fTOFCut(0.), fDebug(-1), 
67 fRecalculateBayesian(kFALSE), fParticleFlux(kLow)
68 #ifdef __EMCALUTIL__
69 , fEMCALPIDUtils(new AliEMCALPIDUtils)
70 #endif
71 {
72   //Ctor
73   
74   //Initialize parameters
75   InitParameters();
76 }
77
78 //________________________________________________
79 AliCaloPID::AliCaloPID(const Int_t flux) : 
80 TObject(), fEMCALPhotonWeight(0.), fEMCALPi0Weight(0.),  
81 fEMCALElectronWeight(0.),  fEMCALChargeWeight(0.),
82 fEMCALNeutralWeight(0.),
83 fPHOSPhotonWeight(0.), fPHOSPi0Weight(0.),  
84 fPHOSElectronWeight(0.), fPHOSChargeWeight(0.) , 
85 fPHOSNeutralWeight(0.), fPHOSWeightFormula(0), 
86 fPHOSPhotonWeightFormula(0x0), fPHOSPi0WeightFormula(0x0),
87 fDispCut(0.),fTOFCut(0.), fDebug(-1), 
88 fRecalculateBayesian(kTRUE), fParticleFlux(flux)
89 #ifdef __EMCALUTIL__
90 , fEMCALPIDUtils(new AliEMCALPIDUtils)
91 #endif
92 {
93         //Ctor
94         
95         //Initialize parameters
96         InitParameters();
97 }
98
99 //________________________________________________
100 AliCaloPID::AliCaloPID(const TTask * emcalpid) : 
101 TObject(), fEMCALPhotonWeight(0.), fEMCALPi0Weight(0.),  
102 fEMCALElectronWeight(0.),  fEMCALChargeWeight(0.),
103 fEMCALNeutralWeight(0.),
104 fPHOSPhotonWeight(0.), fPHOSPi0Weight(0.),  
105 fPHOSElectronWeight(0.), fPHOSChargeWeight(0.) , 
106 fPHOSNeutralWeight(0.), fPHOSWeightFormula(0), 
107 fPHOSPhotonWeightFormula(0x0), fPHOSPi0WeightFormula(0x0),
108 fDispCut(0.),fTOFCut(0.), fDebug(-1), 
109 fRecalculateBayesian(kTRUE), fParticleFlux(-1)
110 #ifdef __EMCALUTIL__
111 , fEMCALPIDUtils( (AliEMCALPIDUtils*) emcalpid)
112 #endif
113 {
114         //Ctor
115         
116         //Initialize parameters
117         InitParameters();
118 }
119
120 //____________________________________________________________________________
121 AliCaloPID::AliCaloPID(const AliCaloPID & pid) :   
122 TObject(pid), fEMCALPhotonWeight(pid.fEMCALPhotonWeight), 
123 fEMCALPi0Weight(pid.fEMCALPi0Weight), 
124 fEMCALElectronWeight(pid.fEMCALElectronWeight), 
125 fEMCALChargeWeight(pid.fEMCALChargeWeight), 
126 fEMCALNeutralWeight(pid.fEMCALNeutralWeight), 
127 fPHOSPhotonWeight(pid.fPHOSPhotonWeight),
128 fPHOSPi0Weight(pid.fPHOSPi0Weight),
129 fPHOSElectronWeight(pid.fPHOSElectronWeight), 
130 fPHOSChargeWeight(pid.fPHOSChargeWeight),
131 fPHOSNeutralWeight(pid.fPHOSNeutralWeight),
132 fPHOSWeightFormula(pid.fPHOSWeightFormula), 
133 fPHOSPhotonWeightFormula(pid.fPHOSPhotonWeightFormula), 
134 fPHOSPi0WeightFormula(pid.fPHOSPi0WeightFormula), 
135 fDispCut(pid.fDispCut),fTOFCut(pid.fTOFCut),
136 fDebug(pid.fDebug), fRecalculateBayesian(pid.fRecalculateBayesian),
137 fParticleFlux(pid.fParticleFlux)
138 #ifdef __EMCALUTIL__
139 , fEMCALPIDUtils(pid.fEMCALPIDUtils)
140 #endif
141 {
142   // cpy ctor
143         
144 }
145
146 //_________________________________________________________________________
147 AliCaloPID & AliCaloPID::operator = (const AliCaloPID & pid)
148 {
149   // assignment operator
150   
151   if(&pid == this) return *this;
152   
153   fEMCALPhotonWeight = pid. fEMCALPhotonWeight ;
154   fEMCALPi0Weight = pid.fEMCALPi0Weight ;
155   fEMCALElectronWeight = pid.fEMCALElectronWeight; 
156   fEMCALChargeWeight = pid.fEMCALChargeWeight;
157   fEMCALNeutralWeight = pid.fEMCALNeutralWeight;
158   
159   fPHOSPhotonWeight = pid.fPHOSPhotonWeight ;
160   fPHOSPi0Weight = pid.fPHOSPi0Weight ;
161   fPHOSElectronWeight = pid.fPHOSElectronWeight; 
162   fPHOSChargeWeight = pid.fPHOSChargeWeight;
163   fPHOSNeutralWeight = pid.fPHOSNeutralWeight;
164   
165   fPHOSWeightFormula       = pid.fPHOSWeightFormula; 
166   fPHOSPhotonWeightFormula = pid.fPHOSPhotonWeightFormula; 
167   fPHOSPi0WeightFormula    = pid.fPHOSPi0WeightFormula;
168   
169   fDispCut  = pid.fDispCut;
170   fTOFCut   = pid.fTOFCut;
171   fDebug    = pid.fDebug;
172   
173   fRecalculateBayesian = pid.fRecalculateBayesian;
174   fParticleFlux        = pid.fParticleFlux;
175 #ifdef __EMCALUTIL__
176   fEMCALPIDUtils       = pid.fEMCALPIDUtils;
177 #endif
178         
179         
180   return *this;
181   
182 }
183
184 //_________________________________
185 AliCaloPID::~AliCaloPID() {
186   //Dtor
187   
188   if(fPHOSPhotonWeightFormula) delete  fPHOSPhotonWeightFormula ;
189   if(fPHOSPi0WeightFormula) delete  fPHOSPi0WeightFormula ;
190 #ifdef __EMCALUTIL__
191         if(fEMCALPIDUtils) delete fEMCALPIDUtils ;
192 #endif
193 }
194
195
196 //_______________________________________________________________
197 void AliCaloPID::InitParameters()
198 {
199   //Initialize the parameters of the PID.
200   
201   fEMCALPhotonWeight   = 0.5 ;
202   fEMCALPi0Weight      = 0.5 ;
203   fEMCALElectronWeight = 0.5 ;
204   fEMCALChargeWeight   = 0.5 ;
205   fEMCALNeutralWeight  = 0.5 ;
206   
207   fPHOSPhotonWeight    = 0.5 ;
208   fPHOSPi0Weight       = 0.5 ;
209   fPHOSElectronWeight  = 0.5 ;
210   fPHOSChargeWeight    = 0.5 ;
211   fPHOSNeutralWeight   = 0.5 ;
212   
213   //Formula to set the PID weight threshold for photon or pi0
214   fPHOSWeightFormula = kTRUE;
215   fPHOSPhotonWeightFormula = 
216     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))");
217   fPHOSPi0WeightFormula = 
218     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))");
219   
220   fDispCut  = 1.5;
221   fTOFCut   = 5.e-9;
222   fDebug = -1;
223         
224   if(fRecalculateBayesian){
225 #ifdef __EMCALUTIL__
226         if(fParticleFlux == kLow){
227                 printf("AliCaloPID::Init() - SetLOWFluxParam\n");
228                 fEMCALPIDUtils->SetLowFluxParam() ;
229         }
230         else if (fParticleFlux == kHigh){
231                 printf("AliCaloPID::Init() - SetHIGHFluxParam\n");
232                 fEMCALPIDUtils->SetHighFluxParam() ;
233         }
234 #endif
235   }
236 }
237
238 //_______________________________________________________________
239 Int_t AliCaloPID::GetPdg(const TString calo, const Double_t * pid, const Float_t energy) const {
240   //Return most probable identity of the particle.
241   
242   if(!pid){ 
243     printf("AliCaloPID::GetPdg() - pid pointer not initialized!!!\n");
244     abort();
245   }
246   
247   Float_t wPh  =  fPHOSPhotonWeight ;
248   Float_t wPi0 =  fPHOSPi0Weight ;
249   Float_t wE   =  fPHOSElectronWeight ;
250   Float_t wCh  =  fPHOSChargeWeight ;
251   Float_t wNe  =  fPHOSNeutralWeight ;
252   
253   
254   if(calo == "PHOS" && fPHOSWeightFormula){
255     wPh  = fPHOSPhotonWeightFormula->Eval(energy) ;
256     wPi0 = fPHOSPi0WeightFormula->Eval(energy);
257   }
258   
259   if(calo == "EMCAL"){
260     
261     wPh  =  fEMCALPhotonWeight ;
262     wPi0 =  fEMCALPi0Weight ;
263     wE   =  fEMCALElectronWeight ;
264     wCh  =  fEMCALChargeWeight ;
265     wNe  =  fEMCALNeutralWeight ;
266     
267   }
268   
269   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",
270                          calo.Data(),pid[AliAODCluster::kPhoton], pid[AliAODCluster::kPi0],
271                          pid[AliAODCluster::kElectron], pid[AliAODCluster::kEleCon],
272                          pid[AliAODCluster::kPion], pid[AliAODCluster::kKaon], pid[AliAODCluster::kProton],
273                          pid[AliAODCluster::kNeutron], pid[AliAODCluster::kKaon0]);
274   
275   Int_t pdg = kNeutralUnknown ;
276   Float_t chargedHadronWeight = pid[AliAODCluster::kProton]+pid[AliAODCluster::kKaon]+
277     pid[AliAODCluster::kPion]+pid[AliAODCluster::kMuon];
278   Float_t neutralHadronWeight = pid[AliAODCluster::kNeutron]+pid[AliAODCluster::kKaon0];
279   Float_t allChargedWeight    = pid[AliAODCluster::kElectron]+pid[AliAODCluster::kEleCon]+ chargedHadronWeight;
280   Float_t allNeutralWeight    = pid[AliAODCluster::kPhoton]+pid[AliAODCluster::kPi0]+ neutralHadronWeight;
281   
282   //Select most probable ID
283   if(calo=="PHOS"){
284     if(pid[AliAODCluster::kPhoton] > wPh) pdg = kPhoton ;
285     else if(pid[AliAODCluster::kPi0] > wPi0) pdg = kPi0 ; 
286     else if(pid[AliAODCluster::kElectron] > wE)  pdg = kElectron ;
287     else if(pid[AliAODCluster::kEleCon] >  wE) pdg = kEleCon ;
288     else if(chargedHadronWeight > wCh) pdg = kChargedHadron ;  
289     else if(neutralHadronWeight > wNe) pdg = kNeutralHadron ; 
290     else if(allChargedWeight >  allNeutralWeight)
291       pdg = kChargedUnknown ; 
292     else 
293       pdg = kNeutralUnknown ;
294   }
295   else{//EMCAL
296
297     if(pid[AliAODCluster::kPhoton]+pid[AliAODCluster::kElectron]  > wPh) pdg = kPhoton ; //temporal sollution until track matching for electrons is considered
298     //if(pid[AliAODCluster::kPhoton]  > wPh) pdg = kPhoton ;
299     else if(pid[AliAODCluster::kPi0] > wPi0) pdg = kPi0 ; 
300     //else if(pid[AliAODCluster::kElectron]  > wE) pdg = kElectron ;
301     else if(chargedHadronWeight + neutralHadronWeight > wCh) pdg = kChargedHadron ;  
302     else if(neutralHadronWeight + chargedHadronWeight > wNe) pdg = kNeutralHadron ; 
303     else pdg =  kNeutralUnknown ;
304     
305   }
306   
307   if(fDebug > 0)printf("AliCaloPID::GetPdg:Final Pdg: %d \n", pdg);
308    
309   return pdg ;
310   
311 }
312
313 //_______________________________________________________________
314 Int_t AliCaloPID::GetPdg(const TString calo,const TLorentzVector mom, const AliAODCaloCluster * cluster) const {
315   //Recalculated PID with all parameters
316   Float_t lambda0 = cluster->GetM02();
317   Float_t energy = mom.E();     
318
319   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",
320                                                 calo.Data(),energy,lambda0,cluster->GetM20(),cluster->GetDispersion(),cluster->GetTOF(), 
321                                                 cluster->GetEmcCpvDistance(), cluster->GetDistToBadChannel(),cluster->GetNExMax());
322
323   if(calo == "EMCAL") {
324           //Recalculate Bayesian
325           if(fRecalculateBayesian){       
326 #ifdef __EMCALUTIL__
327                  
328                   if(fDebug > 0)  {
329                           const Double_t  *pid0 = cluster->PID();
330                           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",
331                                                                  calo.Data(),pid0[AliAODCluster::kPhoton], pid0[AliAODCluster::kPi0],
332                                                                  pid0[AliAODCluster::kElectron], pid0[AliAODCluster::kEleCon],
333                                                                  pid0[AliAODCluster::kPion], pid0[AliAODCluster::kKaon], pid0[AliAODCluster::kProton],
334                                                                  pid0[AliAODCluster::kNeutron], pid0[AliAODCluster::kKaon0]);
335                   }
336                   
337                  fEMCALPIDUtils->ComputePID(energy, lambda0);
338                  Double_t pid[AliPID::kSPECIESN];
339                  for(Int_t i = 0; i < AliPID::kSPECIESN; i++) pid[i] = fEMCALPIDUtils->GetPIDFinal(i);
340                  return GetPdg(calo, pid, energy);
341                   
342 #endif
343           
344         }
345           
346         // If no use of bayesian, simple PID  
347     if(lambda0 < 0.25) return kPhoton ;
348     //else return  kNeutralHadron ; 
349         else return  kPi0 ;
350   }
351   
352   //   if(calo == "PHOS") {
353   //    if(cluster->GetM02()< 0.25) return kPhoton ;
354   //    else return  kNeutralHadron ; 
355   //  }
356   
357   return  kNeutralHadron ; 
358   
359 }
360
361 //__________________________________________________
362 TString  AliCaloPID::GetPIDParametersList()  {
363   //Put data member values in string to keep in output container
364   
365   TString parList ; //this will be list of parameters used for this analysis.
366   char onePar[255] ;
367   sprintf(onePar,"--- AliCaloPID ---\n") ;
368   parList+=onePar ;     
369   sprintf(onePar,"fDispCut =%2.2f (Cut on dispersion, used in PID evaluation) \n",fDispCut) ;
370   parList+=onePar ;
371   sprintf(onePar,"fTOFCut  =%e (Cut on TOF, used in PID evaluation) \n",fTOFCut) ;
372   parList+=onePar ;
373   sprintf(onePar,"fEMCALPhotonWeight =%2.2f (EMCAL bayesian weight for photons)\n",fEMCALPhotonWeight) ;
374   parList+=onePar ;
375   sprintf(onePar,"fEMCALPi0Weight =%2.2f (EMCAL bayesian weight for pi0)\n",fEMCALPi0Weight) ;
376   parList+=onePar ;
377   sprintf(onePar,"fEMCALElectronWeight =%2.2f(EMCAL bayesian weight for electrons)\n",fEMCALElectronWeight) ;
378   parList+=onePar ;
379   sprintf(onePar,"fEMCALChargeWeight =%2.2f (EMCAL bayesian weight for charged hadrons)\n",fEMCALChargeWeight) ;
380   parList+=onePar ;
381   sprintf(onePar,"fEMCALNeutralWeight =%2.2f (EMCAL bayesian weight for neutral hadrons)\n",fEMCALNeutralWeight) ;
382   parList+=onePar ;
383   sprintf(onePar,"fPHOSPhotonWeight =%2.2f (PHOS bayesian weight for photons)\n",fPHOSPhotonWeight) ;
384   parList+=onePar ;
385   sprintf(onePar,"fPHOSPi0Weight =%2.2f (PHOS bayesian weight for pi0)\n",fPHOSPi0Weight) ;
386   parList+=onePar ;
387   sprintf(onePar,"fPHOSElectronWeight =%2.2f(PHOS bayesian weight for electrons)\n",fPHOSElectronWeight) ;
388   parList+=onePar ;
389   sprintf(onePar,"fPHOSChargeWeight =%2.2f (PHOS bayesian weight for charged hadrons)\n",fPHOSChargeWeight) ;
390   parList+=onePar ;
391   sprintf(onePar,"fPHOSNeutralWeight =%2.2f (PHOS bayesian weight for neutral hadrons)\n",fPHOSNeutralWeight) ;
392   parList+=onePar ;
393   
394   if(fPHOSWeightFormula){
395         sprintf(onePar,"PHOS Photon Weight Formula: %s\n",(fPHOSPhotonWeightFormula->GetExpFormula("p")).Data()) ;
396     parList+=onePar;
397         sprintf(onePar,"PHOS Pi0    Weight Formula: %s\n",(fPHOSPi0WeightFormula->GetExpFormula("p")).Data()) ;
398         parList+=onePar;          
399   }
400   
401   return parList; 
402   
403 }
404
405 //________________________________________________________________
406 void AliCaloPID::Print(const Option_t * opt) const
407 {
408   
409   //Print some relevant parameters set for the analysis
410   if(! opt)
411     return;
412   
413   printf("***** Print: %s %s ******\n", GetName(), GetTitle() ) ;
414   
415   printf("PHOS PID weight , photon %0.2f, pi0 %0.2f, e %0.2f, charge %0.2f, neutral %0.2f \n",  
416          fPHOSPhotonWeight,  fPHOSPi0Weight, 
417          fPHOSElectronWeight,  fPHOSChargeWeight,   fPHOSNeutralWeight) ; 
418   printf("EMCAL PID weight, photon %0.2f, pi0 %0.2f, e %0.2f, charge %0.2f, neutral %0.2f\n",   
419          fEMCALPhotonWeight,  fEMCALPi0Weight, 
420          fEMCALElectronWeight,  fEMCALChargeWeight,  fEMCALNeutralWeight) ; 
421   
422   printf("PHOS Parametrized weight on?  =     %d\n",  fPHOSWeightFormula) ; 
423   if(fPHOSWeightFormula){
424     printf("Photon weight formula = %s\n", (fPHOSPhotonWeightFormula->GetExpFormula("p")).Data());
425     printf("Pi0    weight formula = %s\n", (fPHOSPhotonWeightFormula->GetExpFormula("p")).Data());
426   }
427   
428   printf("TOF cut        = %e\n",fTOFCut);
429   printf("Dispersion cut = %2.2f\n",fDispCut);
430   printf("Debug level    = %d\n",fDebug);
431   printf("Recalculate Bayesian?    = %d\n",fRecalculateBayesian);
432  if(fRecalculateBayesian) printf("Particle Flux?    = %d\n",fParticleFlux);
433   printf(" \n");
434   
435
436
437 //_______________________________________________________________
438 void AliCaloPID::SetPIDBits(const TString calo, const AliAODCaloCluster * cluster, AliAODPWG4Particle * ph) {
439   //Set Bits for PID selection
440   
441   //Dispersion/lambdas
442   Double_t disp=cluster->GetDispersion()  ;
443         //    Double_t m20=calo->GetM20() ;
444         //    Double_t m02=calo->GetM02() ; 
445   ph->SetDispBit(disp<fDispCut) ;  
446   
447   //TOF
448   Double_t tof=cluster->GetTOF()  ;
449   ph->SetTOFBit(TMath::Abs(tof)<fTOFCut) ; 
450   
451   //Charged veto
452   //    Double_t cpvR=calo->GetEmcCpvDistance() ; 
453   Int_t ntr=cluster->GetNTracksMatched();  //number of track matched
454   ph->SetChargedBit(ntr>0) ;  //Temporary cut, should we evaluate distance?
455   
456   //Set PID pdg
457   ph->SetPdg(GetPdg(calo,cluster->PID(),ph->E()));
458   
459   if(fDebug > 0){ 
460     printf("AliCaloPID::SetPIDBits: TOF %e, Dispersion %2.2f, NTracks %d\n",tof , disp, ntr);   
461     printf("AliCaloPID::SetPIDBits: pdg %d, bits: TOF %d, Dispersion %d, Charge %d\n",
462              ph->GetPdg(), ph->GetTOFBit() , ph->GetDispBit() , ph->GetChargedBit()); 
463   }
464 }
465
466