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