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 **************************************************************************/
16 /* $Id: AliESDpid.cxx 64123 2013-09-05 15:09:53Z morsch $ */
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 //-----------------------------------------------------------------
32 #include "AliTOFHeader.h"
33 #include "AliESDpid.h"
34 #include "AliESDEvent.h"
35 #include "AliESDtrack.h"
36 #include "AliMCEvent.h"
37 #include "AliTOFPIDParams.h"
39 #include <AliDetectorPID.h>
43 Int_t AliESDpid::MakePID(AliESDEvent *event, Bool_t TPConly, Float_t /*timeZeroTOF*/) const {
45 // Calculate probabilities for all detectors, except if TPConly==kTRUE
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
54 Float_t timeZeroTOF = 0;
56 timeZeroTOF = event->GetT0();
58 Int_t nTrk=event->GetNumberOfTracks();
59 for (Int_t iTrk=0; iTrk<nTrk; iTrk++) {
60 AliESDtrack *track=event->GetTrack(iTrk);
64 //MakeTOFPID(track, timeZeroTOF);
65 //MakeHMPIDPID(track);
72 //_________________________________________________________________________
73 Float_t AliESDpid::GetTPCsignalTunedOnData(const AliVTrack *t) const {
74 AliESDtrack *track = (AliESDtrack *) t;
75 Float_t dedx = track->GetTPCsignalTunedOnData();
77 if(dedx > 0) return dedx;
79 dedx = t->GetTPCsignal();
80 track->SetTPCsignalTunedOnData(dedx);
81 if(dedx < 20) return dedx;
83 AliPID::EParticleType type = AliPID::kPion;
85 AliMCEventHandler* eventHandler=dynamic_cast<AliMCEventHandler*>(fEventHandler);
87 AliMCEvent* mcEvent = eventHandler->MCEvent();
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());
95 if(iS==AliPID::ParticleCode(AliPID::kElectron)){
96 type = AliPID::kElectron;
98 else if(iS==AliPID::ParticleCode(AliPID::kMuon)){
101 else if(iS==AliPID::ParticleCode(AliPID::kPion)){
102 type = AliPID::kPion;
104 else if(iS==AliPID::ParticleCode(AliPID::kKaon)){
105 type = AliPID::kKaon;
107 else if(iS==AliPID::ParticleCode(AliPID::kProton)){
108 type = AliPID::kProton;
110 else if(iS==AliPID::ParticleCode(AliPID::kDeuteron)){ // d
111 type = AliPID::kDeuteron;
113 else if(iS==AliPID::ParticleCode(AliPID::kTriton)){ // t
114 type = AliPID::kTriton;
116 else if(iS==AliPID::ParticleCode(AliPID::kHe3)){ // 3He
119 else if(iS==AliPID::ParticleCode(AliPID::kAlpha)){ // 4He
120 type = AliPID::kAlpha;
124 } else kGood = kFALSE;
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;
138 track->SetTPCsignalTunedOnData(dedx);
141 //_________________________________________________________________________
142 Float_t AliESDpid::GetTOFsignalTunedOnData(const AliVTrack *t) const {
143 AliESDtrack *track = (AliESDtrack *) t;
144 Double_t tofSignal = track->GetTOFsignalTunedOnData();
146 if(tofSignal < 99999) return (Float_t)tofSignal; // it has been already set
147 // read additional mismatch fraction
148 Float_t addmism = GetTOFPIDParams()->GetTOFadditionalMismForMC();
150 Float_t centr = GetCurrentCentrality();
151 if(centr > 50) addmism *= 0.1667;
152 else if(centr > 20) addmism *= 0.33;
155 tofSignal = t->GetTOFsignal() + fTOFResponse.GetTailRandomValue(t->Pt(),t->Eta(),t->GetTOFsignal(),addmism);
156 track->SetTOFsignalTunedOnData(tofSignal);
157 return (Float_t)tofSignal;
159 //_________________________________________________________________________
160 void AliESDpid::MakeTPCPID(AliESDtrack *track) const
163 // TPC pid using bethe-bloch and gaussian response
165 if ((track->GetStatus()&AliESDtrack::kTPCin )==0)
166 if ((track->GetStatus()&AliESDtrack::kTPCout)==0) return;
168 Double_t mom = track->GetP();
169 const AliExternalTrackParam *in=track->GetInnerParam();
170 if (in) mom = in->GetP();
172 Double_t p[AliPID::kSPECIES];
173 Double_t dedx=track->GetTPCsignal();
174 Bool_t mismatch=kTRUE, heavy=kTRUE;
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;
183 p[j]=TMath::Exp(-0.5*(dedx-bethe)*(dedx-bethe)/(sigma*sigma))/sigma;
187 // Check for particles heavier than (AliPID::kSPECIES - 1)
188 if (dedx < (bethe + fRange*sigma)) heavy=kFALSE;
193 for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1./AliPID::kSPECIES;
197 if (heavy) track->ResetStatus(AliESDtrack::kTPCpid);
200 //_________________________________________________________________________
201 void AliESDpid::MakeITSPID(AliESDtrack *track) const
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
211 if ((track->GetStatus()&AliESDtrack::kITSin)==0 &&
212 (track->GetStatus()&AliESDtrack::kITSout)==0) return;
214 Double_t mom=track->GetP();
215 if (fITSPIDmethod == kITSTruncMean) {
216 Double_t dedx=track->GetITSsignal();
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;
227 if(nPointsForPid<3) { // track not to be used for combined PID purposes
228 track->ResetStatus(AliESDtrack::kITSpid);
232 Double_t p[AliPID::kSPECIES];
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;
242 p[j]=TMath::Exp(-0.5*(dedx-bethe)*(dedx-bethe)/(sigma*sigma))/sigma;
246 // Check for particles heavier than (AliPID::kSPECIES - 1)
247 if (dedx < (bethe + fRange*sigma)) heavy=kFALSE;
252 for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1./AliPID::kSPECIES;
256 if (heavy) track->ResetStatus(AliESDtrack::kITSpid);
258 else { // Likelihood method
259 Double_t condprobfun[AliPID::kSPECIES];
261 track->GetITSdEdxSamples(qclu);
262 fITSResponse.GetITSProbabilities(mom,qclu,condprobfun);
263 track->SetITSpid(condprobfun);
267 //_________________________________________________________________________
268 void AliESDpid::MakeTOFPID(AliESDtrack *track, Float_t /*timeZeroTOF*/) const
271 // TOF PID using gaussian response
274 if ((track->GetStatus()&AliESDtrack::kTOFout)==0) return;
275 if ((track->GetStatus()&AliESDtrack::kTIME)==0) return;
276 if ((track->GetStatus()&AliESDtrack::kITSin)==0) return;
278 Int_t ibin = fTOFResponse.GetMomBin(track->GetP());
279 Float_t timezero = fTOFResponse.GetT0bin(ibin);
281 Double_t time[AliPID::kSPECIESC];
282 track->GetIntegratedTimes(time);
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));
289 AliDebugGeneral("AliESDpid::MakeTOFPID",2,
290 Form("Expected TOF signals [ps]: %f %f %f %f %f",
291 time[AliPID::kElectron],
295 time[AliPID::kProton]));
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]
306 Double_t tof = track->GetTOFsignal() - timezero;
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;
316 p[j] = TMath::Exp(-0.5*(tof-time[j])*(tof-time[j])/(sig*sig))/sig;
318 // Check the mismatching
320 // Double_t mass = AliPID::ParticleMass(j);
321 // Double_t pm = fTOFResponse.GetMismatchProbability(track->GetP(),mass);
322 // if (p[j]>pm) mismatch = kFALSE;
324 // Check for particles heavier than (AliPID::kSPECIES - 1)
325 if (tof < (time[j] + fRange*sig)) heavy=kFALSE;
331 for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1./AliPID::kSPECIES;
336 if (heavy) track->ResetStatus(AliESDtrack::kTOFpid);
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);
342 //_________________________________________________________________________
343 void AliESDpid::MakeTRDPID(AliESDtrack *track) const
346 // Method to recalculate the TRD PID probabilities
348 Double_t prob[AliPID::kSPECIES];
349 GetComputeTRDProbability(track, AliPID::kSPECIES, prob);
350 track->SetTRDpid(prob);
352 //_________________________________________________________________________
353 void AliESDpid::CombinePID(AliESDtrack *track) const
356 // Combine the information of various detectors
357 // to determine the Particle Identification
359 Double_t p[AliPID::kSPECIES]={1.};
361 if (track->IsOn(AliESDtrack::kITSpid)) {
362 Double_t d[AliPID::kSPECIES];
364 for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]*=d[j];
367 if (track->IsOn(AliESDtrack::kTPCpid)) {
368 Double_t d[AliPID::kSPECIES];
370 for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]*=d[j];
373 if (track->IsOn(AliESDtrack::kTRDpid)) {
374 Double_t d[AliPID::kSPECIES];
376 for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]*=d[j];
379 if (track->IsOn(AliESDtrack::kTOFpid)) {
380 Double_t d[AliPID::kSPECIES];
382 for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]*=d[j];
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];
393 //_________________________________________________________________________
394 Bool_t AliESDpid::CheckTOFMatching(AliESDtrack *track) const{
396 // Check pid matching of TOF with TPC as reference
398 Bool_t status = kFALSE;
400 Double_t exptimes[AliPID::kSPECIESC];
401 track->GetIntegratedTimes(exptimes);
403 Float_t p = track->P();
405 Float_t dedx = track->GetTPCsignal();
406 Float_t time = track->GetTOFsignal() - fTOFResponse.GetStartTime(p);
409 track->GetInnerPxPyPz(ptpc);
410 Float_t momtpc=TMath::Sqrt(ptpc[0]*ptpc[0] + ptpc[1]*ptpc[1] + ptpc[2]*ptpc[2]);
412 for(Int_t i=0;i < AliPID::kSPECIES;i++){
413 AliPID::EParticleType type=AliPID::EParticleType(i);
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);
420 if(TMath::Abs(dedx - dedxExp) < fRangeTOFMismatch * resolutionTPC){
427 Float_t resolutionTOFpr = fTOFResponse.GetExpectedSigma(p, exptimes[4], AliPID::ParticleMass(4));
428 if(!status && (exptimes[4] + fRange*resolutionTOFpr < time)) status = kTRUE;
434 //_________________________________________________________________________
435 Float_t AliESDpid::GetSignalDeltaTOFold(const AliVParticle *track, AliPID::EParticleType type, Bool_t ratio/*=kFALSE*/) const
438 // TOF signal - expected
440 AliVTrack *vtrack=(AliVTrack*)track;
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.;
449 if (!ratio) delta=tofTime-expTime;
450 else if (expTime>1.e-20) delta=tofTime/expTime;
455 //_________________________________________________________________________
456 Float_t AliESDpid::GetNumberOfSigmasTOFold(const AliVParticle *track, AliPID::EParticleType type) const
459 // Number of sigma implementation for the TOF
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();
467 Double_t expTime = fTOFResponse.GetExpectedSignal(vtrack,type);
468 return (tofTime - fTOFResponse.GetStartTime(vtrack->P()) - expTime)/fTOFResponse.GetExpectedSigma(vtrack->P(),expTime,AliPID::ParticleMassZ(type));
471 //_________________________________________________________________________
472 void AliESDpid::SetPIDForTracking(AliESDtrack *esdtr) const
474 // assign mass for tracking
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
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);
491 // or with AliPIDCombined
492 // pidProb.ComputeProbabilities(esdtr, this, p);
494 // find max probability
497 for (Int_t i=0; i<AliPID::kSPECIESC; ++i) if (prob[i]>max) {pid=i; max=prob[i];}
499 //int pid = AliPID::kPion; // this should be substituted by real most probable TPC pid (e,mu -> pion) or poin if no PID possible
502 if (pid>AliPID::kSPECIESC-1) pid = AliPID::kPion;
504 esdtr->SetPIDForTracking( pid );
509 //_________________________________________________________________________
510 void AliESDpid::MakePIDForTracking(AliESDEvent *event) const
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);