ZDC information added
[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"
704be597 24#include "TString.h"
ae982df3 25
26#include "AliESDtrack.h"
27#include "AliKalmanTrack.h"
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");
195 if (fITStrack) delete fITStrack;
196 if (fTRDtrack) delete fTRDtrack;
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;
219 Warning("GetMass()","Undefined mass !");
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:
363 Error("UpdateTrackParams()","Wrong flag !\n");
364 return kFALSE;
365 }
366
ae982df3 367 return kTRUE;
368}
369
67c3dcbe 370//_______________________________________________________________________
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
ae982df3 387//_______________________________________________________________________
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
704be597 526void AliESDtrack::GetOuterPxPyPz(Double_t *p, TString det) 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. ;
532 if (det == "PHOS") {
533 if (fOx==0)
534 return;
535 Double_t phi=TMath::ASin(fOp[2]) + fOalpha;
536 Double_t pt=1./TMath::Abs(fOp[4]);
537 p[0]=pt*TMath::Cos(phi);
538 p[1]=pt*TMath::Sin(phi);
539 p[2]=pt*fOp[3];
540 }
541 else if (det == "EMCAL" ) {
542 if (fXx==0)
543 return;
544 Double_t phi=TMath::ASin(fXp[2]) + fXalpha;
545 Double_t pt=1./TMath::Abs(fXp[4]);
546 p[0]=pt*TMath::Cos(phi);
547 p[1]=pt*TMath::Sin(phi);
548 p[2]=pt*fXp[3];
549 }
550 else
551 Warning("GetOuterPxPyPz", "Only valid for PHOS or EMCAL") ;
672b5f43 552}
553
704be597 554void AliESDtrack::GetOuterXYZ(Double_t *xyz, TString det) const {
672b5f43 555 //---------------------------------------------------------------------
556 // This function returns the global track position
704be597 557 // af the radius of the PHOS/EMCAL
558 //---------------------------------------------------------------------
559 xyz[0]=xyz[1]=xyz[2]=0.;
560 if ( det == "PHOS" ) {
561 if (fOx==0)
562 return;
563 Double_t phi=TMath::ATan2(fOp[0],fOx) + fOalpha;
564 Double_t r=TMath::Sqrt(fOx*fOx + fOp[0]*fOp[0]);
565 xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fOp[1];
566 }
567 else if ( det == "EMCAL" ) {
568 if (fXx==0)
569 return;
570 Double_t phi=TMath::ATan2(fXp[0],fOx) + fXalpha;
571 Double_t r=TMath::Sqrt(fXx*fXx + fXp[0]*fXp[0]);
572 xyz[0]=r*TMath::Cos(phi);
573 xyz[1]=r*TMath::Sin(phi);
574 xyz[2]=fXp[1];
575 }
672b5f43 576}
577
ae982df3 578//_______________________________________________________________________
579void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
4427806c 580 // Returns the array with integrated times for each particle hypothesis
ae982df3 581 for (Int_t i=0; i<kSPECIES; i++) times[i]=fTrackTime[i];
582}
583
584//_______________________________________________________________________
585void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
4427806c 586 // Sets the array with integrated times for each particle hypotesis
ae982df3 587 for (Int_t i=0; i<kSPECIES; i++) fTrackTime[i]=times[i];
588}
589
c630aafd 590//_______________________________________________________________________
4427806c 591void AliESDtrack::SetITSpid(const Double_t *p) {
592 // Sets values for the probability of each particle type (in ITS)
c630aafd 593 for (Int_t i=0; i<kSPECIES; i++) fITSr[i]=p[i];
594 SetStatus(AliESDtrack::kITSpid);
595}
596
babd135a 597void AliESDtrack::SetITSChi2MIP(const Float_t *chi2mip){
c4d11b15 598 for (Int_t i=0; i<12; i++) fITSchi2MIP[i]=chi2mip[i];
babd135a 599}
c630aafd 600//_______________________________________________________________________
601void AliESDtrack::GetITSpid(Double_t *p) const {
4427806c 602 // Gets the probability of each particle type (in ITS)
c630aafd 603 for (Int_t i=0; i<kSPECIES; i++) p[i]=fITSr[i];
604}
605
ae982df3 606//_______________________________________________________________________
607Int_t AliESDtrack::GetITSclusters(UInt_t *idx) const {
608 //---------------------------------------------------------------------
609 // This function returns indices of the assgined ITS clusters
610 //---------------------------------------------------------------------
611 for (Int_t i=0; i<fITSncls; i++) idx[i]=fITSindex[i];
612 return fITSncls;
613}
614
615//_______________________________________________________________________
05e445cd 616Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
ae982df3 617 //---------------------------------------------------------------------
618 // This function returns indices of the assgined ITS clusters
619 //---------------------------------------------------------------------
d1420ddf 620 if (idx!=0)
621 for (Int_t i=0; i<180; i++) idx[i]=fTPCindex[i]; // MI I prefer some constant
ae982df3 622 return fTPCncls;
623}
8c6a71ab 624
625//_______________________________________________________________________
626void AliESDtrack::SetTPCpid(const Double_t *p) {
4427806c 627 // Sets values for the probability of each particle type (in TPC)
8c6a71ab 628 for (Int_t i=0; i<kSPECIES; i++) fTPCr[i]=p[i];
629 SetStatus(AliESDtrack::kTPCpid);
630}
631
632//_______________________________________________________________________
633void AliESDtrack::GetTPCpid(Double_t *p) const {
4427806c 634 // Gets the probability of each particle type (in TPC)
8c6a71ab 635 for (Int_t i=0; i<kSPECIES; i++) p[i]=fTPCr[i];
636}
637
bb2ceb1f 638//_______________________________________________________________________
639Int_t AliESDtrack::GetTRDclusters(UInt_t *idx) const {
640 //---------------------------------------------------------------------
641 // This function returns indices of the assgined TRD clusters
642 //---------------------------------------------------------------------
d1420ddf 643 if (idx!=0)
c4d11b15 644 for (Int_t i=0; i<130; i++) idx[i]=fTRDindex[i]; // MI I prefer some constant
bb2ceb1f 645 return fTRDncls;
646}
647
c630aafd 648//_______________________________________________________________________
649void AliESDtrack::SetTRDpid(const Double_t *p) {
4427806c 650 // Sets values for the probability of each particle type (in TRD)
c630aafd 651 for (Int_t i=0; i<kSPECIES; i++) fTRDr[i]=p[i];
652 SetStatus(AliESDtrack::kTRDpid);
653}
654
655//_______________________________________________________________________
656void AliESDtrack::GetTRDpid(Double_t *p) const {
4427806c 657 // Gets the probability of each particle type (in TRD)
c630aafd 658 for (Int_t i=0; i<kSPECIES; i++) p[i]=fTRDr[i];
659}
660
79e94bf8 661//_______________________________________________________________________
662void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
663{
4427806c 664 // Sets the probability of particle type iSpecies to p (in TRD)
79e94bf8 665 fTRDr[iSpecies] = p;
666}
667
668Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
669{
4427806c 670 // Returns the probability of particle type iSpecies (in TRD)
79e94bf8 671 return fTRDr[iSpecies];
672}
673
c630aafd 674//_______________________________________________________________________
675void AliESDtrack::SetTOFpid(const Double_t *p) {
4427806c 676 // Sets the probability of each particle type (in TOF)
c630aafd 677 for (Int_t i=0; i<kSPECIES; i++) fTOFr[i]=p[i];
678 SetStatus(AliESDtrack::kTOFpid);
679}
680
681//_______________________________________________________________________
682void AliESDtrack::GetTOFpid(Double_t *p) const {
4427806c 683 // Gets probabilities of each particle type (in TOF)
c630aafd 684 for (Int_t i=0; i<kSPECIES; i++) p[i]=fTOFr[i];
685}
686
4a78b8c5 687
688
689//_______________________________________________________________________
690void AliESDtrack::SetPHOSpid(const Double_t *p) {
691 // Sets the probability of each particle type (in PHOS)
ac2f7574 692 for (Int_t i=0; i<kSPECIESN; i++) fPHOSr[i]=p[i];
4a78b8c5 693 SetStatus(AliESDtrack::kPHOSpid);
694}
695
696//_______________________________________________________________________
697void AliESDtrack::GetPHOSpid(Double_t *p) const {
698 // Gets probabilities of each particle type (in PHOS)
ac2f7574 699 for (Int_t i=0; i<kSPECIESN; i++) p[i]=fPHOSr[i];
4a78b8c5 700}
701
704be597 702//_______________________________________________________________________
703void AliESDtrack::SetEMCALpid(const Double_t *p) {
704 // Sets the probability of each particle type (in EMCAL)
705 for (Int_t i=0; i<kSPECIESN; i++) fEMCALr[i]=p[i];
706 SetStatus(AliESDtrack::kEMCALpid);
707}
708
709//_______________________________________________________________________
710void AliESDtrack::GetEMCALpid(Double_t *p) const {
711 // Gets probabilities of each particle type (in EMCAL)
712 for (Int_t i=0; i<kSPECIESN; i++) p[i]=fEMCALr[i];
713}
4a78b8c5 714
715//_______________________________________________________________________
716void AliESDtrack::SetRICHpid(const Double_t *p) {
717 // Sets the probability of each particle type (in RICH)
718 for (Int_t i=0; i<kSPECIES; i++) fRICHr[i]=p[i];
719 SetStatus(AliESDtrack::kRICHpid);
720}
721
722//_______________________________________________________________________
723void AliESDtrack::GetRICHpid(Double_t *p) const {
724 // Gets probabilities of each particle type (in RICH)
725 for (Int_t i=0; i<kSPECIES; i++) p[i]=fRICHr[i];
726}
727
728
729
8c6a71ab 730//_______________________________________________________________________
731void AliESDtrack::SetESDpid(const Double_t *p) {
4427806c 732 // Sets the probability of each particle type for the ESD track
8c6a71ab 733 for (Int_t i=0; i<kSPECIES; i++) fR[i]=p[i];
734 SetStatus(AliESDtrack::kESDpid);
735}
736
737//_______________________________________________________________________
738void AliESDtrack::GetESDpid(Double_t *p) const {
4427806c 739 // Gets probability of each particle type for the ESD track
8c6a71ab 740 for (Int_t i=0; i<kSPECIES; i++) p[i]=fR[i];
741}
742
ac2f7574 743//_______________________________________________________________________
744void AliESDtrack::Print(Option_t *) const {
745 // Prints info on the track
746
747 Info("Print","Track info") ;
748 Double_t p[kSPECIESN] ;
749 Int_t index = 0 ;
750 if( IsOn(kITSpid) ){
751 printf("From ITS: ") ;
752 GetITSpid(p) ;
753 for(index = 0 ; index < kSPECIES; index++)
754 printf("%f, ", p[index]) ;
755 printf("\n signal = %f\n", GetITSsignal()) ;
756 }
757 if( IsOn(kTPCpid) ){
758 printf("From TPC: ") ;
759 GetTPCpid(p) ;
760 for(index = 0 ; index < kSPECIES; index++)
761 printf("%f, ", p[index]) ;
762 printf("\n signal = %f\n", GetTPCsignal()) ;
763 }
764 if( IsOn(kTRDpid) ){
765 printf("From TRD: ") ;
766 GetTRDpid(p) ;
767 for(index = 0 ; index < kSPECIES; index++)
768 printf("%f, ", p[index]) ;
769 printf("\n signal = %f\n", GetTRDsignal()) ;
770 }
771 if( IsOn(kTOFpid) ){
772 printf("From TOF: ") ;
773 GetTOFpid(p) ;
774 for(index = 0 ; index < kSPECIES; index++)
775 printf("%f, ", p[index]) ;
776 printf("\n signal = %f\n", GetTOFsignal()) ;
777 }
778 if( IsOn(kRICHpid) ){
779 printf("From TOF: ") ;
780 GetRICHpid(p) ;
781 for(index = 0 ; index < kSPECIES; index++)
782 printf("%f, ", p[index]) ;
783 printf("\n signal = %f\n", GetRICHsignal()) ;
784 }
785 if( IsOn(kPHOSpid) ){
786 printf("From PHOS: ") ;
787 GetPHOSpid(p) ;
788 for(index = 0 ; index < kSPECIESN; index++)
789 printf("%f, ", p[index]) ;
790 printf("\n signal = %f\n", GetPHOSsignal()) ;
791 }
704be597 792 if( IsOn(kEMCALpid) ){
793 printf("From EMCAL: ") ;
794 GetEMCALpid(p) ;
795 for(index = 0 ; index < kSPECIESN; index++)
796 printf("%f, ", p[index]) ;
797 printf("\n signal = %f\n", GetEMCALsignal()) ;
798 }
ac2f7574 799}