STEER/ESD/AliESDpid.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
  16 /* $Id: AliESDpid.cxx 64123 2013-09-05 15:09:53Z morsch $ */
  17
  18 //-----------------------------------------------------------------
  19 //           Implementation of the combined PID class
  20 //           For the Event Summary Data Class
  21 //           produced by the reconstruction process
  22 //           and containing information on the particle identification
  23 //      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
  24 //-----------------------------------------------------------------
  25
  26 #include "TArrayI.h"
  27 #include "TArrayF.h"
  28
  29 #include "TRandom.h"
  30 #include "AliLog.h"
  31 #include "AliPID.h"
  32 #include "AliTOFHeader.h"
  33 #include "AliESDpid.h"
  34 #include "AliESDEvent.h"
  35 #include "AliESDtrack.h"
  36 #include "AliMCEvent.h"
  37 #include "AliTOFPIDParams.h"
  38
  39 #include <AliDetectorPID.h>
  40
  41 ClassImp(AliESDpid)
  42
  43 Int_t AliESDpid::MakePID(AliESDEvent *event, Bool_t TPConly, Float_t /*timeZeroTOF*/) const {
  44   //
  45   //  Calculate probabilities for all detectors, except if TPConly==kTRUE
  46   //  and combine PID
  47   //
  48   //   Option TPConly==kTRUE is used during reconstruction,
  49   //  because ITS tracking uses TPC pid
  50   //  HMPID and TRD pid are done in detector reconstructors
  51   //
  52
  53   /*
  54   Float_t timeZeroTOF = 0;
  55   if (subtractT0)
  56     timeZeroTOF = event->GetT0();
  57   */
  58   Int_t nTrk=event->GetNumberOfTracks();
  59   for (Int_t iTrk=0; iTrk<nTrk; iTrk++) {
  60     AliESDtrack *track=event->GetTrack(iTrk);
  61     MakeTPCPID(track);
  62     if (!TPConly) {
  63       MakeITSPID(track);
  64       //MakeTOFPID(track, timeZeroTOF);
  65       //MakeHMPIDPID(track);
  66       //MakeTRDPID(track);
  67     }
  68     CombinePID(track);
  69   }
  70   return 0;
  71 }
  72 //_________________________________________________________________________
  73 Float_t AliESDpid::GetTPCsignalTunedOnData(const AliVTrack *t) const {
  74     AliESDtrack *track = (AliESDtrack *) t;
  75     Float_t dedx = track->GetTPCsignalTunedOnData();
  76
  77     if(dedx > 0) return dedx;
  78
  79     dedx = t->GetTPCsignal();
  80     track->SetTPCsignalTunedOnData(dedx);
  81     if(dedx < 20) return dedx;
  82
  83     AliPID::EParticleType type = AliPID::kPion;
  84
  85     AliMCEventHandler* eventHandler=dynamic_cast<AliMCEventHandler*>(fEventHandler);
  86     if (eventHandler) {
  87         AliMCEvent* mcEvent = eventHandler->MCEvent();
  88         if(mcEvent){
  89             Bool_t kGood = kTRUE;
  90             AliMCParticle *MCpart = (AliMCParticle *) mcEvent->GetTrack(TMath::Abs(t->GetLabel()));
  91             if (MCpart != NULL) { // protect against label-0 track (initial proton in Pythia events)
  92               TParticle *part = MCpart->Particle();
  93               Int_t iS = TMath::Abs(part->GetPdgCode());
  94
  95               if(iS==AliPID::ParticleCode(AliPID::kElectron)){
  96                 type = AliPID::kElectron;
  97               }
  98               else if(iS==AliPID::ParticleCode(AliPID::kMuon)){
  99                 type = AliPID::kMuon;
 100               }
 101               else if(iS==AliPID::ParticleCode(AliPID::kPion)){
 102                 type = AliPID::kPion;
 103               }
 104               else if(iS==AliPID::ParticleCode(AliPID::kKaon)){
 105                 type = AliPID::kKaon;
 106               }
 107               else if(iS==AliPID::ParticleCode(AliPID::kProton)){
 108                 type = AliPID::kProton;
 109               }
 110               else if(iS==AliPID::ParticleCode(AliPID::kDeuteron)){ // d
 111                 type = AliPID::kDeuteron;
 112               }
 113               else if(iS==AliPID::ParticleCode(AliPID::kTriton)){ // t
 114                 type = AliPID::kTriton;
 115               }
 116               else if(iS==AliPID::ParticleCode(AliPID::kHe3)){ // 3He
 117                 type = AliPID::kHe3;
 118               }
 119               else if(iS==AliPID::ParticleCode(AliPID::kAlpha)){ // 4He
 120                 type = AliPID::kAlpha;
 121               }
 122               else
 123                 kGood = kFALSE;
 124             } else kGood = kFALSE;
 125
 126             if(kGood){
 127         //TODO maybe introduce different dEdxSources?
 128         Double_t bethe = fTPCResponse.GetExpectedSignal(track, type, AliTPCPIDResponse::kdEdxDefault, this->UseTPCEtaCorrection(),
 129                                                         this->UseTPCMultiplicityCorrection());
 130         Double_t sigma = fTPCResponse.GetExpectedSigma(track, type, AliTPCPIDResponse::kdEdxDefault, this->UseTPCEtaCorrection(),
 131                                                        this->UseTPCMultiplicityCorrection());
 132                 dedx = gRandom->Gaus(bethe,sigma);
 133 //              if(iS == AliPID::ParticleCode(AliPID::kHe3) || iS == AliPID::ParticleCode(AliPID::kAlpha)) dedx *= 5;
 134             }
 135         }
 136     }
 137
 138     track->SetTPCsignalTunedOnData(dedx);
 139     return dedx;
 140 }
 141 //_________________________________________________________________________
 142 Float_t AliESDpid::GetTOFsignalTunedOnData(const AliVTrack *t) const {
 143     AliESDtrack *track = (AliESDtrack *) t;
 144     Double_t tofSignal = track->GetTOFsignalTunedOnData();
 145
 146     if(tofSignal <  99999) return (Float_t)tofSignal; // it has been already set
 147     // read additional mismatch fraction
 148     Float_t addmism = GetTOFPIDParams()->GetTOFadditionalMismForMC();
 149     if(addmism > 1.){
 150       Float_t centr = GetCurrentCentrality();
 151       if(centr > 50) addmism *= 0.1667;
 152       else if(centr > 20) addmism *= 0.33;
 153     }
 154
 155     tofSignal = t->GetTOFsignal() + fTOFResponse.GetTailRandomValue(t->Pt(),t->Eta(),t->GetTOFsignal(),addmism);
 156     track->SetTOFsignalTunedOnData(tofSignal);
 157     return (Float_t)tofSignal;
 158 }
 159 //_________________________________________________________________________
 160 void AliESDpid::MakeTPCPID(AliESDtrack *track) const
 161 {
 162   //
 163   //  TPC pid using bethe-bloch and gaussian response
 164   //
 165   if ((track->GetStatus()&AliESDtrack::kTPCin )==0)
 166     if ((track->GetStatus()&AliESDtrack::kTPCout)==0) return;
 167
 168     Double_t mom = track->GetP();
 169     const AliExternalTrackParam *in=track->GetInnerParam();
 170     if (in) mom = in->GetP();
 171
 172     Double_t p[AliPID::kSPECIES];
 173     Double_t dedx=track->GetTPCsignal();
 174     Bool_t mismatch=kTRUE, heavy=kTRUE;
 175
 176     for (Int_t j=0; j<AliPID::kSPECIES; j++) {
 177       AliPID::EParticleType type=AliPID::EParticleType(j);
 178       Double_t bethe=fTPCResponse.GetExpectedSignal(mom,type);
 179       Double_t sigma=fTPCResponse.GetExpectedSigma(mom,track->GetTPCsignalN(),type);
 180       if (TMath::Abs(dedx-bethe) > fRange*sigma) {
 181         p[j]=TMath::Exp(-0.5*fRange*fRange)/sigma;
 182       } else {
 183         p[j]=TMath::Exp(-0.5*(dedx-bethe)*(dedx-bethe)/(sigma*sigma))/sigma;
 184         mismatch=kFALSE;
 185       }
 186
 187       // Check for particles heavier than (AliPID::kSPECIES - 1)
 188       if (dedx < (bethe + fRange*sigma)) heavy=kFALSE;
 189
 190     }
 191
 192     if (mismatch)
 193        for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1./AliPID::kSPECIES;
 194
 195     track->SetTPCpid(p);
 196
 197     if (heavy) track->ResetStatus(AliESDtrack::kTPCpid);
 198
 199 }
 200 //_________________________________________________________________________
 201 void AliESDpid::MakeITSPID(AliESDtrack *track) const
 202 {
 203   //
 204   // ITS PID
 205   // Two options, depending on fITSPIDmethod:
 206   //  1) Truncated mean method
 207   //  2) Likelihood, using charges measured in all 4 layers and
 208   //     Landau+gaus response functions
 209   //
 210
 211   if ((track->GetStatus()&AliESDtrack::kITSin)==0 &&
 212       (track->GetStatus()&AliESDtrack::kITSout)==0) return;
 213
 214   Double_t mom=track->GetP();
 215   if (fITSPIDmethod == kITSTruncMean) {
 216     Double_t dedx=track->GetITSsignal();
 217     Bool_t isSA=kTRUE;
 218     Double_t momITS=mom;
 219     ULong_t trStatus=track->GetStatus();
 220     if(trStatus&AliESDtrack::kTPCin) isSA=kFALSE;
 221     UChar_t clumap=track->GetITSClusterMap();
 222     Int_t nPointsForPid=0;
 223     for(Int_t i=2; i<6; i++){
 224       if(clumap&(1<<i)) ++nPointsForPid;
 225     }
 226
 227     if(nPointsForPid<3) { // track not to be used for combined PID purposes
 228       track->ResetStatus(AliESDtrack::kITSpid);
 229       return;
 230     }
 231
 232     Double_t p[AliPID::kSPECIES];
 233
 234     Bool_t mismatch=kTRUE, heavy=kTRUE;
 235     for (Int_t j=0; j<AliPID::kSPECIES; j++) {
 236       Double_t mass=AliPID::ParticleMass(j);//GeV/c^2
 237       Double_t bethe=fITSResponse.Bethe(momITS,mass);
 238       Double_t sigma=fITSResponse.GetResolution(bethe,nPointsForPid,isSA);
 239       if (TMath::Abs(dedx-bethe) > fRange*sigma) {
 240         p[j]=TMath::Exp(-0.5*fRange*fRange)/sigma;
 241       } else {
 242         p[j]=TMath::Exp(-0.5*(dedx-bethe)*(dedx-bethe)/(sigma*sigma))/sigma;
 243         mismatch=kFALSE;
 244       }
 245
 246       // Check for particles heavier than (AliPID::kSPECIES - 1)
 247       if (dedx < (bethe + fRange*sigma)) heavy=kFALSE;
 248
 249     }
 250
 251     if (mismatch)
 252        for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1./AliPID::kSPECIES;
 253
 254     track->SetITSpid(p);
 255
 256     if (heavy) track->ResetStatus(AliESDtrack::kITSpid);
 257   }
 258   else {  // Likelihood method
 259     Double_t condprobfun[AliPID::kSPECIES];
 260     Double_t qclu[4];
 261     track->GetITSdEdxSamples(qclu);
 262     fITSResponse.GetITSProbabilities(mom,qclu,condprobfun);
 263     track->SetITSpid(condprobfun);
 264   }
 265
 266 }
 267 //_________________________________________________________________________
 268 void AliESDpid::MakeTOFPID(AliESDtrack *track, Float_t /*timeZeroTOF*/) const
 269 {
 270   //
 271   //   TOF PID using gaussian response
 272   //
 273
 274   if ((track->GetStatus()&AliESDtrack::kTOFout)==0) return;
 275   if ((track->GetStatus()&AliESDtrack::kTIME)==0) return;
 276   if ((track->GetStatus()&AliESDtrack::kITSin)==0) return;
 277
 278   Int_t ibin = fTOFResponse.GetMomBin(track->GetP());
 279   Float_t timezero = fTOFResponse.GetT0bin(ibin);
 280
 281   Double_t time[AliPID::kSPECIESC];
 282   track->GetIntegratedTimes(time);
 283
 284   Double_t sigma[AliPID::kSPECIES];
 285   for (Int_t iPart = 0; iPart < AliPID::kSPECIES; iPart++) {
 286     sigma[iPart] = fTOFResponse.GetExpectedSigma(track->GetP(),time[iPart],AliPID::ParticleMass(iPart));
 287   }
 288
 289   AliDebugGeneral("AliESDpid::MakeTOFPID",2,
 290            Form("Expected TOF signals [ps]: %f %f %f %f %f",
 291                   time[AliPID::kElectron],
 292                   time[AliPID::kMuon],
 293                   time[AliPID::kPion],
 294                   time[AliPID::kKaon],
 295                   time[AliPID::kProton]));
 296
 297   AliDebugGeneral("AliESDpid::MakeTOFPID",2,
 298            Form("Expected TOF std deviations [ps]: %f %f %f %f %f",
 299                   sigma[AliPID::kElectron],
 300                   sigma[AliPID::kMuon],
 301                   sigma[AliPID::kPion],
 302                   sigma[AliPID::kKaon],
 303                   sigma[AliPID::kProton]
 304                   ));
 305
 306   Double_t tof = track->GetTOFsignal() - timezero;
 307
 308   Double_t p[AliPID::kSPECIES];
 309 //   Bool_t mismatch = kTRUE;
 310   Bool_t heavy = kTRUE;
 311   for (Int_t j=0; j<AliPID::kSPECIES; j++) {
 312     Double_t sig = sigma[j];
 313     if (TMath::Abs(tof-time[j]) > (fRange+2)*sig) {
 314         p[j] = TMath::Exp(-0.5*(fRange+2)*(fRange+2))/sig;
 315     } else
 316       p[j] = TMath::Exp(-0.5*(tof-time[j])*(tof-time[j])/(sig*sig))/sig;
 317
 318     // Check the mismatching
 319
 320 //     Double_t mass = AliPID::ParticleMass(j);
 321 //     Double_t pm = fTOFResponse.GetMismatchProbability(track->GetP(),mass);
 322 //     if (p[j]>pm) mismatch = kFALSE;
 323
 324     // Check for particles heavier than (AliPID::kSPECIES - 1)
 325     if (tof < (time[j] + fRange*sig)) heavy=kFALSE;
 326
 327   }
 328
 329   /*
 330     if (mismatch)
 331     for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1./AliPID::kSPECIES;
 332   */
 333
 334   track->SetTOFpid(p);
 335
 336   if (heavy) track->ResetStatus(AliESDtrack::kTOFpid);
 337
 338   // kTOFmismatch flas is not set because deprecated from 18/02/2013
 339   //  if (!CheckTOFMatching(track)) track->SetStatus(AliESDtrack::kTOFmismatch);
 340   //  else track->ResetStatus(AliESDtrack::kTOFmismatch);
 341 }
 342 //_________________________________________________________________________
 343 void AliESDpid::MakeTRDPID(AliESDtrack *track) const
 344 {
 345   //
 346   // Method to recalculate the TRD PID probabilities
 347   //
 348   Double_t prob[AliPID::kSPECIES];
 349   GetComputeTRDProbability(track, AliPID::kSPECIES, prob);
 350   track->SetTRDpid(prob);
 351 }
 352 //_________________________________________________________________________
 353 void AliESDpid::CombinePID(AliESDtrack *track) const
 354 {
 355   //
 356   // Combine the information of various detectors
 357   // to determine the Particle Identification
 358   //
 359   Double_t p[AliPID::kSPECIES]={1.};
 360
 361   if (track->IsOn(AliESDtrack::kITSpid)) {
 362     Double_t d[AliPID::kSPECIES];
 363     track->GetITSpid(d);
 364     for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]*=d[j];
 365   }
 366
 367   if (track->IsOn(AliESDtrack::kTPCpid)) {
 368     Double_t d[AliPID::kSPECIES];
 369     track->GetTPCpid(d);
 370     for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]*=d[j];
 371   }
 372
 373   if (track->IsOn(AliESDtrack::kTRDpid)) {
 374     Double_t d[AliPID::kSPECIES];
 375     track->GetTRDpid(d);
 376     for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]*=d[j];
 377   }
 378
 379   if (track->IsOn(AliESDtrack::kTOFpid)) {
 380     Double_t d[AliPID::kSPECIES];
 381     track->GetTOFpid(d);
 382     for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]*=d[j];
 383   }
 384
 385   if (track->IsOn(AliESDtrack::kHMPIDpid)) {
 386     Double_t d[AliPID::kSPECIES];
 387     track->GetHMPIDpid(d);
 388     for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]*=d[j];
 389   }
 390
 391   track->SetESDpid(p);
 392 }
 393 //_________________________________________________________________________
 394 Bool_t AliESDpid::CheckTOFMatching(AliESDtrack *track) const{
 395   //
 396   // Check pid matching of TOF with TPC as reference
 397   //
 398     Bool_t status = kFALSE;
 399
 400     Double_t exptimes[AliPID::kSPECIESC];
 401     track->GetIntegratedTimes(exptimes);
 402
 403     Float_t p = track->P();
 404
 405     Float_t dedx = track->GetTPCsignal();
 406     Float_t time = track->GetTOFsignal() - fTOFResponse.GetStartTime(p);
 407
 408     Double_t ptpc[3];
 409     track->GetInnerPxPyPz(ptpc);
 410     Float_t momtpc=TMath::Sqrt(ptpc[0]*ptpc[0] + ptpc[1]*ptpc[1] + ptpc[2]*ptpc[2]);
 411
 412     for(Int_t i=0;i < AliPID::kSPECIES;i++){
 413         AliPID::EParticleType type=AliPID::EParticleType(i);
 414
 415         Float_t resolutionTOF = fTOFResponse.GetExpectedSigma(p, exptimes[i], AliPID::ParticleMass(i));
 416         if(TMath::Abs(exptimes[i] - time) < fRange * resolutionTOF){
 417             Float_t dedxExp = fTPCResponse.GetExpectedSignal(momtpc,type);
 418             Float_t resolutionTPC = fTPCResponse.GetExpectedSigma(momtpc,track->GetTPCsignalN(),type);
 419
 420             if(TMath::Abs(dedx - dedxExp) < fRangeTOFMismatch * resolutionTPC){
 421                 status = kTRUE;
 422             }
 423         }
 424     }
 425
 426     // for nuclei
 427     Float_t resolutionTOFpr = fTOFResponse.GetExpectedSigma(p, exptimes[4], AliPID::ParticleMass(4));
 428     if(!status && (exptimes[4] + fRange*resolutionTOFpr < time)) status = kTRUE;
 429
 430
 431     return status;
 432 }
 433
 434 //_________________________________________________________________________
 435 Float_t AliESDpid::GetSignalDeltaTOFold(const AliVParticle *track, AliPID::EParticleType type, Bool_t ratio/*=kFALSE*/) const
 436 {
 437   //
 438   // TOF signal - expected
 439   //
 440   AliVTrack *vtrack=(AliVTrack*)track;
 441
 442   const Double_t expTime = fTOFResponse.GetExpectedSignal(vtrack,type);
 443   Double_t tofTime = 99999;
 444   if (fTuneMConData && ((fTuneMConDataMask & kDetTOF) == kDetTOF) ) tofTime = (Double_t)this->GetTOFsignalTunedOnData((AliVTrack*)vtrack);
 445   else tofTime=vtrack->GetTOFsignal();
 446   tofTime = tofTime  - fTOFResponse.GetStartTime(vtrack->P());
 447   Double_t delta=-9999.;
 448
 449   if (!ratio) delta=tofTime-expTime;
 450   else if (expTime>1.e-20) delta=tofTime/expTime;
 451
 452   return delta;
 453 }
 454
 455 //_________________________________________________________________________
 456 Float_t AliESDpid::GetNumberOfSigmasTOFold(const AliVParticle *track, AliPID::EParticleType type) const
 457 {
 458   //
 459   // Number of sigma implementation for the TOF
 460   //
 461
 462   AliVTrack *vtrack=(AliVTrack*)track;
 463   Double_t tofTime = 99999;
 464   if (fTuneMConData && ((fTuneMConDataMask & kDetTOF) == kDetTOF) ) tofTime = (Double_t)this->GetTOFsignalTunedOnData((AliVTrack*)vtrack);
 465   else tofTime=vtrack->GetTOFsignal();
 466
 467   Double_t expTime = fTOFResponse.GetExpectedSignal(vtrack,type);
 468   return (tofTime - fTOFResponse.GetStartTime(vtrack->P()) - expTime)/fTOFResponse.GetExpectedSigma(vtrack->P(),expTime,AliPID::ParticleMassZ(type));
 469 }
 470
 471 //_________________________________________________________________________
 472 void AliESDpid::SetPIDForTracking(AliESDtrack *esdtr) const
 473 {
 474   // assign mass for tracking
 475   //
 476
 477   // in principle AliPIDCombined could be used to also set priors
 478   //AliPIDCombined pidProb;
 479   //pidProb.SetDetectorMask(kDetTPC);              // use only TPC information, couls also be changed
 480   //pidProb.SetSelectedSpecies(AliPID::kSPECIESC); // number of species to use
 481   //pidProb.SetDefaultTPCPriors();                 // load default priors
 482
 483   Double_t prob[AliPID::kSPECIESC]={0.};
 484   EDetPidStatus pidStatus=ComputePIDProbability(kTPC, esdtr, AliPID::kSPECIESC, prob);
 485   // check if a valid signal was found, otherwise return pion mass
 486   if (pidStatus!=kDetPidOk) {
 487     esdtr->SetPIDForTracking(AliPID::kPion);
 488     return;
 489   }
 490
 491   // or with AliPIDCombined
 492   // pidProb.ComputeProbabilities(esdtr, this, p);
 493
 494   // find max probability
 495   Float_t max=0.;
 496   Int_t pid=-1;
 497   for (Int_t i=0; i<AliPID::kSPECIESC; ++i) if (prob[i]>max) {pid=i; max=prob[i];}
 498
 499   //int pid = AliPID::kPion; // this should be substituted by real most probable TPC pid (e,mu -> pion) or poin if no PID possible
 500
 501   //
 502   if (pid>AliPID::kSPECIESC-1) pid = AliPID::kPion;
 503   //
 504   esdtr->SetPIDForTracking( pid );
 505   //
 506 }
 507
 508
 509 //_________________________________________________________________________
 510 void AliESDpid::MakePIDForTracking(AliESDEvent *event) const
 511 {
 512   // assign masses using for tracking
 513   Int_t nTrk=event->GetNumberOfTracks();
 514   for (Int_t iTrk=nTrk; iTrk--;) {
 515     AliESDtrack *track = event->GetTrack(iTrk);
 516     SetPIDForTracking(track);
 517   }
 518
 519 }