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