1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 //-----------------------------------------------------------------
25 #include "AliESDtrack.h"
26 #include "AliKalmanTrack.h"
31 //_______________________________________________________________________
32 AliESDtrack::AliESDtrack() :
58 fTPCClusterMap(159),//number of padrows
83 // The default ESD constructor
85 for (Int_t i=0; i<AliPID::kSPECIES; i++) {
95 for (Int_t i=0; i<AliPID::kSPECIESN; i++) {
101 fPHOSpos[0]=fPHOSpos[1]=fPHOSpos[2]=0.;
102 fEMCALpos[0]=fEMCALpos[1]=fEMCALpos[2]=0.;
104 for (i=0; i<5; i++) {
105 fRp[i]=fCp[i]=fIp[i]=fTp[i]=0.;
107 for (i=0; i<15; i++) {
108 fRc[i]=fCc[i]=fIc[i]=fTc[i]=0.;
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;}
127 //_______________________________________________________________________
128 AliESDtrack::AliESDtrack(const AliESDtrack& track):
130 fFlags(track.fFlags),
131 fLabel(track.fLabel),
133 fTrackLength(track.fTrackLength),
136 fStopVertex(track.fStopVertex),
137 fRalpha(track.fRalpha),
139 fCalpha(track.fCalpha),
141 fCchi2(track.fCchi2),
142 fIalpha(track.fIalpha),
144 fTalpha(track.fTalpha),
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),
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)
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];
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];
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];
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];
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];
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];
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];}
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];
211 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
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];
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];
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];
223 for (Int_t i=0;i<AliPID::kSPECIES;i++) fRICHr[i]=track.fRICHr[i];
225 //_______________________________________________________________________
226 AliESDtrack::~AliESDtrack(){
228 // This is destructor according Coding Conventrions
230 //printf("Delete track\n");
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
251 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
254 // Reset track parameters constrained to the primary vertex
257 for (Int_t i=0;i<5;i++) fCp[i] = 0;
258 for (Int_t i=0;i<15;i++) fCc[i] = 0;
261 // Reset track parameters at the inner wall of TPC
264 for (Int_t i=0;i<5;i++) fIp[i] = 0;
265 for (Int_t i=0;i<15;i++) fIc[i] = 0;
267 // Reset track parameters at the inner wall of the TRD
270 for (Int_t i=0;i<5;i++) fTp[i] = 0;
271 for (Int_t i=0;i<15;i++) fTc[i] = 0;
273 // Reset ITS track related information
275 for (Int_t i=0;i<12;i++) fITSchi2MIP[i] = 0;
277 for (Int_t i=0;i<6;i++) fITSindex[i]= 0;
279 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]= 0;
284 // Reset TPC related track information
287 for (Int_t i=0;i<180;i++) fTPCindex[i] = 0;
290 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=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;
296 // Reset TRD related track information
300 for (Int_t i=0;i<130;i++) fTRDindex[i] = 0;
302 for (Int_t i=0;i<kNPlane;i++) {
306 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
311 // Reset TOF related track information
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;
319 // Reset PHOS related track information
320 for (Int_t i=0;i<3;i++) fPHOSpos[i] = 0;
322 for (Int_t i=0;i<AliPID::kSPECIESN;i++) fPHOSr[i] = 0;
324 // Reset EMCAL related track information
325 for (Int_t i=0;i<3;i++) fEMCALpos[i] = 0;
327 for (Int_t i=0;i<AliPID::kSPECIESN;i++) fEMCALr[i] = 0;
329 // Reset RICH related track information
334 for (Int_t i=0;i<AliPID::kSPECIES;i++) fRICHr[i] = 0;
341 //_______________________________________________________________________
342 Double_t AliESDtrack::GetMass() const {
343 // Returns the mass of the most probable particle type
346 for (Int_t i=0; i<AliPID::kSPECIES; i++) {
347 if (fR[i]>max) {k=i; max=fR[i];}
349 if (k==0) { // dE/dx "crossing points" in the TPC
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);
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);
365 //_______________________________________________________________________
366 Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags) {
368 // This function updates track's running parameters
373 fLabel=t->GetLabel();
375 if (t->IsStartedTimeIntegral()) {
377 Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
378 SetIntegratedLength(t->GetIntegratedLength());
381 fRalpha=t->GetAlpha();
382 t->GetExternalParameters(fRx,fRp);
383 t->GetExternalCovariance(fRc);
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();
396 case kTPCin: case kTPCrefit:
397 fTPCLabel = t->GetLabel();
402 for (i=0; i<5; i++) fIp[i]=fRp[i];
403 for (i=0; i<15;i++) fIc[i]=fRc[i];
407 fTPCncls=t->GetNumberOfClusters();
408 fTPCchi2=t->GetChi2();
410 {//prevrow must be declared in separate namespace, otherwise compiler cries:
411 //"jump to case label crosses initialization of `Int_t prevrow'"
413 // for (Int_t i=0;i<fTPCncls;i++)
414 for (Int_t i=0;i<160;i++)
416 fTPCindex[i]=t->GetClusterIndex(i);
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
426 fTPCClusterMap.SetBitNumber(row,kTRUE);
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"
433 prevrow = row;//if previous bit was not assigned yet == this is the first one
436 { //we don't know the order (inner to outer or reverse)
437 //just to be save in case it is going to change
450 for (Int_t j = n+1; j < m; j++)
452 fTPCClusterMap.SetBitNumber(j,kFALSE);
456 // End Of Piotr's Cluster Map for HBT
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
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();
475 t->GetExternalParameters(fTx,fTp);
476 t->GetExternalCovariance(fTc);
477 fTalpha = t->GetAlpha();
478 fTRDncls0 = t->GetNumberOfClusters();
487 AliError("Wrong flag !");
494 //_______________________________________________________________________
496 AliESDtrack::SetConstrainedTrackParams(const AliKalmanTrack *t, Double_t chi2) {
498 // This function sets the constrained track parameters
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];
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 //---------------------------------------------------------------------
517 for (Int_t i=0; i<5; i++) p[i]=fRp[i];
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 //---------------------------------------------------------------------
527 Double_t f1=fRp[2], f2=f1 + dx*fRp[4]/AliKalmanTrack::GetConvConst();
529 if (TMath::Abs(f2) >= 0.9999) return kFALSE;
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];
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];
550 //_______________________________________________________________________
552 AliESDtrack::GetConstrainedExternalParameters(Double_t &x, Double_t p[5])const{
553 //---------------------------------------------------------------------
554 // This function returns the constrained external track parameters
555 //---------------------------------------------------------------------
557 for (Int_t i=0; i<5; i++) p[i]=fCp[i];
559 //_______________________________________________________________________
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];
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]);
579 Bool_t Local2GlobalMomentum(Double_t p[3],Double_t alpha) {
580 //----------------------------------------------------------------
581 // This function performs local->global transformation of the
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:
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;
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];
605 Bool_t Local2GlobalPosition(Double_t r[3],Double_t alpha) {
606 //----------------------------------------------------------------
607 // This function performs local->global transformation of the
609 // When called, the arguments are:
613 // alpha - rotation angle.
614 // The result is returned as:
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;
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);
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);
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);
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);
659 void AliESDtrack::GetCovariance(Double_t cv[21]) const {
660 //---------------------------------------------------------------------
661 // This function returns the global covariance matrix of the track params
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]
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.;
676 if (TMath::Abs(fRp[2]) > 0.999999) {
677 for (Int_t i=0; i<21; i++) cv[i]=0.;
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]);
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];
689 cv[0]=fRc[0]*m00*m00;
690 cv[1]=fRc[0]*m00*m10;
691 cv[2]=fRc[0]*m10*m10;
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);
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);
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);
731 void AliESDtrack::GetInnerExternalParameters(Double_t &x, Double_t p[5]) const
734 //---------------------------------------------------------------------
735 // This function returns external representation of the track parameters at Inner Layer of TPC
736 //---------------------------------------------------------------------
738 for (Int_t i=0; i<5; i++) p[i]=fIp[i];
740 void AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const
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];
750 void AliESDtrack::GetTRDExternalParameters(Double_t &x, Double_t&alpha, Double_t p[5], Double_t cov[15]) const
753 //this function returns TRD parameters
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];
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 //---------------------------------------------------------------------
767 p[1]=fRp[2]+(x-fRx)*fRp[4]/AliKalmanTrack::GetConvConst();
769 return Local2GlobalMomentum(p,fRalpha);
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 //---------------------------------------------------------------------
778 Double_t f1=fRp[2], f2=f1 + dx*fRp[4]/AliKalmanTrack::GetConvConst();
780 if (TMath::Abs(f2) >= 0.9999) return kFALSE;
782 Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
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);
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];
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];
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);
808 void AliESDtrack::SetITSChi2MIP(const Float_t *chi2mip){
809 for (Int_t i=0; i<12; i++) fITSchi2MIP[i]=chi2mip[i];
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];
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];
826 //_______________________________________________________________________
827 Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
828 //---------------------------------------------------------------------
829 // This function returns indices of the assgined ITS clusters
830 //---------------------------------------------------------------------
832 for (Int_t i=0; i<180; i++) idx[i]=fTPCindex[i]; // MI I prefer some constant
836 Float_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
838 // GetDensity of the clusters on given region between row0 and row1
839 // Dead zone effect takin into acoount
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++;
850 if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
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
860 // for (Int_t i=0; i<AliPID::kSPECIES; i++) {
863 // for (Int_t i=0; i<AliPID::kSPECIES; i++) {
865 // fTPCr[i]=p[i]/sump;
871 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTPCr[i] = p[i];
872 SetStatus(AliESDtrack::kTPCpid);
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];
881 //_______________________________________________________________________
882 Int_t AliESDtrack::GetTRDclusters(UInt_t *idx) const {
883 //---------------------------------------------------------------------
884 // This function returns indices of the assgined TRD clusters
885 //---------------------------------------------------------------------
887 for (Int_t i=0; i<130; i++) idx[i]=fTRDindex[i]; // MI I prefer some constant
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);
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];
904 //_______________________________________________________________________
905 void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
907 // Sets the probability of particle type iSpecies to p (in TRD)
911 Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
913 // Returns the probability of particle type iSpecies (in TRD)
914 return fTRDr[iSpecies];
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);
924 //_______________________________________________________________________
925 void AliESDtrack::SetTOFLabel(const Int_t *p) {
927 for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
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];
936 //_______________________________________________________________________
937 void AliESDtrack::GetTOFLabel(Int_t *p) const {
939 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
942 //_______________________________________________________________________
943 void AliESDtrack::GetTOFInfo(Float_t *info) const {
945 for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
948 //_______________________________________________________________________
949 void AliESDtrack::SetTOFInfo(Float_t*info) {
951 for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
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);
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];
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);
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];
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);
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];
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);
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];
1010 //_______________________________________________________________________
1011 void AliESDtrack::Print(Option_t *) const {
1012 // Prints info on the track
1014 printf("ESD track info\n") ;
1015 Double_t p[AliPID::kSPECIESN] ;
1017 if( IsOn(kITSpid) ){
1018 printf("From ITS: ") ;
1020 for(index = 0 ; index < AliPID::kSPECIES; index++)
1021 printf("%f, ", p[index]) ;
1022 printf("\n signal = %f\n", GetITSsignal()) ;
1024 if( IsOn(kTPCpid) ){
1025 printf("From TPC: ") ;
1027 for(index = 0 ; index < AliPID::kSPECIES; index++)
1028 printf("%f, ", p[index]) ;
1029 printf("\n signal = %f\n", GetTPCsignal()) ;
1031 if( IsOn(kTRDpid) ){
1032 printf("From TRD: ") ;
1034 for(index = 0 ; index < AliPID::kSPECIES; index++)
1035 printf("%f, ", p[index]) ;
1036 printf("\n signal = %f\n", GetTRDsignal()) ;
1038 if( IsOn(kTOFpid) ){
1039 printf("From TOF: ") ;
1041 for(index = 0 ; index < AliPID::kSPECIES; index++)
1042 printf("%f, ", p[index]) ;
1043 printf("\n signal = %f\n", GetTOFsignal()) ;
1045 if( IsOn(kRICHpid) ){
1046 printf("From TOF: ") ;
1048 for(index = 0 ; index < AliPID::kSPECIES; index++)
1049 printf("%f, ", p[index]) ;
1050 printf("\n signal = %f\n", GetRICHsignal()) ;
1052 if( IsOn(kPHOSpid) ){
1053 printf("From PHOS: ") ;
1055 for(index = 0 ; index < AliPID::kSPECIESN; index++)
1056 printf("%f, ", p[index]) ;
1057 printf("\n signal = %f\n", GetPHOSsignal()) ;
1059 if( IsOn(kEMCALpid) ){
1060 printf("From EMCAL: ") ;
1062 for(index = 0 ; index < AliPID::kSPECIESN; index++)
1063 printf("%f, ", p[index]) ;
1064 printf("\n signal = %f\n", GetEMCALsignal()) ;