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
24 // What do you need to know before starting analysis
25 // (by Marian Ivanov: marian.ivanov@cern.ch)
29 // 1. What is the AliESDtrack
30 // 2. What informations do we store
31 // 3. How to use the information for analysis
34 // 1.AliESDtrack is the container of the information about the track/particle
35 // reconstructed during Barrel Tracking.
36 // The track information is propagated from one tracking detector to
37 // other using the functionality of AliESDtrack - Current parameters.
39 // No global fit model is used.
40 // Barrel tracking use Kalman filtering technique, it gives optimal local
41 // track parameters at given point under certian assumptions.
43 // Kalman filter take into account additional effect which are
44 // difficult to handle using global fit.
46 // a.) Multiple scattering
48 // c.) Non homogenous magnetic field
50 // In general case, following barrel detectors are contributing to
51 // the Kalman track information:
56 // In general 3 reconstruction itteration are performed:
57 // 1. Find tracks - sequence TPC->ITS
58 // 2. PropagateBack - sequence ITS->TPC->TRD -> Outer PID detectors
59 // 3. Refit invward - sequence TRD->TPC->ITS
60 // The current tracks are updated after each detector (see bellow).
61 // In specical cases a track sanpshots are stored.
64 // For some type of analysis (+visualization) track local parameters at
65 // different position are neccesary. A snapshots during the track
66 // propagation are created.
67 // (See AliExternalTrackParam class for desctiption of variables and
70 // a. Current parameters - class itself (AliExternalTrackParam)
71 // Contributors: general case TRD->TPC->ITS
72 // Preferable usage: Decission - primary or secondary track
73 // NOTICE - By default the track parameters are stored at the DCA point
74 // to the primary vertex. optimal for primary tracks,
75 // far from optimal for secondary tracks.
76 // b. Constrained parameters - Kalman information updated with
77 // the Primary vertex information
78 // Contributors: general case TRD->TPC->ITS
79 // Preferable usage: Use only for tracks selected as primary
80 // NOTICE - not real constrain - taken as additional measurement
81 // with corresponding error
83 // const AliExternalTrackParam *GetConstrainedParam() const {return fCp;}
84 // c. Inner parameters - Track parameters at inner wall of the TPC
85 // Contributors: general case TRD->TPC
87 // const AliExternalTrackParam *GetInnerParam() const { return fIp;}
89 // d. TPCinnerparam - contributors - TPC only
91 // Preferable usage: Requested for HBT study
92 // (smaller correlations as using also ITS information)
93 // NOTICE - the track parameters are propagated to the DCA to
95 // Optimal for primary, far from optimal for secondary tracks
97 // const AliExternalTrackParam *GetTPCInnerParam() const {return fTPCInner;}
99 // e. Outer parameters -
100 // Contributors- general case - ITS-> TPC -> TRD
101 // The last point - Outer parameters radius is determined
102 // e.a) Local inclination angle bigger than threshold -
103 // Low momenta tracks
104 // e.a) Catastrofic energy losss in material
105 // e.b) Not further improvement (no space points)
107 // a.) Tracking: Starting parameter for Refit inward
110 // NOTICE: Should be not used for the physic analysis
112 // const AliExternalTrackParam *GetOuterParam() const { return fOp;}
114 //-----------------------------------------------------------------
117 #include <TParticle.h>
118 #include <TDatabasePDG.h>
120 #include "AliESDVertex.h"
121 #include "AliESDtrack.h"
122 #include "AliESDEvent.h"
123 #include "AliKalmanTrack.h"
124 #include "AliVTrack.h"
126 #include "AliTrackPointArray.h"
127 #include "TPolyMarker3D.h"
129 ClassImp(AliESDtrack)
131 void SetPIDValues(Double_t * dest, const Double_t * src, Int_t n) {
132 // This function copies "n" PID weights from "scr" to "dest"
133 // and normalizes their sum to 1 thus producing conditional probabilities.
134 // The negative weights are set to 0.
135 // In case all the weights are non-positive they are replaced by
136 // uniform probabilities
140 Float_t uniform = 1./(Float_t)n;
143 for (Int_t i=0; i<n; i++)
153 for (Int_t i=0; i<n; i++) dest[i] /= sum;
155 for (Int_t i=0; i<n; i++) dest[i] = uniform;
158 //_______________________________________________________________________
159 AliESDtrack::AliESDtrack() :
160 AliExternalTrackParam(),
166 fFriendTrack(new AliESDfriendTrack()),
167 fTPCClusterMap(159),//number of padrows
168 fTPCSharedMap(159),//number of padrows
179 fCaloIndex(kEMCALNoMatch),
185 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
188 fCdd(0),fCdz(0),fCzz(0),
204 fTOFsignalToT(99999),
205 fTOFsignalRaw(99999),
228 fVertexID(-2),// -2 means an orphan track
232 // The default ESD constructor
235 for (i=0; i<AliPID::kSPECIES; i++) {
245 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
246 for (i=0; i<3; i++) { fV0Indexes[i]=0;}
247 for (i=0;i<kTRDnPlanes;i++) {
250 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
251 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
252 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
253 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
254 for (i=0;i<12;i++) {fITSModule[i]=-1;}
257 //_______________________________________________________________________
258 AliESDtrack::AliESDtrack(const AliESDtrack& track):
259 AliExternalTrackParam(track),
266 fTPCClusterMap(track.fTPCClusterMap),
267 fTPCSharedMap(track.fTPCSharedMap),
268 fFlags(track.fFlags),
270 fLabel(track.fLabel),
271 fITSLabel(track.fITSLabel),
272 fTPCLabel(track.fTPCLabel),
273 fTRDLabel(track.fTRDLabel),
274 fTOFCalChannel(track.fTOFCalChannel),
275 fTOFindex(track.fTOFindex),
276 fHMPIDqn(track.fHMPIDqn),
277 fHMPIDcluIdx(track.fHMPIDcluIdx),
278 fCaloIndex(track.fCaloIndex),
279 fHMPIDtrkTheta(track.fHMPIDtrkTheta),
280 fHMPIDtrkPhi(track.fHMPIDtrkPhi),
281 fHMPIDsignal(track.fHMPIDsignal),
282 fTrackLength(track.fTrackLength),
283 fdTPC(track.fdTPC),fzTPC(track.fzTPC),
284 fCddTPC(track.fCddTPC),fCdzTPC(track.fCdzTPC),fCzzTPC(track.fCzzTPC),
285 fCchi2TPC(track.fCchi2TPC),
286 fD(track.fD),fZ(track.fZ),
287 fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
288 fCchi2(track.fCchi2),
289 fITSchi2(track.fITSchi2),
290 fTPCchi2(track.fTPCchi2),
291 fTPCchi2Iter1(track.fTPCchi2Iter1),
292 fTRDchi2(track.fTRDchi2),
293 fTOFchi2(track.fTOFchi2),
294 fHMPIDchi2(track.fHMPIDchi2),
295 fGlobalChi2(track.fGlobalChi2),
296 fITSsignal(track.fITSsignal),
297 fTPCsignal(track.fTPCsignal),
298 fTPCsignalS(track.fTPCsignalS),
299 fTRDsignal(track.fTRDsignal),
300 fTRDQuality(track.fTRDQuality),
301 fTRDBudget(track.fTRDBudget),
302 fTOFsignal(track.fTOFsignal),
303 fTOFsignalToT(track.fTOFsignalToT),
304 fTOFsignalRaw(track.fTOFsignalRaw),
305 fTOFsignalDz(track.fTOFsignalDz),
306 fTOFsignalDx(track.fTOFsignalDx),
307 fTOFdeltaBC(track.fTOFdeltaBC),
308 fTOFl0l1(track.fTOFl0l1),
309 fCaloDx(track.fCaloDx),
310 fCaloDz(track.fCaloDz),
311 fHMPIDtrkX(track.fHMPIDtrkX),
312 fHMPIDtrkY(track.fHMPIDtrkY),
313 fHMPIDmipX(track.fHMPIDmipX),
314 fHMPIDmipY(track.fHMPIDmipY),
315 fTPCncls(track.fTPCncls),
316 fTPCnclsF(track.fTPCnclsF),
317 fTPCsignalN(track.fTPCsignalN),
318 fTPCnclsIter1(track.fTPCnclsIter1),
319 fTPCnclsFIter1(track.fTPCnclsIter1),
320 fITSncls(track.fITSncls),
321 fITSClusterMap(track.fITSClusterMap),
322 fTRDncls(track.fTRDncls),
323 fTRDncls0(track.fTRDncls0),
324 fTRDntracklets(track.fTRDntracklets),
325 fTRDnSlices(track.fTRDnSlices),
327 fVertexID(track.fVertexID),
328 fESDEvent(track.fESDEvent)
333 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i]=track.fTrackTime[i];
334 for (Int_t i=0;i<AliPID::kSPECIES;i++) fR[i]=track.fR[i];
336 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
338 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[i];
339 for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=track.fITSdEdxSamples[i];}
340 for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
341 for (Int_t i=0; i<3;i++) { fKinkIndexes[i]=track.fKinkIndexes[i];}
342 for (Int_t i=0; i<3;i++) { fV0Indexes[i]=track.fV0Indexes[i];}
344 for (Int_t i=0;i<kTRDnPlanes;i++) {
345 fTRDTimBin[i]=track.fTRDTimBin[i];
349 fTRDslices=new Double32_t[fTRDnSlices];
350 for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=track.fTRDslices[i];
353 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
354 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
355 for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
356 for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
357 for (Int_t i=0;i<12;i++) fITSModule[i]=track.fITSModule[i];
358 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i]=track.fHMPIDr[i];
360 if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
361 if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
362 if (track.fTPCInner) fTPCInner=new AliExternalTrackParam(*track.fTPCInner);
363 if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
364 if (track.fHMPIDp) fHMPIDp=new AliExternalTrackParam(*track.fHMPIDp);
366 if (track.fFriendTrack) fFriendTrack=new AliESDfriendTrack(*(track.fFriendTrack));
369 //_______________________________________________________________________
370 AliESDtrack::AliESDtrack(const AliVTrack *track) :
371 AliExternalTrackParam(track),
378 fTPCClusterMap(159),//number of padrows
379 fTPCSharedMap(159),//number of padrows
390 fCaloIndex(kEMCALNoMatch),
396 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
399 fCdd(0),fCdz(0),fCzz(0),
415 fTOFsignalToT(99999),
416 fTOFsignalRaw(99999),
439 fVertexID(-2), // -2 means an orphan track
443 // ESD track from AliVTrack.
444 // This is not a copy constructor !
447 if (track->InheritsFrom("AliExternalTrackParam")) {
448 AliError("This is not a copy constructor. Use AliESDtrack(const AliESDtrack &) !");
449 AliWarning("Calling the default constructor...");
454 // Reset all the arrays
456 for (i=0; i<AliPID::kSPECIES; i++) {
466 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
467 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
468 for (i=0;i<kTRDnPlanes;i++) {
471 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
472 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
473 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
474 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
475 for (i=0;i<12;i++) {fITSModule[i]=-1;}
478 SetID(track->GetID());
480 // Set ITS cluster map
481 fITSClusterMap=track->GetITSClusterMap();
485 if(HasPointOnITSLayer(i)) fITSncls++;
489 fTPCncls=track->GetTPCNcls();
492 // Set the combined PID
493 const Double_t *pid = track->PID();
495 for (i=0; i<AliPID::kSPECIES; i++) fR[i]=pid[i];
497 // AliESD track label
498 SetLabel(track->GetLabel());
500 SetStatus(track->GetStatus());
503 //_______________________________________________________________________
504 AliESDtrack::AliESDtrack(TParticle * part) :
505 AliExternalTrackParam(),
512 fTPCClusterMap(159),//number of padrows
513 fTPCSharedMap(159),//number of padrows
524 fCaloIndex(kEMCALNoMatch),
530 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
533 fCdd(0),fCdz(0),fCzz(0),
549 fTOFsignalToT(99999),
550 fTOFsignalRaw(99999),
573 fVertexID(-2), // -2 means an orphan track
577 // ESD track from TParticle
580 // Reset all the arrays
582 for (i=0; i<AliPID::kSPECIES; i++) {
592 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
593 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
594 for (i=0;i<kTRDnPlanes;i++) {
597 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
598 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
599 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
600 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
601 for (i=0;i<12;i++) {fITSModule[i]=-1;}
603 // Calculate the AliExternalTrackParam content
610 // Calculate alpha: the rotation angle of the corresponding local system (TPC sector)
611 alpha = part->Phi()*180./TMath::Pi();
612 if (alpha<0) alpha+= 360.;
613 if (alpha>360) alpha -= 360.;
615 Int_t sector = (Int_t)(alpha/20.);
616 alpha = 10. + 20.*sector;
618 alpha *= TMath::Pi();
620 // Covariance matrix: no errors, the parameters are exact
621 for (i=0; i<15; i++) covar[i]=0.;
623 // Get the vertex of origin and the momentum
624 TVector3 ver(part->Vx(),part->Vy(),part->Vz());
625 TVector3 mom(part->Px(),part->Py(),part->Pz());
627 // Rotate to the local coordinate system (TPC sector)
631 // X of the referense plane
634 Int_t pdgCode = part->GetPdgCode();
637 TDatabasePDG::Instance()->GetParticle(pdgCode)->Charge();
641 param[2] = TMath::Sin(mom.Phi());
642 param[3] = mom.Pz()/mom.Pt();
643 param[4] = TMath::Sign(1/mom.Pt(),charge);
645 // Set AliExternalTrackParam
646 Set(xref, alpha, param, covar);
651 switch (TMath::Abs(pdgCode)) {
677 // If the particle is not e,mu,pi,K or p the PID probabilities are set to 0
678 if (indexPID < AliPID::kSPECIES) {
684 fHMPIDr[indexPID]=1.;
687 // AliESD track label
688 SetLabel(part->GetUniqueID());
692 //_______________________________________________________________________
693 AliESDtrack::~AliESDtrack(){
695 // This is destructor according Coding Conventrions
697 //printf("Delete track\n");
708 AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source){
711 if(&source == this) return *this;
712 AliExternalTrackParam::operator=(source);
716 // we have the trackparam: assign or copy construct
717 if(fCp)*fCp = *source.fCp;
718 else fCp = new AliExternalTrackParam(*source.fCp);
721 // no track param delete the old one
727 // we have the trackparam: assign or copy construct
728 if(fIp)*fIp = *source.fIp;
729 else fIp = new AliExternalTrackParam(*source.fIp);
732 // no track param delete the old one
738 if(source.fTPCInner){
739 // we have the trackparam: assign or copy construct
740 if(fTPCInner) *fTPCInner = *source.fTPCInner;
741 else fTPCInner = new AliExternalTrackParam(*source.fTPCInner);
744 // no track param delete the old one
745 if(fTPCInner)delete fTPCInner;
751 // we have the trackparam: assign or copy construct
752 if(fOp) *fOp = *source.fOp;
753 else fOp = new AliExternalTrackParam(*source.fOp);
756 // no track param delete the old one
763 // we have the trackparam: assign or copy construct
764 if(fHMPIDp) *fHMPIDp = *source.fHMPIDp;
765 else fHMPIDp = new AliExternalTrackParam(*source.fHMPIDp);
768 // no track param delete the old one
769 if(fHMPIDp)delete fHMPIDp;
774 // copy also the friend track
775 // use copy constructor
776 if(source.fFriendTrack){
777 // we have the trackparam: assign or copy construct
778 delete fFriendTrack; fFriendTrack=new AliESDfriendTrack(*source.fFriendTrack);
781 // no track param delete the old one
782 delete fFriendTrack; fFriendTrack= 0;
785 fTPCClusterMap = source.fTPCClusterMap;
786 fTPCSharedMap = source.fTPCSharedMap;
788 fFlags = source.fFlags;
790 fLabel = source.fLabel;
791 fITSLabel = source.fITSLabel;
792 for(int i = 0; i< 12;++i){
793 fITSModule[i] = source.fITSModule[i];
795 fTPCLabel = source.fTPCLabel;
796 fTRDLabel = source.fTRDLabel;
797 for(int i = 0; i< 3;++i){
798 fTOFLabel[i] = source.fTOFLabel[i];
800 fTOFCalChannel = source.fTOFCalChannel;
801 fTOFindex = source.fTOFindex;
802 fHMPIDqn = source.fHMPIDqn;
803 fHMPIDcluIdx = source.fHMPIDcluIdx;
804 fCaloIndex = source.fCaloIndex;
806 for(int i = 0; i< 3;++i){
807 fKinkIndexes[i] = source.fKinkIndexes[i];
808 fV0Indexes[i] = source.fV0Indexes[i];
811 for(int i = 0; i< AliPID::kSPECIES;++i){
812 fR[i] = source.fR[i];
813 fITSr[i] = source.fITSr[i];
814 fTPCr[i] = source.fTPCr[i];
815 fTRDr[i] = source.fTRDr[i];
816 fTOFr[i] = source.fTOFr[i];
817 fHMPIDr[i] = source.fHMPIDr[i];
818 fTrackTime[i] = source.fTrackTime[i];
821 fHMPIDtrkTheta = source.fHMPIDtrkTheta;
822 fHMPIDtrkPhi = source.fHMPIDtrkPhi;
823 fHMPIDsignal = source.fHMPIDsignal;
826 fTrackLength = source. fTrackLength;
827 fdTPC = source.fdTPC;
828 fzTPC = source.fzTPC;
829 fCddTPC = source.fCddTPC;
830 fCdzTPC = source.fCdzTPC;
831 fCzzTPC = source.fCzzTPC;
832 fCchi2TPC = source.fCchi2TPC;
839 fCchi2 = source.fCchi2;
841 fITSchi2 = source.fITSchi2;
842 fTPCchi2 = source.fTPCchi2;
843 fTPCchi2Iter1 = source.fTPCchi2Iter1;
844 fTRDchi2 = source.fTRDchi2;
845 fTOFchi2 = source.fTOFchi2;
846 fHMPIDchi2 = source.fHMPIDchi2;
848 fGlobalChi2 = source.fGlobalChi2;
850 fITSsignal = source.fITSsignal;
851 for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=source.fITSdEdxSamples[i];}
852 fTPCsignal = source.fTPCsignal;
853 fTPCsignalS = source.fTPCsignalS;
854 for(int i = 0; i< 4;++i){
855 fTPCPoints[i] = source.fTPCPoints[i];
857 fTRDsignal = source.fTRDsignal;
859 for(int i = 0;i < kTRDnPlanes;++i){
860 fTRDTimBin[i] = source.fTRDTimBin[i];
866 fTRDnSlices=source.fTRDnSlices;
868 fTRDslices=new Double32_t[fTRDnSlices];
869 for(int j = 0;j < fTRDnSlices;++j) fTRDslices[j] = source.fTRDslices[j];
872 fTRDQuality = source.fTRDQuality;
873 fTRDBudget = source.fTRDBudget;
874 fTOFsignal = source.fTOFsignal;
875 fTOFsignalToT = source.fTOFsignalToT;
876 fTOFsignalRaw = source.fTOFsignalRaw;
877 fTOFsignalDz = source.fTOFsignalDz;
878 fTOFsignalDx = source.fTOFsignalDx;
879 fTOFdeltaBC = source.fTOFdeltaBC;
880 fTOFl0l1 = source.fTOFl0l1;
882 for(int i = 0;i<10;++i){
883 fTOFInfo[i] = source.fTOFInfo[i];
886 fHMPIDtrkX = source.fHMPIDtrkX;
887 fHMPIDtrkY = source.fHMPIDtrkY;
888 fHMPIDmipX = source.fHMPIDmipX;
889 fHMPIDmipY = source.fHMPIDmipY;
891 fTPCncls = source.fTPCncls;
892 fTPCnclsF = source.fTPCnclsF;
893 fTPCsignalN = source.fTPCsignalN;
894 fTPCnclsIter1 = source.fTPCnclsIter1;
895 fTPCnclsFIter1 = source.fTPCnclsFIter1;
897 fITSncls = source.fITSncls;
898 fITSClusterMap = source.fITSClusterMap;
899 fTRDncls = source.fTRDncls;
900 fTRDncls0 = source.fTRDncls0;
901 fTRDntracklets = source.fTRDntracklets;
902 fVertexID = source.fVertexID;
908 void AliESDtrack::Copy(TObject &obj) const {
910 // this overwrites the virtual TOBject::Copy()
911 // to allow run time copying without casting
914 if(this==&obj)return;
915 AliESDtrack *robj = dynamic_cast<AliESDtrack*>(&obj);
916 if(!robj)return; // not an AliESDtrack
923 void AliESDtrack::AddCalibObject(TObject * object){
925 // add calib object to the list
927 if (!fFriendTrack) fFriendTrack = new AliESDfriendTrack;
928 fFriendTrack->AddCalibObject(object);
931 TObject * AliESDtrack::GetCalibObject(Int_t index){
933 // return calib objct at given position
935 if (!fFriendTrack) return 0;
936 return fFriendTrack->GetCalibObject(index);
940 Bool_t AliESDtrack::FillTPCOnlyTrack(AliESDtrack &track){
942 // Fills the information of the TPC-only first reconstruction pass
943 // into the passed ESDtrack object. For consistency fTPCInner is also filled
948 // For data produced before r26675
949 // RelateToVertexTPC was not properly called during reco
950 // so you'll have to call it again, before FillTPCOnlyTrack
951 // Float_t p[2],cov[3];
952 // track->GetImpactParametersTPC(p,cov);
953 // if(p[0]==0&&p[1]==0) // <- Default values
954 // track->RelateToVertexTPC(esd->GetPrimaryVertexTPC(),esd->GetMagneticField(),kVeryBig);
957 if(!fTPCInner)return kFALSE;
959 // fill the TPC track params to the global track parameters
960 track.Set(fTPCInner->GetX(),fTPCInner->GetAlpha(),fTPCInner->GetParameter(),fTPCInner->GetCovariance());
963 track.fCdd = fCddTPC;
964 track.fCdz = fCdzTPC;
965 track.fCzz = fCzzTPC;
967 // copy the TPCinner parameters
968 if(track.fTPCInner) *track.fTPCInner = *fTPCInner;
969 else track.fTPCInner = new AliExternalTrackParam(*fTPCInner);
972 track.fCddTPC = fCddTPC;
973 track.fCdzTPC = fCdzTPC;
974 track.fCzzTPC = fCzzTPC;
975 track.fCchi2TPC = fCchi2TPC;
978 // copy all other TPC specific parameters
980 // replace label by TPC label
981 track.fLabel = fTPCLabel;
982 track.fTPCLabel = fTPCLabel;
984 track.fTPCchi2 = fTPCchi2;
985 track.fTPCchi2Iter1 = fTPCchi2Iter1;
986 track.fTPCsignal = fTPCsignal;
987 track.fTPCsignalS = fTPCsignalS;
988 for(int i = 0;i<4;++i)track.fTPCPoints[i] = fTPCPoints[i];
990 track.fTPCncls = fTPCncls;
991 track.fTPCnclsF = fTPCnclsF;
992 track.fTPCsignalN = fTPCsignalN;
993 track.fTPCnclsIter1 = fTPCnclsIter1;
994 track.fTPCnclsFIter1 = fTPCnclsFIter1;
997 for(int i=0;i<AliPID::kSPECIES;++i){
998 track.fTPCr[i] = fTPCr[i];
999 // combined PID is TPC only!
1000 track.fR[i] = fTPCr[i];
1002 track.fTPCClusterMap = fTPCClusterMap;
1003 track.fTPCSharedMap = fTPCSharedMap;
1007 track.fFlags = kTPCin;
1010 track.fFlags |= fFlags & kTPCpid; //copy the TPCpid status flag
1012 for (Int_t i=0;i<3;i++) track.fKinkIndexes[i] = fKinkIndexes[i];
1018 //_______________________________________________________________________
1019 void AliESDtrack::MakeMiniESDtrack(){
1020 // Resets everything except
1021 // fFlags: Reconstruction status flags
1022 // fLabel: Track label
1023 // fID: Unique ID of the track
1024 // Impact parameter information
1025 // fR[AliPID::kSPECIES]: combined "detector response probability"
1026 // Running track parameters in the base class (AliExternalTrackParam)
1030 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
1032 // Reset track parameters constrained to the primary vertex
1035 // Reset track parameters at the inner wall of TPC
1037 delete fTPCInner;fTPCInner=0;
1038 // Reset track parameters at the inner wall of the TRD
1040 // Reset track parameters at the HMPID
1041 delete fHMPIDp;fHMPIDp = 0;
1044 // Reset ITS track related information
1049 for (Int_t i=0;i<4;i++) fITSdEdxSamples[i] = 0.;
1050 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
1053 // Reset TPC related track information
1065 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=0;
1067 for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
1068 for (Int_t i=0; i<3;i++) fKinkIndexes[i] = 0;
1069 for (Int_t i=0; i<3;i++) fV0Indexes[i] = 0;
1071 // Reset TRD related track information
1076 for (Int_t i=0;i<kTRDnPlanes;i++) {
1079 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
1084 delete[] fTRDslices;
1089 // Reset TOF related track information
1093 fTOFCalChannel = -1;
1094 fTOFsignalToT = 99999;
1095 fTOFsignalRaw = 99999;
1100 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
1101 for (Int_t i=0;i<3;i++) fTOFLabel[i] = -1;
1102 for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
1104 // Reset HMPID related track information
1109 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
1116 fCaloIndex = kEMCALNoMatch;
1118 // reset global track chi2
1121 fVertexID = -2; // an orphan track
1123 delete fFriendTrack; fFriendTrack = 0;
1125 //_______________________________________________________________________
1126 Double_t AliESDtrack::GetMass() const {
1127 // Returns the mass of the most probable particle type
1130 for (i=0; i<AliPID::kSPECIES-1; i++) {
1131 if (fR[i] != fR[i+1]) break;
1133 // If all the probabilities are equal, return the pion mass
1134 if (i == AliPID::kSPECIES-1) return AliPID::ParticleMass(AliPID::kPion);
1138 for (i=0; i<AliPID::kSPECIES; i++) {
1139 if (fR[i]>max) {k=i; max=fR[i];}
1141 if (k==0) { // dE/dx "crossing points" in the TPC
1143 if ((p>0.38)&&(p<0.48))
1144 if (fR[0]<fR[3]*10.) return AliPID::ParticleMass(AliPID::kKaon);
1145 if ((p>0.75)&&(p<0.85))
1146 if (fR[0]<fR[4]*10.) return AliPID::ParticleMass(AliPID::kProton);
1149 if (k==1) return AliPID::ParticleMass(AliPID::kMuon);
1150 if (k==2||k==-1) return AliPID::ParticleMass(AliPID::kPion);
1151 if (k==3) return AliPID::ParticleMass(AliPID::kKaon);
1152 if (k==4) return AliPID::ParticleMass(AliPID::kProton);
1153 AliWarning("Undefined mass !");
1154 return AliPID::ParticleMass(AliPID::kPion);
1157 //______________________________________________________________________________
1158 Double_t AliESDtrack::M() const
1160 // Returns the assumed mass
1161 // (the pion mass, if the particle can't be identified properly).
1163 AliWarning("This is the ESD mass. Use it with care !");
1167 //______________________________________________________________________________
1168 Double_t AliESDtrack::E() const
1170 // Returns the energy of the particle given its assumed mass.
1171 // Assumes the pion mass if the particle can't be identified properly.
1175 return TMath::Sqrt(p*p + m*m);
1178 //______________________________________________________________________________
1179 Double_t AliESDtrack::Y() const
1181 // Returns the rapidity of a particle given its assumed mass.
1182 // Assumes the pion mass if the particle can't be identified properly.
1186 if (e != TMath::Abs(pz)) { // energy was not equal to pz
1187 return 0.5*TMath::Log((e+pz)/(e-pz));
1188 } else { // energy was equal to pz
1193 //_______________________________________________________________________
1194 Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
1196 // This function updates track's running parameters
1201 fLabel=t->GetLabel();
1203 if (t->IsStartedTimeIntegral()) {
1205 Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
1206 SetIntegratedLength(t->GetIntegratedLength());
1209 Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1210 if (flags==kITSout) fFriendTrack->SetITSOut(*t);
1211 if (flags==kTPCout) fFriendTrack->SetTPCOut(*t);
1212 if (flags==kTRDrefit) fFriendTrack->SetTRDIn(*t);
1216 case kITSin: case kITSout: case kITSrefit:
1219 fITSncls=t->GetNumberOfClusters();
1220 Int_t* indexITS = new Int_t[AliESDfriendTrack::kMaxITScluster];
1221 for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
1222 indexITS[i]=t->GetClusterIndex(i);
1225 Int_t l=(indexITS[i] & 0xf0000000) >> 28;
1226 SETBIT(fITSClusterMap,l);
1229 fFriendTrack->SetITSIndices(indexITS,AliESDfriendTrack::kMaxITScluster);
1232 fITSchi2=t->GetChi2();
1233 fITSsignal=t->GetPIDsignal();
1234 fITSLabel = t->GetLabel();
1235 // keep in fOp the parameters outside ITS for ITS stand-alone tracks
1236 if (flags==kITSout) {
1237 if (!fOp) fOp=new AliExternalTrackParam(*t);
1239 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1244 case kTPCin: case kTPCrefit:
1246 fTPCLabel = t->GetLabel();
1247 if (flags==kTPCin) {
1248 fTPCInner=new AliExternalTrackParam(*t);
1249 fTPCnclsIter1=t->GetNumberOfClusters();
1250 fTPCchi2Iter1=t->GetChi2();
1252 if (!fIp) fIp=new AliExternalTrackParam(*t);
1254 fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1258 Int_t* indexTPC = new Int_t[AliESDfriendTrack::kMaxTPCcluster];
1259 if (flags & kTPCout){
1260 if (!fOp) fOp=new AliExternalTrackParam(*t);
1262 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1264 fTPCncls=t->GetNumberOfClusters();
1265 fTPCchi2=t->GetChi2();
1267 {//prevrow must be declared in separate namespace, otherwise compiler cries:
1268 //"jump to case label crosses initialization of `Int_t prevrow'"
1270 // for (Int_t i=0;i<fTPCncls;i++)
1271 for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)
1273 indexTPC[i]=t->GetClusterIndex(i);
1274 Int_t idx = indexTPC[i];
1276 if (idx<0) continue;
1278 // Piotr's Cluster Map for HBT
1279 // ### please change accordingly if cluster array is changing
1280 // to "New TPC Tracking" style (with gaps in array)
1281 Int_t sect = (idx&0xff000000)>>24;
1282 Int_t row = (idx&0x00ff0000)>>16;
1283 if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
1285 fTPCClusterMap.SetBitNumber(row,kTRUE);
1287 //Fill the gap between previous row and this row with 0 bits
1288 //In case ### pleas change it as well - just set bit 0 in case there
1289 //is no associated clusters for current "i"
1292 prevrow = row;//if previous bit was not assigned yet == this is the first one
1295 { //we don't know the order (inner to outer or reverse)
1296 //just to be save in case it is going to change
1309 for (Int_t j = n+1; j < m; j++)
1311 fTPCClusterMap.SetBitNumber(j,kFALSE);
1315 // End Of Piotr's Cluster Map for HBT
1317 fFriendTrack->SetTPCIndices(indexTPC,AliESDfriendTrack::kMaxTPCcluster);
1321 fTPCsignal=t->GetPIDsignal();
1325 case kTRDin: case kTRDrefit:
1329 fTRDLabel = t->GetLabel();
1330 fTRDchi2 = t->GetChi2();
1331 fTRDncls = t->GetNumberOfClusters();
1332 Int_t* indexTRD = new Int_t[AliESDfriendTrack::kMaxTRDcluster];
1333 for (Int_t i=0;i<AliESDfriendTrack::kMaxTRDcluster;i++) indexTRD[i]=-2;
1334 for (Int_t i=0;i<6;i++) indexTRD[i]=t->GetTrackletIndex(i);
1335 fFriendTrack->SetTRDIndices(indexTRD,AliESDfriendTrack::kMaxTRDcluster);
1339 fTRDsignal=t->GetPIDsignal();
1343 if (!fOp) fOp=new AliExternalTrackParam(*t);
1345 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1346 fTRDncls0 = t->GetNumberOfClusters();
1355 if (!fHMPIDp) fHMPIDp=new AliExternalTrackParam(*t);
1357 fHMPIDp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1360 AliError("Wrong flag !");
1367 //_______________________________________________________________________
1368 void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
1369 //---------------------------------------------------------------------
1370 // This function returns external representation of the track parameters
1371 //---------------------------------------------------------------------
1373 for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
1376 //_______________________________________________________________________
1377 void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
1378 //---------------------------------------------------------------------
1379 // This function returns external representation of the cov. matrix
1380 //---------------------------------------------------------------------
1381 for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
1384 //_______________________________________________________________________
1385 Bool_t AliESDtrack::GetConstrainedExternalParameters
1386 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1387 //---------------------------------------------------------------------
1388 // This function returns the constrained external track parameters
1389 //---------------------------------------------------------------------
1390 if (!fCp) return kFALSE;
1391 alpha=fCp->GetAlpha();
1393 for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
1397 //_______________________________________________________________________
1399 AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
1400 //---------------------------------------------------------------------
1401 // This function returns the constrained external cov. matrix
1402 //---------------------------------------------------------------------
1403 if (!fCp) return kFALSE;
1404 for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
1409 AliESDtrack::GetInnerExternalParameters
1410 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1411 //---------------------------------------------------------------------
1412 // This function returns external representation of the track parameters
1413 // at the inner layer of TPC
1414 //---------------------------------------------------------------------
1415 if (!fIp) return kFALSE;
1416 alpha=fIp->GetAlpha();
1418 for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
1423 AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const {
1424 //---------------------------------------------------------------------
1425 // This function returns external representation of the cov. matrix
1426 // at the inner layer of TPC
1427 //---------------------------------------------------------------------
1428 if (!fIp) return kFALSE;
1429 for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
1434 AliESDtrack::SetOuterParam(const AliExternalTrackParam *p, ULong_t flags) {
1436 // This is a direct setter for the outer track parameters
1439 if (fOp) delete fOp;
1440 fOp=new AliExternalTrackParam(*p);
1444 AliESDtrack::SetOuterHmpParam(const AliExternalTrackParam *p, ULong_t flags) {
1446 // This is a direct setter for the outer track parameters
1449 if (fHMPIDp) delete fHMPIDp;
1450 fHMPIDp=new AliExternalTrackParam(*p);
1454 AliESDtrack::GetOuterExternalParameters
1455 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1456 //---------------------------------------------------------------------
1457 // This function returns external representation of the track parameters
1458 // at the inner layer of TRD
1459 //---------------------------------------------------------------------
1460 if (!fOp) return kFALSE;
1461 alpha=fOp->GetAlpha();
1463 for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
1468 AliESDtrack::GetOuterHmpExternalParameters
1469 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1470 //---------------------------------------------------------------------
1471 // This function returns external representation of the track parameters
1472 // at the inner layer of TRD
1473 //---------------------------------------------------------------------
1474 if (!fHMPIDp) return kFALSE;
1475 alpha=fHMPIDp->GetAlpha();
1477 for (Int_t i=0; i<5; i++) p[i]=fHMPIDp->GetParameter()[i];
1482 AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
1483 //---------------------------------------------------------------------
1484 // This function returns external representation of the cov. matrix
1485 // at the inner layer of TRD
1486 //---------------------------------------------------------------------
1487 if (!fOp) return kFALSE;
1488 for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
1493 AliESDtrack::GetOuterHmpExternalCovariance(Double_t cov[15]) const {
1494 //---------------------------------------------------------------------
1495 // This function returns external representation of the cov. matrix
1496 // at the inner layer of TRD
1497 //---------------------------------------------------------------------
1498 if (!fHMPIDp) return kFALSE;
1499 for (Int_t i=0; i<15; i++) cov[i]=fHMPIDp->GetCovariance()[i];
1503 Int_t AliESDtrack::GetNcls(Int_t idet) const
1505 // Get number of clusters by subdetector index
1519 if (fTOFindex != -1)
1525 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1526 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1537 Int_t AliESDtrack::GetClusters(Int_t idet, Int_t *idx) const
1539 // Get cluster index array by subdetector index
1544 ncls = GetITSclusters(idx);
1547 ncls = GetTPCclusters(idx);
1550 ncls = GetTRDclusters(idx);
1553 if (fTOFindex != -1) {
1561 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1562 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1563 idx[0] = GetHMPIDcluIdx();
1576 //_______________________________________________________________________
1577 void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
1578 // Returns the array with integrated times for each particle hypothesis
1579 for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
1582 //_______________________________________________________________________
1583 void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
1584 // Sets the array with integrated times for each particle hypotesis
1585 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
1588 //_______________________________________________________________________
1589 void AliESDtrack::SetITSpid(const Double_t *p) {
1590 // Sets values for the probability of each particle type (in ITS)
1591 SetPIDValues(fITSr,p,AliPID::kSPECIES);
1592 SetStatus(AliESDtrack::kITSpid);
1595 //_______________________________________________________________________
1596 void AliESDtrack::GetITSpid(Double_t *p) const {
1597 // Gets the probability of each particle type (in ITS)
1598 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
1601 //_______________________________________________________________________
1602 Char_t AliESDtrack::GetITSclusters(Int_t *idx) const {
1603 //---------------------------------------------------------------------
1604 // This function returns indices of the assgined ITS clusters
1605 //---------------------------------------------------------------------
1607 Int_t *index=fFriendTrack->GetITSindices();
1608 for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) {
1609 if ( (i>=fITSncls) && (i<6) ) idx[i]=-1;
1621 //_______________________________________________________________________
1622 Bool_t AliESDtrack::GetITSModuleIndexInfo(Int_t ilayer,Int_t &idet,Int_t &status,
1623 Float_t &xloc,Float_t &zloc) const {
1624 //----------------------------------------------------------------------
1625 // This function encodes in the module number also the status of cluster association
1626 // "status" can have the following values:
1627 // 1 "found" (cluster is associated),
1628 // 2 "dead" (module is dead from OCDB),
1629 // 3 "skipped" (module or layer forced to be skipped),
1630 // 4 "outinz" (track out of z acceptance),
1631 // 5 "nocls" (no clusters in the road),
1632 // 6 "norefit" (cluster rejected during refit),
1633 // 7 "deadzspd" (holes in z in SPD)
1634 // Also given are the coordinates of the crossing point of track and module
1635 // (in the local module ref. system)
1636 // WARNING: THIS METHOD HAS TO BE SYNCHRONIZED WITH AliITStrackV2::GetModuleIndexInfo()!
1637 //----------------------------------------------------------------------
1639 if(fITSModule[ilayer]==-1) {
1642 xloc=-99.; zloc=-99.;
1646 Int_t module = fITSModule[ilayer];
1648 idet = Int_t(module/1000000);
1650 module -= idet*1000000;
1652 status = Int_t(module/100000);
1654 module -= status*100000;
1656 Int_t signs = Int_t(module/10000);
1658 module-=signs*10000;
1660 Int_t xInt = Int_t(module/100);
1663 Int_t zInt = module;
1665 if(signs==1) { xInt*=1; zInt*=1; }
1666 if(signs==2) { xInt*=1; zInt*=-1; }
1667 if(signs==3) { xInt*=-1; zInt*=1; }
1668 if(signs==4) { xInt*=-1; zInt*=-1; }
1670 xloc = 0.1*(Float_t)xInt;
1671 zloc = 0.1*(Float_t)zInt;
1673 if(status==4) idet = -1;
1678 //_______________________________________________________________________
1679 UShort_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
1680 //---------------------------------------------------------------------
1681 // This function returns indices of the assgined ITS clusters
1682 //---------------------------------------------------------------------
1684 Int_t *index=fFriendTrack->GetTPCindices();
1687 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
1690 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=-2;
1696 Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
1698 // GetDensity of the clusters on given region between row0 and row1
1699 // Dead zone effect takin into acoount
1704 Int_t *index=fFriendTrack->GetTPCindices();
1705 for (Int_t i=row0;i<=row1;i++){
1706 Int_t idx = index[i];
1707 if (idx!=-1) good++; // track outside of dead zone
1710 Float_t density=0.5;
1711 if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
1715 //_______________________________________________________________________
1716 void AliESDtrack::SetTPCpid(const Double_t *p) {
1717 // Sets values for the probability of each particle type (in TPC)
1718 SetPIDValues(fTPCr,p,AliPID::kSPECIES);
1719 SetStatus(AliESDtrack::kTPCpid);
1722 //_______________________________________________________________________
1723 void AliESDtrack::GetTPCpid(Double_t *p) const {
1724 // Gets the probability of each particle type (in TPC)
1725 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
1728 //_______________________________________________________________________
1729 UChar_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
1730 //---------------------------------------------------------------------
1731 // This function returns indices of the assgined TRD clusters
1732 //---------------------------------------------------------------------
1734 Int_t *index=fFriendTrack->GetTRDindices();
1737 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
1740 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=-2;
1746 //_______________________________________________________________________
1747 UChar_t AliESDtrack::GetTRDtracklets(Int_t *idx) const {
1749 // This function returns the number of TRD tracklets used in tracking
1750 // and it fills the indices of these tracklets in the array "idx" as they
1751 // are registered in the TRD track list.
1754 // 1. The idx array has to be allocated with a size >= AliESDtrack::kTRDnPlanes
1755 // 2. The idx array store not only the index but also the layer of the tracklet.
1756 // Therefore tracks with TRD gaps contain default values for indices [-1]
1758 if (!idx) return GetTRDntracklets();
1759 Int_t *index=fFriendTrack->GetTRDindices();
1761 for (Int_t i=0; i<kTRDnPlanes; i++){
1763 if(index[i]>=0) n++;
1771 //_______________________________________________________________________
1772 void AliESDtrack::SetTRDpid(const Double_t *p) {
1773 // Sets values for the probability of each particle type (in TRD)
1774 SetPIDValues(fTRDr,p,AliPID::kSPECIES);
1775 SetStatus(AliESDtrack::kTRDpid);
1778 //_______________________________________________________________________
1779 void AliESDtrack::GetTRDpid(Double_t *p) const {
1780 // Gets the probability of each particle type (in TRD)
1781 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
1784 //_______________________________________________________________________
1785 void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
1787 // Sets the probability of particle type iSpecies to p (in TRD)
1788 fTRDr[iSpecies] = p;
1791 Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
1793 // Returns the probability of particle type iSpecies (in TRD)
1794 return fTRDr[iSpecies];
1797 //____________________________________________________
1798 Int_t AliESDtrack::GetNumberOfTRDslices() const
1800 // built in backward compatibility
1801 Int_t idx = fTRDnSlices - (kTRDnPlanes<<1);
1802 return idx<18 ? fTRDnSlices/kTRDnPlanes : idx/kTRDnPlanes;
1805 //____________________________________________________
1806 Double_t AliESDtrack::GetTRDmomentum(Int_t plane, Double_t *sp) const
1808 //Returns momentum estimation and optional its error (sp)
1809 // in TRD layer "plane".
1812 AliDebug(2, "No TRD info allocated for this track.");
1815 if ((plane<0) || (plane>=kTRDnPlanes)) {
1816 AliWarning(Form("Request for TRD plane[%d] outside range.", plane));
1820 Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
1821 // Protection for backward compatibility
1822 if(idx<(GetNumberOfTRDslices()*kTRDnPlanes)) return -1.;
1824 if(sp) (*sp) = fTRDslices[idx+kTRDnPlanes];
1825 return fTRDslices[idx];
1828 //____________________________________________________
1829 Double_t AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
1830 //Gets the charge from the slice of the plane
1833 //AliError("No TRD slices allocated for this track !");
1836 if ((plane<0) || (plane>=kTRDnPlanes)) {
1837 AliError("Info for TRD plane not available !");
1840 Int_t ns=GetNumberOfTRDslices();
1841 if ((slice<-1) || (slice>=ns)) {
1842 //AliError("Wrong TRD slice !");
1846 if(slice>=0) return fTRDslices[plane*ns + slice];
1848 // return average of the dEdx measurements
1849 Double_t q=0.; Double32_t *s = &fTRDslices[plane*ns];
1850 for (Int_t i=0; i<ns; i++, s++) if((*s)>0.) q+=(*s);
1854 //____________________________________________________
1855 void AliESDtrack::SetNumberOfTRDslices(Int_t n) {
1856 //Sets the number of slices used for PID
1857 if (fTRDnSlices) return;
1860 fTRDslices=new Double32_t[fTRDnSlices];
1862 // set-up correctly the allocated memory
1863 memset(fTRDslices, 0, n*sizeof(Double32_t));
1864 for (Int_t i=GetNumberOfTRDslices(); i--;) fTRDslices[i]=-1.;
1867 //____________________________________________________
1868 void AliESDtrack::SetTRDslice(Double_t q, Int_t plane, Int_t slice) {
1869 //Sets the charge q in the slice of the plane
1871 AliError("No TRD slices allocated for this track !");
1874 if ((plane<0) || (plane>=kTRDnPlanes)) {
1875 AliError("Info for TRD plane not allocated !");
1878 Int_t ns=GetNumberOfTRDslices();
1879 if ((slice<0) || (slice>=ns)) {
1880 AliError("Wrong TRD slice !");
1883 Int_t n=plane*ns + slice;
1888 //____________________________________________________
1889 void AliESDtrack::SetTRDmomentum(Double_t p, Int_t plane, Double_t *sp)
1892 AliError("No TRD slices allocated for this track !");
1895 if ((plane<0) || (plane>=kTRDnPlanes)) {
1896 AliError("Info for TRD plane not allocated !");
1900 Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
1901 // Protection for backward compatibility
1902 if(idx<GetNumberOfTRDslices()*kTRDnPlanes) return;
1904 if(sp) fTRDslices[idx+kTRDnPlanes] = (*sp);
1905 fTRDslices[idx] = p;
1909 //_______________________________________________________________________
1910 void AliESDtrack::SetTOFpid(const Double_t *p) {
1911 // Sets the probability of each particle type (in TOF)
1912 SetPIDValues(fTOFr,p,AliPID::kSPECIES);
1913 SetStatus(AliESDtrack::kTOFpid);
1916 //_______________________________________________________________________
1917 void AliESDtrack::SetTOFLabel(const Int_t *p) {
1919 for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
1922 //_______________________________________________________________________
1923 void AliESDtrack::GetTOFpid(Double_t *p) const {
1924 // Gets probabilities of each particle type (in TOF)
1925 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
1928 //_______________________________________________________________________
1929 void AliESDtrack::GetTOFLabel(Int_t *p) const {
1931 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
1934 //_______________________________________________________________________
1935 void AliESDtrack::GetTOFInfo(Float_t *info) const {
1937 for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
1940 //_______________________________________________________________________
1941 void AliESDtrack::SetTOFInfo(Float_t*info) {
1943 for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
1948 //_______________________________________________________________________
1949 void AliESDtrack::SetHMPIDpid(const Double_t *p) {
1950 // Sets the probability of each particle type (in HMPID)
1951 SetPIDValues(fHMPIDr,p,AliPID::kSPECIES);
1952 SetStatus(AliESDtrack::kHMPIDpid);
1955 //_______________________________________________________________________
1956 void AliESDtrack::GetHMPIDpid(Double_t *p) const {
1957 // Gets probabilities of each particle type (in HMPID)
1958 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fHMPIDr[i];
1963 //_______________________________________________________________________
1964 void AliESDtrack::SetESDpid(const Double_t *p) {
1965 // Sets the probability of each particle type for the ESD track
1966 SetPIDValues(fR,p,AliPID::kSPECIES);
1967 SetStatus(AliESDtrack::kESDpid);
1970 //_______________________________________________________________________
1971 void AliESDtrack::GetESDpid(Double_t *p) const {
1972 // Gets probability of each particle type for the ESD track
1973 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
1976 //_______________________________________________________________________
1977 Bool_t AliESDtrack::RelateToVertexTPC(const AliESDVertex *vtx,
1978 Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
1980 // Try to relate the TPC-only track parameters to the vertex "vtx",
1981 // if the (rough) transverse impact parameter is not bigger then "maxd".
1982 // Magnetic field is "b" (kG).
1984 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
1985 // b) The impact parameters and their covariance matrix are calculated.
1986 // c) An attempt to constrain the TPC-only params to the vertex is done.
1987 // The constrained params are returned via "cParam".
1989 // In the case of success, the returned value is kTRUE
1990 // otherwise, it's kFALSE)
1993 if (!fTPCInner) return kFALSE;
1994 if (!vtx) return kFALSE;
1996 Double_t dz[2],cov[3];
1997 if (!fTPCInner->PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
2005 Double_t covar[6]; vtx->GetCovMatrix(covar);
2006 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2007 Double_t c[3]={covar[2],0.,covar[5]};
2009 Double_t chi2=GetPredictedChi2(p,c);
2010 if (chi2>kVeryBig) return kFALSE;
2014 if (!cParam) return kTRUE;
2016 *cParam = *fTPCInner;
2017 if (!cParam->Update(p,c)) return kFALSE;
2022 //_______________________________________________________________________
2023 Bool_t AliESDtrack::RelateToVertexTPCBxByBz(const AliESDVertex *vtx,
2024 Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2026 // Try to relate the TPC-only track parameters to the vertex "vtx",
2027 // if the (rough) transverse impact parameter is not bigger then "maxd".
2029 // All three components of the magnetic field ,"b[3]" (kG),
2030 // are taken into account.
2032 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
2033 // b) The impact parameters and their covariance matrix are calculated.
2034 // c) An attempt to constrain the TPC-only params to the vertex is done.
2035 // The constrained params are returned via "cParam".
2037 // In the case of success, the returned value is kTRUE
2038 // otherwise, it's kFALSE)
2041 if (!fTPCInner) return kFALSE;
2042 if (!vtx) return kFALSE;
2044 Double_t dz[2],cov[3];
2045 if (!fTPCInner->PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2053 Double_t covar[6]; vtx->GetCovMatrix(covar);
2054 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2055 Double_t c[3]={covar[2],0.,covar[5]};
2057 Double_t chi2=GetPredictedChi2(p,c);
2058 if (chi2>kVeryBig) return kFALSE;
2062 if (!cParam) return kTRUE;
2064 *cParam = *fTPCInner;
2065 if (!cParam->Update(p,c)) return kFALSE;
2070 //_______________________________________________________________________
2071 Bool_t AliESDtrack::RelateToVertex(const AliESDVertex *vtx,
2072 Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
2074 // Try to relate this track to the vertex "vtx",
2075 // if the (rough) transverse impact parameter is not bigger then "maxd".
2076 // Magnetic field is "b" (kG).
2078 // a) The track gets extapolated to the DCA to the vertex.
2079 // b) The impact parameters and their covariance matrix are calculated.
2080 // c) An attempt to constrain this track to the vertex is done.
2081 // The constrained params are returned via "cParam".
2083 // In the case of success, the returned value is kTRUE
2084 // (otherwise, it's kFALSE)
2087 if (!vtx) return kFALSE;
2089 Double_t dz[2],cov[3];
2090 if (!PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
2098 Double_t covar[6]; vtx->GetCovMatrix(covar);
2099 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2100 Double_t c[3]={covar[2],0.,covar[5]};
2102 Double_t chi2=GetPredictedChi2(p,c);
2103 if (chi2>kVeryBig) return kFALSE;
2108 //--- Could now these lines be removed ? ---
2110 fCp=new AliExternalTrackParam(*this);
2112 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
2113 //----------------------------------------
2115 fVertexID = vtx->GetID();
2117 if (!cParam) return kTRUE;
2120 if (!cParam->Update(p,c)) return kFALSE;
2125 //_______________________________________________________________________
2126 Bool_t AliESDtrack::RelateToVertexBxByBz(const AliESDVertex *vtx,
2127 Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2129 // Try to relate this track to the vertex "vtx",
2130 // if the (rough) transverse impact parameter is not bigger then "maxd".
2131 // Magnetic field is "b" (kG).
2133 // a) The track gets extapolated to the DCA to the vertex.
2134 // b) The impact parameters and their covariance matrix are calculated.
2135 // c) An attempt to constrain this track to the vertex is done.
2136 // The constrained params are returned via "cParam".
2138 // In the case of success, the returned value is kTRUE
2139 // (otherwise, it's kFALSE)
2142 if (!vtx) return kFALSE;
2144 Double_t dz[2],cov[3];
2145 if (!PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2153 Double_t covar[6]; vtx->GetCovMatrix(covar);
2154 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2155 Double_t c[3]={covar[2],0.,covar[5]};
2157 Double_t chi2=GetPredictedChi2(p,c);
2158 if (chi2>kVeryBig) return kFALSE;
2163 //--- Could now these lines be removed ? ---
2165 fCp=new AliExternalTrackParam(*this);
2167 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
2168 //----------------------------------------
2170 fVertexID = vtx->GetID();
2172 if (!cParam) return kTRUE;
2175 if (!cParam->Update(p,c)) return kFALSE;
2180 //_______________________________________________________________________
2181 void AliESDtrack::Print(Option_t *) const {
2182 // Prints info on the track
2183 AliExternalTrackParam::Print();
2184 printf("ESD track info\n") ;
2185 Double_t p[AliPID::kSPECIESN] ;
2187 if( IsOn(kITSpid) ){
2188 printf("From ITS: ") ;
2190 for(index = 0 ; index < AliPID::kSPECIES; index++)
2191 printf("%f, ", p[index]) ;
2192 printf("\n signal = %f\n", GetITSsignal()) ;
2194 if( IsOn(kTPCpid) ){
2195 printf("From TPC: ") ;
2197 for(index = 0 ; index < AliPID::kSPECIES; index++)
2198 printf("%f, ", p[index]) ;
2199 printf("\n signal = %f\n", GetTPCsignal()) ;
2201 if( IsOn(kTRDpid) ){
2202 printf("From TRD: ") ;
2204 for(index = 0 ; index < AliPID::kSPECIES; index++)
2205 printf("%f, ", p[index]) ;
2206 printf("\n signal = %f\n", GetTRDsignal()) ;
2208 if( IsOn(kTOFpid) ){
2209 printf("From TOF: ") ;
2211 for(index = 0 ; index < AliPID::kSPECIES; index++)
2212 printf("%f, ", p[index]) ;
2213 printf("\n signal = %f\n", GetTOFsignal()) ;
2215 if( IsOn(kHMPIDpid) ){
2216 printf("From HMPID: ") ;
2218 for(index = 0 ; index < AliPID::kSPECIES; index++)
2219 printf("%f, ", p[index]) ;
2220 printf("\n signal = %f\n", GetHMPIDsignal()) ;
2226 // Draw functionality
2227 // Origin: Marian Ivanov, Marian.Ivanov@cern.ch
2229 void AliESDtrack::FillPolymarker(TPolyMarker3D *pol, Float_t magF, Float_t minR, Float_t maxR, Float_t stepR){
2231 // Fill points in the polymarker
2234 arrayRef.AddLast(new AliExternalTrackParam(*this));
2235 if (fIp) arrayRef.AddLast(new AliExternalTrackParam(*fIp));
2236 if (fOp) arrayRef.AddLast(new AliExternalTrackParam(*fOp));
2237 if (fHMPIDp) arrayRef.AddLast(new AliExternalTrackParam(*fHMPIDp));
2239 Double_t mpos[3]={0,0,0};
2240 Int_t entries=arrayRef.GetEntries();
2241 for (Int_t i=0;i<entries;i++){
2243 ((AliExternalTrackParam*)arrayRef.At(i))->GetXYZ(pos);
2244 mpos[0]+=pos[0]/entries;
2245 mpos[1]+=pos[1]/entries;
2246 mpos[2]+=pos[2]/entries;
2248 // Rotate to the mean position
2250 Float_t fi= TMath::ATan2(mpos[1],mpos[0]);
2251 for (Int_t i=0;i<entries;i++){
2252 Bool_t res = ((AliExternalTrackParam*)arrayRef.At(i))->Rotate(fi);
2253 if (!res) delete arrayRef.RemoveAt(i);
2256 for (Double_t r=minR; r<maxR; r+=stepR){
2258 Double_t mlpos[3]={0,0,0};
2259 for (Int_t i=0;i<entries;i++){
2260 Double_t point[3]={0,0,0};
2261 AliExternalTrackParam *param = ((AliExternalTrackParam*)arrayRef.At(i));
2262 if (!param) continue;
2263 if (param->GetXYZAt(r,magF,point)){
2264 Double_t weight = 1./(10.+(r-param->GetX())*(r-param->GetX()));
2266 mlpos[0]+=point[0]*weight;
2267 mlpos[1]+=point[1]*weight;
2268 mlpos[2]+=point[2]*weight;
2275 pol->SetPoint(counter,mlpos[0],mlpos[1], mlpos[2]);
2276 printf("xyz\t%f\t%f\t%f\n",mlpos[0], mlpos[1],mlpos[2]);
2282 //_______________________________________________________________________
2283 void AliESDtrack::SetITSdEdxSamples(const Double_t s[4]) {
2285 // Store the dE/dx samples measured by the two SSD and two SDD layers.
2286 // These samples are corrected for the track segment length.
2288 for (Int_t i=0; i<4; i++) fITSdEdxSamples[i]=s[i];
2291 //_______________________________________________________________________
2292 void AliESDtrack::GetITSdEdxSamples(Double_t *s) const {
2294 // Get the dE/dx samples measured by the two SSD and two SDD layers.
2295 // These samples are corrected for the track segment length.
2297 for (Int_t i=0; i<4; i++) s[i]=fITSdEdxSamples[i];
2301 UShort_t AliESDtrack::GetTPCnclsS(Int_t i0,Int_t i1) const{
2303 // get number of shared clusters
2305 return fTPCSharedMap.CountBits(i0)-fTPCSharedMap.CountBits(i1);