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),
229 fVertexID(-2),// -2 means an orphan track
233 // The default ESD constructor
236 for (i=0; i<AliPID::kSPECIES; i++) {
246 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
247 for (i=0; i<3; i++) { fV0Indexes[i]=0;}
248 for (i=0;i<kTRDnPlanes;i++) {
251 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
252 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
253 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
254 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
255 for (i=0;i<12;i++) {fITSModule[i]=-1;}
258 //_______________________________________________________________________
259 AliESDtrack::AliESDtrack(const AliESDtrack& track):
260 AliExternalTrackParam(track),
267 fTPCClusterMap(track.fTPCClusterMap),
268 fTPCSharedMap(track.fTPCSharedMap),
269 fFlags(track.fFlags),
271 fLabel(track.fLabel),
272 fITSLabel(track.fITSLabel),
273 fTPCLabel(track.fTPCLabel),
274 fTRDLabel(track.fTRDLabel),
275 fTOFCalChannel(track.fTOFCalChannel),
276 fTOFindex(track.fTOFindex),
277 fHMPIDqn(track.fHMPIDqn),
278 fHMPIDcluIdx(track.fHMPIDcluIdx),
279 fCaloIndex(track.fCaloIndex),
280 fHMPIDtrkTheta(track.fHMPIDtrkTheta),
281 fHMPIDtrkPhi(track.fHMPIDtrkPhi),
282 fHMPIDsignal(track.fHMPIDsignal),
283 fTrackLength(track.fTrackLength),
284 fdTPC(track.fdTPC),fzTPC(track.fzTPC),
285 fCddTPC(track.fCddTPC),fCdzTPC(track.fCdzTPC),fCzzTPC(track.fCzzTPC),
286 fCchi2TPC(track.fCchi2TPC),
287 fD(track.fD),fZ(track.fZ),
288 fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
289 fCchi2(track.fCchi2),
290 fITSchi2(track.fITSchi2),
291 fTPCchi2(track.fTPCchi2),
292 fTPCchi2Iter1(track.fTPCchi2Iter1),
293 fTRDchi2(track.fTRDchi2),
294 fTOFchi2(track.fTOFchi2),
295 fHMPIDchi2(track.fHMPIDchi2),
296 fGlobalChi2(track.fGlobalChi2),
297 fITSsignal(track.fITSsignal),
298 fTPCsignal(track.fTPCsignal),
299 fTPCsignalS(track.fTPCsignalS),
300 fTRDsignal(track.fTRDsignal),
301 fTRDQuality(track.fTRDQuality),
302 fTRDBudget(track.fTRDBudget),
303 fTOFsignal(track.fTOFsignal),
304 fTOFsignalToT(track.fTOFsignalToT),
305 fTOFsignalRaw(track.fTOFsignalRaw),
306 fTOFsignalDz(track.fTOFsignalDz),
307 fTOFsignalDx(track.fTOFsignalDx),
308 fTOFdeltaBC(track.fTOFdeltaBC),
309 fTOFl0l1(track.fTOFl0l1),
310 fCaloDx(track.fCaloDx),
311 fCaloDz(track.fCaloDz),
312 fHMPIDtrkX(track.fHMPIDtrkX),
313 fHMPIDtrkY(track.fHMPIDtrkY),
314 fHMPIDmipX(track.fHMPIDmipX),
315 fHMPIDmipY(track.fHMPIDmipY),
316 fTPCncls(track.fTPCncls),
317 fTPCnclsF(track.fTPCnclsF),
318 fTPCsignalN(track.fTPCsignalN),
319 fTPCnclsIter1(track.fTPCnclsIter1),
320 fTPCnclsFIter1(track.fTPCnclsIter1),
321 fITSncls(track.fITSncls),
322 fITSClusterMap(track.fITSClusterMap),
323 fITSSharedMap(track.fITSSharedMap),
324 fTRDncls(track.fTRDncls),
325 fTRDncls0(track.fTRDncls0),
326 fTRDntracklets(track.fTRDntracklets),
327 fTRDnSlices(track.fTRDnSlices),
329 fVertexID(track.fVertexID),
330 fESDEvent(track.fESDEvent)
335 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i]=track.fTrackTime[i];
336 for (Int_t i=0;i<AliPID::kSPECIES;i++) fR[i]=track.fR[i];
338 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
340 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[i];
341 for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=track.fITSdEdxSamples[i];}
342 for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
343 for (Int_t i=0; i<3;i++) { fKinkIndexes[i]=track.fKinkIndexes[i];}
344 for (Int_t i=0; i<3;i++) { fV0Indexes[i]=track.fV0Indexes[i];}
346 for (Int_t i=0;i<kTRDnPlanes;i++) {
347 fTRDTimBin[i]=track.fTRDTimBin[i];
351 fTRDslices=new Double32_t[fTRDnSlices];
352 for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=track.fTRDslices[i];
355 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
356 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
357 for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
358 for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
359 for (Int_t i=0;i<12;i++) fITSModule[i]=track.fITSModule[i];
360 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i]=track.fHMPIDr[i];
362 if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
363 if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
364 if (track.fTPCInner) fTPCInner=new AliExternalTrackParam(*track.fTPCInner);
365 if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
366 if (track.fHMPIDp) fHMPIDp=new AliExternalTrackParam(*track.fHMPIDp);
368 if (track.fFriendTrack) fFriendTrack=new AliESDfriendTrack(*(track.fFriendTrack));
371 //_______________________________________________________________________
372 AliESDtrack::AliESDtrack(const AliVTrack *track) :
373 AliExternalTrackParam(track),
380 fTPCClusterMap(159),//number of padrows
381 fTPCSharedMap(159),//number of padrows
392 fCaloIndex(kEMCALNoMatch),
398 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
401 fCdd(0),fCdz(0),fCzz(0),
417 fTOFsignalToT(99999),
418 fTOFsignalRaw(99999),
442 fVertexID(-2), // -2 means an orphan track
446 // ESD track from AliVTrack.
447 // This is not a copy constructor !
450 if (track->InheritsFrom("AliExternalTrackParam")) {
451 AliError("This is not a copy constructor. Use AliESDtrack(const AliESDtrack &) !");
452 AliWarning("Calling the default constructor...");
457 // Reset all the arrays
459 for (i=0; i<AliPID::kSPECIES; i++) {
469 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
470 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
471 for (i=0;i<kTRDnPlanes;i++) {
474 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
475 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
476 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
477 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
478 for (i=0;i<12;i++) {fITSModule[i]=-1;}
481 SetID(track->GetID());
483 // Set ITS cluster map
484 fITSClusterMap=track->GetITSClusterMap();
489 if(HasPointOnITSLayer(i)) fITSncls++;
493 fTPCncls=track->GetTPCNcls();
496 // Set the combined PID
497 const Double_t *pid = track->PID();
499 for (i=0; i<AliPID::kSPECIES; i++) fR[i]=pid[i];
501 // AliESD track label
502 SetLabel(track->GetLabel());
504 SetStatus(track->GetStatus());
507 //_______________________________________________________________________
508 AliESDtrack::AliESDtrack(TParticle * part) :
509 AliExternalTrackParam(),
516 fTPCClusterMap(159),//number of padrows
517 fTPCSharedMap(159),//number of padrows
528 fCaloIndex(kEMCALNoMatch),
534 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
537 fCdd(0),fCdz(0),fCzz(0),
553 fTOFsignalToT(99999),
554 fTOFsignalRaw(99999),
578 fVertexID(-2), // -2 means an orphan track
582 // ESD track from TParticle
585 // Reset all the arrays
587 for (i=0; i<AliPID::kSPECIES; i++) {
597 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
598 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
599 for (i=0;i<kTRDnPlanes;i++) {
602 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
603 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
604 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
605 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
606 for (i=0;i<12;i++) {fITSModule[i]=-1;}
608 // Calculate the AliExternalTrackParam content
615 // Calculate alpha: the rotation angle of the corresponding local system (TPC sector)
616 alpha = part->Phi()*180./TMath::Pi();
617 if (alpha<0) alpha+= 360.;
618 if (alpha>360) alpha -= 360.;
620 Int_t sector = (Int_t)(alpha/20.);
621 alpha = 10. + 20.*sector;
623 alpha *= TMath::Pi();
625 // Covariance matrix: no errors, the parameters are exact
626 for (i=0; i<15; i++) covar[i]=0.;
628 // Get the vertex of origin and the momentum
629 TVector3 ver(part->Vx(),part->Vy(),part->Vz());
630 TVector3 mom(part->Px(),part->Py(),part->Pz());
632 // Rotate to the local coordinate system (TPC sector)
636 // X of the referense plane
639 Int_t pdgCode = part->GetPdgCode();
642 TDatabasePDG::Instance()->GetParticle(pdgCode)->Charge();
646 param[2] = TMath::Sin(mom.Phi());
647 param[3] = mom.Pz()/mom.Pt();
648 param[4] = TMath::Sign(1/mom.Pt(),charge);
650 // Set AliExternalTrackParam
651 Set(xref, alpha, param, covar);
656 switch (TMath::Abs(pdgCode)) {
682 // If the particle is not e,mu,pi,K or p the PID probabilities are set to 0
683 if (indexPID < AliPID::kSPECIES) {
689 fHMPIDr[indexPID]=1.;
692 // AliESD track label
693 SetLabel(part->GetUniqueID());
697 //_______________________________________________________________________
698 AliESDtrack::~AliESDtrack(){
700 // This is destructor according Coding Conventrions
702 //printf("Delete track\n");
713 AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source){
716 if(&source == this) return *this;
717 AliExternalTrackParam::operator=(source);
721 // we have the trackparam: assign or copy construct
722 if(fCp)*fCp = *source.fCp;
723 else fCp = new AliExternalTrackParam(*source.fCp);
726 // no track param delete the old one
732 // we have the trackparam: assign or copy construct
733 if(fIp)*fIp = *source.fIp;
734 else fIp = new AliExternalTrackParam(*source.fIp);
737 // no track param delete the old one
743 if(source.fTPCInner){
744 // we have the trackparam: assign or copy construct
745 if(fTPCInner) *fTPCInner = *source.fTPCInner;
746 else fTPCInner = new AliExternalTrackParam(*source.fTPCInner);
749 // no track param delete the old one
750 if(fTPCInner)delete fTPCInner;
756 // we have the trackparam: assign or copy construct
757 if(fOp) *fOp = *source.fOp;
758 else fOp = new AliExternalTrackParam(*source.fOp);
761 // no track param delete the old one
768 // we have the trackparam: assign or copy construct
769 if(fHMPIDp) *fHMPIDp = *source.fHMPIDp;
770 else fHMPIDp = new AliExternalTrackParam(*source.fHMPIDp);
773 // no track param delete the old one
774 if(fHMPIDp)delete fHMPIDp;
779 // copy also the friend track
780 // use copy constructor
781 if(source.fFriendTrack){
782 // we have the trackparam: assign or copy construct
783 delete fFriendTrack; fFriendTrack=new AliESDfriendTrack(*source.fFriendTrack);
786 // no track param delete the old one
787 delete fFriendTrack; fFriendTrack= 0;
790 fTPCClusterMap = source.fTPCClusterMap;
791 fTPCSharedMap = source.fTPCSharedMap;
793 fFlags = source.fFlags;
795 fLabel = source.fLabel;
796 fITSLabel = source.fITSLabel;
797 for(int i = 0; i< 12;++i){
798 fITSModule[i] = source.fITSModule[i];
800 fTPCLabel = source.fTPCLabel;
801 fTRDLabel = source.fTRDLabel;
802 for(int i = 0; i< 3;++i){
803 fTOFLabel[i] = source.fTOFLabel[i];
805 fTOFCalChannel = source.fTOFCalChannel;
806 fTOFindex = source.fTOFindex;
807 fHMPIDqn = source.fHMPIDqn;
808 fHMPIDcluIdx = source.fHMPIDcluIdx;
809 fCaloIndex = source.fCaloIndex;
811 for(int i = 0; i< 3;++i){
812 fKinkIndexes[i] = source.fKinkIndexes[i];
813 fV0Indexes[i] = source.fV0Indexes[i];
816 for(int i = 0; i< AliPID::kSPECIES;++i){
817 fR[i] = source.fR[i];
818 fITSr[i] = source.fITSr[i];
819 fTPCr[i] = source.fTPCr[i];
820 fTRDr[i] = source.fTRDr[i];
821 fTOFr[i] = source.fTOFr[i];
822 fHMPIDr[i] = source.fHMPIDr[i];
823 fTrackTime[i] = source.fTrackTime[i];
826 fHMPIDtrkTheta = source.fHMPIDtrkTheta;
827 fHMPIDtrkPhi = source.fHMPIDtrkPhi;
828 fHMPIDsignal = source.fHMPIDsignal;
831 fTrackLength = source. fTrackLength;
832 fdTPC = source.fdTPC;
833 fzTPC = source.fzTPC;
834 fCddTPC = source.fCddTPC;
835 fCdzTPC = source.fCdzTPC;
836 fCzzTPC = source.fCzzTPC;
837 fCchi2TPC = source.fCchi2TPC;
844 fCchi2 = source.fCchi2;
846 fITSchi2 = source.fITSchi2;
847 fTPCchi2 = source.fTPCchi2;
848 fTPCchi2Iter1 = source.fTPCchi2Iter1;
849 fTRDchi2 = source.fTRDchi2;
850 fTOFchi2 = source.fTOFchi2;
851 fHMPIDchi2 = source.fHMPIDchi2;
853 fGlobalChi2 = source.fGlobalChi2;
855 fITSsignal = source.fITSsignal;
856 for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=source.fITSdEdxSamples[i];}
857 fTPCsignal = source.fTPCsignal;
858 fTPCsignalS = source.fTPCsignalS;
859 for(int i = 0; i< 4;++i){
860 fTPCPoints[i] = source.fTPCPoints[i];
862 fTRDsignal = source.fTRDsignal;
864 for(int i = 0;i < kTRDnPlanes;++i){
865 fTRDTimBin[i] = source.fTRDTimBin[i];
871 fTRDnSlices=source.fTRDnSlices;
873 fTRDslices=new Double32_t[fTRDnSlices];
874 for(int j = 0;j < fTRDnSlices;++j) fTRDslices[j] = source.fTRDslices[j];
877 fTRDQuality = source.fTRDQuality;
878 fTRDBudget = source.fTRDBudget;
879 fTOFsignal = source.fTOFsignal;
880 fTOFsignalToT = source.fTOFsignalToT;
881 fTOFsignalRaw = source.fTOFsignalRaw;
882 fTOFsignalDz = source.fTOFsignalDz;
883 fTOFsignalDx = source.fTOFsignalDx;
884 fTOFdeltaBC = source.fTOFdeltaBC;
885 fTOFl0l1 = source.fTOFl0l1;
887 for(int i = 0;i<10;++i){
888 fTOFInfo[i] = source.fTOFInfo[i];
891 fHMPIDtrkX = source.fHMPIDtrkX;
892 fHMPIDtrkY = source.fHMPIDtrkY;
893 fHMPIDmipX = source.fHMPIDmipX;
894 fHMPIDmipY = source.fHMPIDmipY;
896 fTPCncls = source.fTPCncls;
897 fTPCnclsF = source.fTPCnclsF;
898 fTPCsignalN = source.fTPCsignalN;
899 fTPCnclsIter1 = source.fTPCnclsIter1;
900 fTPCnclsFIter1 = source.fTPCnclsFIter1;
902 fITSncls = source.fITSncls;
903 fITSClusterMap = source.fITSClusterMap;
904 fITSSharedMap = source.fITSSharedMap;
905 fTRDncls = source.fTRDncls;
906 fTRDncls0 = source.fTRDncls0;
907 fTRDntracklets = source.fTRDntracklets;
908 fVertexID = source.fVertexID;
914 void AliESDtrack::Copy(TObject &obj) const {
916 // this overwrites the virtual TOBject::Copy()
917 // to allow run time copying without casting
920 if(this==&obj)return;
921 AliESDtrack *robj = dynamic_cast<AliESDtrack*>(&obj);
922 if(!robj)return; // not an AliESDtrack
929 void AliESDtrack::AddCalibObject(TObject * object){
931 // add calib object to the list
933 if (!fFriendTrack) fFriendTrack = new AliESDfriendTrack;
934 fFriendTrack->AddCalibObject(object);
937 TObject * AliESDtrack::GetCalibObject(Int_t index){
939 // return calib objct at given position
941 if (!fFriendTrack) return 0;
942 return fFriendTrack->GetCalibObject(index);
946 Bool_t AliESDtrack::FillTPCOnlyTrack(AliESDtrack &track){
948 // Fills the information of the TPC-only first reconstruction pass
949 // into the passed ESDtrack object. For consistency fTPCInner is also filled
954 // For data produced before r26675
955 // RelateToVertexTPC was not properly called during reco
956 // so you'll have to call it again, before FillTPCOnlyTrack
957 // Float_t p[2],cov[3];
958 // track->GetImpactParametersTPC(p,cov);
959 // if(p[0]==0&&p[1]==0) // <- Default values
960 // track->RelateToVertexTPC(esd->GetPrimaryVertexTPC(),esd->GetMagneticField(),kVeryBig);
963 if(!fTPCInner)return kFALSE;
965 // fill the TPC track params to the global track parameters
966 track.Set(fTPCInner->GetX(),fTPCInner->GetAlpha(),fTPCInner->GetParameter(),fTPCInner->GetCovariance());
969 track.fCdd = fCddTPC;
970 track.fCdz = fCdzTPC;
971 track.fCzz = fCzzTPC;
973 // copy the TPCinner parameters
974 if(track.fTPCInner) *track.fTPCInner = *fTPCInner;
975 else track.fTPCInner = new AliExternalTrackParam(*fTPCInner);
978 track.fCddTPC = fCddTPC;
979 track.fCdzTPC = fCdzTPC;
980 track.fCzzTPC = fCzzTPC;
981 track.fCchi2TPC = fCchi2TPC;
984 // copy all other TPC specific parameters
986 // replace label by TPC label
987 track.fLabel = fTPCLabel;
988 track.fTPCLabel = fTPCLabel;
990 track.fTPCchi2 = fTPCchi2;
991 track.fTPCchi2Iter1 = fTPCchi2Iter1;
992 track.fTPCsignal = fTPCsignal;
993 track.fTPCsignalS = fTPCsignalS;
994 for(int i = 0;i<4;++i)track.fTPCPoints[i] = fTPCPoints[i];
996 track.fTPCncls = fTPCncls;
997 track.fTPCnclsF = fTPCnclsF;
998 track.fTPCsignalN = fTPCsignalN;
999 track.fTPCnclsIter1 = fTPCnclsIter1;
1000 track.fTPCnclsFIter1 = fTPCnclsFIter1;
1003 for(int i=0;i<AliPID::kSPECIES;++i){
1004 track.fTPCr[i] = fTPCr[i];
1005 // combined PID is TPC only!
1006 track.fR[i] = fTPCr[i];
1008 track.fTPCClusterMap = fTPCClusterMap;
1009 track.fTPCSharedMap = fTPCSharedMap;
1013 track.fFlags = kTPCin;
1016 track.fFlags |= fFlags & kTPCpid; //copy the TPCpid status flag
1018 for (Int_t i=0;i<3;i++) track.fKinkIndexes[i] = fKinkIndexes[i];
1024 //_______________________________________________________________________
1025 void AliESDtrack::MakeMiniESDtrack(){
1026 // Resets everything except
1027 // fFlags: Reconstruction status flags
1028 // fLabel: Track label
1029 // fID: Unique ID of the track
1030 // Impact parameter information
1031 // fR[AliPID::kSPECIES]: combined "detector response probability"
1032 // Running track parameters in the base class (AliExternalTrackParam)
1036 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
1038 // Reset track parameters constrained to the primary vertex
1041 // Reset track parameters at the inner wall of TPC
1043 delete fTPCInner;fTPCInner=0;
1044 // Reset track parameters at the inner wall of the TRD
1046 // Reset track parameters at the HMPID
1047 delete fHMPIDp;fHMPIDp = 0;
1050 // Reset ITS track related information
1056 for (Int_t i=0;i<4;i++) fITSdEdxSamples[i] = 0.;
1057 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
1060 // Reset TPC related track information
1072 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=0;
1074 for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
1075 for (Int_t i=0; i<3;i++) fKinkIndexes[i] = 0;
1076 for (Int_t i=0; i<3;i++) fV0Indexes[i] = 0;
1078 // Reset TRD related track information
1083 for (Int_t i=0;i<kTRDnPlanes;i++) {
1086 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
1091 delete[] fTRDslices;
1096 // Reset TOF related track information
1100 fTOFCalChannel = -1;
1101 fTOFsignalToT = 99999;
1102 fTOFsignalRaw = 99999;
1107 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
1108 for (Int_t i=0;i<3;i++) fTOFLabel[i] = -1;
1109 for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
1111 // Reset HMPID related track information
1116 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
1123 fCaloIndex = kEMCALNoMatch;
1125 // reset global track chi2
1128 fVertexID = -2; // an orphan track
1130 delete fFriendTrack; fFriendTrack = 0;
1132 //_______________________________________________________________________
1133 Double_t AliESDtrack::GetMass() const {
1134 // Returns the mass of the most probable particle type
1137 for (i=0; i<AliPID::kSPECIES-1; i++) {
1138 if (fR[i] != fR[i+1]) break;
1140 // If all the probabilities are equal, return the pion mass
1141 if (i == AliPID::kSPECIES-1) return AliPID::ParticleMass(AliPID::kPion);
1145 for (i=0; i<AliPID::kSPECIES; i++) {
1146 if (fR[i]>max) {k=i; max=fR[i];}
1148 if (k==0) { // dE/dx "crossing points" in the TPC
1150 if ((p>0.38)&&(p<0.48))
1151 if (fR[0]<fR[3]*10.) return AliPID::ParticleMass(AliPID::kKaon);
1152 if ((p>0.75)&&(p<0.85))
1153 if (fR[0]<fR[4]*10.) return AliPID::ParticleMass(AliPID::kProton);
1156 if (k==1) return AliPID::ParticleMass(AliPID::kMuon);
1157 if (k==2||k==-1) return AliPID::ParticleMass(AliPID::kPion);
1158 if (k==3) return AliPID::ParticleMass(AliPID::kKaon);
1159 if (k==4) return AliPID::ParticleMass(AliPID::kProton);
1160 AliWarning("Undefined mass !");
1161 return AliPID::ParticleMass(AliPID::kPion);
1164 //______________________________________________________________________________
1165 Double_t AliESDtrack::M() const
1167 // Returns the assumed mass
1168 // (the pion mass, if the particle can't be identified properly).
1170 AliWarning("This is the ESD mass. Use it with care !");
1174 //______________________________________________________________________________
1175 Double_t AliESDtrack::E() const
1177 // Returns the energy of the particle given its assumed mass.
1178 // Assumes the pion mass if the particle can't be identified properly.
1182 return TMath::Sqrt(p*p + m*m);
1185 //______________________________________________________________________________
1186 Double_t AliESDtrack::Y() const
1188 // Returns the rapidity of a particle given its assumed mass.
1189 // Assumes the pion mass if the particle can't be identified properly.
1193 if (e != TMath::Abs(pz)) { // energy was not equal to pz
1194 return 0.5*TMath::Log((e+pz)/(e-pz));
1195 } else { // energy was equal to pz
1200 //_______________________________________________________________________
1201 Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
1203 // This function updates track's running parameters
1208 fLabel=t->GetLabel();
1210 if (t->IsStartedTimeIntegral()) {
1212 Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
1213 SetIntegratedLength(t->GetIntegratedLength());
1216 Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1217 if (flags==kITSout) fFriendTrack->SetITSOut(*t);
1218 if (flags==kTPCout) fFriendTrack->SetTPCOut(*t);
1219 if (flags==kTRDrefit) fFriendTrack->SetTRDIn(*t);
1223 case kITSin: case kITSout: case kITSrefit:
1226 fITSncls=t->GetNumberOfClusters();
1227 Int_t* indexITS = new Int_t[AliESDfriendTrack::kMaxITScluster];
1228 for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
1229 indexITS[i]=t->GetClusterIndex(i);
1232 Int_t l=(indexITS[i] & 0xf0000000) >> 28;
1233 SETBIT(fITSClusterMap,l);
1236 fFriendTrack->SetITSIndices(indexITS,AliESDfriendTrack::kMaxITScluster);
1239 fITSchi2=t->GetChi2();
1240 fITSsignal=t->GetPIDsignal();
1241 fITSLabel = t->GetLabel();
1242 // keep in fOp the parameters outside ITS for ITS stand-alone tracks
1243 if (flags==kITSout) {
1244 if (!fOp) fOp=new AliExternalTrackParam(*t);
1246 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1251 case kTPCin: case kTPCrefit:
1253 fTPCLabel = t->GetLabel();
1254 if (flags==kTPCin) {
1255 fTPCInner=new AliExternalTrackParam(*t);
1256 fTPCnclsIter1=t->GetNumberOfClusters();
1257 fTPCchi2Iter1=t->GetChi2();
1259 if (!fIp) fIp=new AliExternalTrackParam(*t);
1261 fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1265 Int_t* indexTPC = new Int_t[AliESDfriendTrack::kMaxTPCcluster];
1266 if (flags & kTPCout){
1267 if (!fOp) fOp=new AliExternalTrackParam(*t);
1269 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1271 fTPCncls=t->GetNumberOfClusters();
1272 fTPCchi2=t->GetChi2();
1274 {//prevrow must be declared in separate namespace, otherwise compiler cries:
1275 //"jump to case label crosses initialization of `Int_t prevrow'"
1277 // for (Int_t i=0;i<fTPCncls;i++)
1278 for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)
1280 indexTPC[i]=t->GetClusterIndex(i);
1281 Int_t idx = indexTPC[i];
1283 if (idx<0) continue;
1285 // Piotr's Cluster Map for HBT
1286 // ### please change accordingly if cluster array is changing
1287 // to "New TPC Tracking" style (with gaps in array)
1288 Int_t sect = (idx&0xff000000)>>24;
1289 Int_t row = (idx&0x00ff0000)>>16;
1290 if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
1292 fTPCClusterMap.SetBitNumber(row,kTRUE);
1294 //Fill the gap between previous row and this row with 0 bits
1295 //In case ### pleas change it as well - just set bit 0 in case there
1296 //is no associated clusters for current "i"
1299 prevrow = row;//if previous bit was not assigned yet == this is the first one
1302 { //we don't know the order (inner to outer or reverse)
1303 //just to be save in case it is going to change
1316 for (Int_t j = n+1; j < m; j++)
1318 fTPCClusterMap.SetBitNumber(j,kFALSE);
1322 // End Of Piotr's Cluster Map for HBT
1324 fFriendTrack->SetTPCIndices(indexTPC,AliESDfriendTrack::kMaxTPCcluster);
1328 fTPCsignal=t->GetPIDsignal();
1332 case kTRDin: case kTRDrefit:
1336 fTRDLabel = t->GetLabel();
1337 fTRDchi2 = t->GetChi2();
1338 fTRDncls = t->GetNumberOfClusters();
1339 Int_t* indexTRD = new Int_t[AliESDfriendTrack::kMaxTRDcluster];
1340 for (Int_t i=0;i<AliESDfriendTrack::kMaxTRDcluster;i++) indexTRD[i]=-2;
1341 for (Int_t i=0;i<6;i++) indexTRD[i]=t->GetTrackletIndex(i);
1342 fFriendTrack->SetTRDIndices(indexTRD,AliESDfriendTrack::kMaxTRDcluster);
1346 fTRDsignal=t->GetPIDsignal();
1350 if (!fOp) fOp=new AliExternalTrackParam(*t);
1352 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1353 fTRDncls0 = t->GetNumberOfClusters();
1362 if (!fHMPIDp) fHMPIDp=new AliExternalTrackParam(*t);
1364 fHMPIDp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1367 AliError("Wrong flag !");
1374 //_______________________________________________________________________
1375 void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
1376 //---------------------------------------------------------------------
1377 // This function returns external representation of the track parameters
1378 //---------------------------------------------------------------------
1380 for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
1383 //_______________________________________________________________________
1384 void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
1385 //---------------------------------------------------------------------
1386 // This function returns external representation of the cov. matrix
1387 //---------------------------------------------------------------------
1388 for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
1391 //_______________________________________________________________________
1392 Bool_t AliESDtrack::GetConstrainedExternalParameters
1393 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1394 //---------------------------------------------------------------------
1395 // This function returns the constrained external track parameters
1396 //---------------------------------------------------------------------
1397 if (!fCp) return kFALSE;
1398 alpha=fCp->GetAlpha();
1400 for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
1404 //_______________________________________________________________________
1406 AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
1407 //---------------------------------------------------------------------
1408 // This function returns the constrained external cov. matrix
1409 //---------------------------------------------------------------------
1410 if (!fCp) return kFALSE;
1411 for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
1416 AliESDtrack::GetInnerExternalParameters
1417 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1418 //---------------------------------------------------------------------
1419 // This function returns external representation of the track parameters
1420 // at the inner layer of TPC
1421 //---------------------------------------------------------------------
1422 if (!fIp) return kFALSE;
1423 alpha=fIp->GetAlpha();
1425 for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
1430 AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const {
1431 //---------------------------------------------------------------------
1432 // This function returns external representation of the cov. matrix
1433 // at the inner layer of TPC
1434 //---------------------------------------------------------------------
1435 if (!fIp) return kFALSE;
1436 for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
1441 AliESDtrack::SetOuterParam(const AliExternalTrackParam *p, ULong_t flags) {
1443 // This is a direct setter for the outer track parameters
1446 if (fOp) delete fOp;
1447 fOp=new AliExternalTrackParam(*p);
1451 AliESDtrack::SetOuterHmpParam(const AliExternalTrackParam *p, ULong_t flags) {
1453 // This is a direct setter for the outer track parameters
1456 if (fHMPIDp) delete fHMPIDp;
1457 fHMPIDp=new AliExternalTrackParam(*p);
1461 AliESDtrack::GetOuterExternalParameters
1462 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1463 //---------------------------------------------------------------------
1464 // This function returns external representation of the track parameters
1465 // at the inner layer of TRD
1466 //---------------------------------------------------------------------
1467 if (!fOp) return kFALSE;
1468 alpha=fOp->GetAlpha();
1470 for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
1475 AliESDtrack::GetOuterHmpExternalParameters
1476 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1477 //---------------------------------------------------------------------
1478 // This function returns external representation of the track parameters
1479 // at the inner layer of TRD
1480 //---------------------------------------------------------------------
1481 if (!fHMPIDp) return kFALSE;
1482 alpha=fHMPIDp->GetAlpha();
1484 for (Int_t i=0; i<5; i++) p[i]=fHMPIDp->GetParameter()[i];
1489 AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
1490 //---------------------------------------------------------------------
1491 // This function returns external representation of the cov. matrix
1492 // at the inner layer of TRD
1493 //---------------------------------------------------------------------
1494 if (!fOp) return kFALSE;
1495 for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
1500 AliESDtrack::GetOuterHmpExternalCovariance(Double_t cov[15]) const {
1501 //---------------------------------------------------------------------
1502 // This function returns external representation of the cov. matrix
1503 // at the inner layer of TRD
1504 //---------------------------------------------------------------------
1505 if (!fHMPIDp) return kFALSE;
1506 for (Int_t i=0; i<15; i++) cov[i]=fHMPIDp->GetCovariance()[i];
1510 Int_t AliESDtrack::GetNcls(Int_t idet) const
1512 // Get number of clusters by subdetector index
1526 if (fTOFindex != -1)
1532 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1533 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1544 Int_t AliESDtrack::GetClusters(Int_t idet, Int_t *idx) const
1546 // Get cluster index array by subdetector index
1551 ncls = GetITSclusters(idx);
1554 ncls = GetTPCclusters(idx);
1557 ncls = GetTRDclusters(idx);
1560 if (fTOFindex != -1) {
1568 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1569 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1570 idx[0] = GetHMPIDcluIdx();
1583 //_______________________________________________________________________
1584 void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
1585 // Returns the array with integrated times for each particle hypothesis
1586 for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
1589 //_______________________________________________________________________
1590 void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
1591 // Sets the array with integrated times for each particle hypotesis
1592 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
1595 //_______________________________________________________________________
1596 void AliESDtrack::SetITSpid(const Double_t *p) {
1597 // Sets values for the probability of each particle type (in ITS)
1598 SetPIDValues(fITSr,p,AliPID::kSPECIES);
1599 SetStatus(AliESDtrack::kITSpid);
1602 //_______________________________________________________________________
1603 void AliESDtrack::GetITSpid(Double_t *p) const {
1604 // Gets the probability of each particle type (in ITS)
1605 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
1608 //_______________________________________________________________________
1609 Char_t AliESDtrack::GetITSclusters(Int_t *idx) const {
1610 //---------------------------------------------------------------------
1611 // This function returns indices of the assgined ITS clusters
1612 //---------------------------------------------------------------------
1614 Int_t *index=fFriendTrack->GetITSindices();
1615 for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) {
1616 if ( (i>=fITSncls) && (i<6) ) idx[i]=-1;
1628 //_______________________________________________________________________
1629 Bool_t AliESDtrack::GetITSModuleIndexInfo(Int_t ilayer,Int_t &idet,Int_t &status,
1630 Float_t &xloc,Float_t &zloc) const {
1631 //----------------------------------------------------------------------
1632 // This function encodes in the module number also the status of cluster association
1633 // "status" can have the following values:
1634 // 1 "found" (cluster is associated),
1635 // 2 "dead" (module is dead from OCDB),
1636 // 3 "skipped" (module or layer forced to be skipped),
1637 // 4 "outinz" (track out of z acceptance),
1638 // 5 "nocls" (no clusters in the road),
1639 // 6 "norefit" (cluster rejected during refit),
1640 // 7 "deadzspd" (holes in z in SPD)
1641 // Also given are the coordinates of the crossing point of track and module
1642 // (in the local module ref. system)
1643 // WARNING: THIS METHOD HAS TO BE SYNCHRONIZED WITH AliITStrackV2::GetModuleIndexInfo()!
1644 //----------------------------------------------------------------------
1646 if(fITSModule[ilayer]==-1) {
1649 xloc=-99.; zloc=-99.;
1653 Int_t module = fITSModule[ilayer];
1655 idet = Int_t(module/1000000);
1657 module -= idet*1000000;
1659 status = Int_t(module/100000);
1661 module -= status*100000;
1663 Int_t signs = Int_t(module/10000);
1665 module-=signs*10000;
1667 Int_t xInt = Int_t(module/100);
1670 Int_t zInt = module;
1672 if(signs==1) { xInt*=1; zInt*=1; }
1673 if(signs==2) { xInt*=1; zInt*=-1; }
1674 if(signs==3) { xInt*=-1; zInt*=1; }
1675 if(signs==4) { xInt*=-1; zInt*=-1; }
1677 xloc = 0.1*(Float_t)xInt;
1678 zloc = 0.1*(Float_t)zInt;
1680 if(status==4) idet = -1;
1685 //_______________________________________________________________________
1686 UShort_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
1687 //---------------------------------------------------------------------
1688 // This function returns indices of the assgined ITS clusters
1689 //---------------------------------------------------------------------
1691 Int_t *index=fFriendTrack->GetTPCindices();
1694 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
1697 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=-2;
1703 //_______________________________________________________________________
1704 Float_t AliESDtrack::GetTPCClusterInfo(Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1) const
1707 // TPC cluster information
1708 // type 0: get fraction of found/findable clusters with neighbourhood definition
1709 // 1: findable clusters with neighbourhood definition
1710 // 2: found clusters
1712 // definition of findable clusters:
1713 // a cluster is defined as findable if there is another cluster
1714 // within +- nNeighbours pad rows. The idea is to overcome threshold
1715 // effects with a very simple algorithm.
1718 if (type==2) return fTPCClusterMap.CountBits();
1722 Int_t last=-nNeighbours;
1724 for (Int_t i=row0; i<row1; ++i){
1725 //look to current row
1726 if (fTPCClusterMap[i]) {
1732 //look to nNeighbours before
1733 if ((i-last)<=nNeighbours) {
1737 //look to nNeighbours after
1738 for (Int_t j=i+1; j<i+1+nNeighbours; ++j){
1739 if (fTPCClusterMap[j]){
1745 if (type==1) return findable;
1750 fraction=(Float_t)found/(Float_t)findable;
1755 return 0; // undefined type - default value
1758 //_______________________________________________________________________
1759 Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
1761 // GetDensity of the clusters on given region between row0 and row1
1762 // Dead zone effect takin into acoount
1767 Int_t *index=fFriendTrack->GetTPCindices();
1768 for (Int_t i=row0;i<=row1;i++){
1769 Int_t idx = index[i];
1770 if (idx!=-1) good++; // track outside of dead zone
1773 Float_t density=0.5;
1774 if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
1778 //_______________________________________________________________________
1779 void AliESDtrack::SetTPCpid(const Double_t *p) {
1780 // Sets values for the probability of each particle type (in TPC)
1781 SetPIDValues(fTPCr,p,AliPID::kSPECIES);
1782 SetStatus(AliESDtrack::kTPCpid);
1785 //_______________________________________________________________________
1786 void AliESDtrack::GetTPCpid(Double_t *p) const {
1787 // Gets the probability of each particle type (in TPC)
1788 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
1791 //_______________________________________________________________________
1792 UChar_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
1793 //---------------------------------------------------------------------
1794 // This function returns indices of the assgined TRD clusters
1795 //---------------------------------------------------------------------
1797 Int_t *index=fFriendTrack->GetTRDindices();
1800 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
1803 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=-2;
1809 //_______________________________________________________________________
1810 UChar_t AliESDtrack::GetTRDtracklets(Int_t *idx) const {
1812 // This function returns the number of TRD tracklets used in tracking
1813 // and it fills the indices of these tracklets in the array "idx" as they
1814 // are registered in the TRD track list.
1817 // 1. The idx array has to be allocated with a size >= AliESDtrack::kTRDnPlanes
1818 // 2. The idx array store not only the index but also the layer of the tracklet.
1819 // Therefore tracks with TRD gaps contain default values for indices [-1]
1821 if (!idx) return GetTRDntracklets();
1822 Int_t *index=fFriendTrack->GetTRDindices();
1824 for (Int_t i=0; i<kTRDnPlanes; i++){
1826 if(index[i]>=0) n++;
1834 //_______________________________________________________________________
1835 void AliESDtrack::SetTRDpid(const Double_t *p) {
1836 // Sets values for the probability of each particle type (in TRD)
1837 SetPIDValues(fTRDr,p,AliPID::kSPECIES);
1838 SetStatus(AliESDtrack::kTRDpid);
1841 //_______________________________________________________________________
1842 void AliESDtrack::GetTRDpid(Double_t *p) const {
1843 // Gets the probability of each particle type (in TRD)
1844 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
1847 //_______________________________________________________________________
1848 void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
1850 // Sets the probability of particle type iSpecies to p (in TRD)
1851 fTRDr[iSpecies] = p;
1854 Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
1856 // Returns the probability of particle type iSpecies (in TRD)
1857 return fTRDr[iSpecies];
1860 //____________________________________________________
1861 Int_t AliESDtrack::GetNumberOfTRDslices() const
1863 // built in backward compatibility
1864 Int_t idx = fTRDnSlices - (kTRDnPlanes<<1);
1865 return idx<18 ? fTRDnSlices/kTRDnPlanes : idx/kTRDnPlanes;
1868 //____________________________________________________
1869 Double_t AliESDtrack::GetTRDmomentum(Int_t plane, Double_t *sp) const
1871 //Returns momentum estimation and optional its error (sp)
1872 // in TRD layer "plane".
1875 AliDebug(2, "No TRD info allocated for this track.");
1878 if ((plane<0) || (plane>=kTRDnPlanes)) {
1879 AliWarning(Form("Request for TRD plane[%d] outside range.", plane));
1883 Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
1884 // Protection for backward compatibility
1885 if(idx<(GetNumberOfTRDslices()*kTRDnPlanes)) return -1.;
1887 if(sp) (*sp) = fTRDslices[idx+kTRDnPlanes];
1888 return fTRDslices[idx];
1891 //____________________________________________________
1892 Double_t AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
1893 //Gets the charge from the slice of the plane
1896 //AliError("No TRD slices allocated for this track !");
1899 if ((plane<0) || (plane>=kTRDnPlanes)) {
1900 AliError("Info for TRD plane not available !");
1903 Int_t ns=GetNumberOfTRDslices();
1904 if ((slice<-1) || (slice>=ns)) {
1905 //AliError("Wrong TRD slice !");
1909 if(slice>=0) return fTRDslices[plane*ns + slice];
1911 // return average of the dEdx measurements
1912 Double_t q=0.; Double32_t *s = &fTRDslices[plane*ns];
1913 for (Int_t i=0; i<ns; i++, s++) if((*s)>0.) q+=(*s);
1917 //____________________________________________________
1918 void AliESDtrack::SetNumberOfTRDslices(Int_t n) {
1919 //Sets the number of slices used for PID
1920 if (fTRDnSlices) return;
1923 fTRDslices=new Double32_t[fTRDnSlices];
1925 // set-up correctly the allocated memory
1926 memset(fTRDslices, 0, n*sizeof(Double32_t));
1927 for (Int_t i=GetNumberOfTRDslices(); i--;) fTRDslices[i]=-1.;
1930 //____________________________________________________
1931 void AliESDtrack::SetTRDslice(Double_t q, Int_t plane, Int_t slice) {
1932 //Sets the charge q in the slice of the plane
1934 AliError("No TRD slices allocated for this track !");
1937 if ((plane<0) || (plane>=kTRDnPlanes)) {
1938 AliError("Info for TRD plane not allocated !");
1941 Int_t ns=GetNumberOfTRDslices();
1942 if ((slice<0) || (slice>=ns)) {
1943 AliError("Wrong TRD slice !");
1946 Int_t n=plane*ns + slice;
1951 //____________________________________________________
1952 void AliESDtrack::SetTRDmomentum(Double_t p, Int_t plane, Double_t *sp)
1955 AliError("No TRD slices allocated for this track !");
1958 if ((plane<0) || (plane>=kTRDnPlanes)) {
1959 AliError("Info for TRD plane not allocated !");
1963 Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
1964 // Protection for backward compatibility
1965 if(idx<GetNumberOfTRDslices()*kTRDnPlanes) return;
1967 if(sp) fTRDslices[idx+kTRDnPlanes] = (*sp);
1968 fTRDslices[idx] = p;
1972 //_______________________________________________________________________
1973 void AliESDtrack::SetTOFpid(const Double_t *p) {
1974 // Sets the probability of each particle type (in TOF)
1975 SetPIDValues(fTOFr,p,AliPID::kSPECIES);
1976 SetStatus(AliESDtrack::kTOFpid);
1979 //_______________________________________________________________________
1980 void AliESDtrack::SetTOFLabel(const Int_t *p) {
1982 for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
1985 //_______________________________________________________________________
1986 void AliESDtrack::GetTOFpid(Double_t *p) const {
1987 // Gets probabilities of each particle type (in TOF)
1988 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
1991 //_______________________________________________________________________
1992 void AliESDtrack::GetTOFLabel(Int_t *p) const {
1994 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
1997 //_______________________________________________________________________
1998 void AliESDtrack::GetTOFInfo(Float_t *info) const {
2000 for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
2003 //_______________________________________________________________________
2004 void AliESDtrack::SetTOFInfo(Float_t*info) {
2006 for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
2011 //_______________________________________________________________________
2012 void AliESDtrack::SetHMPIDpid(const Double_t *p) {
2013 // Sets the probability of each particle type (in HMPID)
2014 SetPIDValues(fHMPIDr,p,AliPID::kSPECIES);
2015 SetStatus(AliESDtrack::kHMPIDpid);
2018 //_______________________________________________________________________
2019 void AliESDtrack::GetHMPIDpid(Double_t *p) const {
2020 // Gets probabilities of each particle type (in HMPID)
2021 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fHMPIDr[i];
2026 //_______________________________________________________________________
2027 void AliESDtrack::SetESDpid(const Double_t *p) {
2028 // Sets the probability of each particle type for the ESD track
2029 SetPIDValues(fR,p,AliPID::kSPECIES);
2030 SetStatus(AliESDtrack::kESDpid);
2033 //_______________________________________________________________________
2034 void AliESDtrack::GetESDpid(Double_t *p) const {
2035 // Gets probability of each particle type for the ESD track
2036 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
2039 //_______________________________________________________________________
2040 Bool_t AliESDtrack::RelateToVertexTPC(const AliESDVertex *vtx,
2041 Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
2043 // Try to relate the TPC-only track parameters to the vertex "vtx",
2044 // if the (rough) transverse impact parameter is not bigger then "maxd".
2045 // Magnetic field is "b" (kG).
2047 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
2048 // b) The impact parameters and their covariance matrix are calculated.
2049 // c) An attempt to constrain the TPC-only params to the vertex is done.
2050 // The constrained params are returned via "cParam".
2052 // In the case of success, the returned value is kTRUE
2053 // otherwise, it's kFALSE)
2056 if (!fTPCInner) return kFALSE;
2057 if (!vtx) return kFALSE;
2059 Double_t dz[2],cov[3];
2060 if (!fTPCInner->PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
2068 Double_t covar[6]; vtx->GetCovMatrix(covar);
2069 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2070 Double_t c[3]={covar[2],0.,covar[5]};
2072 Double_t chi2=GetPredictedChi2(p,c);
2073 if (chi2>kVeryBig) return kFALSE;
2077 if (!cParam) return kTRUE;
2079 *cParam = *fTPCInner;
2080 if (!cParam->Update(p,c)) return kFALSE;
2085 //_______________________________________________________________________
2086 Bool_t AliESDtrack::RelateToVertexTPCBxByBz(const AliESDVertex *vtx,
2087 Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2089 // Try to relate the TPC-only track parameters to the vertex "vtx",
2090 // if the (rough) transverse impact parameter is not bigger then "maxd".
2092 // All three components of the magnetic field ,"b[3]" (kG),
2093 // are taken into account.
2095 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
2096 // b) The impact parameters and their covariance matrix are calculated.
2097 // c) An attempt to constrain the TPC-only params to the vertex is done.
2098 // The constrained params are returned via "cParam".
2100 // In the case of success, the returned value is kTRUE
2101 // otherwise, it's kFALSE)
2104 if (!fTPCInner) return kFALSE;
2105 if (!vtx) return kFALSE;
2107 Double_t dz[2],cov[3];
2108 if (!fTPCInner->PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2116 Double_t covar[6]; vtx->GetCovMatrix(covar);
2117 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2118 Double_t c[3]={covar[2],0.,covar[5]};
2120 Double_t chi2=GetPredictedChi2(p,c);
2121 if (chi2>kVeryBig) return kFALSE;
2125 if (!cParam) return kTRUE;
2127 *cParam = *fTPCInner;
2128 if (!cParam->Update(p,c)) return kFALSE;
2133 //_______________________________________________________________________
2134 Bool_t AliESDtrack::RelateToVertex(const AliESDVertex *vtx,
2135 Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
2137 // Try to relate this track to the vertex "vtx",
2138 // if the (rough) transverse impact parameter is not bigger then "maxd".
2139 // Magnetic field is "b" (kG).
2141 // a) The track gets extapolated to the DCA to the vertex.
2142 // b) The impact parameters and their covariance matrix are calculated.
2143 // c) An attempt to constrain this track to the vertex is done.
2144 // The constrained params are returned via "cParam".
2146 // In the case of success, the returned value is kTRUE
2147 // (otherwise, it's kFALSE)
2150 if (!vtx) return kFALSE;
2152 Double_t dz[2],cov[3];
2153 if (!PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
2161 Double_t covar[6]; vtx->GetCovMatrix(covar);
2162 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2163 Double_t c[3]={covar[2],0.,covar[5]};
2165 Double_t chi2=GetPredictedChi2(p,c);
2166 if (chi2>kVeryBig) return kFALSE;
2171 //--- Could now these lines be removed ? ---
2173 fCp=new AliExternalTrackParam(*this);
2175 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
2176 //----------------------------------------
2178 fVertexID = vtx->GetID();
2180 if (!cParam) return kTRUE;
2183 if (!cParam->Update(p,c)) return kFALSE;
2188 //_______________________________________________________________________
2189 Bool_t AliESDtrack::RelateToVertexBxByBz(const AliESDVertex *vtx,
2190 Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2192 // Try to relate this track to the vertex "vtx",
2193 // if the (rough) transverse impact parameter is not bigger then "maxd".
2194 // Magnetic field is "b" (kG).
2196 // a) The track gets extapolated to the DCA to the vertex.
2197 // b) The impact parameters and their covariance matrix are calculated.
2198 // c) An attempt to constrain this track to the vertex is done.
2199 // The constrained params are returned via "cParam".
2201 // In the case of success, the returned value is kTRUE
2202 // (otherwise, it's kFALSE)
2205 if (!vtx) return kFALSE;
2207 Double_t dz[2],cov[3];
2208 if (!PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2216 Double_t covar[6]; vtx->GetCovMatrix(covar);
2217 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2218 Double_t c[3]={covar[2],0.,covar[5]};
2220 Double_t chi2=GetPredictedChi2(p,c);
2221 if (chi2>kVeryBig) return kFALSE;
2226 //--- Could now these lines be removed ? ---
2228 fCp=new AliExternalTrackParam(*this);
2230 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
2231 //----------------------------------------
2233 fVertexID = vtx->GetID();
2235 if (!cParam) return kTRUE;
2238 if (!cParam->Update(p,c)) return kFALSE;
2243 //_______________________________________________________________________
2244 void AliESDtrack::Print(Option_t *) const {
2245 // Prints info on the track
2246 AliExternalTrackParam::Print();
2247 printf("ESD track info\n") ;
2248 Double_t p[AliPID::kSPECIESN] ;
2250 if( IsOn(kITSpid) ){
2251 printf("From ITS: ") ;
2253 for(index = 0 ; index < AliPID::kSPECIES; index++)
2254 printf("%f, ", p[index]) ;
2255 printf("\n signal = %f\n", GetITSsignal()) ;
2257 if( IsOn(kTPCpid) ){
2258 printf("From TPC: ") ;
2260 for(index = 0 ; index < AliPID::kSPECIES; index++)
2261 printf("%f, ", p[index]) ;
2262 printf("\n signal = %f\n", GetTPCsignal()) ;
2264 if( IsOn(kTRDpid) ){
2265 printf("From TRD: ") ;
2267 for(index = 0 ; index < AliPID::kSPECIES; index++)
2268 printf("%f, ", p[index]) ;
2269 printf("\n signal = %f\n", GetTRDsignal()) ;
2271 if( IsOn(kTOFpid) ){
2272 printf("From TOF: ") ;
2274 for(index = 0 ; index < AliPID::kSPECIES; index++)
2275 printf("%f, ", p[index]) ;
2276 printf("\n signal = %f\n", GetTOFsignal()) ;
2278 if( IsOn(kHMPIDpid) ){
2279 printf("From HMPID: ") ;
2281 for(index = 0 ; index < AliPID::kSPECIES; index++)
2282 printf("%f, ", p[index]) ;
2283 printf("\n signal = %f\n", GetHMPIDsignal()) ;
2289 // Draw functionality
2290 // Origin: Marian Ivanov, Marian.Ivanov@cern.ch
2292 void AliESDtrack::FillPolymarker(TPolyMarker3D *pol, Float_t magF, Float_t minR, Float_t maxR, Float_t stepR){
2294 // Fill points in the polymarker
2297 arrayRef.AddLast(new AliExternalTrackParam(*this));
2298 if (fIp) arrayRef.AddLast(new AliExternalTrackParam(*fIp));
2299 if (fOp) arrayRef.AddLast(new AliExternalTrackParam(*fOp));
2300 if (fHMPIDp) arrayRef.AddLast(new AliExternalTrackParam(*fHMPIDp));
2302 Double_t mpos[3]={0,0,0};
2303 Int_t entries=arrayRef.GetEntries();
2304 for (Int_t i=0;i<entries;i++){
2306 ((AliExternalTrackParam*)arrayRef.At(i))->GetXYZ(pos);
2307 mpos[0]+=pos[0]/entries;
2308 mpos[1]+=pos[1]/entries;
2309 mpos[2]+=pos[2]/entries;
2311 // Rotate to the mean position
2313 Float_t fi= TMath::ATan2(mpos[1],mpos[0]);
2314 for (Int_t i=0;i<entries;i++){
2315 Bool_t res = ((AliExternalTrackParam*)arrayRef.At(i))->Rotate(fi);
2316 if (!res) delete arrayRef.RemoveAt(i);
2319 for (Double_t r=minR; r<maxR; r+=stepR){
2321 Double_t mlpos[3]={0,0,0};
2322 for (Int_t i=0;i<entries;i++){
2323 Double_t point[3]={0,0,0};
2324 AliExternalTrackParam *param = ((AliExternalTrackParam*)arrayRef.At(i));
2325 if (!param) continue;
2326 if (param->GetXYZAt(r,magF,point)){
2327 Double_t weight = 1./(10.+(r-param->GetX())*(r-param->GetX()));
2329 mlpos[0]+=point[0]*weight;
2330 mlpos[1]+=point[1]*weight;
2331 mlpos[2]+=point[2]*weight;
2338 pol->SetPoint(counter,mlpos[0],mlpos[1], mlpos[2]);
2339 printf("xyz\t%f\t%f\t%f\n",mlpos[0], mlpos[1],mlpos[2]);
2345 //_______________________________________________________________________
2346 void AliESDtrack::SetITSdEdxSamples(const Double_t s[4]) {
2348 // Store the dE/dx samples measured by the two SSD and two SDD layers.
2349 // These samples are corrected for the track segment length.
2351 for (Int_t i=0; i<4; i++) fITSdEdxSamples[i]=s[i];
2354 //_______________________________________________________________________
2355 void AliESDtrack::GetITSdEdxSamples(Double_t *s) const {
2357 // Get the dE/dx samples measured by the two SSD and two SDD layers.
2358 // These samples are corrected for the track segment length.
2360 for (Int_t i=0; i<4; i++) s[i]=fITSdEdxSamples[i];
2364 UShort_t AliESDtrack::GetTPCnclsS(Int_t i0,Int_t i1) const{
2366 // get number of shared TPC clusters
2368 return fTPCSharedMap.CountBits(i0)-fTPCSharedMap.CountBits(i1);
2371 UShort_t AliESDtrack::GetTPCncls(Int_t i0,Int_t i1) const{
2373 // get number of TPC clusters
2375 return fTPCClusterMap.CountBits(i0)-fTPCClusterMap.CountBits(i1);