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 //-----------------------------------------------------------------
24 #include <TParticle.h>
26 #include "AliESDVertex.h"
27 #include "AliESDtrack.h"
28 #include "AliKalmanTrack.h"
30 #include "AliTrackPointArray.h"
34 void SetPIDValues(Double_t * dest, const Double_t * src, Int_t n) {
35 // This function copies "n" PID weights from "scr" to "dest"
36 // and normalizes their sum to 1 thus producing conditional probabilities.
37 // The negative weights are set to 0.
38 // In case all the weights are non-positive they are replaced by
39 // uniform probabilities
43 Float_t uniform = 1./(Float_t)n;
46 for (Int_t i=0; i<n; i++)
56 for (Int_t i=0; i<n; i++) dest[i] /= sum;
58 for (Int_t i=0; i<n; i++) dest[i] = uniform;
61 //_______________________________________________________________________
62 AliESDtrack::AliESDtrack() :
63 AliExternalTrackParam(),
68 fFriendTrack(new AliESDfriendTrack()),
69 fTPCClusterMap(159),//number of padrows
70 fTPCSharedMap(159),//number of padrows
81 fEMCALindex(kEMCALNoMatch),
87 fCdd(0),fCdz(0),fCzz(0),
118 // The default ESD constructor
121 for (i=0; i<AliPID::kSPECIES; i++) {
131 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
132 for (i=0; i<3; i++) { fV0Indexes[i]=0;}
133 for (i=0;i<kNPlane;i++) {
134 for (j=0;j<kNSlice;j++) {
135 fTRDsignals[i][j]=0.;
139 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
140 for (i=0;i<3;i++) {fTOFLabel[i]=0;}
141 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
144 //_______________________________________________________________________
145 AliESDtrack::AliESDtrack(const AliESDtrack& track):
146 AliExternalTrackParam(track),
152 fTPCClusterMap(track.fTPCClusterMap),
153 fTPCSharedMap(track.fTPCSharedMap),
154 fFlags(track.fFlags),
156 fLabel(track.fLabel),
157 fITSLabel(track.fITSLabel),
158 fTPCLabel(track.fTPCLabel),
159 fTRDLabel(track.fTRDLabel),
160 fTOFCalChannel(track.fTOFCalChannel),
161 fTOFindex(track.fTOFindex),
162 fHMPIDqn(track.fHMPIDqn),
163 fHMPIDcluIdx(track.fHMPIDcluIdx),
164 fEMCALindex(track.fEMCALindex),
165 fHMPIDtrkTheta(track.fHMPIDtrkTheta),
166 fHMPIDtrkPhi(track.fHMPIDtrkPhi),
167 fHMPIDsignal(track.fHMPIDsignal),
168 fTrackLength(track.fTrackLength),
169 fD(track.fD),fZ(track.fZ),
170 fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
171 fCchi2(track.fCchi2),
172 fITSchi2(track.fITSchi2),
173 fTPCchi2(track.fTPCchi2),
174 fTRDchi2(track.fTRDchi2),
175 fTOFchi2(track.fTOFchi2),
176 fHMPIDchi2(track.fHMPIDchi2),
177 fITSsignal(track.fITSsignal),
178 fTPCsignal(track.fTPCsignal),
179 fTPCsignalS(track.fTPCsignalS),
180 fTRDsignal(track.fTRDsignal),
181 fTRDQuality(track.fTRDQuality),
182 fTRDBudget(track.fTRDBudget),
183 fTOFsignal(track.fTOFsignal),
184 fTOFsignalToT(track.fTOFsignalToT),
185 fTOFsignalRaw(track.fTOFsignalRaw),
186 fTOFsignalDz(track.fTOFsignalDz),
187 fHMPIDtrkX(track.fHMPIDtrkX),
188 fHMPIDtrkY(track.fHMPIDtrkY),
189 fHMPIDmipX(track.fHMPIDmipX),
190 fHMPIDmipY(track.fHMPIDmipY),
191 fTPCncls(track.fTPCncls),
192 fTPCnclsF(track.fTPCnclsF),
193 fTPCsignalN(track.fTPCsignalN),
194 fITSncls(track.fITSncls),
195 fITSClusterMap(track.fITSClusterMap),
196 fTRDncls(track.fTRDncls),
197 fTRDncls0(track.fTRDncls0),
198 fTRDpidQuality(track.fTRDpidQuality)
203 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i]=track.fTrackTime[i];
204 for (Int_t i=0;i<AliPID::kSPECIES;i++) fR[i]=track.fR[i];
206 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
208 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[i];
209 for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
210 for (Int_t i=0; i<3;i++) { fKinkIndexes[i]=track.fKinkIndexes[i];}
211 for (Int_t i=0; i<3;i++) { fV0Indexes[i]=track.fV0Indexes[i];}
213 for (Int_t i=0;i<kNPlane;i++) {
214 for (Int_t j=0;j<kNSlice;j++) {
215 fTRDsignals[i][j]=track.fTRDsignals[i][j];
217 fTRDTimBin[i]=track.fTRDTimBin[i];
219 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
220 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
221 for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
222 for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
223 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i]=track.fHMPIDr[i];
225 if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
226 if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
227 if (track.fTPCInner) fTPCInner=new AliExternalTrackParam(*track.fTPCInner);
228 if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
230 if (track.fFriendTrack) fFriendTrack=new AliESDfriendTrack(*(track.fFriendTrack));
233 //_______________________________________________________________________
234 AliESDtrack::AliESDtrack(TParticle * part) :
235 AliExternalTrackParam(),
241 fTPCClusterMap(159),//number of padrows
242 fTPCSharedMap(159),//number of padrows
253 fEMCALindex(kEMCALNoMatch),
259 fCdd(0),fCdz(0),fCzz(0),
290 // ESD track from TParticle
293 // Reset all the arrays
295 for (i=0; i<AliPID::kSPECIES; i++) {
305 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
306 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
307 for (i=0;i<kNPlane;i++) {
308 for (j=0;j<kNSlice;j++) {
309 fTRDsignals[i][j]=0.;
313 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
314 for (i=0;i<3;i++) {fTOFLabel[i]=0;}
315 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
317 // Calculate the AliExternalTrackParam content
324 // Calculate alpha: the rotation angle of the corresponding local system (TPC sector)
325 alpha = part->Phi()*180./TMath::Pi();
326 if (alpha<0) alpha+= 360.;
327 if (alpha>360) alpha -= 360.;
329 Int_t sector = (Int_t)(alpha/20.);
330 alpha = 10. + 20.*sector;
332 alpha *= TMath::Pi();
334 // Covariance matrix: no errors, the parameters are exact
335 for (i=0; i<15; i++) covar[i]=0.;
337 // Get the vertex of origin and the momentum
338 TVector3 ver(part->Vx(),part->Vy(),part->Vz());
339 TVector3 mom(part->Px(),part->Py(),part->Pz());
341 // Rotate to the local coordinate system (TPC sector)
345 // X of the referense plane
348 Int_t pdgCode = part->GetPdgCode();
351 TDatabasePDG::Instance()->GetParticle(pdgCode)->Charge();
355 param[2] = TMath::Sin(mom.Phi());
356 param[3] = mom.Pz()/mom.Pt();
357 param[4] = TMath::Sign(1/mom.Pt(),charge);
359 // Set AliExternalTrackParam
360 Set(xref, alpha, param, covar);
365 switch (TMath::Abs(pdgCode)) {
391 // If the particle is not e,mu,pi,K or p the PID probabilities are set to 0
392 if (indexPID < AliPID::kSPECIES) {
398 fHMPIDr[indexPID]=1.;
401 // AliESD track label
402 SetLabel(part->GetUniqueID());
406 //_______________________________________________________________________
407 AliESDtrack::~AliESDtrack(){
409 // This is destructor according Coding Conventrions
411 //printf("Delete track\n");
419 void AliESDtrack::AddCalibObject(TObject * object){
421 // add calib object to the list
423 if (!fFriendTrack) fFriendTrack = new AliESDfriendTrack;
424 fFriendTrack->AddCalibObject(object);
427 TObject * AliESDtrack::GetCalibObject(Int_t index){
429 // return calib objct at given position
431 if (!fFriendTrack) return 0;
432 return fFriendTrack->GetCalibObject(index);
436 //_______________________________________________________________________
437 void AliESDtrack::MakeMiniESDtrack(){
438 // Resets everything except
439 // fFlags: Reconstruction status flags
440 // fLabel: Track label
441 // fID: Unique ID of the track
442 // fD: Impact parameter in XY-plane
443 // fZ: Impact parameter in Z
444 // fR[AliPID::kSPECIES]: combined "detector response probability"
445 // Running track parameters in the base class (AliExternalTrackParam)
449 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
451 // Reset track parameters constrained to the primary vertex
455 // Reset track parameters at the inner wall of TPC
457 delete fTPCInner;fTPCInner=0;
458 // Reset track parameters at the inner wall of the TRD
462 // Reset ITS track related information
467 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
470 // Reset TPC related track information
479 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=0;
481 for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
482 for (Int_t i=0; i<3;i++) fKinkIndexes[i] = 0;
483 for (Int_t i=0; i<3;i++) fV0Indexes[i] = 0;
485 // Reset TRD related track information
490 for (Int_t i=0;i<kNPlane;i++) {
491 for (Int_t j=0;j<kNSlice;j++) {
492 fTRDsignals[i][j] = 0;
496 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
502 // Reset TOF related track information
510 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
511 for (Int_t i=0;i<3;i++) fTOFLabel[i] = 0;
512 for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
514 // Reset HMPID related track information
519 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
526 fEMCALindex = kEMCALNoMatch;
528 delete fFriendTrack; fFriendTrack = 0;
530 //_______________________________________________________________________
531 Double_t AliESDtrack::GetMass() const {
532 // Returns the mass of the most probable particle type
535 for (Int_t i=0; i<AliPID::kSPECIES; i++) {
536 if (fR[i]>max) {k=i; max=fR[i];}
538 if (k==0) { // dE/dx "crossing points" in the TPC
540 if ((p>0.38)&&(p<0.48))
541 if (fR[0]<fR[3]*10.) return AliPID::ParticleMass(AliPID::kKaon);
542 if ((p>0.75)&&(p<0.85))
543 if (fR[0]<fR[4]*10.) return AliPID::ParticleMass(AliPID::kProton);
546 if (k==1) return AliPID::ParticleMass(AliPID::kMuon);
547 if (k==2||k==-1) return AliPID::ParticleMass(AliPID::kPion);
548 if (k==3) return AliPID::ParticleMass(AliPID::kKaon);
549 if (k==4) return AliPID::ParticleMass(AliPID::kProton);
550 AliWarning("Undefined mass !");
551 return AliPID::ParticleMass(AliPID::kPion);
554 //______________________________________________________________________________
555 Double_t AliESDtrack::E() const
557 // Returns the energy of the particle given its assumed mass.
558 // Assumes the pion mass if the particle can't be identified properly.
562 return TMath::Sqrt(p*p + m*m);
565 //______________________________________________________________________________
566 Double_t AliESDtrack::Y() const
568 // Returns the rapidity of a particle given its assumed mass.
569 // Assumes the pion mass if the particle can't be identified properly.
573 if (e != TMath::Abs(pz)) { // energy was not equal to pz
574 return 0.5*TMath::Log((e+pz)/(e-pz));
575 } else { // energy was equal to pz
580 //_______________________________________________________________________
581 Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
583 // This function updates track's running parameters
589 fLabel=t->GetLabel();
591 if (t->IsStartedTimeIntegral()) {
593 Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
594 SetIntegratedLength(t->GetIntegratedLength());
597 Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
601 case kITSin: case kITSout: case kITSrefit:
603 fITSncls=t->GetNumberOfClusters();
604 index=fFriendTrack->GetITSindices();
605 for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
606 index[i]=t->GetClusterIndex(i);
608 Int_t l=(index[i] & 0xf0000000) >> 28;
609 SETBIT(fITSClusterMap,l);
612 fITSchi2=t->GetChi2();
613 fITSsignal=t->GetPIDsignal();
614 fITSLabel = t->GetLabel();
617 case kTPCin: case kTPCrefit:
618 fTPCLabel = t->GetLabel();
619 if (flags==kTPCin) fTPCInner=new AliExternalTrackParam(*t);
620 if (!fIp) fIp=new AliExternalTrackParam(*t);
622 fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
624 index=fFriendTrack->GetTPCindices();
625 if (flags & kTPCout){
626 if (!fOp) fOp=new AliExternalTrackParam(*t);
628 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
630 fTPCncls=t->GetNumberOfClusters();
631 fTPCchi2=t->GetChi2();
633 {//prevrow must be declared in separate namespace, otherwise compiler cries:
634 //"jump to case label crosses initialization of `Int_t prevrow'"
636 // for (Int_t i=0;i<fTPCncls;i++)
637 for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)
639 index[i]=t->GetClusterIndex(i);
640 Int_t idx = index[i];
644 // Piotr's Cluster Map for HBT
645 // ### please change accordingly if cluster array is changing
646 // to "New TPC Tracking" style (with gaps in array)
647 Int_t sect = (idx&0xff000000)>>24;
648 Int_t row = (idx&0x00ff0000)>>16;
649 if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
651 fTPCClusterMap.SetBitNumber(row,kTRUE);
653 //Fill the gap between previous row and this row with 0 bits
654 //In case ### pleas change it as well - just set bit 0 in case there
655 //is no associated clusters for current "i"
658 prevrow = row;//if previous bit was not assigned yet == this is the first one
661 { //we don't know the order (inner to outer or reverse)
662 //just to be save in case it is going to change
675 for (Int_t j = n+1; j < m; j++)
677 fTPCClusterMap.SetBitNumber(j,kFALSE);
681 // End Of Piotr's Cluster Map for HBT
684 fTPCsignal=t->GetPIDsignal();
687 case kTRDout: case kTRDin: case kTRDrefit:
688 index=fFriendTrack->GetTRDindices();
689 fTRDLabel = t->GetLabel();
690 fTRDncls=t->GetNumberOfClusters();
691 fTRDchi2=t->GetChi2();
692 for (Int_t i=0;i<fTRDncls;i++) index[i]=t->GetClusterIndex(i);
693 fTRDsignal=t->GetPIDsignal();
696 if (!fOp) fOp=new AliExternalTrackParam(*t);
698 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
699 fTRDncls0 = t->GetNumberOfClusters();
708 AliError("Wrong flag !");
715 //_______________________________________________________________________
716 void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
717 //---------------------------------------------------------------------
718 // This function returns external representation of the track parameters
719 //---------------------------------------------------------------------
721 for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
724 //_______________________________________________________________________
725 void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
726 //---------------------------------------------------------------------
727 // This function returns external representation of the cov. matrix
728 //---------------------------------------------------------------------
729 for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
732 //_______________________________________________________________________
733 Bool_t AliESDtrack::GetConstrainedExternalParameters
734 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
735 //---------------------------------------------------------------------
736 // This function returns the constrained external track parameters
737 //---------------------------------------------------------------------
738 if (!fCp) return kFALSE;
739 alpha=fCp->GetAlpha();
741 for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
745 //_______________________________________________________________________
747 AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
748 //---------------------------------------------------------------------
749 // This function returns the constrained external cov. matrix
750 //---------------------------------------------------------------------
751 if (!fCp) return kFALSE;
752 for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
757 AliESDtrack::GetInnerExternalParameters
758 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
759 //---------------------------------------------------------------------
760 // This function returns external representation of the track parameters
761 // at the inner layer of TPC
762 //---------------------------------------------------------------------
763 if (!fIp) return kFALSE;
764 alpha=fIp->GetAlpha();
766 for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
771 AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const {
772 //---------------------------------------------------------------------
773 // This function returns external representation of the cov. matrix
774 // at the inner layer of TPC
775 //---------------------------------------------------------------------
776 if (!fIp) return kFALSE;
777 for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
782 AliESDtrack::GetOuterExternalParameters
783 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
784 //---------------------------------------------------------------------
785 // This function returns external representation of the track parameters
786 // at the inner layer of TRD
787 //---------------------------------------------------------------------
788 if (!fOp) return kFALSE;
789 alpha=fOp->GetAlpha();
791 for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
796 AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
797 //---------------------------------------------------------------------
798 // This function returns external representation of the cov. matrix
799 // at the inner layer of TRD
800 //---------------------------------------------------------------------
801 if (!fOp) return kFALSE;
802 for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
806 Int_t AliESDtrack::GetNcls(Int_t idet) const
808 // Get number of clusters by subdetector index
831 Int_t AliESDtrack::GetClusters(Int_t idet, Int_t *idx) const
833 // Get cluster index array by subdetector index
838 ncls = GetITSclusters(idx);
841 ncls = GetTPCclusters(idx);
844 ncls = GetTRDclusters(idx);
847 if (fTOFindex != 0) {
848 idx[0] = GetTOFcluster();
858 //_______________________________________________________________________
859 void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
860 // Returns the array with integrated times for each particle hypothesis
861 for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
864 //_______________________________________________________________________
865 void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
866 // Sets the array with integrated times for each particle hypotesis
867 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
870 //_______________________________________________________________________
871 void AliESDtrack::SetITSpid(const Double_t *p) {
872 // Sets values for the probability of each particle type (in ITS)
873 SetPIDValues(fITSr,p,AliPID::kSPECIES);
874 SetStatus(AliESDtrack::kITSpid);
877 //_______________________________________________________________________
878 void AliESDtrack::GetITSpid(Double_t *p) const {
879 // Gets the probability of each particle type (in ITS)
880 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
883 //_______________________________________________________________________
884 Char_t AliESDtrack::GetITSclusters(Int_t *idx) const {
885 //---------------------------------------------------------------------
886 // This function returns indices of the assgined ITS clusters
887 //---------------------------------------------------------------------
889 Int_t *index=fFriendTrack->GetITSindices();
890 for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) idx[i]=index[i];
895 //_______________________________________________________________________
896 UShort_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
897 //---------------------------------------------------------------------
898 // This function returns indices of the assgined ITS clusters
899 //---------------------------------------------------------------------
901 Int_t *index=fFriendTrack->GetTPCindices();
902 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
907 Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
909 // GetDensity of the clusters on given region between row0 and row1
910 // Dead zone effect takin into acoount
915 Int_t *index=fFriendTrack->GetTPCindices();
916 for (Int_t i=row0;i<=row1;i++){
917 Int_t idx = index[i];
918 if (idx!=-1) good++; // track outside of dead zone
922 if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
926 //_______________________________________________________________________
927 void AliESDtrack::SetTPCpid(const Double_t *p) {
928 // Sets values for the probability of each particle type (in TPC)
929 SetPIDValues(fTPCr,p,AliPID::kSPECIES);
930 SetStatus(AliESDtrack::kTPCpid);
933 //_______________________________________________________________________
934 void AliESDtrack::GetTPCpid(Double_t *p) const {
935 // Gets the probability of each particle type (in TPC)
936 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
939 //_______________________________________________________________________
940 UChar_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
941 //---------------------------------------------------------------------
942 // This function returns indices of the assgined TRD clusters
943 //---------------------------------------------------------------------
945 Int_t *index=fFriendTrack->GetTRDindices();
946 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
951 //_______________________________________________________________________
952 void AliESDtrack::SetTRDpid(const Double_t *p) {
953 // Sets values for the probability of each particle type (in TRD)
954 SetPIDValues(fTRDr,p,AliPID::kSPECIES);
955 SetStatus(AliESDtrack::kTRDpid);
958 //_______________________________________________________________________
959 void AliESDtrack::GetTRDpid(Double_t *p) const {
960 // Gets the probability of each particle type (in TRD)
961 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
964 //_______________________________________________________________________
965 void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
967 // Sets the probability of particle type iSpecies to p (in TRD)
971 Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
973 // Returns the probability of particle type iSpecies (in TRD)
974 return fTRDr[iSpecies];
977 //_______________________________________________________________________
978 void AliESDtrack::SetTOFpid(const Double_t *p) {
979 // Sets the probability of each particle type (in TOF)
980 SetPIDValues(fTOFr,p,AliPID::kSPECIES);
981 SetStatus(AliESDtrack::kTOFpid);
984 //_______________________________________________________________________
985 void AliESDtrack::SetTOFLabel(const Int_t *p) {
987 for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
990 //_______________________________________________________________________
991 void AliESDtrack::GetTOFpid(Double_t *p) const {
992 // Gets probabilities of each particle type (in TOF)
993 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
996 //_______________________________________________________________________
997 void AliESDtrack::GetTOFLabel(Int_t *p) const {
999 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
1002 //_______________________________________________________________________
1003 void AliESDtrack::GetTOFInfo(Float_t *info) const {
1005 for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
1008 //_______________________________________________________________________
1009 void AliESDtrack::SetTOFInfo(Float_t*info) {
1011 for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
1016 //_______________________________________________________________________
1017 void AliESDtrack::SetHMPIDpid(const Double_t *p) {
1018 // Sets the probability of each particle type (in HMPID)
1019 SetPIDValues(fHMPIDr,p,AliPID::kSPECIES);
1020 SetStatus(AliESDtrack::kHMPIDpid);
1023 //_______________________________________________________________________
1024 void AliESDtrack::GetHMPIDpid(Double_t *p) const {
1025 // Gets probabilities of each particle type (in HMPID)
1026 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fHMPIDr[i];
1031 //_______________________________________________________________________
1032 void AliESDtrack::SetESDpid(const Double_t *p) {
1033 // Sets the probability of each particle type for the ESD track
1034 SetPIDValues(fR,p,AliPID::kSPECIES);
1035 SetStatus(AliESDtrack::kESDpid);
1038 //_______________________________________________________________________
1039 void AliESDtrack::GetESDpid(Double_t *p) const {
1040 // Gets probability of each particle type for the ESD track
1041 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
1044 //_______________________________________________________________________
1045 Bool_t AliESDtrack::RelateToVertex
1046 (const AliESDVertex *vtx, Double_t b, Double_t maxd) {
1048 // Try to relate this track to the vertex "vtx",
1049 // if the (rough) transverse impact parameter is not bigger then "maxd".
1050 // Magnetic field is "b" (kG).
1052 // a) The track gets extapolated to the DCA to the vertex.
1053 // b) The impact parameters and their covariance matrix are calculated.
1054 // c) An attempt to constrain this track to the vertex is done.
1056 // In the case of success, the returned value is kTRUE
1057 // (otherwise, it's kFALSE)
1060 if (!vtx) return kFALSE;
1062 Double_t alpha=GetAlpha();
1063 Double_t sn=TMath::Sin(alpha), cs=TMath::Cos(alpha);
1064 Double_t x=GetX(), y=GetParameter()[0], snp=GetParameter()[2];
1065 Double_t xv= vtx->GetXv()*cs + vtx->GetYv()*sn;
1066 Double_t yv=-vtx->GetXv()*sn + vtx->GetYv()*cs, zv=vtx->GetZv();
1069 //Estimate the impact parameter neglecting the track curvature
1070 Double_t d=TMath::Abs(x*snp - y*TMath::Sqrt(1.- snp*snp));
1071 if (d > maxd) return kFALSE;
1073 //Propagate to the DCA
1074 Double_t crv=kB2C*b*GetParameter()[4];
1075 if (TMath::Abs(b) < kAlmost0Field) crv=0.;
1077 Double_t tgfv=-(crv*x - snp)/(crv*y + TMath::Sqrt(1.-snp*snp));
1078 sn=tgfv/TMath::Sqrt(1.+ tgfv*tgfv);
1079 if (TMath::Abs(tgfv)>0.) cs = sn/tgfv;
1083 yv=-xv*sn + yv*cs; xv=x;
1085 if (!Propagate(alpha+TMath::ASin(sn),xv,b)) return kFALSE;
1087 fD = GetParameter()[0] - yv;
1088 fZ = GetParameter()[1] - zv;
1090 Double_t cov[6]; vtx->GetCovMatrix(cov);
1092 //***** Improvements by A.Dainese
1093 alpha=GetAlpha(); sn=TMath::Sin(alpha); cs=TMath::Cos(alpha);
1094 Double_t s2ylocvtx = cov[0]*sn*sn + cov[2]*cs*cs - 2.*cov[1]*cs*sn;
1095 fCdd = GetCovariance()[0] + s2ylocvtx; // neglecting correlations
1096 fCdz = GetCovariance()[1]; // between (x,y) and z
1097 fCzz = GetCovariance()[2] + cov[5]; // in vertex's covariance matrix
1101 Double_t p[2]={yv,zv}, c[3]={cov[2],0.,cov[5]};
1102 Double_t chi2=GetPredictedChi2(p,c);
1104 if (chi2>77.) return kFALSE;
1106 AliExternalTrackParam tmp(*this);
1107 if (!tmp.Update(p,c)) return kFALSE;
1110 if (!fCp) fCp=new AliExternalTrackParam();
1111 new (fCp) AliExternalTrackParam(tmp);
1117 //_______________________________________________________________________
1118 void AliESDtrack::Print(Option_t *) const {
1119 // Prints info on the track
1121 printf("ESD track info\n") ;
1122 Double_t p[AliPID::kSPECIESN] ;
1124 if( IsOn(kITSpid) ){
1125 printf("From ITS: ") ;
1127 for(index = 0 ; index < AliPID::kSPECIES; index++)
1128 printf("%f, ", p[index]) ;
1129 printf("\n signal = %f\n", GetITSsignal()) ;
1131 if( IsOn(kTPCpid) ){
1132 printf("From TPC: ") ;
1134 for(index = 0 ; index < AliPID::kSPECIES; index++)
1135 printf("%f, ", p[index]) ;
1136 printf("\n signal = %f\n", GetTPCsignal()) ;
1138 if( IsOn(kTRDpid) ){
1139 printf("From TRD: ") ;
1141 for(index = 0 ; index < AliPID::kSPECIES; index++)
1142 printf("%f, ", p[index]) ;
1143 printf("\n signal = %f\n", GetTRDsignal()) ;
1145 if( IsOn(kTOFpid) ){
1146 printf("From TOF: ") ;
1148 for(index = 0 ; index < AliPID::kSPECIES; index++)
1149 printf("%f, ", p[index]) ;
1150 printf("\n signal = %f\n", GetTOFsignal()) ;
1152 if( IsOn(kHMPIDpid) ){
1153 printf("From HMPID: ") ;
1155 for(index = 0 ; index < AliPID::kSPECIES; index++)
1156 printf("%f, ", p[index]) ;
1157 printf("\n signal = %f\n", GetHMPIDsignal()) ;