]>
Commit | Line | Data |
---|---|---|
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 | |
41 | ClassImp(AliESDpid) | |
42 | ||
f858b00e | 43 | Int_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 | 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 | ||
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 | 141 | Float_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 | 159 | void 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 | //_________________________________________________________________________ | |
200 | void 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 | 267 | void 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 | 342 | void 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 | 352 | void 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 | //_________________________________________________________________________ |
394 | Bool_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 | 435 | Float_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 | 456 | Float_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 | //_________________________________________________________________________ | |
472 | void 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 | //_________________________________________________________________________ | |
486 | void 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 | } |