Typo
[u/mrichter/AliRoot.git] / STEER / AliESDtrack.cxx
CommitLineData
ae982df3 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 **************************************************************************/
ae982df3 15//-----------------------------------------------------------------
16// Implementation of the ESD track class
4427806c 17// ESD = Event Summary Data
ae982df3 18// This is the class to deal with during the phisical analysis of data
4427806c 19// Origin: Iouri Belikov, CERN
20// e-mail: Jouri.Belikov@cern.ch
ae982df3 21//-----------------------------------------------------------------
22
23#include "TMath.h"
24
25#include "AliESDtrack.h"
26#include "AliKalmanTrack.h"
5f7789fc 27#include "AliLog.h"
ae982df3 28
29ClassImp(AliESDtrack)
30
31//_______________________________________________________________________
32AliESDtrack::AliESDtrack() :
2bad268c 33fFlags(0),
34fLabel(0),
35fTrackLength(0),
36fStopVertex(0),
37fRalpha(0),
38fRx(0),
a866ac60 39fCalpha(0),
40fCx(0),
67c3dcbe 41fCchi2(1e10),
a866ac60 42fIalpha(0),
43fIx(0),
c4d11b15 44fTalpha(0),
45fTx(0),
a866ac60 46fOalpha(0),
47fOx(0),
2bad268c 48fITSchi2(0),
ae982df3 49fITSncls(0),
2bad268c 50fITSsignal(0),
2bad268c 51fTPCchi2(0),
05e445cd 52fTPCncls(0),
a866ac60 53fTPCClusterMap(159),//number of padrows
2bad268c 54fTPCsignal(0),
55fTRDchi2(0),
56fTRDncls(0),
c4d11b15 57fTRDncls0(0),
2bad268c 58fTRDsignal(0),
59fTOFchi2(0),
60fTOFindex(0),
4a78b8c5 61fTOFsignal(-1),
62fPHOSsignal(-1),
704be597 63fEMCALsignal(-1),
4a78b8c5 64fRICHsignal(-1)
ae982df3 65{
66 //
67 // The default ESD constructor
68 //
2bad268c 69 for (Int_t i=0; i<kSPECIES; i++) {
4a78b8c5 70 fTrackTime[i]=0.;
71 fR[i]=1.;
72 fITSr[i]=1.;
73 fTPCr[i]=1.;
74 fTRDr[i]=1.;
75 fTOFr[i]=1.;
4a78b8c5 76 fRICHr[i]=1.;
2bad268c 77 }
ac2f7574 78
704be597 79 for (Int_t i=0; i<kSPECIESN; i++) {
80 fPHOSr[i] = 1.;
81 fEMCALr[i] = 1.;
82 }
83
ac2f7574 84
4a78b8c5 85 fPHOSpos[0]=fPHOSpos[1]=fPHOSpos[2]=0.;
704be597 86 fEMCALpos[0]=fEMCALpos[1]=fEMCALpos[2]=0.;
bb2ceb1f 87 Int_t i;
c4d11b15 88 for (i=0; i<5; i++) { fRp[i]=0.; fCp[i]=0.; fIp[i]=0.; fOp[i]=0.; fTp[i]=0.;}
89 for (i=0; i<15; i++) { fRc[i]=0.; fCc[i]=0.; fIc[i]=0.; fOc[i]=0.; fTc[i]=0.; }
a866ac60 90 for (i=0; i<6; i++) { fITSindex[i]=0; }
91 for (i=0; i<180; i++){ fTPCindex[i]=0; }
c4d11b15 92 for (i=0; i<130; i++) { fTRDindex[i]=0; }
6e5b1b04 93 fTPCLabel = 0;
94 fTRDLabel = 0;
95 fITSLabel = 0;
c4d11b15 96 fITStrack = 0;
97 fTRDtrack = 0;
98}
99
100//_______________________________________________________________________
101
102AliESDtrack::AliESDtrack(const AliESDtrack& track):TObject(track){
103 //
104 //copy constructor
105 //
106 fFlags = track.fFlags;
107 fLabel =track.fLabel;
108 fTrackLength =track.fTrackLength;
109 for (Int_t i=0;i<kSPECIES;i++) fTrackTime[i] =track.fTrackTime[i];
110 for (Int_t i=0;i<kSPECIES;i++) fR[i] =track.fR[i];
111 fStopVertex =track.fStopVertex;
112 //
113 fRalpha =track.fRalpha;
114 fRx =track.fRx;
115 for (Int_t i=0;i<5;i++) fRp[i] =track.fRp[i];
116 for (Int_t i=0;i<15;i++) fRc[i] =track.fRc[i];
117 //
118 fCalpha =track.fCalpha;
119 fCx =track.fCx;
120 for (Int_t i=0;i<5;i++) fCp[i] =track.fCp[i];
121 for (Int_t i=0;i<15;i++) fCc[i] =track.fCc[i];
122 fCchi2 =track.fCchi2;
123 //
124 fIalpha =track.fIalpha;
125 fIx =track.fIx;
126 for (Int_t i=0;i<5;i++) fIp[i] =track.fIp[i];
127 for (Int_t i=0;i<15;i++) fIc[i] =track.fIc[i];
128 //
129 fTalpha =track.fTalpha;
130 fTx =track.fTx;
131 for (Int_t i=0;i<5;i++) fTp[i] =track.fTp[i];
132 for (Int_t i=0;i<15;i++) fTc[i] =track.fTc[i];
133 //
134 fOalpha =track.fOalpha;
135 fOx =track.fOx;
136 for (Int_t i=0;i<5;i++) fOp[i] =track.fOp[i];
137 for (Int_t i=0;i<15;i++) fOc[i] =track.fOc[i];
138 //
139 fXalpha =track.fXalpha;
140 fXx =track.fXx;
141 for (Int_t i=0;i<5;i++) fXp[i] =track.fXp[i];
142 for (Int_t i=0;i<15;i++) fXc[i] =track.fXc[i];
143 //
144 fITSchi2 =track.fITSchi2;
145 for (Int_t i=0;i<12;i++) fITSchi2MIP[i] =track.fITSchi2MIP[i];
146 fITSncls =track.fITSncls;
147 for (Int_t i=0;i<6;i++) fITSindex[i]=track.fITSindex[i];
148 fITSsignal =track.fITSsignal;
149 for (Int_t i=0;i<kSPECIES;i++) fITSr[i]=track.fITSr[i];
150 fITSLabel =track.fITSLabel;
151 fITSFakeRatio =track.fITSFakeRatio;
152 fITStrack =0; //coping separatelly - in user code
153 //
154 fTPCchi2 =track.fTPCchi2;
155 fTPCncls =track.fTPCncls;
156 for (Int_t i=0;i<180;i++) fTPCindex[i]=track.fTPCindex[i];
157 fTPCClusterMap=track.fTPCClusterMap;
158 fTPCsignal=track.fTPCsignal;
159 for (Int_t i=0;i<kSPECIES;i++) fTPCr[i]=track.fTPCr[i];
160 fTPCLabel=track.fTPCLabel;
161 //
162 fTRDchi2=track.fTRDchi2;
163 fTRDncls=track.fTRDncls;
164 fTRDncls0=track.fTRDncls0;
165 for (Int_t i=0;i<130;i++) fTRDindex[i]=track.fTRDindex[i];
166 fTRDsignal=track.fTRDsignal;
167 for (Int_t i=0;i<kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
168 fTRDLabel=track.fTRDLabel;
169 fTRDtrack=0;
170 //
171 fTOFchi2=track.fTOFchi2;
172 fTOFindex=track.fTOFindex;
173 fTOFsignal=track.fTOFsignal;
174 for (Int_t i=0;i<kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
175 //
176 for (Int_t i=0;i<3;i++) fPHOSpos[i]=track.fPHOSpos[i];
177 fPHOSsignal=track.fPHOSsignal;
4162b1d0 178 for (Int_t i=0;i<kSPECIESN;i++) fPHOSr[i]=track.fPHOSr[i];
c4d11b15 179 //
180 for (Int_t i=0;i<3;i++) fEMCALpos[i]=track.fEMCALpos[i];
181 fEMCALsignal=track.fEMCALsignal;
4162b1d0 182 for (Int_t i=0;i<kSPECIESN;i++) fEMCALr[i]=track.fEMCALr[i];
c4d11b15 183 //
184 fRICHsignal=track.fRICHsignal;
185 for (Int_t i=0;i<kSPECIES;i++) fRICHr[i]=track.fRICHr[i];
186
ac2f7574 187
ae982df3 188}
c4d11b15 189//_______________________________________________________________________
190AliESDtrack::~AliESDtrack(){
191 //
192 // This is destructor according Coding Conventrions
193 //
194 //printf("Delete track\n");
3fd96ae3 195 delete fITStrack;
196 delete fTRDtrack;
c4d11b15 197}
ae982df3 198
199//_______________________________________________________________________
4a78b8c5 200Double_t AliESDtrack::GetMass() const {
4427806c 201 // Returns the mass of the most probable particle type
ae982df3 202 Float_t max=0.;
203 Int_t k=-1;
204 for (Int_t i=0; i<kSPECIES; i++) {
205 if (fR[i]>max) {k=i; max=fR[i];}
206 }
db3989b3 207 if (k==0) { // dE/dx "crossing points" in the TPC
208 Double_t p=GetP();
209 if ((p>0.38)&&(p<0.48))
210 if (fR[0]<fR[3]*10.) return 0.49368;
211 if ((p>0.75)&&(p<0.85))
212 if (fR[0]<fR[4]*10.) return 0.93827;
213 return 0.00051;
214 }
c4d11b15 215 if (k==1) return 0.10566;
ae982df3 216 if (k==2||k==-1) return 0.13957;
217 if (k==3) return 0.49368;
218 if (k==4) return 0.93827;
5f7789fc 219 AliWarning("Undefined mass !");
ae982df3 220 return 0.13957;
221}
222
223//_______________________________________________________________________
ad2f1f2b 224Bool_t AliESDtrack::UpdateTrackParams(AliKalmanTrack *t, ULong_t flags) {
ae982df3 225 //
226 // This function updates track's running parameters
227 //
9b859005 228 SetStatus(flags);
229 fLabel=t->GetLabel();
230
231 if (t->IsStartedTimeIntegral()) {
232 SetStatus(kTIME);
233 Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
234 SetIntegratedLength(t->GetIntegratedLength());
235 }
236
237 fRalpha=t->GetAlpha();
238 t->GetExternalParameters(fRx,fRp);
239 t->GetExternalCovariance(fRc);
240
ae982df3 241 switch (flags) {
ad2f1f2b 242
9b859005 243 case kITSin: case kITSout: case kITSrefit:
ae982df3 244 fITSncls=t->GetNumberOfClusters();
245 fITSchi2=t->GetChi2();
246 for (Int_t i=0;i<fITSncls;i++) fITSindex[i]=t->GetClusterIndex(i);
247 fITSsignal=t->GetPIDsignal();
6e5b1b04 248 fITSLabel = t->GetLabel();
babd135a 249 fITSFakeRatio = t->GetFakeRatio();
ae982df3 250 break;
ad2f1f2b 251
9b859005 252 case kTPCin: case kTPCrefit:
6e5b1b04 253 fTPCLabel = t->GetLabel();
9b859005 254 fIalpha=fRalpha;
255 fIx=fRx;
256 {
257 Int_t i;
258 for (i=0; i<5; i++) fIp[i]=fRp[i];
259 for (i=0; i<15;i++) fIc[i]=fRc[i];
260 }
261 case kTPCout:
a866ac60 262
ae982df3 263 fTPCncls=t->GetNumberOfClusters();
264 fTPCchi2=t->GetChi2();
a866ac60 265
266 {//prevrow must be declared in separate namespace, otherwise compiler cries:
267 //"jump to case label crosses initialization of `Int_t prevrow'"
268 Int_t prevrow = -1;
6e5b1b04 269 // for (Int_t i=0;i<fTPCncls;i++)
270 for (Int_t i=0;i<160;i++)
a866ac60 271 {
272 fTPCindex[i]=t->GetClusterIndex(i);
273
274 // Piotr's Cluster Map for HBT
275 // ### please change accordingly if cluster array is changing
276 // to "New TPC Tracking" style (with gaps in array)
277 Int_t idx = fTPCindex[i];
278 Int_t sect = (idx&0xff000000)>>24;
279 Int_t row = (idx&0x00ff0000)>>16;
280 if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
281
282 fTPCClusterMap.SetBitNumber(row,kTRUE);
283
284 //Fill the gap between previous row and this row with 0 bits
285 //In case ### pleas change it as well - just set bit 0 in case there
286 //is no associated clusters for current "i"
287 if (prevrow < 0)
288 {
289 prevrow = row;//if previous bit was not assigned yet == this is the first one
290 }
291 else
292 { //we don't know the order (inner to outer or reverse)
293 //just to be save in case it is going to change
294 Int_t n = 0, m = 0;
295 if (prevrow < row)
296 {
297 n = prevrow;
298 m = row;
299 }
300 else
301 {
302 n = row;
303 m = prevrow;
304 }
305
306 for (Int_t j = n+1; j < m; j++)
307 {
308 fTPCClusterMap.SetBitNumber(j,kFALSE);
309 }
310 prevrow = row;
311 }
312 // End Of Piotr's Cluster Map for HBT
313 }
314 }
ae982df3 315 fTPCsignal=t->GetPIDsignal();
316 {Double_t mass=t->GetMass(); // preliminary mass setting
317 if (mass>0.5) fR[4]=1.; // used by
318 else if (mass<0.4) fR[2]=1.; // the ITS reconstruction
a866ac60 319 else fR[3]=1.;}
320 //
ae982df3 321 break;
9b859005 322
672b5f43 323 case kTRDout:
704be597 324 { //requested by the PHOS/EMCAL ("temporary solution")
db3989b3 325 Int_t i;
326 Double_t x=460.,buf[15];
327 if (t->PropagateTo(x,30.,0.)) {
e964f790 328 fOalpha=t->GetAlpha();
db3989b3 329 t->GetExternalParameters(x,buf); fOx=x;
330 for (i=0; i<5; i++) fOp[i]=buf[i];
331 t->GetExternalCovariance(buf);
332 for (i=0; i<15; i++) fOc[i]=buf[i];
e964f790 333 }
db3989b3 334 x=450.;
335 if (t->PropagateTo(x,30.,0.)) {
704be597 336 fXalpha=t->GetAlpha();
db3989b3 337 t->GetExternalParameters(x,buf); fXx=x;
338 for (i=0; i<5; i++) fXp[i]=buf[i];
339 t->GetExternalCovariance(buf);
340 for (i=0; i<15; i++) fXc[i]=buf[i];
704be597 341 }
672b5f43 342 }
343 case kTRDin: case kTRDrefit:
6e5b1b04 344 fTRDLabel = t->GetLabel();
c4d11b15 345
79e94bf8 346 fTRDncls=t->GetNumberOfClusters();
347 fTRDchi2=t->GetChi2();
bb2ceb1f 348 for (Int_t i=0;i<fTRDncls;i++) fTRDindex[i]=t->GetClusterIndex(i);
79e94bf8 349 fTRDsignal=t->GetPIDsignal();
350 break;
c4d11b15 351 case kTRDbackup:
352 t->GetExternalParameters(fTx,fTp);
353 t->GetExternalCovariance(fTc);
354 fTRDncls0 = t->GetNumberOfClusters();
355 break;
356 case kTOFin:
357 break;
358 case kTOFout:
359 break;
d0862fea 360 case kTRDStop:
361 break;
ae982df3 362 default:
5f7789fc 363 AliError("Wrong flag !");
ae982df3 364 return kFALSE;
365 }
366
ae982df3 367 return kTRUE;
368}
369
370//_______________________________________________________________________
67c3dcbe 371void
372AliESDtrack::SetConstrainedTrackParams(AliKalmanTrack *t, Double_t chi2) {
373 //
374 // This function sets the constrained track parameters
375 //
db3989b3 376 Int_t i;
377 Double_t x,buf[15];
67c3dcbe 378 fCalpha=t->GetAlpha();
db3989b3 379 t->GetExternalParameters(x,buf); fCx=x;
380 for (i=0; i<5; i++) fCp[i]=buf[i];
381 t->GetExternalCovariance(buf);
382 for (i=0; i<15; i++) fCc[i]=buf[i];
67c3dcbe 383 fCchi2=chi2;
384}
385
386
387//_______________________________________________________________________
ae982df3 388void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
389 //---------------------------------------------------------------------
390 // This function returns external representation of the track parameters
391 //---------------------------------------------------------------------
392 x=fRx;
393 for (Int_t i=0; i<5; i++) p[i]=fRp[i];
394}
67c3dcbe 395//_______________________________________________________________________
a866ac60 396void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
67c3dcbe 397 //---------------------------------------------------------------------
398 // This function returns external representation of the cov. matrix
399 //---------------------------------------------------------------------
a866ac60 400 for (Int_t i=0; i<15; i++) cov[i]=fRc[i];
67c3dcbe 401}
402
403
404//_______________________________________________________________________
405void
406AliESDtrack::GetConstrainedExternalParameters(Double_t &x, Double_t p[5])const{
407 //---------------------------------------------------------------------
408 // This function returns the constrained external track parameters
409 //---------------------------------------------------------------------
410 x=fCx;
411 for (Int_t i=0; i<5; i++) p[i]=fCp[i];
412}
413//_______________________________________________________________________
414void
415AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
416 //---------------------------------------------------------------------
417 // This function returns the constrained external cov. matrix
418 //---------------------------------------------------------------------
419 for (Int_t i=0; i<15; i++) c[i]=fCc[i];
420}
421
ae982df3 422
423Double_t AliESDtrack::GetP() const {
424 //---------------------------------------------------------------------
425 // This function returns the track momentum
426 //---------------------------------------------------------------------
2157f4f2 427 if (TMath::Abs(fRp[4])<=0) return 0;
ae982df3 428 Double_t pt=1./TMath::Abs(fRp[4]);
5bc70ad8 429 return pt*TMath::Sqrt(1.+ fRp[3]*fRp[3]);
ae982df3 430}
431
67c3dcbe 432void AliESDtrack::GetConstrainedPxPyPz(Double_t *p) const {
433 //---------------------------------------------------------------------
434 // This function returns the constrained global track momentum components
435 //---------------------------------------------------------------------
2157f4f2 436 if (TMath::Abs(fCp[4])<=0) {
437 p[0]=p[1]=p[2]=0;
438 return;
439 }
67c3dcbe 440 Double_t phi=TMath::ASin(fCp[2]) + fCalpha;
441 Double_t pt=1./TMath::Abs(fCp[4]);
442 p[0]=pt*TMath::Cos(phi); p[1]=pt*TMath::Sin(phi); p[2]=pt*fCp[3];
443}
444void AliESDtrack::GetConstrainedXYZ(Double_t *xyz) const {
445 //---------------------------------------------------------------------
446 // This function returns the global track position
447 //---------------------------------------------------------------------
448 Double_t phi=TMath::ATan2(fCp[0],fCx) + fCalpha;
449 Double_t r=TMath::Sqrt(fCx*fCx + fCp[0]*fCp[0]);
450 xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fCp[1];
451}
452
ae982df3 453void AliESDtrack::GetPxPyPz(Double_t *p) const {
454 //---------------------------------------------------------------------
455 // This function returns the global track momentum components
456 //---------------------------------------------------------------------
2157f4f2 457 if (TMath::Abs(fRp[4])<=0) {
458 p[0]=p[1]=p[2]=0;
459 return;
460 }
ae982df3 461 Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
462 Double_t pt=1./TMath::Abs(fRp[4]);
463 p[0]=pt*TMath::Cos(phi); p[1]=pt*TMath::Sin(phi); p[2]=pt*fRp[3];
464}
ae982df3 465void AliESDtrack::GetXYZ(Double_t *xyz) const {
466 //---------------------------------------------------------------------
467 // This function returns the global track position
468 //---------------------------------------------------------------------
bb2ceb1f 469 Double_t phi=TMath::ATan2(fRp[0],fRx) + fRalpha;
ae982df3 470 Double_t r=TMath::Sqrt(fRx*fRx + fRp[0]*fRp[0]);
471 xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fRp[1];
472}
473
67c3dcbe 474
9b859005 475void AliESDtrack::GetInnerPxPyPz(Double_t *p) const {
476 //---------------------------------------------------------------------
477 // This function returns the global track momentum components
478 // af the entrance of the TPC
479 //---------------------------------------------------------------------
e964f790 480 if (fIx==0) {p[0]=p[1]=p[2]=0.; return;}
9b859005 481 Double_t phi=TMath::ASin(fIp[2]) + fIalpha;
482 Double_t pt=1./TMath::Abs(fIp[4]);
483 p[0]=pt*TMath::Cos(phi); p[1]=pt*TMath::Sin(phi); p[2]=pt*fIp[3];
484}
485
486void AliESDtrack::GetInnerXYZ(Double_t *xyz) const {
487 //---------------------------------------------------------------------
488 // This function returns the global track position
489 // af the entrance of the TPC
490 //---------------------------------------------------------------------
e964f790 491 if (fIx==0) {xyz[0]=xyz[1]=xyz[2]=0.; return;}
9b859005 492 Double_t phi=TMath::ATan2(fIp[0],fIx) + fIalpha;
493 Double_t r=TMath::Sqrt(fIx*fIx + fIp[0]*fIp[0]);
494 xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fIp[1];
495}
496
a866ac60 497void AliESDtrack::GetInnerExternalParameters(Double_t &x, Double_t p[5]) const
498{
499 //skowron
500 //---------------------------------------------------------------------
501 // This function returns external representation of the track parameters at Inner Layer of TPC
502 //---------------------------------------------------------------------
503 x=fIx;
504 for (Int_t i=0; i<5; i++) p[i]=fIp[i];
505}
506void AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const
507{
508 //skowron
509 //---------------------------------------------------------------------
510 // This function returns external representation of the cov. matrix at Inner Layer of TPC
511 //---------------------------------------------------------------------
512 for (Int_t i=0; i<15; i++) cov[i]=fIc[i];
513
514}
515
c4d11b15 516void AliESDtrack::GetTRDExternalParameters(Double_t &x, Double_t p[5], Double_t cov[15]) const
517{
518 //
519 //this function returns TRD parameters
520 //
521 x=fTx;
522 for (Int_t i=0; i<5; i++) p[i]=fTp[i];
523 for (Int_t i=0; i<15; i++) cov[i]=fTc[i];
524}
525
3fd96ae3 526void AliESDtrack::GetOuterPxPyPzPHOS(Double_t *p) const {
672b5f43 527 //---------------------------------------------------------------------
528 // This function returns the global track momentum components
529 // af the radius of the PHOS
530 //---------------------------------------------------------------------
704be597 531 p[0]=p[1]=p[2]=0. ;
3fd96ae3 532 if (fOx==0)
533 return;
534 Double_t phi=TMath::ASin(fOp[2]) + fOalpha;
535 Double_t pt=1./TMath::Abs(fOp[4]);
536 p[0]=pt*TMath::Cos(phi);
537 p[1]=pt*TMath::Sin(phi);
538 p[2]=pt*fOp[3];
539}
540void AliESDtrack::GetOuterPxPyPzEMCAL(Double_t *p) const {
541 //---------------------------------------------------------------------
542 // This function returns the global track momentum components
543 // af the radius of the EMCAL
544 //---------------------------------------------------------------------
545 if (fXx==0)
546 return;
547 Double_t phi=TMath::ASin(fXp[2]) + fXalpha;
548 Double_t pt=1./TMath::Abs(fXp[4]);
549 p[0]=pt*TMath::Cos(phi);
550 p[1]=pt*TMath::Sin(phi);
551 p[2]=pt*fXp[3];
672b5f43 552}
553
3fd96ae3 554void AliESDtrack::GetOuterXYZPHOS(Double_t *xyz) const {
672b5f43 555 //---------------------------------------------------------------------
556 // This function returns the global track position
3fd96ae3 557 // af the radius of the PHOS
704be597 558 //---------------------------------------------------------------------
559 xyz[0]=xyz[1]=xyz[2]=0.;
3fd96ae3 560 if (fOx==0)
561 return;
562 Double_t phi=TMath::ATan2(fOp[0],fOx) + fOalpha;
563 Double_t r=TMath::Sqrt(fOx*fOx + fOp[0]*fOp[0]);
564 xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fOp[1];
565}
566void AliESDtrack::GetOuterXYZEMCAL(Double_t *xyz) const {
567 //---------------------------------------------------------------------
568 // This function returns the global track position
569 // af the radius of the EMCAL
570 //---------------------------------------------------------------------
571 if (fXx==0)
572 return;
573 Double_t phi=TMath::ATan2(fXp[0],fOx) + fXalpha;
574 Double_t r=TMath::Sqrt(fXx*fXx + fXp[0]*fXp[0]);
575 xyz[0]=r*TMath::Cos(phi);
576 xyz[1]=r*TMath::Sin(phi);
577 xyz[2]=fXp[1];
578}
672b5f43 579
ae982df3 580//_______________________________________________________________________
ae982df3 581void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
4427806c 582 // Returns the array with integrated times for each particle hypothesis
ae982df3 583 for (Int_t i=0; i<kSPECIES; i++) times[i]=fTrackTime[i];
584}
585
586//_______________________________________________________________________
587void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
4427806c 588 // Sets the array with integrated times for each particle hypotesis
ae982df3 589 for (Int_t i=0; i<kSPECIES; i++) fTrackTime[i]=times[i];
590}
591
592//_______________________________________________________________________
4427806c 593void AliESDtrack::SetITSpid(const Double_t *p) {
594 // Sets values for the probability of each particle type (in ITS)
c630aafd 595 for (Int_t i=0; i<kSPECIES; i++) fITSr[i]=p[i];
596 SetStatus(AliESDtrack::kITSpid);
597}
598
babd135a 599void AliESDtrack::SetITSChi2MIP(const Float_t *chi2mip){
c4d11b15 600 for (Int_t i=0; i<12; i++) fITSchi2MIP[i]=chi2mip[i];
babd135a 601}
c630aafd 602//_______________________________________________________________________
603void AliESDtrack::GetITSpid(Double_t *p) const {
4427806c 604 // Gets the probability of each particle type (in ITS)
c630aafd 605 for (Int_t i=0; i<kSPECIES; i++) p[i]=fITSr[i];
606}
607
608//_______________________________________________________________________
ae982df3 609Int_t AliESDtrack::GetITSclusters(UInt_t *idx) const {
610 //---------------------------------------------------------------------
611 // This function returns indices of the assgined ITS clusters
612 //---------------------------------------------------------------------
613 for (Int_t i=0; i<fITSncls; i++) idx[i]=fITSindex[i];
614 return fITSncls;
615}
616
617//_______________________________________________________________________
05e445cd 618Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
ae982df3 619 //---------------------------------------------------------------------
620 // This function returns indices of the assgined ITS clusters
621 //---------------------------------------------------------------------
d1420ddf 622 if (idx!=0)
623 for (Int_t i=0; i<180; i++) idx[i]=fTPCindex[i]; // MI I prefer some constant
ae982df3 624 return fTPCncls;
625}
8c6a71ab 626
627//_______________________________________________________________________
628void AliESDtrack::SetTPCpid(const Double_t *p) {
4427806c 629 // Sets values for the probability of each particle type (in TPC)
8c6a71ab 630 for (Int_t i=0; i<kSPECIES; i++) fTPCr[i]=p[i];
631 SetStatus(AliESDtrack::kTPCpid);
632}
633
634//_______________________________________________________________________
635void AliESDtrack::GetTPCpid(Double_t *p) const {
4427806c 636 // Gets the probability of each particle type (in TPC)
8c6a71ab 637 for (Int_t i=0; i<kSPECIES; i++) p[i]=fTPCr[i];
638}
639
640//_______________________________________________________________________
bb2ceb1f 641Int_t AliESDtrack::GetTRDclusters(UInt_t *idx) const {
642 //---------------------------------------------------------------------
643 // This function returns indices of the assgined TRD clusters
644 //---------------------------------------------------------------------
d1420ddf 645 if (idx!=0)
c4d11b15 646 for (Int_t i=0; i<130; i++) idx[i]=fTRDindex[i]; // MI I prefer some constant
bb2ceb1f 647 return fTRDncls;
648}
649
650//_______________________________________________________________________
c630aafd 651void AliESDtrack::SetTRDpid(const Double_t *p) {
4427806c 652 // Sets values for the probability of each particle type (in TRD)
c630aafd 653 for (Int_t i=0; i<kSPECIES; i++) fTRDr[i]=p[i];
654 SetStatus(AliESDtrack::kTRDpid);
655}
656
657//_______________________________________________________________________
658void AliESDtrack::GetTRDpid(Double_t *p) const {
4427806c 659 // Gets the probability of each particle type (in TRD)
c630aafd 660 for (Int_t i=0; i<kSPECIES; i++) p[i]=fTRDr[i];
661}
662
663//_______________________________________________________________________
79e94bf8 664void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
665{
4427806c 666 // Sets the probability of particle type iSpecies to p (in TRD)
79e94bf8 667 fTRDr[iSpecies] = p;
668}
669
670Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
671{
4427806c 672 // Returns the probability of particle type iSpecies (in TRD)
79e94bf8 673 return fTRDr[iSpecies];
674}
675
676//_______________________________________________________________________
c630aafd 677void AliESDtrack::SetTOFpid(const Double_t *p) {
4427806c 678 // Sets the probability of each particle type (in TOF)
c630aafd 679 for (Int_t i=0; i<kSPECIES; i++) fTOFr[i]=p[i];
680 SetStatus(AliESDtrack::kTOFpid);
681}
682
683//_______________________________________________________________________
684void AliESDtrack::GetTOFpid(Double_t *p) const {
4427806c 685 // Gets probabilities of each particle type (in TOF)
c630aafd 686 for (Int_t i=0; i<kSPECIES; i++) p[i]=fTOFr[i];
687}
688
4a78b8c5 689
690
691//_______________________________________________________________________
692void AliESDtrack::SetPHOSpid(const Double_t *p) {
693 // Sets the probability of each particle type (in PHOS)
ac2f7574 694 for (Int_t i=0; i<kSPECIESN; i++) fPHOSr[i]=p[i];
4a78b8c5 695 SetStatus(AliESDtrack::kPHOSpid);
696}
697
698//_______________________________________________________________________
699void AliESDtrack::GetPHOSpid(Double_t *p) const {
700 // Gets probabilities of each particle type (in PHOS)
ac2f7574 701 for (Int_t i=0; i<kSPECIESN; i++) p[i]=fPHOSr[i];
4a78b8c5 702}
703
704be597 704//_______________________________________________________________________
705void AliESDtrack::SetEMCALpid(const Double_t *p) {
706 // Sets the probability of each particle type (in EMCAL)
707 for (Int_t i=0; i<kSPECIESN; i++) fEMCALr[i]=p[i];
708 SetStatus(AliESDtrack::kEMCALpid);
709}
710
711//_______________________________________________________________________
712void AliESDtrack::GetEMCALpid(Double_t *p) const {
713 // Gets probabilities of each particle type (in EMCAL)
714 for (Int_t i=0; i<kSPECIESN; i++) p[i]=fEMCALr[i];
715}
4a78b8c5 716
717//_______________________________________________________________________
718void AliESDtrack::SetRICHpid(const Double_t *p) {
719 // Sets the probability of each particle type (in RICH)
720 for (Int_t i=0; i<kSPECIES; i++) fRICHr[i]=p[i];
721 SetStatus(AliESDtrack::kRICHpid);
722}
723
724//_______________________________________________________________________
725void AliESDtrack::GetRICHpid(Double_t *p) const {
726 // Gets probabilities of each particle type (in RICH)
727 for (Int_t i=0; i<kSPECIES; i++) p[i]=fRICHr[i];
728}
729
730
731
c630aafd 732//_______________________________________________________________________
8c6a71ab 733void AliESDtrack::SetESDpid(const Double_t *p) {
4427806c 734 // Sets the probability of each particle type for the ESD track
8c6a71ab 735 for (Int_t i=0; i<kSPECIES; i++) fR[i]=p[i];
736 SetStatus(AliESDtrack::kESDpid);
737}
738
739//_______________________________________________________________________
740void AliESDtrack::GetESDpid(Double_t *p) const {
4427806c 741 // Gets probability of each particle type for the ESD track
8c6a71ab 742 for (Int_t i=0; i<kSPECIES; i++) p[i]=fR[i];
743}
744
ac2f7574 745//_______________________________________________________________________
746void AliESDtrack::Print(Option_t *) const {
747 // Prints info on the track
748
5f7789fc 749 printf("ESD track info\n") ;
ac2f7574 750 Double_t p[kSPECIESN] ;
751 Int_t index = 0 ;
752 if( IsOn(kITSpid) ){
753 printf("From ITS: ") ;
754 GetITSpid(p) ;
755 for(index = 0 ; index < kSPECIES; index++)
756 printf("%f, ", p[index]) ;
757 printf("\n signal = %f\n", GetITSsignal()) ;
758 }
759 if( IsOn(kTPCpid) ){
760 printf("From TPC: ") ;
761 GetTPCpid(p) ;
762 for(index = 0 ; index < kSPECIES; index++)
763 printf("%f, ", p[index]) ;
764 printf("\n signal = %f\n", GetTPCsignal()) ;
765 }
766 if( IsOn(kTRDpid) ){
767 printf("From TRD: ") ;
768 GetTRDpid(p) ;
769 for(index = 0 ; index < kSPECIES; index++)
770 printf("%f, ", p[index]) ;
771 printf("\n signal = %f\n", GetTRDsignal()) ;
772 }
773 if( IsOn(kTOFpid) ){
774 printf("From TOF: ") ;
775 GetTOFpid(p) ;
776 for(index = 0 ; index < kSPECIES; index++)
777 printf("%f, ", p[index]) ;
778 printf("\n signal = %f\n", GetTOFsignal()) ;
779 }
780 if( IsOn(kRICHpid) ){
781 printf("From TOF: ") ;
782 GetRICHpid(p) ;
783 for(index = 0 ; index < kSPECIES; index++)
784 printf("%f, ", p[index]) ;
785 printf("\n signal = %f\n", GetRICHsignal()) ;
786 }
787 if( IsOn(kPHOSpid) ){
788 printf("From PHOS: ") ;
789 GetPHOSpid(p) ;
790 for(index = 0 ; index < kSPECIESN; index++)
791 printf("%f, ", p[index]) ;
792 printf("\n signal = %f\n", GetPHOSsignal()) ;
793 }
704be597 794 if( IsOn(kEMCALpid) ){
795 printf("From EMCAL: ") ;
796 GetEMCALpid(p) ;
797 for(index = 0 ; index < kSPECIESN; index++)
798 printf("%f, ", p[index]) ;
799 printf("\n signal = %f\n", GetEMCALsignal()) ;
800 }
ac2f7574 801}