Modifications needed to use PID framework based mass during tracking and
[u/mrichter/AliRoot.git] / STEER / ESD / AliESDpid.cxx
CommitLineData
8c6a71ab 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
115179c6 16/* $Id: AliESDpid.cxx 64123 2013-09-05 15:09:53Z morsch $ */
4f679a16 17
8c6a71ab 18//-----------------------------------------------------------------
19// Implementation of the combined PID class
4f679a16 20// For the Event Summary Data Class
21// produced by the reconstruction process
22// and containing information on the particle identification
8c6a71ab 23// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
24//-----------------------------------------------------------------
25
f858b00e 26#include "TArrayI.h"
27#include "TArrayF.h"
28
539a5a59 29#include "TRandom.h"
10d100d4 30#include "AliLog.h"
31#include "AliPID.h"
f858b00e 32#include "AliTOFHeader.h"
8c6a71ab 33#include "AliESDpid.h"
af885e0f 34#include "AliESDEvent.h"
8c6a71ab 35#include "AliESDtrack.h"
539a5a59 36#include "AliMCEvent.h"
c53e310b 37#include "AliTOFPIDParams.h"
539a5a59 38
00a38d07 39#include <AliDetectorPID.h>
8c6a71ab 40
41ClassImp(AliESDpid)
42
f858b00e 43Int_t AliESDpid::MakePID(AliESDEvent *event, Bool_t TPConly, Float_t timeZeroTOF) const {
10d100d4 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 /*
f858b00e 54 Float_t timeZeroTOF = 0;
10d100d4 55 if (subtractT0)
f858b00e 56 timeZeroTOF = event->GetT0();
10d100d4 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);
115179c6 64 //MakeTOFPID(track, timeZeroTOF);
10d100d4 65 //MakeHMPIDPID(track);
ce5d6908 66 //MakeTRDPID(track);
10d100d4 67 }
68 CombinePID(track);
69 }
70 return 0;
71}
8c6a71ab 72//_________________________________________________________________________
539a5a59 73Float_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
539a5a59 79 dedx = t->GetTPCsignal();
80 track->SetTPCsignalTunedOnData(dedx);
81 if(dedx < 20) return dedx;
82
83 AliPID::EParticleType type = AliPID::kPion;
84
a864479b 85 AliMCEventHandler* eventHandler=dynamic_cast<AliMCEventHandler*>(fEventHandler);
539a5a59 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 TParticle *part = MCpart->Particle();
92
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
125 if(kGood){
f85a3764 126 //TODO maybe introduce different dEdxSources?
87da0205 127 Double_t bethe = fTPCResponse.GetExpectedSignal(track, type, AliTPCPIDResponse::kdEdxDefault, this->UseTPCEtaCorrection(),
128 this->UseTPCMultiplicityCorrection());
129 Double_t sigma = fTPCResponse.GetExpectedSigma(track, type, AliTPCPIDResponse::kdEdxDefault, this->UseTPCEtaCorrection(),
130 this->UseTPCMultiplicityCorrection());
539a5a59 131 dedx = gRandom->Gaus(bethe,sigma);
567624b5 132// if(iS == AliPID::ParticleCode(AliPID::kHe3) || iS == AliPID::ParticleCode(AliPID::kAlpha)) dedx *= 5;
539a5a59 133 }
134 }
135 }
136
137 track->SetTPCsignalTunedOnData(dedx);
138 return dedx;
139}
140//_________________________________________________________________________
a2c30af1 141Float_t AliESDpid::GetTOFsignalTunedOnData(const AliVTrack *t) const {
142 AliESDtrack *track = (AliESDtrack *) t;
143 Double_t tofSignal = track->GetTOFsignalTunedOnData();
144
145 if(tofSignal < 99999) return (Float_t)tofSignal; // it has been already set
c53e310b 146 // read additional mismatch fraction
147 Float_t addmism = GetTOFPIDParams()->GetTOFadditionalMismForMC();
148 if(addmism > 1.){
149 Float_t centr = GetCurrentCentrality();
150 if(centr > 50) addmism *= 0.1667;
151 else if(centr > 20) addmism *= 0.33;
152 }
a2c30af1 153
c53e310b 154 tofSignal = t->GetTOFsignal() + fTOFResponse.GetTailRandomValue(t->Pt(),t->Eta(),t->GetTOFsignal(),addmism);
a2c30af1 155 track->SetTOFsignalTunedOnData(tofSignal);
156 return (Float_t)tofSignal;
157}
158//_________________________________________________________________________
10d100d4 159void AliESDpid::MakeTPCPID(AliESDtrack *track) const
8c6a71ab 160{
4f679a16 161 //
10d100d4 162 // TPC pid using bethe-bloch and gaussian response
4f679a16 163 //
10d100d4 164 if ((track->GetStatus()&AliESDtrack::kTPCin )==0)
165 if ((track->GetStatus()&AliESDtrack::kTPCout)==0) return;
8c6a71ab 166
10d100d4 167 Double_t mom = track->GetP();
168 const AliExternalTrackParam *in=track->GetInnerParam();
169 if (in) mom = in->GetP();
8c6a71ab 170
10d100d4 171 Double_t p[AliPID::kSPECIES];
172 Double_t dedx=track->GetTPCsignal();
173 Bool_t mismatch=kTRUE, heavy=kTRUE;
8c6a71ab 174
10d100d4 175 for (Int_t j=0; j<AliPID::kSPECIES; j++) {
176 AliPID::EParticleType type=AliPID::EParticleType(j);
177 Double_t bethe=fTPCResponse.GetExpectedSignal(mom,type);
178 Double_t sigma=fTPCResponse.GetExpectedSigma(mom,track->GetTPCsignalN(),type);
179 if (TMath::Abs(dedx-bethe) > fRange*sigma) {
180 p[j]=TMath::Exp(-0.5*fRange*fRange)/sigma;
181 } else {
182 p[j]=TMath::Exp(-0.5*(dedx-bethe)*(dedx-bethe)/(sigma*sigma))/sigma;
183 mismatch=kFALSE;
184 }
8c6a71ab 185
10d100d4 186 // Check for particles heavier than (AliPID::kSPECIES - 1)
187 if (dedx < (bethe + fRange*sigma)) heavy=kFALSE;
c630aafd 188
4a78b8c5 189 }
190
10d100d4 191 if (mismatch)
77638021 192 for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1./AliPID::kSPECIES;
10d100d4 193
194 track->SetTPCpid(p);
195
196 if (heavy) track->ResetStatus(AliESDtrack::kTPCpid);
197
198}
199//_________________________________________________________________________
200void AliESDpid::MakeITSPID(AliESDtrack *track) const
201{
202 //
203 // ITS PID
204 // Two options, depending on fITSPIDmethod:
205 // 1) Truncated mean method
206 // 2) Likelihood, using charges measured in all 4 layers and
207 // Landau+gaus response functions
208 //
209
210 if ((track->GetStatus()&AliESDtrack::kITSin)==0 &&
211 (track->GetStatus()&AliESDtrack::kITSout)==0) return;
212
213 Double_t mom=track->GetP();
214 if (fITSPIDmethod == kITSTruncMean) {
215 Double_t dedx=track->GetITSsignal();
15e979c9 216 Bool_t isSA=kTRUE;
217 Double_t momITS=mom;
218 ULong_t trStatus=track->GetStatus();
99daa709 219 if(trStatus&AliESDtrack::kTPCin) isSA=kFALSE;
15e979c9 220 UChar_t clumap=track->GetITSClusterMap();
221 Int_t nPointsForPid=0;
222 for(Int_t i=2; i<6; i++){
223 if(clumap&(1<<i)) ++nPointsForPid;
224 }
225
226 if(nPointsForPid<3) { // track not to be used for combined PID purposes
227 track->ResetStatus(AliESDtrack::kITSpid);
228 return;
229 }
230
10d100d4 231 Double_t p[10];
15e979c9 232
10d100d4 233 Bool_t mismatch=kTRUE, heavy=kTRUE;
234 for (Int_t j=0; j<AliPID::kSPECIES; j++) {
235 Double_t mass=AliPID::ParticleMass(j);//GeV/c^2
15e979c9 236 Double_t bethe=fITSResponse.Bethe(momITS,mass);
237 Double_t sigma=fITSResponse.GetResolution(bethe,nPointsForPid,isSA);
10d100d4 238 if (TMath::Abs(dedx-bethe) > fRange*sigma) {
239 p[j]=TMath::Exp(-0.5*fRange*fRange)/sigma;
240 } else {
241 p[j]=TMath::Exp(-0.5*(dedx-bethe)*(dedx-bethe)/(sigma*sigma))/sigma;
242 mismatch=kFALSE;
243 }
244
245 // Check for particles heavier than (AliPID::kSPECIES - 1)
246 if (dedx < (bethe + fRange*sigma)) heavy=kFALSE;
247
4a78b8c5 248 }
c630aafd 249
10d100d4 250 if (mismatch)
251 for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1./AliPID::kSPECIES;
252
253 track->SetITSpid(p);
254
255 if (heavy) track->ResetStatus(AliESDtrack::kITSpid);
256 }
257 else { // Likelihood method
258 Double_t condprobfun[AliPID::kSPECIES];
259 Double_t qclu[4];
260 track->GetITSdEdxSamples(qclu);
261 fITSResponse.GetITSProbabilities(mom,qclu,condprobfun);
262 track->SetITSpid(condprobfun);
8c6a71ab 263 }
7a8614f3 264
10d100d4 265}
266//_________________________________________________________________________
f858b00e 267void AliESDpid::MakeTOFPID(AliESDtrack *track, Float_t /*timeZeroTOF*/) const
10d100d4 268{
269 //
270 // TOF PID using gaussian response
271 //
f858b00e 272
10d100d4 273 if ((track->GetStatus()&AliESDtrack::kTOFout)==0) return;
274 if ((track->GetStatus()&AliESDtrack::kTIME)==0) return;
a512bf97 275 if ((track->GetStatus()&AliESDtrack::kITSin)==0) return;
10d100d4 276
f858b00e 277 Int_t ibin = fTOFResponse.GetMomBin(track->GetP());
278 Float_t timezero = fTOFResponse.GetT0bin(ibin);
279
00a38d07 280 Double_t time[AliPID::kSPECIES];
10d100d4 281 track->GetIntegratedTimes(time);
282
283 Double_t sigma[AliPID::kSPECIES];
284 for (Int_t iPart = 0; iPart < AliPID::kSPECIES; iPart++) {
285 sigma[iPart] = fTOFResponse.GetExpectedSigma(track->GetP(),time[iPart],AliPID::ParticleMass(iPart));
286 }
287
288 AliDebugGeneral("AliESDpid::MakeTOFPID",2,
289 Form("Expected TOF signals [ps]: %f %f %f %f %f",
290 time[AliPID::kElectron],
291 time[AliPID::kMuon],
292 time[AliPID::kPion],
293 time[AliPID::kKaon],
294 time[AliPID::kProton]));
295
296 AliDebugGeneral("AliESDpid::MakeTOFPID",2,
297 Form("Expected TOF std deviations [ps]: %f %f %f %f %f",
298 sigma[AliPID::kElectron],
299 sigma[AliPID::kMuon],
300 sigma[AliPID::kPion],
301 sigma[AliPID::kKaon],
302 sigma[AliPID::kProton]
303 ));
304
f858b00e 305 Double_t tof = track->GetTOFsignal() - timezero;
10d100d4 306
307 Double_t p[AliPID::kSPECIES];
355b831b 308// Bool_t mismatch = kTRUE;
309 Bool_t heavy = kTRUE;
10d100d4 310 for (Int_t j=0; j<AliPID::kSPECIES; j++) {
311 Double_t sig = sigma[j];
f858b00e 312 if (TMath::Abs(tof-time[j]) > (fRange+2)*sig) {
313 p[j] = TMath::Exp(-0.5*(fRange+2)*(fRange+2))/sig;
10d100d4 314 } else
315 p[j] = TMath::Exp(-0.5*(tof-time[j])*(tof-time[j])/(sig*sig))/sig;
316
317 // Check the mismatching
ee251349 318
355b831b 319// Double_t mass = AliPID::ParticleMass(j);
320// Double_t pm = fTOFResponse.GetMismatchProbability(track->GetP(),mass);
321// if (p[j]>pm) mismatch = kFALSE;
10d100d4 322
323 // Check for particles heavier than (AliPID::kSPECIES - 1)
324 if (tof < (time[j] + fRange*sig)) heavy=kFALSE;
325
326 }
327
ee251349 328 /*
329 if (mismatch)
77638021 330 for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1./AliPID::kSPECIES;
ee251349 331 */
10d100d4 332
333 track->SetTOFpid(p);
334
ee251349 335 if (heavy) track->ResetStatus(AliESDtrack::kTOFpid);
f858b00e 336
784e3441 337 // kTOFmismatch flas is not set because deprecated from 18/02/2013
338 // if (!CheckTOFMatching(track)) track->SetStatus(AliESDtrack::kTOFmismatch);
339 // else track->ResetStatus(AliESDtrack::kTOFmismatch);
10d100d4 340}
341//_________________________________________________________________________
b439f460 342void AliESDpid::MakeTRDPID(AliESDtrack *track) const
343{
344 //
345 // Method to recalculate the TRD PID probabilities
346 //
ea235c90 347 Double_t prob[AliPID::kSPECIES];
1c9d11be 348 GetComputeTRDProbability(track, AliPID::kSPECIES, prob);
b439f460 349 track->SetTRDpid(prob);
350}
351//_________________________________________________________________________
10d100d4 352void AliESDpid::CombinePID(AliESDtrack *track) const
353{
354 //
355 // Combine the information of various detectors
356 // to determine the Particle Identification
357 //
358 Int_t ns=AliPID::kSPECIES;
359 Double_t p[10]={1.,1.,1.,1.,1.,1.,1.,1.,1.,1.};
360
361 if (track->IsOn(AliESDtrack::kITSpid)) {
362 Double_t d[10];
363 track->GetITSpid(d);
364 for (Int_t j=0; j<ns; j++) p[j]*=d[j];
365 }
366
367 if (track->IsOn(AliESDtrack::kTPCpid)) {
368 Double_t d[10];
369 track->GetTPCpid(d);
370 for (Int_t j=0; j<ns; j++) p[j]*=d[j];
371 }
372
373 if (track->IsOn(AliESDtrack::kTRDpid)) {
374 Double_t d[10];
375 track->GetTRDpid(d);
376 for (Int_t j=0; j<ns; j++) p[j]*=d[j];
377 }
378
379 if (track->IsOn(AliESDtrack::kTOFpid)) {
380 Double_t d[10];
381 track->GetTOFpid(d);
382 for (Int_t j=0; j<ns; j++) p[j]*=d[j];
383 }
384
385 if (track->IsOn(AliESDtrack::kHMPIDpid)) {
386 Double_t d[10];
387 track->GetHMPIDpid(d);
388 for (Int_t j=0; j<ns; j++) p[j]*=d[j];
389 }
390
391 track->SetESDpid(p);
8c6a71ab 392}
f858b00e 393//_________________________________________________________________________
394Bool_t AliESDpid::CheckTOFMatching(AliESDtrack *track) const{
ea235c90 395 //
396 // Check pid matching of TOF with TPC as reference
397 //
f858b00e 398 Bool_t status = kFALSE;
399
400 Double_t exptimes[5];
401 track->GetIntegratedTimes(exptimes);
402
f858b00e 403 Float_t p = track->P();
404
7170298c 405 Float_t dedx = track->GetTPCsignal();
406 Float_t time = track->GetTOFsignal() - fTOFResponse.GetStartTime(p);
407
f858b00e 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 < 5;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
7170298c 420 if(TMath::Abs(dedx - dedxExp) < fRangeTOFMismatch * resolutionTPC){
f858b00e 421 status = kTRUE;
422 }
423 }
424 }
425
426 // for nuclei
c1252298 427 Float_t resolutionTOFpr = fTOFResponse.GetExpectedSigma(p, exptimes[4], AliPID::ParticleMass(4));
428 if(!status && (exptimes[4] + fRange*resolutionTOFpr < time)) status = kTRUE;
f858b00e 429
430
431 return status;
432}
00a38d07 433
567624b5 434//_________________________________________________________________________
1d59271b 435Float_t AliESDpid::GetSignalDeltaTOFold(const AliVParticle *track, AliPID::EParticleType type, Bool_t ratio/*=kFALSE*/) const
567624b5 436{
437 //
438 // TOF signal - expected
439 //
440 AliVTrack *vtrack=(AliVTrack*)track;
441
1d59271b 442 const Double_t expTime = fTOFResponse.GetExpectedSignal(vtrack,type);
a2c30af1 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());
1d59271b 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;
567624b5 453}
454
455//_________________________________________________________________________
355b831b 456Float_t AliESDpid::GetNumberOfSigmasTOFold(const AliVParticle *track, AliPID::EParticleType type) const
00a38d07 457{
458 //
459 // Number of sigma implementation for the TOF
460 //
355b831b 461
00a38d07 462 AliVTrack *vtrack=(AliVTrack*)track;
a2c30af1 463 Double_t tofTime = 99999;
464 if (fTuneMConData && ((fTuneMConDataMask & kDetTOF) == kDetTOF) ) tofTime = (Double_t)this->GetTOFsignalTunedOnData((AliVTrack*)vtrack);
465 else tofTime=vtrack->GetTOFsignal();
355b831b 466
00a38d07 467 Double_t expTime = fTOFResponse.GetExpectedSignal(vtrack,type);
a2c30af1 468 return (tofTime - fTOFResponse.GetStartTime(vtrack->P()) - expTime)/fTOFResponse.GetExpectedSigma(vtrack->P(),expTime,AliPID::ParticleMassZ(type));
00a38d07 469}
1d26da6d 470
471//_________________________________________________________________________
472void AliESDpid::SetMassForTracking(AliESDtrack *esdtr) const
473{
474 // assign mass for tracking
475 //
476 int pid = AliPID::kPion; // this should be substituted by real most probable TPC pid (e,mu -> pion) or poin if no PID possible
477 //
478 if (pid<AliPID::kPion || pid>AliPID::kSPECIESC-1) pid = AliPID::kPion;
479 //
480 esdtr->SetMassForTracking( AliPID::ParticleCharge(pid)==1 ? AliPID::ParticleMass(pid) : -AliPID::ParticleMass(pid));
481 //
482}
483
484
485//_________________________________________________________________________
486void AliESDpid::MakePIDForTracking(AliESDEvent *event) const
487{
488 // assign masses using for tracking
489 Int_t nTrk=event->GetNumberOfTracks();
490 for (Int_t iTrk=nTrk; iTrk--;) {
491 AliESDtrack *track = event->GetTrack(iTrk);
492 SetMassForTracking(track);
493 }
494
495}