Efficient C++ initialization of data members
[u/mrichter/AliRoot.git] / STEER / AliESDtrack.cxx
... / ...
CommitLineData
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// Implementation of the ESD track class
17// ESD = Event Summary Data
18// This is the class to deal with during the phisics analysis of data
19// Origin: Iouri Belikov, CERN
20// e-mail: Jouri.Belikov@cern.ch
21//-----------------------------------------------------------------
22
23#include "TMath.h"
24
25#include "AliESDVertex.h"
26#include "AliESDtrack.h"
27#include "AliKalmanTrack.h"
28#include "AliTrackPointArray.h"
29#include "AliLog.h"
30
31ClassImp(AliESDtrack)
32
33void SetPIDValues(Float_t * dest, const Double_t * src, Int_t n) {
34 // This function copies "n" PID weights from "scr" to "dest"
35 // and normalizes their sum to 1 thus producing conditional probabilities.
36 // The negative weights are set to 0.
37 // In case all the weights are non-positive they are replaced by
38 // uniform probabilities
39
40 if (n<=0) return;
41
42 Float_t uniform = 1./(Float_t)n;
43
44 Float_t sum = 0;
45 for (Int_t i=0; i<n; i++)
46 if (src[i]>=0) {
47 sum+=src[i];
48 dest[i] = src[i];
49 }
50 else {
51 dest[i] = 0;
52 }
53
54 if(sum>0)
55 for (Int_t i=0; i<n; i++) dest[i] /= sum;
56 else
57 for (Int_t i=0; i<n; i++) dest[i] = uniform;
58}
59
60//_______________________________________________________________________
61AliESDtrack::AliESDtrack() :
62 AliExternalTrackParam(),
63 fFlags(0),
64 fLabel(0),
65 fID(0),
66 fTrackLength(0),
67 fD(0),fZ(0),
68 fCdd(0),fCdz(0),fCzz(0),
69 fStopVertex(0),
70 fCp(0),
71 fCchi2(1e10),
72 fIp(0),
73 fOp(0),
74 fITSchi2(0),
75 fITSncls(0),
76 fITSsignal(0),
77 fITSLabel(0),
78 fITSFakeRatio(0),
79 fITStrack(0),
80 fTPCchi2(0),
81 fTPCncls(0),
82 fTPCnclsF(0),
83 fTPCClusterMap(159),//number of padrows
84 fTPCsignal(0),
85 fTPCsignalN(0),
86 fTPCsignalS(0),
87 fTPCLabel(0),
88 fTRDchi2(0),
89 fTRDncls(0),
90 fTRDncls0(0),
91 fTRDsignal(0),
92 fTRDLabel(0),
93 fTRDQuality(0),
94 fTRDBudget(0),
95 fTRDtrack(0),
96 fTOFchi2(0),
97 fTOFindex(0),
98 fTOFCalChannel(-1),
99 fTOFsignal(-1),
100 fTOFsignalToT(0),
101 // fPHOSsignal(-1),
102 fRICHchi2(1e10),
103 fRICHncls(0),
104 fRICHindex(0),
105 fRICHsignal(-1),
106 fRICHtheta(0),
107 fRICHphi(0),
108 fRICHdx(0),
109 fRICHdy(0),
110 fPoints(0)
111{
112 //
113 // The default ESD constructor
114 //
115 for (Int_t i=0; i<AliPID::kSPECIES; i++) {
116 fTrackTime[i]=0.;
117 fR[i]=1.;
118 fITSr[i]=1.;
119 fTPCr[i]=1.;
120 fTRDr[i]=1.;
121 fTOFr[i]=1.;
122 fRICHr[i]=1.;
123 }
124
125 // for (Int_t i=0; i<AliPID::kSPECIESN; i++) {
126 // fPHOSr[i] = 1.;
127 // }
128 // fPHOSpos[0]=fPHOSpos[1]=fPHOSpos[2]=0.;
129
130 Int_t i;
131 for (i=0; i<12; i++) fITSchi2MIP[i]=1e10;
132 for (i=0; i<12; i++) { fITSindex[i]=-1; }
133 for (i=0; i<180; i++) { fTPCindex[i]=-2; }
134 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
135 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
136 for (i=0; i<180; i++) { fTRDindex[i]=-2; }
137 for (i=0;i<kNPlane;i++) {fTRDsignals[i]=0.; fTRDTimBin[i]=-1;}
138 for (i=0;i<4;i++) {fTPCPoints[i]=-1;}
139 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
140 for (i=0;i<10;i++) {fTOFInfo[i]=-1;}
141 fTPCLabel = 0;
142 fTRDLabel = 0;
143 fTRDQuality =0;
144 fTRDBudget =0;
145 fITSLabel = 0;
146 fITStrack = 0;
147 fTRDtrack = 0;
148}
149
150//_______________________________________________________________________
151AliESDtrack::AliESDtrack(const AliESDtrack& track):
152 AliExternalTrackParam(track),
153 fFlags(track.fFlags),
154 fLabel(track.fLabel),
155 fID(track.fID),
156 fTrackLength(track.fTrackLength),
157 fD(track.fD),fZ(track.fZ),
158 fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
159 fStopVertex(track.fStopVertex),
160 fCp(0),
161 fCchi2(track.fCchi2),
162 fIp(0),
163 fOp(0),
164 fITSchi2(track.fITSchi2),
165 fITSncls(track.fITSncls),
166 fITSsignal(track.fITSsignal),
167 fITSLabel(track.fITSLabel),
168 fITSFakeRatio(track.fITSFakeRatio),
169 fITStrack(0), //coping separatelly - in user code
170 fTPCchi2(track.fTPCchi2),
171 fTPCncls(track.fTPCncls),
172 fTPCnclsF(track.fTPCnclsF),
173 fTPCClusterMap(track.fTPCClusterMap),
174 fTPCsignal(track.fTPCsignal),
175 fTPCsignalN(track.fTPCsignalN),
176 fTPCsignalS(track.fTPCsignalS),
177 fTPCLabel(track.fTPCLabel),
178 fTRDchi2(track.fTRDchi2),
179 fTRDncls(track.fTRDncls),
180 fTRDncls0(track.fTRDncls0),
181 fTRDsignal(track.fTRDsignal),
182 fTRDLabel(track.fTRDLabel),
183 fTRDQuality(track.fTRDQuality),
184 fTRDBudget(track.fTRDBudget),
185 fTRDtrack(0),
186 fTOFchi2(track.fTOFchi2),
187 fTOFindex(track.fTOFindex),
188 fTOFCalChannel(track.fTOFCalChannel),
189 fTOFsignal(track.fTOFsignal),
190 fTOFsignalToT(track.fTOFsignalToT),
191 //fPHOSsignal(track.fPHOSsignal),
192 fRICHchi2(track.fRICHchi2),
193 fRICHncls(track.fRICHncls),
194 fRICHindex(track.fRICHindex),
195 fRICHsignal(track.fRICHsignal),
196 fRICHtheta(track.fRICHtheta),
197 fRICHphi(track.fRICHphi),
198 fRICHdx(track.fRICHdx),
199 fRICHdy(track.fRICHdy)
200{
201 //
202 //copy constructor
203 //
204 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i]=track.fTrackTime[i];
205 for (Int_t i=0;i<AliPID::kSPECIES;i++) fR[i]=track.fR[i];
206 //
207 for (Int_t i=0;i<12;i++) fITSchi2MIP[i]=track.fITSchi2MIP[i];
208 for (Int_t i=0;i<12;i++) fITSindex[i]=track.fITSindex[i];
209 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
210 //
211 for (Int_t i=0;i<180;i++) fTPCindex[i]=track.fTPCindex[i];
212 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[i];
213 for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
214 for (Int_t i=0; i<3;i++) { fKinkIndexes[i]=track.fKinkIndexes[i];}
215 for (Int_t i=0; i<3;i++) { fV0Indexes[i]=track.fV0Indexes[i];}
216 //
217 for (Int_t i=0;i<180;i++) fTRDindex[i]=track.fTRDindex[i];
218 for (Int_t i=0;i<kNPlane;i++) {
219 fTRDsignals[i]=track.fTRDsignals[i];
220 fTRDTimBin[i]=track.fTRDTimBin[i];
221 }
222 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
223 //
224 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
225 for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
226 for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
227 //
228 // for (Int_t i=0;i<3;i++) fPHOSpos[i]=track.fPHOSpos[i];
229 //for (Int_t i=0;i<AliPID::kSPECIESN;i++) fPHOSr[i]=track.fPHOSr[i];
230 //
231 for (Int_t i=0;i<AliPID::kSPECIES;i++) fRICHr[i]=track.fRICHr[i];
232
233 if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
234 if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
235 if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
236 fPoints =0;
237 if (track.fPoints){
238 fPoints = new AliTrackPointArray(*(track.fPoints));
239 }
240}
241//_______________________________________________________________________
242AliESDtrack::~AliESDtrack(){
243 //
244 // This is destructor according Coding Conventrions
245 //
246 //printf("Delete track\n");
247 delete fIp;
248 delete fOp;
249 delete fCp;
250 delete fITStrack;
251 delete fTRDtrack;
252 delete fPoints;
253}
254
255//_______________________________________________________________________
256void AliESDtrack::MakeMiniESDtrack(){
257 // Resets everything except
258 // fFlags: Reconstruction status flags
259 // fLabel: Track label
260 // fID: Unique ID of the track
261 // fD: Impact parameter in XY-plane
262 // fZ: Impact parameter in Z
263 // fR[AliPID::kSPECIES]: combined "detector response probability"
264 // Running track parameters
265 // fRalpha: track rotation angle
266 // fRx: X-coordinate of the track reference plane
267 // fRp[5]: external track parameters
268 // fRc[15]: external cov. matrix of the track parameters
269
270 fTrackLength = 0;
271 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
272 fStopVertex = 0;
273
274 // Reset track parameters constrained to the primary vertex
275 fCp = 0;
276 fCchi2 = 0;
277
278 // Reset track parameters at the inner wall of TPC
279 fIp = 0;
280
281 // Reset track parameters at the inner wall of the TRD
282 fOp = 0;
283
284 // Reset ITS track related information
285 fITSchi2 = 0;
286 for (Int_t i=0;i<12;i++) fITSchi2MIP[i]=0;
287 fITSncls = 0;
288 for (Int_t i=0;i<12;i++) fITSindex[i]=-1;
289 fITSsignal = 0;
290 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
291 fITSLabel = 0;
292 fITSFakeRatio = 0;
293 fITStrack =0;
294
295 // Reset TPC related track information
296 fTPCchi2 = 0;
297 fTPCncls = 0;
298 fTPCnclsF = 0;
299 for (Int_t i=0;i<180;i++) fTPCindex[i] = -2;
300 fTPCClusterMap = 0;
301 fTPCsignal= 0;
302 fTPCsignalS= 0;
303 fTPCsignalN= 0;
304 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=0;
305 fTPCLabel=0;
306 for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
307 for (Int_t i=0; i<3;i++) fKinkIndexes[i] = 0;
308 for (Int_t i=0; i<3;i++) fV0Indexes[i] = 0;
309
310 // Reset TRD related track information
311 fTRDchi2 = 0;
312 fTRDncls = 0;
313 fTRDncls0 = 0;
314 for (Int_t i=0;i<180;i++) fTRDindex[i] = -2;
315 fTRDsignal = 0;
316 for (Int_t i=0;i<kNPlane;i++) {
317 fTRDsignals[i] = 0;
318 fTRDTimBin[i] = 0;
319 }
320 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
321 fTRDLabel = 0;
322 fTRDtrack = 0;
323 fTRDQuality = 0;
324 fTRDBudget = 0;
325
326 // Reset TOF related track information
327 fTOFchi2 = 0;
328 fTOFindex = 0;
329 fTOFsignal = 0;
330 fTOFCalChannel = -1;
331 fTOFsignalToT = 0;
332 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
333 for (Int_t i=0;i<3;i++) fTOFLabel[i] = 0;
334 for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
335
336 // Reset PHOS related track information
337 //for (Int_t i=0;i<3;i++) fPHOSpos[i] = 0;
338 //fPHOSsignal = 0;
339 //for (Int_t i=0;i<AliPID::kSPECIESN;i++) fPHOSr[i] = 0;
340
341 // Reset RICH related track information
342 fRICHchi2 = 0;
343 fRICHncls = 0;
344 fRICHindex = 0;
345 fRICHsignal = 0;
346 for (Int_t i=0;i<AliPID::kSPECIES;i++) fRICHr[i] = 0;
347 fRICHtheta = 0;
348 fRICHphi = 0;
349 fRICHdx = 0;
350 fRICHdy = 0;
351
352 fPoints = 0;
353}
354//_______________________________________________________________________
355Double_t AliESDtrack::GetMass() const {
356 // Returns the mass of the most probable particle type
357 Float_t max=0.;
358 Int_t k=-1;
359 for (Int_t i=0; i<AliPID::kSPECIES; i++) {
360 if (fR[i]>max) {k=i; max=fR[i];}
361 }
362 if (k==0) { // dE/dx "crossing points" in the TPC
363 Double_t p=GetP();
364 if ((p>0.38)&&(p<0.48))
365 if (fR[0]<fR[3]*10.) return AliPID::ParticleMass(AliPID::kKaon);
366 if ((p>0.75)&&(p<0.85))
367 if (fR[0]<fR[4]*10.) return AliPID::ParticleMass(AliPID::kProton);
368 return 0.00051;
369 }
370 if (k==1) return AliPID::ParticleMass(AliPID::kMuon);
371 if (k==2||k==-1) return AliPID::ParticleMass(AliPID::kPion);
372 if (k==3) return AliPID::ParticleMass(AliPID::kKaon);
373 if (k==4) return AliPID::ParticleMass(AliPID::kProton);
374 AliWarning("Undefined mass !");
375 return AliPID::ParticleMass(AliPID::kPion);
376}
377
378//_______________________________________________________________________
379Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
380 //
381 // This function updates track's running parameters
382 //
383 Bool_t rc=kTRUE;
384
385 SetStatus(flags);
386 fLabel=t->GetLabel();
387
388 if (t->IsStartedTimeIntegral()) {
389 SetStatus(kTIME);
390 Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
391 SetIntegratedLength(t->GetIntegratedLength());
392 }
393
394 Set(*t);
395
396 switch (flags) {
397
398 case kITSin: case kITSout: case kITSrefit:
399 fITSncls=t->GetNumberOfClusters();
400 fITSchi2=t->GetChi2();
401 for (Int_t i=0;i<12;i++) fITSindex[i]=t->GetClusterIndex(i);
402 fITSsignal=t->GetPIDsignal();
403 fITSLabel = t->GetLabel();
404 fITSFakeRatio = t->GetFakeRatio();
405 break;
406
407 case kTPCin: case kTPCrefit:
408 fTPCLabel = t->GetLabel();
409 if (!fIp) fIp=new AliExternalTrackParam(*t);
410 else fIp->Set(*t);
411 case kTPCout:
412 if (flags & kTPCout){
413 if (!fOp) fOp=new AliExternalTrackParam(*t);
414 else fOp->Set(*t);
415 }
416 fTPCncls=t->GetNumberOfClusters();
417 fTPCchi2=t->GetChi2();
418
419 {//prevrow must be declared in separate namespace, otherwise compiler cries:
420 //"jump to case label crosses initialization of `Int_t prevrow'"
421 Int_t prevrow = -1;
422 // for (Int_t i=0;i<fTPCncls;i++)
423 for (Int_t i=0;i<160;i++)
424 {
425 fTPCindex[i]=t->GetClusterIndex(i);
426
427 if (fTPCindex[i]<0) continue;
428
429 // Piotr's Cluster Map for HBT
430 // ### please change accordingly if cluster array is changing
431 // to "New TPC Tracking" style (with gaps in array)
432 Int_t idx = fTPCindex[i];
433 Int_t sect = (idx&0xff000000)>>24;
434 Int_t row = (idx&0x00ff0000)>>16;
435 if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
436
437 fTPCClusterMap.SetBitNumber(row,kTRUE);
438
439 //Fill the gap between previous row and this row with 0 bits
440 //In case ### pleas change it as well - just set bit 0 in case there
441 //is no associated clusters for current "i"
442 if (prevrow < 0)
443 {
444 prevrow = row;//if previous bit was not assigned yet == this is the first one
445 }
446 else
447 { //we don't know the order (inner to outer or reverse)
448 //just to be save in case it is going to change
449 Int_t n = 0, m = 0;
450 if (prevrow < row)
451 {
452 n = prevrow;
453 m = row;
454 }
455 else
456 {
457 n = row;
458 m = prevrow;
459 }
460
461 for (Int_t j = n+1; j < m; j++)
462 {
463 fTPCClusterMap.SetBitNumber(j,kFALSE);
464 }
465 prevrow = row;
466 }
467 // End Of Piotr's Cluster Map for HBT
468 }
469 }
470 fTPCsignal=t->GetPIDsignal();
471 break;
472
473 case kTRDout: case kTRDin: case kTRDrefit:
474 fTRDLabel = t->GetLabel();
475 fTRDncls=t->GetNumberOfClusters();
476 fTRDchi2=t->GetChi2();
477 for (Int_t i=0;i<fTRDncls;i++) fTRDindex[i]=t->GetClusterIndex(i);
478 fTRDsignal=t->GetPIDsignal();
479 break;
480 case kTRDbackup:
481 if (!fOp) fOp=new AliExternalTrackParam(*t);
482 else fOp->Set(*t);
483 fTRDncls0 = t->GetNumberOfClusters();
484 break;
485 case kTOFin:
486 break;
487 case kTOFout:
488 break;
489 case kTRDStop:
490 break;
491 default:
492 AliError("Wrong flag !");
493 return kFALSE;
494 }
495
496 return rc;
497}
498
499//_______________________________________________________________________
500void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
501 //---------------------------------------------------------------------
502 // This function returns external representation of the track parameters
503 //---------------------------------------------------------------------
504 x=GetX();
505 for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
506}
507
508//_______________________________________________________________________
509void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
510 //---------------------------------------------------------------------
511 // This function returns external representation of the cov. matrix
512 //---------------------------------------------------------------------
513 for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
514}
515
516//_______________________________________________________________________
517Bool_t AliESDtrack::GetConstrainedExternalParameters
518 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
519 //---------------------------------------------------------------------
520 // This function returns the constrained external track parameters
521 //---------------------------------------------------------------------
522 if (!fCp) return kFALSE;
523 alpha=fCp->GetAlpha();
524 x=fCp->GetX();
525 for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
526 return kTRUE;
527}
528
529//_______________________________________________________________________
530Bool_t
531AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
532 //---------------------------------------------------------------------
533 // This function returns the constrained external cov. matrix
534 //---------------------------------------------------------------------
535 if (!fCp) return kFALSE;
536 for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
537 return kTRUE;
538}
539
540Bool_t
541AliESDtrack::GetInnerExternalParameters
542 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
543 //---------------------------------------------------------------------
544 // This function returns external representation of the track parameters
545 // at the inner layer of TPC
546 //---------------------------------------------------------------------
547 if (!fIp) return kFALSE;
548 alpha=fIp->GetAlpha();
549 x=fIp->GetX();
550 for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
551 return kTRUE;
552}
553
554Bool_t
555AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const {
556 //---------------------------------------------------------------------
557 // This function returns external representation of the cov. matrix
558 // at the inner layer of TPC
559 //---------------------------------------------------------------------
560 if (!fIp) return kFALSE;
561 for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
562 return kTRUE;
563}
564
565Bool_t
566AliESDtrack::GetOuterExternalParameters
567 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
568 //---------------------------------------------------------------------
569 // This function returns external representation of the track parameters
570 // at the inner layer of TRD
571 //---------------------------------------------------------------------
572 if (!fOp) return kFALSE;
573 alpha=fOp->GetAlpha();
574 x=fOp->GetX();
575 for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
576 return kTRUE;
577}
578
579Bool_t
580AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
581 //---------------------------------------------------------------------
582 // This function returns external representation of the cov. matrix
583 // at the inner layer of TRD
584 //---------------------------------------------------------------------
585 if (!fOp) return kFALSE;
586 for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
587 return kTRUE;
588}
589
590Int_t AliESDtrack::GetNcls(Int_t idet) const
591{
592 // Get number of clusters by subdetector index
593 //
594 Int_t ncls = 0;
595 switch(idet){
596 case 0:
597 ncls = fITSncls;
598 break;
599 case 1:
600 ncls = fTPCncls;
601 break;
602 case 2:
603 ncls = fTRDncls;
604 break;
605 case 3:
606 if (fTOFindex != 0)
607 ncls = 1;
608 break;
609 default:
610 break;
611 }
612 return ncls;
613}
614
615Int_t AliESDtrack::GetClusters(Int_t idet, Int_t *idx) const
616{
617 // Get cluster index array by subdetector index
618 //
619 Int_t ncls = 0;
620 switch(idet){
621 case 0:
622 ncls = GetITSclusters(idx);
623 break;
624 case 1:
625 ncls = GetTPCclusters(idx);
626 break;
627 case 2:
628 ncls = GetTRDclusters(idx);
629 break;
630 case 3:
631 if (fTOFindex != 0) {
632 idx[0] = GetTOFcluster();
633 ncls = 1;
634 }
635 break;
636 default:
637 break;
638 }
639 return ncls;
640}
641
642//_______________________________________________________________________
643void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
644 // Returns the array with integrated times for each particle hypothesis
645 for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
646}
647
648//_______________________________________________________________________
649void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
650 // Sets the array with integrated times for each particle hypotesis
651 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
652}
653
654//_______________________________________________________________________
655void AliESDtrack::SetITSpid(const Double_t *p) {
656 // Sets values for the probability of each particle type (in ITS)
657 SetPIDValues(fITSr,p,AliPID::kSPECIES);
658 SetStatus(AliESDtrack::kITSpid);
659}
660
661void AliESDtrack::SetITSChi2MIP(const Float_t *chi2mip){
662 for (Int_t i=0; i<12; i++) fITSchi2MIP[i]=chi2mip[i];
663}
664//_______________________________________________________________________
665void AliESDtrack::GetITSpid(Double_t *p) const {
666 // Gets the probability of each particle type (in ITS)
667 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
668}
669
670//_______________________________________________________________________
671Int_t AliESDtrack::GetITSclusters(Int_t *idx) const {
672 //---------------------------------------------------------------------
673 // This function returns indices of the assgined ITS clusters
674 //---------------------------------------------------------------------
675 for (Int_t i=0; i<12; i++) idx[i]=fITSindex[i];
676 return fITSncls;
677}
678
679//_______________________________________________________________________
680Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
681 //---------------------------------------------------------------------
682 // This function returns indices of the assgined ITS clusters
683 //---------------------------------------------------------------------
684 if (idx!=0)
685 for (Int_t i=0; i<180; i++) idx[i]=fTPCindex[i]; // MI I prefer some constant
686 return fTPCncls;
687}
688
689Float_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
690 //
691 // GetDensity of the clusters on given region between row0 and row1
692 // Dead zone effect takin into acoount
693 //
694 Int_t good = 0;
695 Int_t found = 0;
696 //
697 for (Int_t i=row0;i<=row1;i++){
698 Int_t index = fTPCindex[i];
699 if (index!=-1) good++; // track outside of dead zone
700 if (index>0) found++;
701 }
702 Float_t density=0.5;
703 if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
704 return density;
705}
706
707//_______________________________________________________________________
708void AliESDtrack::SetTPCpid(const Double_t *p) {
709 // Sets values for the probability of each particle type (in TPC)
710 SetPIDValues(fTPCr,p,AliPID::kSPECIES);
711 SetStatus(AliESDtrack::kTPCpid);
712}
713
714//_______________________________________________________________________
715void AliESDtrack::GetTPCpid(Double_t *p) const {
716 // Gets the probability of each particle type (in TPC)
717 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
718}
719
720//_______________________________________________________________________
721Int_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
722 //---------------------------------------------------------------------
723 // This function returns indices of the assgined TRD clusters
724 //---------------------------------------------------------------------
725 if (idx!=0)
726 for (Int_t i=0; i<180; i++) idx[i]=fTRDindex[i]; // MI I prefer some constant
727 return fTRDncls;
728}
729
730//_______________________________________________________________________
731void AliESDtrack::SetTRDpid(const Double_t *p) {
732 // Sets values for the probability of each particle type (in TRD)
733 SetPIDValues(fTRDr,p,AliPID::kSPECIES);
734 SetStatus(AliESDtrack::kTRDpid);
735}
736
737//_______________________________________________________________________
738void AliESDtrack::GetTRDpid(Double_t *p) const {
739 // Gets the probability of each particle type (in TRD)
740 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
741}
742
743//_______________________________________________________________________
744void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
745{
746 // Sets the probability of particle type iSpecies to p (in TRD)
747 fTRDr[iSpecies] = p;
748}
749
750Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
751{
752 // Returns the probability of particle type iSpecies (in TRD)
753 return fTRDr[iSpecies];
754}
755
756//_______________________________________________________________________
757void AliESDtrack::SetTOFpid(const Double_t *p) {
758 // Sets the probability of each particle type (in TOF)
759 SetPIDValues(fTOFr,p,AliPID::kSPECIES);
760 SetStatus(AliESDtrack::kTOFpid);
761}
762
763//_______________________________________________________________________
764void AliESDtrack::SetTOFLabel(const Int_t *p) {
765 // Sets (in TOF)
766 for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
767}
768
769//_______________________________________________________________________
770void AliESDtrack::GetTOFpid(Double_t *p) const {
771 // Gets probabilities of each particle type (in TOF)
772 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
773}
774
775//_______________________________________________________________________
776void AliESDtrack::GetTOFLabel(Int_t *p) const {
777 // Gets (in TOF)
778 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
779}
780
781//_______________________________________________________________________
782void AliESDtrack::GetTOFInfo(Float_t *info) const {
783 // Gets (in TOF)
784 for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
785}
786
787//_______________________________________________________________________
788void AliESDtrack::SetTOFInfo(Float_t*info) {
789 // Gets (in TOF)
790 for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
791}
792
793
794
795//_______________________________________________________________________
796void AliESDtrack::SetRICHpid(const Double_t *p) {
797 // Sets the probability of each particle type (in RICH)
798 SetPIDValues(fRICHr,p,AliPID::kSPECIES);
799 SetStatus(AliESDtrack::kRICHpid);
800}
801
802//_______________________________________________________________________
803void AliESDtrack::GetRICHpid(Double_t *p) const {
804 // Gets probabilities of each particle type (in RICH)
805 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fRICHr[i];
806}
807
808
809
810//_______________________________________________________________________
811void AliESDtrack::SetESDpid(const Double_t *p) {
812 // Sets the probability of each particle type for the ESD track
813 SetPIDValues(fR,p,AliPID::kSPECIES);
814 SetStatus(AliESDtrack::kESDpid);
815}
816
817//_______________________________________________________________________
818void AliESDtrack::GetESDpid(Double_t *p) const {
819 // Gets probability of each particle type for the ESD track
820 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
821}
822
823//_______________________________________________________________________
824Bool_t AliESDtrack::RelateToVertex
825(const AliESDVertex *vtx, Double_t b, Double_t maxd) {
826 //
827 // Try to relate this track to the vertex "vtx",
828 // if the (rough) transverse impact parameter is not bigger then "maxd".
829 // Magnetic field is "b" (kG).
830 //
831 // a) The track gets extapolated to the DCA to the vertex.
832 // b) The impact parameters and their covariance matrix are calculated.
833 // c) An attempt to constrain this track to the vertex is done.
834 //
835 // In the case of success, the returned value is kTRUE
836 // (otherwise, it's kFALSE)
837 //
838 Double_t alpha=GetAlpha();
839 Double_t sn=TMath::Sin(alpha), cs=TMath::Cos(alpha);
840 Double_t x=GetX(), y=GetParameter()[0], snp=GetParameter()[2];
841 Double_t xv= vtx->GetXv()*cs + vtx->GetYv()*sn;
842 Double_t yv=-vtx->GetXv()*sn + vtx->GetYv()*cs, zv=vtx->GetZv();
843 x-=xv; y-=yv;
844
845 //Estimate the impact parameter neglecting the track curvature
846 Double_t d=TMath::Abs(x*snp - y*TMath::Sqrt(1.- snp*snp));
847 if (d > maxd) return kFALSE;
848
849 //Propagate to the DCA
850 Double_t crv=0.299792458e-3*b*GetParameter()[4];
851 Double_t tgfv=-(crv*x - snp)/(crv*y + TMath::Sqrt(1.-snp*snp));
852 sn=tgfv/TMath::Sqrt(1.+ tgfv*tgfv); cs=TMath::Sqrt(1.- sn*sn);
853
854 x = xv*cs + yv*sn;
855 yv=-xv*sn + yv*cs; xv=x;
856
857 if (!Propagate(alpha+TMath::ASin(sn),xv,b)) return kFALSE;
858
859 fD = GetParameter()[0] - yv;
860 fZ = GetParameter()[1] - zv;
861
862 Double_t cov[6]; vtx->GetCovMatrix(cov);
863 fCdd = GetCovariance()[0] + cov[2]; // neglecting non-diagonals
864 fCdz = GetCovariance()[1]; // in the vertex's
865 fCzz = GetCovariance()[2] + cov[5]; // covariance matrix
866
867 {//Try to constrain
868 Double_t p[2]={yv,zv}, c[3]={cov[2],0.,cov[5]};
869 Double_t chi2=GetPredictedChi2(p,c);
870
871 if (chi2>77.) return kFALSE;
872
873 AliExternalTrackParam tmp(*this);
874 if (!tmp.Update(p,c)) return kFALSE;
875
876 fCchi2=chi2;
877 if (!fCp) fCp=new AliExternalTrackParam();
878 new (fCp) AliExternalTrackParam(tmp);
879 }
880
881 return kTRUE;
882}
883
884//_______________________________________________________________________
885void AliESDtrack::Print(Option_t *) const {
886 // Prints info on the track
887
888 printf("ESD track info\n") ;
889 Double_t p[AliPID::kSPECIESN] ;
890 Int_t index = 0 ;
891 if( IsOn(kITSpid) ){
892 printf("From ITS: ") ;
893 GetITSpid(p) ;
894 for(index = 0 ; index < AliPID::kSPECIES; index++)
895 printf("%f, ", p[index]) ;
896 printf("\n signal = %f\n", GetITSsignal()) ;
897 }
898 if( IsOn(kTPCpid) ){
899 printf("From TPC: ") ;
900 GetTPCpid(p) ;
901 for(index = 0 ; index < AliPID::kSPECIES; index++)
902 printf("%f, ", p[index]) ;
903 printf("\n signal = %f\n", GetTPCsignal()) ;
904 }
905 if( IsOn(kTRDpid) ){
906 printf("From TRD: ") ;
907 GetTRDpid(p) ;
908 for(index = 0 ; index < AliPID::kSPECIES; index++)
909 printf("%f, ", p[index]) ;
910 printf("\n signal = %f\n", GetTRDsignal()) ;
911 }
912 if( IsOn(kTOFpid) ){
913 printf("From TOF: ") ;
914 GetTOFpid(p) ;
915 for(index = 0 ; index < AliPID::kSPECIES; index++)
916 printf("%f, ", p[index]) ;
917 printf("\n signal = %f\n", GetTOFsignal()) ;
918 }
919 if( IsOn(kRICHpid) ){
920 printf("From RICH: ") ;
921 GetRICHpid(p) ;
922 for(index = 0 ; index < AliPID::kSPECIES; index++)
923 printf("%f, ", p[index]) ;
924 printf("\n signal = %f\n", GetRICHsignal()) ;
925 }
926}