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 phisics analysis of data
  19 //      Origin: Iouri Belikov, CERN
  20 //      e-mail: Jouri.Belikov@cern.ch
  21 //-----------------------------------------------------------------
  22
  23 #include "TMath.h"
  24
  25 #include "AliESDtrack.h"
  26 #include "AliKalmanTrack.h"
  27 #include "AliLog.h"
  28
  29 ClassImp(AliESDtrack)
  30
  31 //_______________________________________________________________________
  32 AliESDtrack::AliESDtrack() :
  33   TObject(),
  34   fFlags(0),
  35   fLabel(0),
  36   fID(0),
  37   fTrackLength(0),
  38   fD(0),
  39   fZ(0),
  40   fStopVertex(0),
  41   fRalpha(0),
  42   fRx(0),
  43   fCalpha(0),
  44   fCx(0),
  45   fCchi2(1e10),
  46   fIalpha(0),
  47   fIx(0),
  48   fTalpha(0),
  49   fTx(0),
  50   fITSchi2(0),
  51   fITSncls(0),
  52   fITSsignal(0),
  53   fITSLabel(0),
  54   fITSFakeRatio(0),
  55   fITStrack(0),
  56   fTPCchi2(0),
  57   fTPCncls(0),
  58   fTPCClusterMap(159),//number of padrows
  59   fTPCsignal(0),
  60   fTPCLabel(0),
  61   fTRDchi2(0),
  62   fTRDncls(0),
  63   fTRDncls0(0),
  64   fTRDsignal(0),
  65   fTRDLabel(0),
  66   fTRDQuality(0),
  67   fTRDtrack(0),
  68   fTOFchi2(0),
  69   fTOFindex(0),
  70   fTOFsignal(-1),
  71   fPHOSsignal(-1),
  72   fEMCALsignal(-1),
  73   fRICHchi2(1e10),
  74   fRICHncls(0),
  75   fRICHindex(0),
  76   fRICHsignal(-1),
  77   fRICHtheta(0),
  78   fRICHphi(0),
  79   fRICHdx(0),
  80   fRICHdy(0)
  81 {
  82   //
  83   // The default ESD constructor
  84   //
  85   for (Int_t i=0; i<AliPID::kSPECIES; i++) {
  86     fTrackTime[i]=0.;
  87     fR[i]=1.;
  88     fITSr[i]=1.;
  89     fTPCr[i]=1.;
  90     fTRDr[i]=1.;
  91     fTOFr[i]=1.;
  92     fRICHr[i]=1.;
  93   }
  94
  95   for (Int_t i=0; i<AliPID::kSPECIESN; i++) {
  96     fPHOSr[i]  = 1.;
  97     fEMCALr[i] = 1.;
  98   }
  99
 100
 101   fPHOSpos[0]=fPHOSpos[1]=fPHOSpos[2]=0.;
 102   fEMCALpos[0]=fEMCALpos[1]=fEMCALpos[2]=0.;
 103   Int_t i;
 104   for (i=0; i<5; i++)  {
 105     fRp[i]=fCp[i]=fIp[i]=fTp[i]=0.;
 106   }
 107   for (i=0; i<15; i++) {
 108     fRc[i]=fCc[i]=fIc[i]=fTc[i]=0.;
 109   }
 110   for (i=0; i<6; i++)  { fITSindex[i]=0; }
 111   for (i=0; i<180; i++){ fTPCindex[i]=0; }
 112   for (i=0; i<3;i++)   { fKinkIndexes[i]=0;}
 113   for (i=0; i<3;i++)   { fV0Indexes[i]=-1;}
 114   for (i=0; i<130; i++) { fTRDindex[i]=0; }
 115   for (i=0;i<kNPlane;i++) {fTRDsignals[i]=0.; fTRDTimBin[i]=-1;}
 116   for (Int_t i=0;i<4;i++) {fTPCPoints[i]=-1;}
 117   for (Int_t i=0;i<3;i++) {fTOFLabel[i]=-1;}
 118   for (Int_t i=0;i<10;i++) {fTOFInfo[i]=-1;}
 119   fTPCLabel = 0;
 120   fTRDLabel = 0;
 121   fTRDQuality =0;
 122   fITSLabel = 0;
 123   fITStrack = 0;
 124   fTRDtrack = 0;
 125 }
 126
 127 //_______________________________________________________________________
 128 AliESDtrack::AliESDtrack(const AliESDtrack& track):
 129   TObject(track),
 130   fFlags(track.fFlags),
 131   fLabel(track.fLabel),
 132   fID(track.fID),
 133   fTrackLength(track.fTrackLength),
 134   fD(track.fD),
 135   fZ(track.fZ),
 136   fStopVertex(track.fStopVertex),
 137   fRalpha(track.fRalpha),
 138   fRx(track.fRx),
 139   fCalpha(track.fCalpha),
 140   fCx(track.fCx),
 141   fCchi2(track.fCchi2),
 142   fIalpha(track.fIalpha),
 143   fIx(track.fIx),
 144   fTalpha(track.fTalpha),
 145   fTx(track.fTx),
 146   fITSchi2(track.fITSchi2),
 147   fITSncls(track.fITSncls),
 148   fITSsignal(track.fITSsignal),
 149   fITSLabel(track.fITSLabel),
 150   fITSFakeRatio(track.fITSFakeRatio),
 151   fITStrack(0),    //coping separatelly - in user code
 152   fTPCchi2(track.fTPCchi2),
 153   fTPCncls(track.fTPCncls),
 154   fTPCClusterMap(track.fTPCClusterMap),
 155   fTPCsignal(track.fTPCsignal),
 156   fTPCLabel(track.fTPCLabel),
 157   fTRDchi2(track.fTRDchi2),
 158   fTRDncls(track.fTRDncls),
 159   fTRDncls0(track.fTRDncls0),
 160   fTRDsignal(track.fTRDsignal),
 161   fTRDLabel(track.fTRDLabel),
 162   fTRDQuality(track.fTRDQuality),
 163   fTRDtrack(0),
 164   fTOFchi2(track.fTOFchi2),
 165   fTOFindex(track.fTOFindex),
 166   fTOFsignal(track.fTOFsignal),
 167   fPHOSsignal(track.fPHOSsignal),
 168   fEMCALsignal(track.fEMCALsignal),
 169   fRICHchi2(track.fRICHchi2),
 170   fRICHncls(track.fRICHncls),
 171   fRICHindex(track.fRICHindex),
 172   fRICHsignal(track.fRICHsignal),
 173   fRICHtheta(track.fRICHtheta),
 174   fRICHphi(track.fRICHphi),
 175   fRICHdx(track.fRICHdx),
 176   fRICHdy(track.fRICHdy)
 177 {
 178   //
 179   //copy constructor
 180   //
 181   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] =track.fTrackTime[i];
 182   for (Int_t i=0;i<AliPID::kSPECIES;i++)  fR[i] =track.fR[i];
 183   //
 184   for (Int_t i=0;i<5;i++) fRp[i] =track.fRp[i];
 185   for (Int_t i=0;i<15;i++) fRc[i] =track.fRc[i];
 186   //
 187   for (Int_t i=0;i<5;i++) fCp[i] =track.fCp[i];
 188   for (Int_t i=0;i<15;i++)  fCc[i] =track.fCc[i];
 189   //
 190   for (Int_t i=0;i<5;i++) fIp[i] =track.fIp[i];
 191   for (Int_t i=0;i<15;i++)  fIc[i] =track.fIc[i];
 192   //
 193   for (Int_t i=0;i<5;i++) fTp[i] =track.fTp[i];
 194   for (Int_t i=0;i<15;i++)  fTc[i] =track.fTc[i];
 195   //
 196   for (Int_t i=0;i<12;i++) fITSchi2MIP[i] =track.fITSchi2MIP[i];
 197   for (Int_t i=0;i<6;i++) fITSindex[i]=track.fITSindex[i];
 198   for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
 199   //
 200   for (Int_t i=0;i<180;i++) fTPCindex[i]=track.fTPCindex[i];
 201   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[i];
 202   for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
 203   for (Int_t i=0; i<3;i++)   { fKinkIndexes[i]=track.fKinkIndexes[i];}
 204   for (Int_t i=0; i<3;i++)   { fV0Indexes[i]=track.fV0Indexes[i];}
 205   //
 206   for (Int_t i=0;i<130;i++) fTRDindex[i]=track.fTRDindex[i];
 207   for (Int_t i=0;i<kNPlane;i++) {
 208       fTRDsignals[i]=track.fTRDsignals[i];
 209       fTRDTimBin[i]=track.fTRDTimBin[i];
 210   }
 211   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
 212   //
 213   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
 214   for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
 215   for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
 216   //
 217   for (Int_t i=0;i<3;i++) fPHOSpos[i]=track.fPHOSpos[i];
 218   for (Int_t i=0;i<AliPID::kSPECIESN;i++) fPHOSr[i]=track.fPHOSr[i];
 219   //
 220   for (Int_t i=0;i<3;i++) fEMCALpos[i]=track.fEMCALpos[i];
 221   for (Int_t i=0;i<AliPID::kSPECIESN;i++) fEMCALr[i]=track.fEMCALr[i];
 222   //
 223   for (Int_t i=0;i<AliPID::kSPECIES;i++) fRICHr[i]=track.fRICHr[i];
 224 }
 225 //_______________________________________________________________________
 226 AliESDtrack::~AliESDtrack(){
 227   //
 228   // This is destructor according Coding Conventrions
 229   //
 230   //printf("Delete track\n");
 231   delete fITStrack;
 232   delete fTRDtrack;
 233 }
 234
 235 //_______________________________________________________________________
 236 void AliESDtrack::MakeMiniESDtrack(){
 237   // Resets everything except
 238   // fFlags: Reconstruction status flags
 239   // fLabel: Track label
 240   // fID:  Unique ID of the track
 241   // fD: Impact parameter in XY-plane
 242   // fZ: Impact parameter in Z
 243   // fR[AliPID::kSPECIES]: combined "detector response probability"
 244   // Running track parameters
 245   // fRalpha: track rotation angle
 246   // fRx: X-coordinate of the track reference plane
 247   // fRp[5]: external track parameters
 248   // fRc[15]: external cov. matrix of the track parameters
 249
 250   fTrackLength = 0;
 251   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
 252   fStopVertex = 0;
 253
 254   // Reset track parameters constrained to the primary vertex
 255   fCalpha = 0;
 256   fCx = 0;
 257   for (Int_t i=0;i<5;i++) fCp[i] = 0;
 258   for (Int_t i=0;i<15;i++)  fCc[i] = 0;
 259   fCchi2 = 0;
 260
 261   // Reset track parameters at the inner wall of TPC
 262   fIalpha = 0;
 263   fIx = 0;
 264   for (Int_t i=0;i<5;i++) fIp[i] = 0;
 265   for (Int_t i=0;i<15;i++)  fIc[i] = 0;
 266
 267   // Reset track parameters at the inner wall of the TRD
 268   fTalpha = 0;
 269   fTx = 0;
 270   for (Int_t i=0;i<5;i++) fTp[i] = 0;
 271   for (Int_t i=0;i<15;i++)  fTc[i] = 0;
 272
 273   // Reset ITS track related information
 274   fITSchi2 = 0;
 275   for (Int_t i=0;i<12;i++) fITSchi2MIP[i] = 0;
 276   fITSncls = 0;
 277   for (Int_t i=0;i<6;i++) fITSindex[i]= 0;
 278   fITSsignal = 0;
 279   for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]= 0;
 280   fITSLabel = 0;
 281   fITSFakeRatio = 0;
 282   fITStrack =0;
 283
 284   // Reset TPC related track information
 285   fTPCchi2 = 0;
 286   fTPCncls = 0;
 287   for (Int_t i=0;i<180;i++) fTPCindex[i] = 0;
 288   fTPCClusterMap = 0;
 289   fTPCsignal= 0;
 290   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=0;
 291   fTPCLabel=0;
 292   for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
 293   for (Int_t i=0; i<3;i++)   fKinkIndexes[i] = 0;
 294   for (Int_t i=0; i<3;i++)   fV0Indexes[i] = 0;
 295
 296   // Reset TRD related track information
 297   fTRDchi2 = 0;
 298   fTRDncls = 0;
 299   fTRDncls0 = 0;
 300   for (Int_t i=0;i<130;i++) fTRDindex[i] = 0;
 301   fTRDsignal = 0;
 302   for (Int_t i=0;i<kNPlane;i++) {
 303       fTRDsignals[i] = 0;
 304       fTRDTimBin[i]  = 0;
 305   }
 306   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
 307   fTRDLabel = 0;
 308   fTRDtrack = 0;
 309   fTRDQuality  = 0;
 310
 311   // Reset TOF related track information
 312   fTOFchi2 = 0;
 313   fTOFindex = 0;
 314   fTOFsignal = 0;
 315   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
 316   for (Int_t i=0;i<3;i++) fTOFLabel[i] = 0;
 317   for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
 318
 319   // Reset PHOS related track information
 320   for (Int_t i=0;i<3;i++) fPHOSpos[i] = 0;
 321   fPHOSsignal = 0;
 322   for (Int_t i=0;i<AliPID::kSPECIESN;i++) fPHOSr[i] = 0;
 323
 324   // Reset EMCAL related track information
 325   for (Int_t i=0;i<3;i++) fEMCALpos[i] = 0;
 326   fEMCALsignal = 0;
 327   for (Int_t i=0;i<AliPID::kSPECIESN;i++) fEMCALr[i] = 0;
 328
 329   // Reset RICH related track information
 330   fRICHchi2 = 0;
 331   fRICHncls = 0;
 332   fRICHindex = 0;
 333   fRICHsignal = 0;
 334   for (Int_t i=0;i<AliPID::kSPECIES;i++) fRICHr[i] = 0;
 335   fRICHtheta = 0;
 336   fRICHphi = 0;
 337   fRICHdx = 0;
 338   fRICHdy = 0;
 339
 340 }
 341 //_______________________________________________________________________
 342 Double_t AliESDtrack::GetMass() const {
 343   // Returns the mass of the most probable particle type
 344   Float_t max=0.;
 345   Int_t k=-1;
 346   for (Int_t i=0; i<AliPID::kSPECIES; i++) {
 347     if (fR[i]>max) {k=i; max=fR[i];}
 348   }
 349   if (k==0) { // dE/dx "crossing points" in the TPC
 350      Double_t p=GetP();
 351      if ((p>0.38)&&(p<0.48))
 352         if (fR[0]<fR[3]*10.) return AliPID::ParticleMass(AliPID::kKaon);
 353      if ((p>0.75)&&(p<0.85))
 354         if (fR[0]<fR[4]*10.) return AliPID::ParticleMass(AliPID::kProton);
 355      return 0.00051;
 356   }
 357   if (k==1) return AliPID::ParticleMass(AliPID::kMuon);
 358   if (k==2||k==-1) return AliPID::ParticleMass(AliPID::kPion);
 359   if (k==3) return AliPID::ParticleMass(AliPID::kKaon);
 360   if (k==4) return AliPID::ParticleMass(AliPID::kProton);
 361   AliWarning("Undefined mass !");
 362   return AliPID::ParticleMass(AliPID::kPion);
 363 }
 364
 365 //_______________________________________________________________________
 366 Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags) {
 367   //
 368   // This function updates track's running parameters
 369   //
 370   Bool_t rc=kTRUE;
 371
 372   SetStatus(flags);
 373   fLabel=t->GetLabel();
 374
 375   if (t->IsStartedTimeIntegral()) {
 376     SetStatus(kTIME);
 377     Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
 378     SetIntegratedLength(t->GetIntegratedLength());
 379   }
 380
 381   fRalpha=t->GetAlpha();
 382   t->GetExternalParameters(fRx,fRp);
 383   t->GetExternalCovariance(fRc);
 384
 385   switch (flags) {
 386
 387   case kITSin: case kITSout: case kITSrefit:
 388     fITSncls=t->GetNumberOfClusters();
 389     fITSchi2=t->GetChi2();
 390     for (Int_t i=0;i<fITSncls;i++) fITSindex[i]=t->GetClusterIndex(i);
 391     fITSsignal=t->GetPIDsignal();
 392     fITSLabel = t->GetLabel();
 393     fITSFakeRatio = t->GetFakeRatio();
 394     break;
 395
 396   case kTPCin: case kTPCrefit:
 397     fTPCLabel = t->GetLabel();
 398     fIalpha=fRalpha;
 399     fIx=fRx;
 400     {
 401       Int_t i;
 402       for (i=0; i<5; i++) fIp[i]=fRp[i];
 403       for (i=0; i<15;i++) fIc[i]=fRc[i];
 404     }
 405   case kTPCout:
 406
 407     fTPCncls=t->GetNumberOfClusters();
 408     fTPCchi2=t->GetChi2();
 409
 410      {//prevrow must be declared in separate namespace, otherwise compiler cries:
 411       //"jump to case label crosses initialization of `Int_t prevrow'"
 412        Int_t prevrow = -1;
 413        //       for (Int_t i=0;i<fTPCncls;i++)
 414        for (Int_t i=0;i<160;i++)
 415         {
 416           fTPCindex[i]=t->GetClusterIndex(i);
 417
 418           // Piotr's Cluster Map for HBT
 419           // ### please change accordingly if cluster array is changing
 420           // to "New TPC Tracking" style (with gaps in array)
 421           Int_t idx = fTPCindex[i];
 422           Int_t sect = (idx&0xff000000)>>24;
 423           Int_t row = (idx&0x00ff0000)>>16;
 424           if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
 425
 426           fTPCClusterMap.SetBitNumber(row,kTRUE);
 427
 428           //Fill the gap between previous row and this row with 0 bits
 429           //In case  ###  pleas change it as well - just set bit 0 in case there
 430           //is no associated clusters for current "i"
 431           if (prevrow < 0)
 432            {
 433              prevrow = row;//if previous bit was not assigned yet == this is the first one
 434            }
 435           else
 436            { //we don't know the order (inner to outer or reverse)
 437              //just to be save in case it is going to change
 438              Int_t n = 0, m = 0;
 439              if (prevrow < row)
 440               {
 441                 n = prevrow;
 442                 m = row;
 443               }
 444              else
 445               {
 446                 n = row;
 447                 m = prevrow;
 448               }
 449
 450              for (Int_t j = n+1; j < m; j++)
 451               {
 452                 fTPCClusterMap.SetBitNumber(j,kFALSE);
 453               }
 454              prevrow = row;
 455            }
 456           // End Of Piotr's Cluster Map for HBT
 457         }
 458      }
 459     fTPCsignal=t->GetPIDsignal();
 460     {Double_t mass=t->GetMass();    // preliminary mass setting
 461     if (mass>0.5) fR[4]=1.;         //        used by
 462     else if (mass<0.4) fR[2]=1.;    // the ITS reconstruction
 463     else fR[3]=1.;}
 464                      //
 465     break;
 466
 467   case kTRDout: case kTRDin: case kTRDrefit:
 468     fTRDLabel = t->GetLabel();
 469     fTRDncls=t->GetNumberOfClusters();
 470     fTRDchi2=t->GetChi2();
 471     for (Int_t i=0;i<fTRDncls;i++) fTRDindex[i]=t->GetClusterIndex(i);
 472     fTRDsignal=t->GetPIDsignal();
 473     break;
 474   case kTRDbackup:
 475     t->GetExternalParameters(fTx,fTp);
 476     t->GetExternalCovariance(fTc);
 477     fTalpha = t->GetAlpha();
 478     fTRDncls0 = t->GetNumberOfClusters();
 479     break;
 480   case kTOFin:
 481     break;
 482   case kTOFout:
 483     break;
 484   case kTRDStop:
 485     break;
 486   default:
 487     AliError("Wrong flag !");
 488     return kFALSE;
 489   }
 490
 491   return rc;
 492 }
 493
 494 //_______________________________________________________________________
 495 void
 496 AliESDtrack::SetConstrainedTrackParams(const AliKalmanTrack *t, Double_t chi2) {
 497   //
 498   // This function sets the constrained track parameters
 499   //
 500   Int_t i;
 501   Double_t x,buf[15];
 502   fCalpha=t->GetAlpha();
 503   t->GetExternalParameters(x,buf); fCx=x;
 504   for (i=0; i<5; i++) fCp[i]=buf[i];
 505   t->GetExternalCovariance(buf);
 506   for (i=0; i<15; i++) fCc[i]=buf[i];
 507   fCchi2=chi2;
 508 }
 509
 510
 511 //_______________________________________________________________________
 512 void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
 513   //---------------------------------------------------------------------
 514   // This function returns external representation of the track parameters
 515   //---------------------------------------------------------------------
 516   x=fRx;
 517   for (Int_t i=0; i<5; i++) p[i]=fRp[i];
 518 }
 519
 520 //_______________________________________________________________________
 521 Bool_t AliESDtrack::GetExternalParametersAt(Double_t x, Double_t p[5]) const {
 522   //---------------------------------------------------------------------
 523   // This function returns external representation of the track parameters
 524   // at the position given by the first argument
 525   //---------------------------------------------------------------------
 526   Double_t dx=x-fRx;
 527   Double_t f1=fRp[2], f2=f1 + dx*fRp[4]/AliKalmanTrack::GetConvConst();
 528
 529   if (TMath::Abs(f2) >= 0.9999) return kFALSE;
 530
 531   Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
 532   p[0] = fRp[0] + dx*(f1+f2)/(r1+r2);
 533   p[1] = fRp[1] + dx*(f1+f2)/(f1*r2 + f2*r1)*fRp[3];
 534   p[2] = f2;
 535   p[3] = fRp[3];
 536   p[4] = fRp[4];
 537
 538   return kTRUE;
 539 }
 540
 541 //_______________________________________________________________________
 542 void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
 543   //---------------------------------------------------------------------
 544   // This function returns external representation of the cov. matrix
 545   //---------------------------------------------------------------------
 546   for (Int_t i=0; i<15; i++) cov[i]=fRc[i];
 547 }
 548
 549
 550 //_______________________________________________________________________
 551 void
 552 AliESDtrack::GetConstrainedExternalParameters(Double_t &x, Double_t p[5])const{
 553   //---------------------------------------------------------------------
 554   // This function returns the constrained external track parameters
 555   //---------------------------------------------------------------------
 556   x=fCx;
 557   for (Int_t i=0; i<5; i++) p[i]=fCp[i];
 558 }
 559 //_______________________________________________________________________
 560 void
 561 AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
 562   //---------------------------------------------------------------------
 563   // This function returns the constrained external cov. matrix
 564   //---------------------------------------------------------------------
 565   for (Int_t i=0; i<15; i++) c[i]=fCc[i];
 566 }
 567
 568
 569 Double_t AliESDtrack::GetP() const {
 570   //---------------------------------------------------------------------
 571   // This function returns the track momentum
 572   // Results for (nearly) straight tracks are meaningless !
 573   //---------------------------------------------------------------------
 574   if (TMath::Abs(fRp[4])<=0) return 0;
 575   Double_t pt=1./TMath::Abs(fRp[4]);
 576   return pt*TMath::Sqrt(1.+ fRp[3]*fRp[3]);
 577 }
 578
 579 Bool_t Local2GlobalMomentum(Double_t p[3],Double_t alpha) {
 580   //----------------------------------------------------------------
 581   // This function performs local->global transformation of the
 582   // track momentum.
 583   // When called, the arguments are:
 584   //    p[0] = 1/pt of the track;
 585   //    p[1] = sine of local azim. angle of the track momentum;
 586   //    p[2] = tangent of the track momentum dip angle;
 587   //   alpha - rotation angle.
 588   // The result is returned as:
 589   //    p[0] = px
 590   //    p[1] = py
 591   //    p[2] = pz
 592   // Results for (nearly) straight tracks are meaningless !
 593   //----------------------------------------------------------------
 594   if (TMath::Abs(p[0])<=0)        return kFALSE;
 595   if (TMath::Abs(p[1])> 0.999999) return kFALSE;
 596
 597   Double_t pt=1./TMath::Abs(p[0]);
 598   Double_t cs=TMath::Cos(alpha), sn=TMath::Sin(alpha);
 599   Double_t r=TMath::Sqrt(1 - p[1]*p[1]);
 600   p[0]=pt*(r*cs - p[1]*sn); p[1]=pt*(p[1]*cs + r*sn); p[2]=pt*p[2];
 601
 602   return kTRUE;
 603 }
 604
 605 Bool_t Local2GlobalPosition(Double_t r[3],Double_t alpha) {
 606   //----------------------------------------------------------------
 607   // This function performs local->global transformation of the
 608   // track position.
 609   // When called, the arguments are:
 610   //    r[0] = local x
 611   //    r[1] = local y
 612   //    r[2] = local z
 613   //   alpha - rotation angle.
 614   // The result is returned as:
 615   //    r[0] = global x
 616   //    r[1] = global y
 617   //    r[2] = global z
 618   //----------------------------------------------------------------
 619   Double_t cs=TMath::Cos(alpha), sn=TMath::Sin(alpha), x=r[0];
 620   r[0]=x*cs - r[1]*sn; r[1]=x*sn + r[1]*cs;
 621
 622   return kTRUE;
 623 }
 624
 625 Bool_t AliESDtrack::GetConstrainedPxPyPz(Double_t *p) const {
 626   //---------------------------------------------------------------------
 627   // This function returns the constrained global track momentum components
 628   // Results for (nearly) straight tracks are meaningless !
 629   //---------------------------------------------------------------------
 630   p[0]=fCp[4]; p[1]=fCp[2]; p[2]=fCp[3];
 631   return Local2GlobalMomentum(p,fCalpha);
 632 }
 633
 634 Bool_t AliESDtrack::GetConstrainedXYZ(Double_t *r) const {
 635   //---------------------------------------------------------------------
 636   // This function returns the constrained global track position
 637   //---------------------------------------------------------------------
 638   r[0]=fCx; r[1]=fCp[0]; r[2]=fCp[1];
 639   return Local2GlobalPosition(r,fCalpha);
 640 }
 641
 642 Bool_t AliESDtrack::GetPxPyPz(Double_t *p) const {
 643   //---------------------------------------------------------------------
 644   // This function returns the global track momentum components
 645   // Results for (nearly) straight tracks are meaningless !
 646   //---------------------------------------------------------------------
 647   p[0]=fRp[4]; p[1]=fRp[2]; p[2]=fRp[3];
 648   return Local2GlobalMomentum(p,fRalpha);
 649 }
 650
 651 Bool_t AliESDtrack::GetXYZ(Double_t *r) const {
 652   //---------------------------------------------------------------------
 653   // This function returns the global track position
 654   //---------------------------------------------------------------------
 655   r[0]=fRx; r[1]=fRp[0]; r[2]=fRp[1];
 656   return Local2GlobalPosition(r,fRalpha);
 657 }
 658
 659 void AliESDtrack::GetCovariance(Double_t cv[21]) const {
 660   //---------------------------------------------------------------------
 661   // This function returns the global covariance matrix of the track params
 662   //
 663   // Cov(x,x) ... :   cv[0]
 664   // Cov(y,x) ... :   cv[1]  cv[2]
 665   // Cov(z,x) ... :   cv[3]  cv[4]  cv[5]
 666   // Cov(px,x)... :   cv[6]  cv[7]  cv[8]  cv[9]
 667   // Cov(py,x)... :   cv[10] cv[11] cv[12] cv[13] cv[14]
 668   // Cov(pz,x)... :   cv[15] cv[16] cv[17] cv[18] cv[19] cv[20]
 669   //
 670   // Results for (nearly) straight tracks are meaningless !
 671   //---------------------------------------------------------------------
 672   if (TMath::Abs(fRp[4])<=0) {
 673      for (Int_t i=0; i<21; i++) cv[i]=0.;
 674      return;
 675   }
 676   if (TMath::Abs(fRp[2]) > 0.999999) {
 677      for (Int_t i=0; i<21; i++) cv[i]=0.;
 678      return;
 679   }
 680   Double_t pt=1./TMath::Abs(fRp[4]);
 681   Double_t cs=TMath::Cos(fRalpha), sn=TMath::Sin(fRalpha);
 682   Double_t r=TMath::Sqrt(1-fRp[2]*fRp[2]);
 683
 684   Double_t m00=-sn, m10=cs;
 685   Double_t m23=-pt*(sn + fRp[2]*cs/r), m43=-pt*pt*(r*cs - fRp[2]*sn);
 686   Double_t m24= pt*(cs - fRp[2]*sn/r), m44=-pt*pt*(r*sn + fRp[2]*cs);
 687   Double_t m35=pt, m45=-pt*pt*fRp[3];
 688
 689   cv[0]=fRc[0]*m00*m00;
 690   cv[1]=fRc[0]*m00*m10;
 691   cv[2]=fRc[0]*m10*m10;
 692   cv[3]=fRc[1]*m00;
 693   cv[4]=fRc[1]*m10;
 694   cv[5]=fRc[2];
 695   cv[6]=m00*(fRc[3]*m23+fRc[10]*m43);
 696   cv[7]=m10*(fRc[3]*m23+fRc[10]*m43);
 697   cv[8]=fRc[4]*m23+fRc[11]*m43;
 698   cv[9]=m23*(fRc[5]*m23+fRc[12]*m43)+m43*(fRc[12]*m23+fRc[14]*m43);
 699   cv[10]=m00*(fRc[3]*m24+fRc[10]*m44);
 700   cv[11]=m10*(fRc[3]*m24+fRc[10]*m44);
 701   cv[12]=fRc[4]*m24+fRc[11]*m44;
 702   cv[13]=m23*(fRc[5]*m24+fRc[12]*m44)+m43*(fRc[12]*m24+fRc[14]*m44);
 703   cv[14]=m24*(fRc[5]*m24+fRc[12]*m44)+m44*(fRc[12]*m24+fRc[14]*m44);
 704   cv[15]=m00*(fRc[6]*m35+fRc[10]*m45);
 705   cv[16]=m10*(fRc[6]*m35+fRc[10]*m45);
 706   cv[17]=fRc[7]*m35+fRc[11]*m45;
 707   cv[18]=m23*(fRc[8]*m35+fRc[12]*m45)+m43*(fRc[13]*m35+fRc[14]*m45);
 708   cv[19]=m24*(fRc[8]*m35+fRc[12]*m45)+m44*(fRc[13]*m35+fRc[14]*m45);
 709   cv[20]=m35*(fRc[9]*m35+fRc[13]*m45)+m45*(fRc[13]*m35+fRc[14]*m45);
 710 }
 711
 712 Bool_t AliESDtrack::GetInnerPxPyPz(Double_t *p) const {
 713   //---------------------------------------------------------------------
 714   // This function returns the global track momentum components
 715   // af the entrance of the TPC
 716   //---------------------------------------------------------------------
 717   p[0]=fIp[4]; p[1]=fIp[2]; p[2]=fIp[3];
 718   return Local2GlobalMomentum(p,fIalpha);
 719 }
 720
 721 Bool_t AliESDtrack::GetInnerXYZ(Double_t *r) const {
 722   //---------------------------------------------------------------------
 723   // This function returns the global track position
 724   // af the entrance of the TPC
 725   //---------------------------------------------------------------------
 726   if (fIx==0) return kFALSE;
 727   r[0]=fIx; r[1]=fIp[0]; r[2]=fIp[1];
 728   return Local2GlobalPosition(r,fIalpha);
 729 }
 730
 731 void AliESDtrack::GetInnerExternalParameters(Double_t &x, Double_t p[5]) const
 732 {
 733   //skowron
 734  //---------------------------------------------------------------------
 735   // This function returns external representation of the track parameters at Inner Layer of TPC
 736   //---------------------------------------------------------------------
 737   x=fIx;
 738   for (Int_t i=0; i<5; i++) p[i]=fIp[i];
 739 }
 740 void AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const
 741 {
 742  //skowron
 743  //---------------------------------------------------------------------
 744  // This function returns external representation of the cov. matrix at Inner Layer of TPC
 745  //---------------------------------------------------------------------
 746  for (Int_t i=0; i<15; i++) cov[i]=fIc[i];
 747
 748 }
 749
 750 void  AliESDtrack::GetTRDExternalParameters(Double_t &x, Double_t&alpha, Double_t p[5], Double_t cov[15]) const
 751 {
 752   //
 753   //this function returns TRD parameters
 754   //
 755   x=fTx;
 756   alpha = fTalpha;
 757   for (Int_t i=0; i<5; i++) p[i]=fTp[i];
 758   for (Int_t i=0; i<15; i++) cov[i]=fTc[i];
 759 }
 760
 761 Bool_t AliESDtrack::GetPxPyPzAt(Double_t x,Double_t *p) const {
 762   //---------------------------------------------------------------------
 763   // This function returns the global track momentum components
 764   // at the position "x" using the helix track approximation
 765   //---------------------------------------------------------------------
 766   p[0]=fRp[4];
 767   p[1]=fRp[2]+(x-fRx)*fRp[4]/AliKalmanTrack::GetConvConst();
 768   p[2]=fRp[3];
 769   return Local2GlobalMomentum(p,fRalpha);
 770 }
 771
 772 Bool_t AliESDtrack::GetXYZAt(Double_t x, Double_t *r) const {
 773   //---------------------------------------------------------------------
 774   // This function returns the global track position
 775   // af the radius "x" using the helix track approximation
 776   //---------------------------------------------------------------------
 777   Double_t dx=x-fRx;
 778   Double_t f1=fRp[2], f2=f1 + dx*fRp[4]/AliKalmanTrack::GetConvConst();
 779
 780   if (TMath::Abs(f2) >= 0.9999) return kFALSE;
 781
 782   Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
 783   r[0] = x;
 784   r[1] = fRp[0] + dx*(f1+f2)/(r1+r2);
 785   r[2] = fRp[1] + dx*(f1+f2)/(f1*r2 + f2*r1)*fRp[3];
 786   return Local2GlobalPosition(r,fRalpha);
 787 }
 788
 789 //_______________________________________________________________________
 790 void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
 791   // Returns the array with integrated times for each particle hypothesis
 792   for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
 793 }
 794
 795 //_______________________________________________________________________
 796 void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
 797   // Sets the array with integrated times for each particle hypotesis
 798   for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
 799 }
 800
 801 //_______________________________________________________________________
 802 void AliESDtrack::SetITSpid(const Double_t *p) {
 803   // Sets values for the probability of each particle type (in ITS)
 804   for (Int_t i=0; i<AliPID::kSPECIES; i++) fITSr[i]=p[i];
 805   SetStatus(AliESDtrack::kITSpid);
 806 }
 807
 808 void AliESDtrack::SetITSChi2MIP(const Float_t *chi2mip){
 809   for (Int_t i=0; i<12; i++) fITSchi2MIP[i]=chi2mip[i];
 810 }
 811 //_______________________________________________________________________
 812 void AliESDtrack::GetITSpid(Double_t *p) const {
 813   // Gets the probability of each particle type (in ITS)
 814   for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
 815 }
 816
 817 //_______________________________________________________________________
 818 Int_t AliESDtrack::GetITSclusters(UInt_t *idx) const {
 819   //---------------------------------------------------------------------
 820   // This function returns indices of the assgined ITS clusters
 821   //---------------------------------------------------------------------
 822   for (Int_t i=0; i<fITSncls; i++) idx[i]=fITSindex[i];
 823   return fITSncls;
 824 }
 825
 826 //_______________________________________________________________________
 827 Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
 828   //---------------------------------------------------------------------
 829   // This function returns indices of the assgined ITS clusters
 830   //---------------------------------------------------------------------
 831   if (idx!=0)
 832     for (Int_t i=0; i<180; i++) idx[i]=fTPCindex[i];  // MI I prefer some constant
 833   return fTPCncls;
 834 }
 835
 836 Float_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
 837   //
 838   // GetDensity of the clusters on given region between row0 and row1
 839   // Dead zone effect takin into acoount
 840   //
 841   Int_t good  = 0;
 842   Int_t found = 0;
 843   //
 844   for (Int_t i=row0;i<=row1;i++){
 845     Int_t index = fTPCindex[i];
 846     if (index!=-1)  good++;             // track outside of dead zone
 847     if (index>0)    found++;
 848   }
 849   Float_t density=0.5;
 850   if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
 851   return density;
 852 }
 853 //_______________________________________________________________________
 854 void AliESDtrack::SetTPCpid(const Double_t *p) {
 855   // Sets values for the probability of each particle type (in TPC)
 856   // normalize probabiluty to 1
 857   //
 858   //
 859 //   Double_t sump=0;
 860 //   for (Int_t i=0; i<AliPID::kSPECIES; i++) {
 861 //     sump+=p[i];
 862 //   }
 863 //   for (Int_t i=0; i<AliPID::kSPECIES; i++) {
 864 //     if (sump>0){
 865 //       fTPCr[i]=p[i]/sump;
 866 //     }
 867 //     else{
 868 //       fTPCr[i]=p[i];
 869 //     }
 870 //   }
 871   for (Int_t i=0; i<AliPID::kSPECIES; i++) fTPCr[i] = p[i];
 872   SetStatus(AliESDtrack::kTPCpid);
 873 }
 874
 875 //_______________________________________________________________________
 876 void AliESDtrack::GetTPCpid(Double_t *p) const {
 877   // Gets the probability of each particle type (in TPC)
 878   for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
 879 }
 880
 881 //_______________________________________________________________________
 882 Int_t AliESDtrack::GetTRDclusters(UInt_t *idx) const {
 883   //---------------------------------------------------------------------
 884   // This function returns indices of the assgined TRD clusters
 885   //---------------------------------------------------------------------
 886   if (idx!=0)
 887     for (Int_t i=0; i<130; i++) idx[i]=fTRDindex[i];  // MI I prefer some constant
 888   return fTRDncls;
 889 }
 890
 891 //_______________________________________________________________________
 892 void AliESDtrack::SetTRDpid(const Double_t *p) {
 893   // Sets values for the probability of each particle type (in TRD)
 894   for (Int_t i=0; i<AliPID::kSPECIES; i++) fTRDr[i]=p[i];
 895   SetStatus(AliESDtrack::kTRDpid);
 896 }
 897
 898 //_______________________________________________________________________
 899 void AliESDtrack::GetTRDpid(Double_t *p) const {
 900   // Gets the probability of each particle type (in TRD)
 901   for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
 902 }
 903
 904 //_______________________________________________________________________
 905 void    AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
 906 {
 907   // Sets the probability of particle type iSpecies to p (in TRD)
 908   fTRDr[iSpecies] = p;
 909 }
 910
 911 Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
 912 {
 913   // Returns the probability of particle type iSpecies (in TRD)
 914   return fTRDr[iSpecies];
 915 }
 916
 917 //_______________________________________________________________________
 918 void AliESDtrack::SetTOFpid(const Double_t *p) {
 919   // Sets the probability of each particle type (in TOF)
 920   for (Int_t i=0; i<AliPID::kSPECIES; i++) fTOFr[i]=p[i];
 921   SetStatus(AliESDtrack::kTOFpid);
 922 }
 923
 924 //_______________________________________________________________________
 925 void AliESDtrack::SetTOFLabel(const Int_t *p) {
 926   // Sets  (in TOF)
 927   for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
 928 }
 929
 930 //_______________________________________________________________________
 931 void AliESDtrack::GetTOFpid(Double_t *p) const {
 932   // Gets probabilities of each particle type (in TOF)
 933   for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
 934 }
 935
 936 //_______________________________________________________________________
 937 void AliESDtrack::GetTOFLabel(Int_t *p) const {
 938   // Gets (in TOF)
 939   for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
 940 }
 941
 942 //_______________________________________________________________________
 943 void AliESDtrack::GetTOFInfo(Float_t *info) const {
 944   // Gets (in TOF)
 945   for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
 946 }
 947
 948 //_______________________________________________________________________
 949 void AliESDtrack::SetTOFInfo(Float_t*info) {
 950   // Gets (in TOF)
 951   for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
 952 }
 953
 954
 955
 956 //_______________________________________________________________________
 957 void AliESDtrack::SetPHOSpid(const Double_t *p) {
 958   // Sets the probability of each particle type (in PHOS)
 959   for (Int_t i=0; i<AliPID::kSPECIESN; i++) fPHOSr[i]=p[i];
 960   SetStatus(AliESDtrack::kPHOSpid);
 961 }
 962
 963 //_______________________________________________________________________
 964 void AliESDtrack::GetPHOSpid(Double_t *p) const {
 965   // Gets probabilities of each particle type (in PHOS)
 966   for (Int_t i=0; i<AliPID::kSPECIESN; i++) p[i]=fPHOSr[i];
 967 }
 968
 969 //_______________________________________________________________________
 970 void AliESDtrack::SetEMCALpid(const Double_t *p) {
 971   // Sets the probability of each particle type (in EMCAL)
 972   for (Int_t i=0; i<AliPID::kSPECIESN; i++) fEMCALr[i]=p[i];
 973   SetStatus(AliESDtrack::kEMCALpid);
 974 }
 975
 976 //_______________________________________________________________________
 977 void AliESDtrack::GetEMCALpid(Double_t *p) const {
 978   // Gets probabilities of each particle type (in EMCAL)
 979   for (Int_t i=0; i<AliPID::kSPECIESN; i++) p[i]=fEMCALr[i];
 980 }
 981
 982 //_______________________________________________________________________
 983 void AliESDtrack::SetRICHpid(const Double_t *p) {
 984   // Sets the probability of each particle type (in RICH)
 985   for (Int_t i=0; i<AliPID::kSPECIES; i++) fRICHr[i]=p[i];
 986   SetStatus(AliESDtrack::kRICHpid);
 987 }
 988
 989 //_______________________________________________________________________
 990 void AliESDtrack::GetRICHpid(Double_t *p) const {
 991   // Gets probabilities of each particle type (in RICH)
 992   for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fRICHr[i];
 993 }
 994
 995
 996
 997 //_______________________________________________________________________
 998 void AliESDtrack::SetESDpid(const Double_t *p) {
 999   // Sets the probability of each particle type for the ESD track
1000   for (Int_t i=0; i<AliPID::kSPECIES; i++) fR[i]=p[i];
1001   SetStatus(AliESDtrack::kESDpid);
1002 }
1003
1004 //_______________________________________________________________________
1005 void AliESDtrack::GetESDpid(Double_t *p) const {
1006   // Gets probability of each particle type for the ESD track
1007   for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
1008 }
1009
1010 //_______________________________________________________________________
1011 void AliESDtrack::Print(Option_t *) const {
1012   // Prints info on the track
1013
1014   printf("ESD track info\n") ;
1015   Double_t p[AliPID::kSPECIESN] ;
1016   Int_t index = 0 ;
1017   if( IsOn(kITSpid) ){
1018     printf("From ITS: ") ;
1019     GetITSpid(p) ;
1020     for(index = 0 ; index < AliPID::kSPECIES; index++)
1021       printf("%f, ", p[index]) ;
1022     printf("\n           signal = %f\n", GetITSsignal()) ;
1023   }
1024   if( IsOn(kTPCpid) ){
1025     printf("From TPC: ") ;
1026     GetTPCpid(p) ;
1027     for(index = 0 ; index < AliPID::kSPECIES; index++)
1028       printf("%f, ", p[index]) ;
1029     printf("\n           signal = %f\n", GetTPCsignal()) ;
1030   }
1031   if( IsOn(kTRDpid) ){
1032     printf("From TRD: ") ;
1033     GetTRDpid(p) ;
1034     for(index = 0 ; index < AliPID::kSPECIES; index++)
1035       printf("%f, ", p[index]) ;
1036     printf("\n           signal = %f\n", GetTRDsignal()) ;
1037   }
1038   if( IsOn(kTOFpid) ){
1039     printf("From TOF: ") ;
1040     GetTOFpid(p) ;
1041     for(index = 0 ; index < AliPID::kSPECIES; index++)
1042       printf("%f, ", p[index]) ;
1043     printf("\n           signal = %f\n", GetTOFsignal()) ;
1044   }
1045   if( IsOn(kRICHpid) ){
1046     printf("From TOF: ") ;
1047     GetRICHpid(p) ;
1048     for(index = 0 ; index < AliPID::kSPECIES; index++)
1049       printf("%f, ", p[index]) ;
1050     printf("\n           signal = %f\n", GetRICHsignal()) ;
1051   }
1052   if( IsOn(kPHOSpid) ){
1053     printf("From PHOS: ") ;
1054     GetPHOSpid(p) ;
1055     for(index = 0 ; index < AliPID::kSPECIESN; index++)
1056       printf("%f, ", p[index]) ;
1057     printf("\n           signal = %f\n", GetPHOSsignal()) ;
1058   }
1059   if( IsOn(kEMCALpid) ){
1060     printf("From EMCAL: ") ;
1061     GetEMCALpid(p) ;
1062     for(index = 0 ; index < AliPID::kSPECIESN; index++)
1063       printf("%f, ", p[index]) ;
1064     printf("\n           signal = %f\n", GetEMCALsignal()) ;
1065   }
1066 }