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 AliVCluster * 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 "AliVCluster.h"
  50 #include "AliAODPWG4Particle.h"
  51 #include "AliEMCALPIDUtils.h"
  52 #include "AliCalorimeterUtils.h"
  53
  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 fEMCALPIDUtils(new AliEMCALPIDUtils)
  69 {
  70   //Ctor
  71
  72   //Initialize parameters
  73   InitParameters();
  74 }
  75
  76 //________________________________________________
  77 AliCaloPID::AliCaloPID(const Int_t flux) :
  78 TObject(), fEMCALPhotonWeight(0.), fEMCALPi0Weight(0.),
  79 fEMCALElectronWeight(0.),  fEMCALChargeWeight(0.),
  80 fEMCALNeutralWeight(0.),
  81 fPHOSPhotonWeight(0.), fPHOSPi0Weight(0.),
  82 fPHOSElectronWeight(0.), fPHOSChargeWeight(0.) ,
  83 fPHOSNeutralWeight(0.), //fPHOSWeightFormula(0),
  84 //fPHOSPhotonWeightFormula(0x0), fPHOSPi0WeightFormula(0x0),
  85 fDispCut(0.),fTOFCut(0.), fDebug(-1),
  86 fRecalculateBayesian(kTRUE), fParticleFlux(flux),
  87 fEMCALPIDUtils(new AliEMCALPIDUtils)
  88 {
  89         //Ctor
  90
  91         //Initialize parameters
  92         InitParameters();
  93 }
  94
  95 //________________________________________________
  96 AliCaloPID::AliCaloPID(const TTask * emcalpid) :
  97 TObject(), fEMCALPhotonWeight(0.), fEMCALPi0Weight(0.),
  98 fEMCALElectronWeight(0.),  fEMCALChargeWeight(0.),
  99 fEMCALNeutralWeight(0.),
 100 fPHOSPhotonWeight(0.), fPHOSPi0Weight(0.),
 101 fPHOSElectronWeight(0.), fPHOSChargeWeight(0.) ,
 102 fPHOSNeutralWeight(0.), //fPHOSWeightFormula(0),
 103 //fPHOSPhotonWeightFormula(0x0), fPHOSPi0WeightFormula(0x0),
 104 fDispCut(0.),fTOFCut(0.), fDebug(-1),
 105 fRecalculateBayesian(kTRUE), fParticleFlux(-1),
 106 fEMCALPIDUtils( (AliEMCALPIDUtils*) emcalpid)
 107 {
 108         //Ctor
 109
 110         //Initialize parameters
 111         InitParameters();
 112 }
 113
 114 //____________________________________________________________________________
 115 AliCaloPID::AliCaloPID(const AliCaloPID & pid) :
 116 TObject(pid), fEMCALPhotonWeight(pid.fEMCALPhotonWeight),
 117 fEMCALPi0Weight(pid.fEMCALPi0Weight),
 118 fEMCALElectronWeight(pid.fEMCALElectronWeight),
 119 fEMCALChargeWeight(pid.fEMCALChargeWeight),
 120 fEMCALNeutralWeight(pid.fEMCALNeutralWeight),
 121 fPHOSPhotonWeight(pid.fPHOSPhotonWeight),
 122 fPHOSPi0Weight(pid.fPHOSPi0Weight),
 123 fPHOSElectronWeight(pid.fPHOSElectronWeight),
 124 fPHOSChargeWeight(pid.fPHOSChargeWeight),
 125 fPHOSNeutralWeight(pid.fPHOSNeutralWeight),
 126 //fPHOSWeightFormula(pid.fPHOSWeightFormula),
 127 //fPHOSPhotonWeightFormula(new TFormula(*pid.fPHOSPhotonWeightFormula)),
 128 //fPHOSPi0WeightFormula   (new TFormula(*pid.fPHOSPi0WeightFormula)),
 129 fDispCut(pid.fDispCut),fTOFCut(pid.fTOFCut),
 130 fDebug(pid.fDebug), fRecalculateBayesian(pid.fRecalculateBayesian),
 131 fParticleFlux(pid.fParticleFlux),
 132 fEMCALPIDUtils(new AliEMCALPIDUtils(*pid.fEMCALPIDUtils))
 133 {
 134   // cpy ctor
 135
 136 }
 137
 138 //_________________________________________________________________________
 139 //AliCaloPID & AliCaloPID::operator = (const AliCaloPID & pid)
 140 //{
 141 //  // assignment operator
 142 //
 143 //  if(&pid == this) return *this;
 144 //
 145 //  fEMCALPhotonWeight   = pid. fEMCALPhotonWeight ;
 146 //  fEMCALPi0Weight      = pid.fEMCALPi0Weight ;
 147 //  fEMCALElectronWeight = pid.fEMCALElectronWeight;
 148 //  fEMCALChargeWeight   = pid.fEMCALChargeWeight;
 149 //  fEMCALNeutralWeight  = pid.fEMCALNeutralWeight;
 150 //
 151 //  fPHOSPhotonWeight    = pid.fPHOSPhotonWeight ;
 152 //  fPHOSPi0Weight       = pid.fPHOSPi0Weight ;
 153 //  fPHOSElectronWeight  = pid.fPHOSElectronWeight;
 154 //  fPHOSChargeWeight    = pid.fPHOSChargeWeight;
 155 //  fPHOSNeutralWeight   = pid.fPHOSNeutralWeight;
 156 //
 157 //  fPHOSWeightFormula   = pid.fPHOSWeightFormula;
 158 //  delete fPHOSPhotonWeightFormula;  fPHOSPhotonWeightFormula = new TFormula(*pid.fPHOSPhotonWeightFormula);
 159 //  delete fPHOSPi0WeightFormula;     fPHOSPi0WeightFormula    = new TFormula(*pid.fPHOSPi0WeightFormula);
 160 //
 161 //  fDispCut  = pid.fDispCut;
 162 //  fTOFCut   = pid.fTOFCut;
 163 //  fDebug    = pid.fDebug;
 164 //
 165 //  fRecalculateBayesian = pid.fRecalculateBayesian;
 166 //  fParticleFlux        = pid.fParticleFlux;
 167 //
 168 //  delete fEMCALPIDUtils; fEMCALPIDUtils       = new AliEMCALPIDUtils(*pid.fEMCALPIDUtils);
 169 //
 170 //  return *this;
 171 //
 172 //}
 173
 174 //_________________________________
 175 AliCaloPID::~AliCaloPID() {
 176   //Dtor
 177
 178 //  if(fPHOSPhotonWeightFormula) delete fPHOSPhotonWeightFormula ;
 179 //  if(fPHOSPi0WeightFormula)    delete fPHOSPi0WeightFormula ;
 180   if(fEMCALPIDUtils)           delete fEMCALPIDUtils ;
 181 }
 182
 183
 184 //_______________________________________________________________
 185 void AliCaloPID::InitParameters()
 186 {
 187   //Initialize the parameters of the PID.
 188
 189   fEMCALPhotonWeight   = 0.6 ;
 190   fEMCALPi0Weight      = 0.6 ;
 191   fEMCALElectronWeight = 0.6 ;
 192   fEMCALChargeWeight   = 0.6 ;
 193   fEMCALNeutralWeight  = 0.6 ;
 194
 195   fPHOSPhotonWeight    = 0.6 ;
 196   fPHOSPi0Weight       = 0.6 ;
 197   fPHOSElectronWeight  = 0.6 ;
 198   fPHOSChargeWeight    = 0.6 ;
 199   fPHOSNeutralWeight   = 0.6 ;
 200
 201   //Formula to set the PID weight threshold for photon or pi0
 202   //fPHOSWeightFormula = kTRUE;
 203   //if(fPHOSPhotonWeightFormula) delete fPHOSPhotonWeightFormula;
 204   //if(fPHOSPi0WeightFormula)    delete fPHOSPi0WeightFormula;
 205   //fPHOSPhotonWeightFormula =
 206     //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))");
 207   //fPHOSPi0WeightFormula =
 208     //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
 210   fDispCut  = 0.25;
 211   fTOFCut   = 5.e-9;
 212   fDebug = -1;
 213
 214   if(fRecalculateBayesian){
 215         if(fParticleFlux == kLow){
 216                 printf("AliCaloPID::Init() - SetLOWFluxParam\n");
 217                 fEMCALPIDUtils->SetLowFluxParam() ;
 218         }
 219         else if (fParticleFlux == kHigh){
 220                 printf("AliCaloPID::Init() - SetHIGHFluxParam\n");
 221                 fEMCALPIDUtils->SetHighFluxParam() ;
 222         }
 223   }
 224 }
 225
 226 //_______________________________________________________________
 227 Int_t AliCaloPID::GetPdg(const TString calo, const Double_t * pid, const Float_t energy) const {
 228   //Return most probable identity of the particle.
 229
 230   if(!pid){
 231     printf("AliCaloPID::GetPdg() - pid pointer not initialized!!!\n");
 232     abort();
 233   }
 234
 235   Float_t wPh  =  fPHOSPhotonWeight ;
 236   Float_t wPi0 =  fPHOSPi0Weight ;
 237   Float_t wE   =  fPHOSElectronWeight ;
 238   Float_t wCh  =  fPHOSChargeWeight ;
 239   Float_t wNe  =  fPHOSNeutralWeight ;
 240
 241
 242 //  if(calo == "PHOS" && fPHOSWeightFormula){
 243 //    wPh  = fPHOSPhotonWeightFormula->Eval(energy) ;
 244 //    wPi0 = fPHOSPi0WeightFormula->Eval(energy);
 245 //  }
 246
 247   if(calo == "EMCAL"){
 248
 249     wPh  =  fEMCALPhotonWeight ;
 250     wPi0 =  fEMCALPi0Weight ;
 251     wE   =  fEMCALElectronWeight ;
 252     wCh  =  fEMCALChargeWeight ;
 253     wNe  =  fEMCALNeutralWeight ;
 254
 255   }
 256
 257   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",
 258                          calo.Data(),pid[AliVCluster::kPhoton], pid[AliVCluster::kPi0],
 259                          pid[AliVCluster::kElectron], pid[AliVCluster::kEleCon],
 260                          pid[AliVCluster::kPion], pid[AliVCluster::kKaon], pid[AliVCluster::kProton],
 261                          pid[AliVCluster::kNeutron], pid[AliVCluster::kKaon0]);
 262
 263   Int_t pdg = kNeutralUnknown ;
 264   Float_t chargedHadronWeight = pid[AliVCluster::kProton]+pid[AliVCluster::kKaon]+
 265     pid[AliVCluster::kPion]+pid[AliVCluster::kMuon];
 266   Float_t neutralHadronWeight = pid[AliVCluster::kNeutron]+pid[AliVCluster::kKaon0];
 267   Float_t allChargedWeight    = pid[AliVCluster::kElectron]+pid[AliVCluster::kEleCon]+ chargedHadronWeight;
 268   Float_t allNeutralWeight    = pid[AliVCluster::kPhoton]+pid[AliVCluster::kPi0]+ neutralHadronWeight;
 269
 270   //Select most probable ID
 271   if(calo=="PHOS"){
 272     if(pid[AliVCluster::kPhoton] > wPh) pdg = kPhoton ;
 273     else if(pid[AliVCluster::kPi0] > wPi0) pdg = kPi0 ;
 274     else if(pid[AliVCluster::kElectron] > wE)  pdg = kElectron ;
 275     else if(pid[AliVCluster::kEleCon] >  wE) pdg = kEleCon ;
 276     else if(chargedHadronWeight > wCh) pdg = kChargedHadron ;
 277     else if(neutralHadronWeight > wNe) pdg = kNeutralHadron ;
 278     else if(allChargedWeight >  allNeutralWeight)
 279       pdg = kChargedUnknown ;
 280     else
 281       pdg = kNeutralUnknown ;
 282   }
 283   else{//EMCAL
 284
 285     if(pid[AliVCluster::kPhoton]  > wPh)                     pdg = kPhoton ;
 286     else if(pid[AliVCluster::kElectron]  > wE)               pdg = kElectron ;
 287     else if(pid[AliVCluster::kPhoton]+pid[AliVCluster::kElectron]  > wPh) pdg = kPhoton ; //temporal sollution until track matching for electrons is considered
 288     else if(pid[AliVCluster::kPi0] > wPi0)                   pdg = kPi0 ;
 289     else if(chargedHadronWeight + neutralHadronWeight > wCh) pdg = kChargedHadron ;
 290     else if(neutralHadronWeight + chargedHadronWeight > wNe) pdg = kNeutralHadron ;
 291     else                                                     pdg = kNeutralUnknown ;
 292   }
 293
 294   if(fDebug > 0)printf("AliCaloPID::GetPdg:Final Pdg: %d, cluster energy %2.2f \n", pdg,energy);
 295
 296   return pdg ;
 297
 298 }
 299
 300 //_______________________________________________________________
 301 Int_t AliCaloPID::GetPdg(const TString calo,const TLorentzVector mom, const AliVCluster * cluster) const {
 302   //Recalculated PID with all parameters
 303   Float_t lambda0 = cluster->GetM02();
 304   Float_t energy = mom.E();
 305
 306   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",
 307                                                 calo.Data(),energy,lambda0,cluster->GetM20(),cluster->GetDispersion(),cluster->GetTOF(),
 308                                                 cluster->GetEmcCpvDistance(), cluster->GetDistanceToBadChannel(),cluster->GetNExMax());
 309
 310   if(calo == "EMCAL") {
 311           //Recalculate Bayesian
 312           if(fRecalculateBayesian){
 313                   if(fDebug > 0)  {
 314                           const Double_t  *pid0 = cluster->GetPID();
 315                           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",
 316                                                                  calo.Data(),pid0[AliVCluster::kPhoton], pid0[AliVCluster::kPi0],
 317                                                                  pid0[AliVCluster::kElectron], pid0[AliVCluster::kEleCon],
 318                                                                  pid0[AliVCluster::kPion], pid0[AliVCluster::kKaon], pid0[AliVCluster::kProton],
 319                                                                  pid0[AliVCluster::kNeutron], pid0[AliVCluster::kKaon0]);
 320                   }
 321
 322                  fEMCALPIDUtils->ComputePID(energy, lambda0);
 323                  Double_t pid[AliPID::kSPECIESN];
 324                  for(Int_t i = 0; i < AliPID::kSPECIESN; i++) pid[i] = fEMCALPIDUtils->GetPIDFinal(i);
 325                  return GetPdg(calo, pid, energy);
 326
 327
 328         }
 329
 330           // If no use of bayesian, simple PID
 331           if(lambda0 < 0.25) return kPhoton ;
 332           //else return  kNeutralHadron ;
 333           else return  kPi0 ;
 334   }
 335
 336   //   if(calo == "PHOS") {
 337   //    if(cluster->GetM02()< 0.25) return kPhoton ;
 338   //    else return  kNeutralHadron ;
 339   //  }
 340
 341   return  kNeutralHadron ;
 342
 343 }
 344
 345 //__________________________________________________
 346 TString  AliCaloPID::GetPIDParametersList()  {
 347   //Put data member values in string to keep in output container
 348
 349   TString parList ; //this will be list of parameters used for this analysis.
 350   const Int_t buffersize = 255;
 351   char onePar[buffersize] ;
 352   snprintf(onePar,buffersize,"--- AliCaloPID ---\n") ;
 353   parList+=onePar ;
 354   snprintf(onePar,buffersize,"fDispCut =%2.2f (Cut on dispersion, used in PID evaluation) \n",fDispCut) ;
 355   parList+=onePar ;
 356   snprintf(onePar,buffersize,"fTOFCut  =%e (Cut on TOF, used in PID evaluation) \n",fTOFCut) ;
 357   parList+=onePar ;
 358   snprintf(onePar,buffersize,"fEMCALPhotonWeight =%2.2f (EMCAL bayesian weight for photons)\n",fEMCALPhotonWeight) ;
 359   parList+=onePar ;
 360   snprintf(onePar,buffersize,"fEMCALPi0Weight =%2.2f (EMCAL bayesian weight for pi0)\n",fEMCALPi0Weight) ;
 361   parList+=onePar ;
 362   snprintf(onePar,buffersize,"fEMCALElectronWeight =%2.2f(EMCAL bayesian weight for electrons)\n",fEMCALElectronWeight) ;
 363   parList+=onePar ;
 364   snprintf(onePar,buffersize,"fEMCALChargeWeight =%2.2f (EMCAL bayesian weight for charged hadrons)\n",fEMCALChargeWeight) ;
 365   parList+=onePar ;
 366   snprintf(onePar,buffersize,"fEMCALNeutralWeight =%2.2f (EMCAL bayesian weight for neutral hadrons)\n",fEMCALNeutralWeight) ;
 367   parList+=onePar ;
 368   snprintf(onePar,buffersize,"fPHOSPhotonWeight =%2.2f (PHOS bayesian weight for photons)\n",fPHOSPhotonWeight) ;
 369   parList+=onePar ;
 370   snprintf(onePar,buffersize,"fPHOSPi0Weight =%2.2f (PHOS bayesian weight for pi0)\n",fPHOSPi0Weight) ;
 371   parList+=onePar ;
 372   snprintf(onePar,buffersize,"fPHOSElectronWeight =%2.2f(PHOS bayesian weight for electrons)\n",fPHOSElectronWeight) ;
 373   parList+=onePar ;
 374   snprintf(onePar,buffersize,"fPHOSChargeWeight =%2.2f (PHOS bayesian weight for charged hadrons)\n",fPHOSChargeWeight) ;
 375   parList+=onePar ;
 376   snprintf(onePar,buffersize,"fPHOSNeutralWeight =%2.2f (PHOS bayesian weight for neutral hadrons)\n",fPHOSNeutralWeight) ;
 377   parList+=onePar ;
 378
 379 //  if(fPHOSWeightFormula){
 380 //      sprintf(onePar,buffersize,"PHOS Photon Weight Formula: %s\n",(fPHOSPhotonWeightFormula->GetExpFormula("p")).Data()) ;
 381 //    parList+=onePar;
 382 //      sprintf(onePar,buffersize,"PHOS Pi0    Weight Formula: %s\n",(fPHOSPi0WeightFormula->GetExpFormula("p")).Data()) ;
 383 //      parList+=onePar;
 384 //  }
 385
 386   return parList;
 387
 388 }
 389
 390 //________________________________________________________________
 391 void AliCaloPID::Print(const Option_t * opt) const
 392 {
 393
 394   //Print some relevant parameters set for the analysis
 395   if(! opt)
 396     return;
 397
 398   printf("***** Print: %s %s ******\n", GetName(), GetTitle() ) ;
 399
 400   printf("PHOS PID weight , photon %0.2f, pi0 %0.2f, e %0.2f, charge %0.2f, neutral %0.2f \n",
 401          fPHOSPhotonWeight,  fPHOSPi0Weight,
 402          fPHOSElectronWeight,  fPHOSChargeWeight,   fPHOSNeutralWeight) ;
 403   printf("EMCAL PID weight, photon %0.2f, pi0 %0.2f, e %0.2f, charge %0.2f, neutral %0.2f\n",
 404          fEMCALPhotonWeight,  fEMCALPi0Weight,
 405          fEMCALElectronWeight,  fEMCALChargeWeight,  fEMCALNeutralWeight) ;
 406
 407 //  printf("PHOS Parametrized weight on?  =     %d\n",  fPHOSWeightFormula) ;
 408 //  if(fPHOSWeightFormula){
 409 //    printf("Photon weight formula = %s\n", (fPHOSPhotonWeightFormula->GetExpFormula("p")).Data());
 410 //    printf("Pi0    weight formula = %s\n", (fPHOSPhotonWeightFormula->GetExpFormula("p")).Data());
 411 //  }
 412
 413   printf("TOF cut        = %e\n",fTOFCut);
 414   printf("Dispersion cut = %2.2f\n",fDispCut);
 415   printf("Debug level    = %d\n",fDebug);
 416   printf("Recalculate Bayesian?    = %d\n",fRecalculateBayesian);
 417  if(fRecalculateBayesian) printf("Particle Flux?    = %d\n",fParticleFlux);
 418   printf(" \n");
 419
 420 }
 421
 422 //_______________________________________________________________
 423 void AliCaloPID::SetPIDBits(const TString calo, const AliVCluster * cluster, AliAODPWG4Particle * ph, const AliCalorimeterUtils* cu) {
 424   //Set Bits for PID selection
 425
 426   //Dispersion/lambdas
 427   //Double_t disp= cluster->GetDispersion()  ;
 428   Double_t l1  = cluster->GetM20() ;
 429   Double_t l0  = cluster->GetM02() ;
 430   Bool_t isDispOK = kTRUE ;
 431   if(cluster->IsPHOS()){
 432
 433     if(l1>= 0   && l0>= 0   && l1 < 0.1 && l0 < 0.1) isDispOK=kFALSE ;
 434     if(l1>= 0   && l0 > 0.5 && l1 < 0.1 && l0 < 1.5) isDispOK=kTRUE ;
 435     if(l1>= 0   && l0 > 2.0 && l1 < 0.1 && l0 < 2.7) isDispOK=kFALSE ;
 436     if(l1>= 0   && l0 > 2.7 && l1 < 0.1 && l0 < 4.0) isDispOK=kFALSE ;
 437     if(l1 > 0.1 && l1 < 0.7 && l0 > 0.7 && l0 < 2.1) isDispOK=kTRUE ;
 438     if(l1 > 0.1 && l1 < 0.3 && l0 > 3.0 && l0 < 5.0) isDispOK=kFALSE  ;
 439     if(l1 > 0.3 && l1 < 0.7 && l0 > 2.5 && l0 < 4.0) isDispOK=kFALSE ;
 440     if(l1 > 0.7 && l1 < 1.3 && l0 > 1.0 && l0 < 1.6) isDispOK=kTRUE ;
 441     if(l1 > 0.7 && l1 < 1.3 && l0 > 1.6 && l0 < 3.5) isDispOK=kTRUE ;
 442     if(l1 > 1.3 && l1 < 3.5 && l0 > 1.3 && l0 < 3.5) isDispOK=kTRUE ;
 443
 444   }
 445   else{//EMCAL
 446
 447     if(l0 > fDispCut || l0 < 0.) isDispOK = kFALSE;
 448
 449   }
 450
 451   ph->SetDispBit(isDispOK) ;
 452
 453   //TOF
 454   Double_t tof=cluster->GetTOF()  ;
 455   ph->SetTOFBit(TMath::Abs(tof)<fTOFCut) ;
 456
 457   //Charged veto
 458   //Bool_t isNeutral = kTRUE ;
 459   //if(cluster->IsPHOS())  isNeutral = cluster->GetEmcCpvDistance() > 5. ;
 460   //else
 461   Bool_t isNeutral = IsTrackMatched(cluster,cu);
 462
 463   ph->SetChargedBit(isNeutral);
 464
 465   //Set PID pdg
 466   ph->SetPdg(GetPdg(calo,cluster->GetPID(),ph->E()));
 467
 468   if(fDebug > 0){
 469     printf("AliCaloPID::SetPIDBits: TOF %e, Lambda0 %2.2f, Lambda1 %2.2f\n",tof , l0, l1);
 470     printf("AliCaloPID::SetPIDBits: pdg %d, bits: TOF %d, Dispersion %d, Charge %d\n",
 471              ph->GetPdg(), ph->GetTOFBit() , ph->GetDispBit() , ph->GetChargedBit());
 472   }
 473 }
 474
 475 //__________________________________________________________________________
 476 Bool_t AliCaloPID::IsTrackMatched(const AliVCluster* cluster, const AliCalorimeterUtils * cu) const {
 477   //Check if there is any track attached to this cluster
 478
 479   Int_t nMatches = cluster->GetNTracksMatched();
 480
 481   //  printf("N matches %d, first match %d\n",nMatches,cluster->GetTrackMatchedIndex());
 482   //  if     (cluster->GetTrackMatched(0))        printf("\t matched track id %d\n",((AliVTrack*)cluster->GetTrackMatched(0))->GetID()) ;
 483   //  else if(cluster->GetTrackMatchedIndex()>=0) printf("\t matched track id %d\n",((AliVTrack*) GetReader()->GetInputEvent()->GetTrack(cluster->GetTrackMatchedIndex()))->GetID()) ;
 484
 485
 486   if(!strcmp("AliESDCaloCluster",Form("%s",cluster->ClassName())))
 487   {
 488     //If EMCAL track matching needs to be recalculated
 489     if(cluster->IsEMCAL() && cu && cu->IsRecalculationOfClusterTrackMatchingOn()){
 490       Float_t dR = 999., dZ = 999.;
 491       cu->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dR,dZ);
 492       if(dR < 999) return kTRUE;
 493       else         return kFALSE;
 494     }
 495
 496     if (nMatches > 0) {
 497       if (nMatches == 1 ) {
 498         Int_t iESDtrack = cluster->GetTrackMatchedIndex();
 499         //printf("Track Matched index %d\n",iESDtrack);
 500         if(iESDtrack==-1) return kFALSE ;// Default value of array, there is no match
 501         else              return kTRUE;
 502       }//Just one, check
 503       else return kTRUE ;//More than one, there is a match.
 504     }// > 0
 505     else return kFALSE; //It does not happen, but in case
 506
 507   }//ESDs
 508   else
 509   {
 510     //AODs
 511     if(cu && cu->IsRecalculationOfClusterTrackMatchingOn()){
 512       Float_t dR = TMath::Abs(cluster->GetEmcCpvDistance()) ; //FIXME
 513       if(dR > cu->GetCutR()) return kFALSE;
 514       else                   return kTRUE;
 515     }
 516     else {
 517       if(nMatches > 0) return kTRUE; //There is at least one match.
 518       else             return kFALSE;
 519     }
 520   }//AODs or MC (copy into AOD)
 521
 522   return kFALSE;
 523
 524 }
 525
 526