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>
119 #include "AliESDVertex.h"
120 #include "AliESDtrack.h"
121 #include "AliKalmanTrack.h"
122 #include "AliVTrack.h"
124 #include "AliTrackPointArray.h"
125 #include "TPolyMarker3D.h"
127 ClassImp(AliESDtrack)
129 void SetPIDValues(Double_t * dest, const Double_t * src, Int_t n) {
130 // This function copies "n" PID weights from "scr" to "dest"
131 // and normalizes their sum to 1 thus producing conditional probabilities.
132 // The negative weights are set to 0.
133 // In case all the weights are non-positive they are replaced by
134 // uniform probabilities
138 Float_t uniform = 1./(Float_t)n;
141 for (Int_t i=0; i<n; i++)
151 for (Int_t i=0; i<n; i++) dest[i] /= sum;
153 for (Int_t i=0; i<n; i++) dest[i] = uniform;
156 //_______________________________________________________________________
157 AliESDtrack::AliESDtrack() :
158 AliExternalTrackParam(),
163 fFriendTrack(new AliESDfriendTrack()),
164 fTPCClusterMap(159),//number of padrows
165 fTPCSharedMap(159),//number of padrows
176 fEMCALindex(kEMCALNoMatch),
182 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
185 fCdd(0),fCdz(0),fCzz(0),
220 // The default ESD constructor
223 for (i=0; i<AliPID::kSPECIES; i++) {
233 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
234 for (i=0; i<3; i++) { fV0Indexes[i]=0;}
235 for (i=0;i<kTRDnPlanes;i++) {
238 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
239 for (i=0;i<3;i++) {fTOFLabel[i]=0;}
240 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
241 for (i=0;i<12;i++) {fITSModule[i]=-1;}
244 //_______________________________________________________________________
245 AliESDtrack::AliESDtrack(const AliESDtrack& track):
246 AliExternalTrackParam(track),
252 fTPCClusterMap(track.fTPCClusterMap),
253 fTPCSharedMap(track.fTPCSharedMap),
254 fFlags(track.fFlags),
256 fLabel(track.fLabel),
257 fITSLabel(track.fITSLabel),
258 fTPCLabel(track.fTPCLabel),
259 fTRDLabel(track.fTRDLabel),
260 fTOFCalChannel(track.fTOFCalChannel),
261 fTOFindex(track.fTOFindex),
262 fHMPIDqn(track.fHMPIDqn),
263 fHMPIDcluIdx(track.fHMPIDcluIdx),
264 fEMCALindex(track.fEMCALindex),
265 fHMPIDtrkTheta(track.fHMPIDtrkTheta),
266 fHMPIDtrkPhi(track.fHMPIDtrkPhi),
267 fHMPIDsignal(track.fHMPIDsignal),
268 fTrackLength(track.fTrackLength),
269 fdTPC(track.fdTPC),fzTPC(track.fzTPC),
270 fCddTPC(track.fCddTPC),fCdzTPC(track.fCdzTPC),fCzzTPC(track.fCzzTPC),
271 fCchi2TPC(track.fCchi2TPC),
272 fD(track.fD),fZ(track.fZ),
273 fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
274 fCchi2(track.fCchi2),
275 fITSchi2(track.fITSchi2),
276 fTPCchi2(track.fTPCchi2),
277 fTRDchi2(track.fTRDchi2),
278 fTOFchi2(track.fTOFchi2),
279 fHMPIDchi2(track.fHMPIDchi2),
280 fGlobalChi2(track.fGlobalChi2),
281 fITSsignal(track.fITSsignal),
282 fTPCsignal(track.fTPCsignal),
283 fTPCsignalS(track.fTPCsignalS),
284 fTRDsignal(track.fTRDsignal),
285 fTRDQuality(track.fTRDQuality),
286 fTRDBudget(track.fTRDBudget),
287 fTOFsignal(track.fTOFsignal),
288 fTOFsignalToT(track.fTOFsignalToT),
289 fTOFsignalRaw(track.fTOFsignalRaw),
290 fTOFsignalDz(track.fTOFsignalDz),
291 fHMPIDtrkX(track.fHMPIDtrkX),
292 fHMPIDtrkY(track.fHMPIDtrkY),
293 fHMPIDmipX(track.fHMPIDmipX),
294 fHMPIDmipY(track.fHMPIDmipY),
295 fTPCncls(track.fTPCncls),
296 fTPCnclsF(track.fTPCnclsF),
297 fTPCsignalN(track.fTPCsignalN),
298 fITSncls(track.fITSncls),
299 fITSClusterMap(track.fITSClusterMap),
300 fTRDncls(track.fTRDncls),
301 fTRDncls0(track.fTRDncls0),
302 fTRDntracklets(track.fTRDntracklets),
303 fTRDnSlices(track.fTRDnSlices),
309 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i]=track.fTrackTime[i];
310 for (Int_t i=0;i<AliPID::kSPECIES;i++) fR[i]=track.fR[i];
312 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
314 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[i];
315 for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
316 for (Int_t i=0; i<3;i++) { fKinkIndexes[i]=track.fKinkIndexes[i];}
317 for (Int_t i=0; i<3;i++) { fV0Indexes[i]=track.fV0Indexes[i];}
319 for (Int_t i=0;i<kTRDnPlanes;i++) {
320 fTRDTimBin[i]=track.fTRDTimBin[i];
324 fTRDslices=new Double32_t[fTRDnSlices];
325 for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=track.fTRDslices[i];
328 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
329 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
330 for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
331 for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
332 for (Int_t i=0;i<12;i++) fITSModule[i]=track.fITSModule[i];
333 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i]=track.fHMPIDr[i];
335 if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
336 if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
337 if (track.fTPCInner) fTPCInner=new AliExternalTrackParam(*track.fTPCInner);
338 if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
340 if (track.fFriendTrack) fFriendTrack=new AliESDfriendTrack(*(track.fFriendTrack));
343 //_______________________________________________________________________
344 AliESDtrack::AliESDtrack(const AliVTrack *track) :
345 AliExternalTrackParam(track),
351 fTPCClusterMap(159),//number of padrows
352 fTPCSharedMap(159),//number of padrows
363 fEMCALindex(kEMCALNoMatch),
369 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
372 fCdd(0),fCdz(0),fCzz(0),
406 // ESD track from AliVTrack.
407 // This is not a copy constructor !
410 if (track->InheritsFrom("AliExternalTrackParam")) {
411 AliError("This is not a copy constructor. Use AliESDtrack(const AliESDtrack &) !");
412 AliWarning("Calling the default constructor...");
417 // Reset all the arrays
419 for (i=0; i<AliPID::kSPECIES; i++) {
429 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
430 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
431 for (i=0;i<kTRDnPlanes;i++) {
434 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
435 for (i=0;i<3;i++) {fTOFLabel[i]=0;}
436 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
437 for (i=0;i<12;i++) {fITSModule[i]=-1;}
440 SetID(track->GetID());
442 // Set ITS cluster map
443 fITSClusterMap=track->GetITSClusterMap();
447 if(HasPointOnITSLayer(i)) fITSncls++;
450 // Set the combined PID
451 const Double_t *pid = track->PID();
453 for (i=0; i<AliPID::kSPECIES; i++) fR[i]=pid[i];
455 // AliESD track label
456 SetLabel(track->GetLabel());
458 SetStatus(track->GetStatus());
461 //_______________________________________________________________________
462 AliESDtrack::AliESDtrack(TParticle * part) :
463 AliExternalTrackParam(),
469 fTPCClusterMap(159),//number of padrows
470 fTPCSharedMap(159),//number of padrows
481 fEMCALindex(kEMCALNoMatch),
487 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
490 fCdd(0),fCdz(0),fCzz(0),
524 // ESD track from TParticle
527 // Reset all the arrays
529 for (i=0; i<AliPID::kSPECIES; i++) {
539 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
540 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
541 for (i=0;i<kTRDnPlanes;i++) {
544 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
545 for (i=0;i<3;i++) {fTOFLabel[i]=0;}
546 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
547 for (i=0;i<12;i++) {fITSModule[i]=-1;}
549 // Calculate the AliExternalTrackParam content
556 // Calculate alpha: the rotation angle of the corresponding local system (TPC sector)
557 alpha = part->Phi()*180./TMath::Pi();
558 if (alpha<0) alpha+= 360.;
559 if (alpha>360) alpha -= 360.;
561 Int_t sector = (Int_t)(alpha/20.);
562 alpha = 10. + 20.*sector;
564 alpha *= TMath::Pi();
566 // Covariance matrix: no errors, the parameters are exact
567 for (i=0; i<15; i++) covar[i]=0.;
569 // Get the vertex of origin and the momentum
570 TVector3 ver(part->Vx(),part->Vy(),part->Vz());
571 TVector3 mom(part->Px(),part->Py(),part->Pz());
573 // Rotate to the local coordinate system (TPC sector)
577 // X of the referense plane
580 Int_t pdgCode = part->GetPdgCode();
583 TDatabasePDG::Instance()->GetParticle(pdgCode)->Charge();
587 param[2] = TMath::Sin(mom.Phi());
588 param[3] = mom.Pz()/mom.Pt();
589 param[4] = TMath::Sign(1/mom.Pt(),charge);
591 // Set AliExternalTrackParam
592 Set(xref, alpha, param, covar);
597 switch (TMath::Abs(pdgCode)) {
623 // If the particle is not e,mu,pi,K or p the PID probabilities are set to 0
624 if (indexPID < AliPID::kSPECIES) {
630 fHMPIDr[indexPID]=1.;
633 // AliESD track label
634 SetLabel(part->GetUniqueID());
638 //_______________________________________________________________________
639 AliESDtrack::~AliESDtrack(){
641 // This is destructor according Coding Conventrions
643 //printf("Delete track\n");
653 AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source){
656 if(&source == this) return *this;
657 AliExternalTrackParam::operator=(source);
661 // we have the trackparam: assign or copy construct
662 if(fCp)*fCp = *source.fCp;
663 else fCp = new AliExternalTrackParam(*source.fCp);
666 // no track param delete the old one
672 // we have the trackparam: assign or copy construct
673 if(fIp)*fIp = *source.fIp;
674 else fIp = new AliExternalTrackParam(*source.fIp);
677 // no track param delete the old one
683 if(source.fTPCInner){
684 // we have the trackparam: assign or copy construct
685 if(fTPCInner) *fTPCInner = *source.fTPCInner;
686 else fTPCInner = new AliExternalTrackParam(*source.fTPCInner);
689 // no track param delete the old one
690 if(fTPCInner)delete fTPCInner;
696 // we have the trackparam: assign or copy construct
697 if(fOp) *fOp = *source.fOp;
698 else fOp = new AliExternalTrackParam(*source.fOp);
701 // no track param delete the old one
706 // copy also the friend track
707 // use copy constructor
708 if(source.fFriendTrack){
709 // we have the trackparam: assign or copy construct
710 delete fFriendTrack; fFriendTrack=new AliESDfriendTrack(*source.fFriendTrack);
713 // no track param delete the old one
714 delete fFriendTrack; fFriendTrack= 0;
717 fTPCClusterMap = source.fTPCClusterMap;
718 fTPCSharedMap = source.fTPCSharedMap;
720 fFlags = source.fFlags;
722 fLabel = source.fLabel;
723 fITSLabel = source.fITSLabel;
724 for(int i = 0; i< 12;++i){
725 fITSModule[i] = source.fITSModule[i];
727 fTPCLabel = source.fTPCLabel;
728 fTRDLabel = source.fTRDLabel;
729 for(int i = 0; i< 3;++i){
730 fTOFLabel[i] = source.fTOFLabel[i];
732 fTOFCalChannel = source.fTOFCalChannel;
733 fTOFindex = source.fTOFindex;
734 fHMPIDqn = source.fHMPIDqn;
735 fHMPIDcluIdx = source.fHMPIDcluIdx;
736 fEMCALindex = source.fEMCALindex;
738 for(int i = 0; i< 3;++i){
739 fKinkIndexes[i] = source.fKinkIndexes[i];
740 fV0Indexes[i] = source.fV0Indexes[i];
743 for(int i = 0; i< AliPID::kSPECIES;++i){
744 fR[i] = source.fR[i];
745 fITSr[i] = source.fITSr[i];
746 fTPCr[i] = source.fTPCr[i];
747 fTRDr[i] = source.fTRDr[i];
748 fTOFr[i] = source.fTOFr[i];
749 fHMPIDr[i] = source.fHMPIDr[i];
750 fTrackTime[i] = source.fTrackTime[i];
753 fHMPIDtrkTheta = source.fHMPIDtrkTheta;
754 fHMPIDtrkPhi = source.fHMPIDtrkPhi;
755 fHMPIDsignal = source.fHMPIDsignal;
758 fTrackLength = source. fTrackLength;
759 fdTPC = source.fdTPC;
760 fzTPC = source.fzTPC;
761 fCddTPC = source.fCddTPC;
762 fCdzTPC = source.fCdzTPC;
763 fCzzTPC = source.fCzzTPC;
764 fCchi2TPC = source.fCchi2TPC;
771 fCchi2 = source.fCchi2;
773 fITSchi2 = source.fITSchi2;
774 fTPCchi2 = source.fTPCchi2;
775 fTRDchi2 = source.fTRDchi2;
776 fTOFchi2 = source.fTOFchi2;
777 fHMPIDchi2 = source.fHMPIDchi2;
779 fGlobalChi2 = source.fGlobalChi2;
781 fITSsignal = source.fITSsignal;
782 fTPCsignal = source.fTPCsignal;
783 fTPCsignalS = source.fTPCsignalS;
784 for(int i = 0; i< 4;++i){
785 fTPCPoints[i] = source.fTPCPoints[i];
787 fTRDsignal = source.fTRDsignal;
789 for(int i = 0;i < kTRDnPlanes;++i){
790 fTRDTimBin[i] = source.fTRDTimBin[i];
796 fTRDnSlices=source.fTRDnSlices;
798 fTRDslices=new Double32_t[fTRDnSlices];
799 for(int j = 0;j < fTRDnSlices;++j) fTRDslices[j] = source.fTRDslices[j];
802 fTRDQuality = source.fTRDQuality;
803 fTRDBudget = source.fTRDBudget;
804 fTOFsignal = source.fTOFsignal;
805 fTOFsignalToT = source.fTOFsignalToT;
806 fTOFsignalRaw = source.fTOFsignalRaw;
807 fTOFsignalDz = source.fTOFsignalDz;
809 for(int i = 0;i<10;++i){
810 fTOFInfo[i] = source.fTOFInfo[i];
813 fHMPIDtrkX = source.fHMPIDtrkX;
814 fHMPIDtrkY = source.fHMPIDtrkY;
815 fHMPIDmipX = source.fHMPIDmipX;
816 fHMPIDmipY = source.fHMPIDmipY;
818 fTPCncls = source.fTPCncls;
819 fTPCnclsF = source.fTPCnclsF;
820 fTPCsignalN = source.fTPCsignalN;
822 fITSncls = source.fITSncls;
823 fITSClusterMap = source.fITSClusterMap;
824 fTRDncls = source.fTRDncls;
825 fTRDncls0 = source.fTRDncls0;
826 fTRDntracklets = source.fTRDntracklets;
832 void AliESDtrack::Copy(TObject &obj) const {
834 // this overwrites the virtual TOBject::Copy()
835 // to allow run time copying without casting
838 if(this==&obj)return;
839 AliESDtrack *robj = dynamic_cast<AliESDtrack*>(&obj);
840 if(!robj)return; // not an AliESDtrack
847 void AliESDtrack::AddCalibObject(TObject * object){
849 // add calib object to the list
851 if (!fFriendTrack) fFriendTrack = new AliESDfriendTrack;
852 fFriendTrack->AddCalibObject(object);
855 TObject * AliESDtrack::GetCalibObject(Int_t index){
857 // return calib objct at given position
859 if (!fFriendTrack) return 0;
860 return fFriendTrack->GetCalibObject(index);
864 Bool_t AliESDtrack::FillTPCOnlyTrack(AliESDtrack &track){
866 // Fills the information of the TPC-only first reconstruction pass
867 // into the passed ESDtrack object. For consistency fTPCInner is also filled
872 // For data produced before r26675
873 // RelateToVertexTPC was not properly called during reco
874 // so you'll have to call it again, before FillTPCOnlyTrack
875 // Float_t p[2],cov[3];
876 // track->GetImpactParametersTPC(p,cov);
877 // if(p[0]==0&&p[1]==0) // <- Default values
878 // track->RelateToVertexTPC(esd->GetPrimaryVertexTPC(),esd->GetMagneticField(),kVeryBig);
881 if(!fTPCInner)return kFALSE;
883 // fill the TPC track params to the global track parameters
884 track.Set(fTPCInner->GetX(),fTPCInner->GetAlpha(),fTPCInner->GetParameter(),fTPCInner->GetCovariance());
887 track.fCdd = fCddTPC;
888 track.fCdz = fCdzTPC;
889 track.fCzz = fCzzTPC;
891 // copy the TPCinner parameters
892 if(track.fTPCInner) *track.fTPCInner = *fTPCInner;
893 else track.fTPCInner = new AliExternalTrackParam(*fTPCInner);
896 track.fCddTPC = fCddTPC;
897 track.fCdzTPC = fCdzTPC;
898 track.fCzzTPC = fCzzTPC;
899 track.fCchi2TPC = fCchi2TPC;
902 // copy all other TPC specific parameters
904 // replace label by TPC label
905 track.fLabel = fTPCLabel;
906 track.fTPCLabel = fTPCLabel;
908 track.fTPCchi2 = fTPCchi2;
909 track.fTPCsignal = fTPCsignal;
910 track.fTPCsignalS = fTPCsignalS;
911 for(int i = 0;i<4;++i)track.fTPCPoints[i] = fTPCPoints[i];
913 track.fTPCncls = fTPCncls;
914 track.fTPCnclsF = fTPCnclsF;
915 track.fTPCsignalN = fTPCsignalN;
918 for(int i=0;i<AliPID::kSPECIES;++i){
919 track.fTPCr[i] = fTPCr[i];
920 // combined PID is TPC only!
921 track.fR[i] = fTPCr[i];
923 track.fTPCClusterMap = fTPCClusterMap;
924 track.fTPCSharedMap = fTPCSharedMap;
928 track.fFlags = kTPCin;
931 track.fFlags |= fFlags & kTPCpid; //copy the TPCpid status flag
933 for (Int_t i=0;i<3;i++) track.fKinkIndexes[i] = fKinkIndexes[i];
939 //_______________________________________________________________________
940 void AliESDtrack::MakeMiniESDtrack(){
941 // Resets everything except
942 // fFlags: Reconstruction status flags
943 // fLabel: Track label
944 // fID: Unique ID of the track
945 // Impact parameter information
946 // fR[AliPID::kSPECIES]: combined "detector response probability"
947 // Running track parameters in the base class (AliExternalTrackParam)
951 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
953 // Reset track parameters constrained to the primary vertex
956 // Reset track parameters at the inner wall of TPC
958 delete fTPCInner;fTPCInner=0;
959 // Reset track parameters at the inner wall of the TRD
963 // Reset ITS track related information
968 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
971 // Reset TPC related track information
980 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=0;
982 for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
983 for (Int_t i=0; i<3;i++) fKinkIndexes[i] = 0;
984 for (Int_t i=0; i<3;i++) fV0Indexes[i] = 0;
986 // Reset TRD related track information
991 for (Int_t i=0;i<kTRDnPlanes;i++) {
994 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
1004 // Reset TOF related track information
1012 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
1013 for (Int_t i=0;i<3;i++) fTOFLabel[i] = 0;
1014 for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
1016 // Reset HMPID related track information
1021 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
1028 fEMCALindex = kEMCALNoMatch;
1030 // reset global track chi2
1033 delete fFriendTrack; fFriendTrack = 0;
1035 //_______________________________________________________________________
1036 Double_t AliESDtrack::GetMass() const {
1037 // Returns the mass of the most probable particle type
1040 for (Int_t i=0; i<AliPID::kSPECIES; i++) {
1041 if (fR[i]>max) {k=i; max=fR[i];}
1043 if (k==0) { // dE/dx "crossing points" in the TPC
1045 if ((p>0.38)&&(p<0.48))
1046 if (fR[0]<fR[3]*10.) return AliPID::ParticleMass(AliPID::kKaon);
1047 if ((p>0.75)&&(p<0.85))
1048 if (fR[0]<fR[4]*10.) return AliPID::ParticleMass(AliPID::kProton);
1051 if (k==1) return AliPID::ParticleMass(AliPID::kMuon);
1052 if (k==2||k==-1) return AliPID::ParticleMass(AliPID::kPion);
1053 if (k==3) return AliPID::ParticleMass(AliPID::kKaon);
1054 if (k==4) return AliPID::ParticleMass(AliPID::kProton);
1055 AliWarning("Undefined mass !");
1056 return AliPID::ParticleMass(AliPID::kPion);
1059 //______________________________________________________________________________
1060 Double_t AliESDtrack::E() const
1062 // Returns the energy of the particle given its assumed mass.
1063 // Assumes the pion mass if the particle can't be identified properly.
1067 return TMath::Sqrt(p*p + m*m);
1070 //______________________________________________________________________________
1071 Double_t AliESDtrack::Y() const
1073 // Returns the rapidity of a particle given its assumed mass.
1074 // Assumes the pion mass if the particle can't be identified properly.
1078 if (e != TMath::Abs(pz)) { // energy was not equal to pz
1079 return 0.5*TMath::Log((e+pz)/(e-pz));
1080 } else { // energy was equal to pz
1085 //_______________________________________________________________________
1086 Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
1088 // This function updates track's running parameters
1094 fLabel=t->GetLabel();
1096 if (t->IsStartedTimeIntegral()) {
1098 Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
1099 SetIntegratedLength(t->GetIntegratedLength());
1102 Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1106 case kITSin: case kITSout: case kITSrefit:
1108 fITSncls=t->GetNumberOfClusters();
1109 index=fFriendTrack->GetITSindices();
1110 for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
1111 index[i]=t->GetClusterIndex(i);
1113 Int_t l=(index[i] & 0xf0000000) >> 28;
1114 SETBIT(fITSClusterMap,l);
1117 fITSchi2=t->GetChi2();
1118 fITSsignal=t->GetPIDsignal();
1119 fITSLabel = t->GetLabel();
1120 // keep in fOp the parameters outside ITS for ITS stand-alone tracks
1121 if (flags==kITSout) {
1122 if (!fOp) fOp=new AliExternalTrackParam(*t);
1124 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1128 case kTPCin: case kTPCrefit:
1129 fTPCLabel = t->GetLabel();
1130 if (flags==kTPCin) fTPCInner=new AliExternalTrackParam(*t);
1131 if (!fIp) fIp=new AliExternalTrackParam(*t);
1133 fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1135 index=fFriendTrack->GetTPCindices();
1136 if (flags & kTPCout){
1137 if (!fOp) fOp=new AliExternalTrackParam(*t);
1139 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1141 fTPCncls=t->GetNumberOfClusters();
1142 fTPCchi2=t->GetChi2();
1144 {//prevrow must be declared in separate namespace, otherwise compiler cries:
1145 //"jump to case label crosses initialization of `Int_t prevrow'"
1147 // for (Int_t i=0;i<fTPCncls;i++)
1148 for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)
1150 index[i]=t->GetClusterIndex(i);
1151 Int_t idx = index[i];
1153 if (idx<0) continue;
1155 // Piotr's Cluster Map for HBT
1156 // ### please change accordingly if cluster array is changing
1157 // to "New TPC Tracking" style (with gaps in array)
1158 Int_t sect = (idx&0xff000000)>>24;
1159 Int_t row = (idx&0x00ff0000)>>16;
1160 if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
1162 fTPCClusterMap.SetBitNumber(row,kTRUE);
1164 //Fill the gap between previous row and this row with 0 bits
1165 //In case ### pleas change it as well - just set bit 0 in case there
1166 //is no associated clusters for current "i"
1169 prevrow = row;//if previous bit was not assigned yet == this is the first one
1172 { //we don't know the order (inner to outer or reverse)
1173 //just to be save in case it is going to change
1186 for (Int_t j = n+1; j < m; j++)
1188 fTPCClusterMap.SetBitNumber(j,kFALSE);
1192 // End Of Piotr's Cluster Map for HBT
1195 fTPCsignal=t->GetPIDsignal();
1198 case kTRDin: case kTRDrefit:
1201 index = fFriendTrack->GetTRDindices();
1202 fTRDLabel = t->GetLabel();
1203 fTRDchi2 = t->GetChi2();
1204 fTRDncls = t->GetNumberOfClusters();
1205 for (Int_t i=0;i<6;i++) index[i]=t->GetTrackletIndex(i);
1207 fTRDsignal=t->GetPIDsignal();
1210 if (!fOp) fOp=new AliExternalTrackParam(*t);
1212 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1213 fTRDncls0 = t->GetNumberOfClusters();
1222 AliError("Wrong flag !");
1229 //_______________________________________________________________________
1230 void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
1231 //---------------------------------------------------------------------
1232 // This function returns external representation of the track parameters
1233 //---------------------------------------------------------------------
1235 for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
1238 //_______________________________________________________________________
1239 void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
1240 //---------------------------------------------------------------------
1241 // This function returns external representation of the cov. matrix
1242 //---------------------------------------------------------------------
1243 for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
1246 //_______________________________________________________________________
1247 Bool_t AliESDtrack::GetConstrainedExternalParameters
1248 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1249 //---------------------------------------------------------------------
1250 // This function returns the constrained external track parameters
1251 //---------------------------------------------------------------------
1252 if (!fCp) return kFALSE;
1253 alpha=fCp->GetAlpha();
1255 for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
1259 //_______________________________________________________________________
1261 AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
1262 //---------------------------------------------------------------------
1263 // This function returns the constrained external cov. matrix
1264 //---------------------------------------------------------------------
1265 if (!fCp) return kFALSE;
1266 for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
1271 AliESDtrack::GetInnerExternalParameters
1272 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1273 //---------------------------------------------------------------------
1274 // This function returns external representation of the track parameters
1275 // at the inner layer of TPC
1276 //---------------------------------------------------------------------
1277 if (!fIp) return kFALSE;
1278 alpha=fIp->GetAlpha();
1280 for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
1285 AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const {
1286 //---------------------------------------------------------------------
1287 // This function returns external representation of the cov. matrix
1288 // at the inner layer of TPC
1289 //---------------------------------------------------------------------
1290 if (!fIp) return kFALSE;
1291 for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
1296 AliESDtrack::SetOuterParam(const AliExternalTrackParam *p, ULong_t flags) {
1298 // This is a direct setter for the outer track parameters
1301 if (fOp) delete fOp;
1302 fOp=new AliExternalTrackParam(*p);
1306 AliESDtrack::GetOuterExternalParameters
1307 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1308 //---------------------------------------------------------------------
1309 // This function returns external representation of the track parameters
1310 // at the inner layer of TRD
1311 //---------------------------------------------------------------------
1312 if (!fOp) return kFALSE;
1313 alpha=fOp->GetAlpha();
1315 for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
1320 AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
1321 //---------------------------------------------------------------------
1322 // This function returns external representation of the cov. matrix
1323 // at the inner layer of TRD
1324 //---------------------------------------------------------------------
1325 if (!fOp) return kFALSE;
1326 for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
1330 Int_t AliESDtrack::GetNcls(Int_t idet) const
1332 // Get number of clusters by subdetector index
1346 if (fTOFindex != -1)
1352 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1353 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1364 Int_t AliESDtrack::GetClusters(Int_t idet, Int_t *idx) const
1366 // Get cluster index array by subdetector index
1371 ncls = GetITSclusters(idx);
1374 ncls = GetTPCclusters(idx);
1377 ncls = GetTRDclusters(idx);
1380 if (fTOFindex != -1) {
1388 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1389 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1390 idx[0] = GetHMPIDcluIdx();
1403 //_______________________________________________________________________
1404 void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
1405 // Returns the array with integrated times for each particle hypothesis
1406 for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
1409 //_______________________________________________________________________
1410 void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
1411 // Sets the array with integrated times for each particle hypotesis
1412 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
1415 //_______________________________________________________________________
1416 void AliESDtrack::SetITSpid(const Double_t *p) {
1417 // Sets values for the probability of each particle type (in ITS)
1418 SetPIDValues(fITSr,p,AliPID::kSPECIES);
1419 SetStatus(AliESDtrack::kITSpid);
1422 //_______________________________________________________________________
1423 void AliESDtrack::GetITSpid(Double_t *p) const {
1424 // Gets the probability of each particle type (in ITS)
1425 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
1428 //_______________________________________________________________________
1429 Char_t AliESDtrack::GetITSclusters(Int_t *idx) const {
1430 //---------------------------------------------------------------------
1431 // This function returns indices of the assgined ITS clusters
1432 //---------------------------------------------------------------------
1434 Int_t *index=fFriendTrack->GetITSindices();
1435 for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) {
1436 if ( (i>=fITSncls) && (i<6) ) idx[i]=-1;
1437 else idx[i]=index[i];
1443 //_______________________________________________________________________
1444 Bool_t AliESDtrack::GetITSModuleIndexInfo(Int_t ilayer,Int_t &idet,Int_t &status,
1445 Float_t &xloc,Float_t &zloc) const {
1446 //----------------------------------------------------------------------
1447 // This function encodes in the module number also the status of cluster association
1448 // "status" can have the following values:
1449 // 1 "found" (cluster is associated),
1450 // 2 "dead" (module is dead from OCDB),
1451 // 3 "skipped" (module or layer forced to be skipped),
1452 // 4 "outinz" (track out of z acceptance),
1453 // 5 "nocls" (no clusters in the road),
1454 // 6 "norefit" (cluster rejected during refit),
1455 // 7 "deadzspd" (holes in z in SPD)
1456 // Also given are the coordinates of the crossing point of track and module
1457 // (in the local module ref. system)
1458 // WARNING: THIS METHOD HAS TO BE SYNCHRONIZED WITH AliITStrackV2::GetModuleIndexInfo()!
1459 //----------------------------------------------------------------------
1461 if(fITSModule[ilayer]==-1) {
1464 xloc=-99.; zloc=-99.;
1468 Int_t module = fITSModule[ilayer];
1470 idet = Int_t(module/1000000);
1472 module -= idet*1000000;
1474 status = Int_t(module/100000);
1476 module -= status*100000;
1478 Int_t signs = Int_t(module/10000);
1480 module-=signs*10000;
1482 Int_t xInt = Int_t(module/100);
1485 Int_t zInt = module;
1487 if(signs==1) { xInt*=1; zInt*=1; }
1488 if(signs==2) { xInt*=1; zInt*=-1; }
1489 if(signs==3) { xInt*=-1; zInt*=1; }
1490 if(signs==4) { xInt*=-1; zInt*=-1; }
1492 xloc = 0.1*(Float_t)xInt;
1493 zloc = 0.1*(Float_t)zInt;
1495 if(status==4) idet = -1;
1500 //_______________________________________________________________________
1501 UShort_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
1502 //---------------------------------------------------------------------
1503 // This function returns indices of the assgined ITS clusters
1504 //---------------------------------------------------------------------
1506 Int_t *index=fFriendTrack->GetTPCindices();
1507 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
1512 Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
1514 // GetDensity of the clusters on given region between row0 and row1
1515 // Dead zone effect takin into acoount
1520 Int_t *index=fFriendTrack->GetTPCindices();
1521 for (Int_t i=row0;i<=row1;i++){
1522 Int_t idx = index[i];
1523 if (idx!=-1) good++; // track outside of dead zone
1526 Float_t density=0.5;
1527 if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
1531 //_______________________________________________________________________
1532 void AliESDtrack::SetTPCpid(const Double_t *p) {
1533 // Sets values for the probability of each particle type (in TPC)
1534 SetPIDValues(fTPCr,p,AliPID::kSPECIES);
1535 SetStatus(AliESDtrack::kTPCpid);
1538 //_______________________________________________________________________
1539 void AliESDtrack::GetTPCpid(Double_t *p) const {
1540 // Gets the probability of each particle type (in TPC)
1541 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
1544 //_______________________________________________________________________
1545 UChar_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
1546 //---------------------------------------------------------------------
1547 // This function returns indices of the assgined TRD clusters
1548 //---------------------------------------------------------------------
1550 Int_t *index=fFriendTrack->GetTRDindices();
1551 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
1556 //_______________________________________________________________________
1557 UChar_t AliESDtrack::GetTRDtracklets(Int_t *idx) const {
1558 //---------------------------------------------------------------------
1559 // This function returns indices of the assigned TRD tracklets
1560 //---------------------------------------------------------------------
1562 Int_t *index=fFriendTrack->GetTRDindices();
1563 for (Int_t i=0; i<6/*AliESDfriendTrack::kMaxTRDcluster*/; i++) idx[i]=index[i];
1568 //_______________________________________________________________________
1569 void AliESDtrack::SetTRDpid(const Double_t *p) {
1570 // Sets values for the probability of each particle type (in TRD)
1571 SetPIDValues(fTRDr,p,AliPID::kSPECIES);
1572 SetStatus(AliESDtrack::kTRDpid);
1575 //_______________________________________________________________________
1576 void AliESDtrack::GetTRDpid(Double_t *p) const {
1577 // Gets the probability of each particle type (in TRD)
1578 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
1581 //_______________________________________________________________________
1582 void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
1584 // Sets the probability of particle type iSpecies to p (in TRD)
1585 fTRDr[iSpecies] = p;
1588 Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
1590 // Returns the probability of particle type iSpecies (in TRD)
1591 return fTRDr[iSpecies];
1594 void AliESDtrack::SetNumberOfTRDslices(Int_t n) {
1595 //Sets the number of slices used for PID
1596 if (fTRDnSlices != 0) return;
1597 fTRDnSlices=kTRDnPlanes*n;
1598 fTRDslices=new Double32_t[fTRDnSlices];
1599 for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=-1.;
1602 void AliESDtrack::SetTRDslice(Double_t q, Int_t plane, Int_t slice) {
1603 //Sets the charge q in the slice of the plane
1604 Int_t ns=GetNumberOfTRDslices();
1606 AliError("No TRD slices allocated for this track !");
1610 if ((plane<0) || (plane>=kTRDnPlanes)) {
1611 AliError("Wrong TRD plane !");
1614 if ((slice<0) || (slice>=ns)) {
1615 AliError("Wrong TRD slice !");
1618 Int_t n=plane*ns + slice;
1622 Double_t AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
1623 //Gets the charge from the slice of the plane
1624 Int_t ns=GetNumberOfTRDslices();
1626 //AliError("No TRD slices allocated for this track !");
1630 if ((plane<0) || (plane>=kTRDnPlanes)) {
1631 AliError("Wrong TRD plane !");
1634 if ((slice<-1) || (slice>=ns)) {
1635 //AliError("Wrong TRD slice !");
1641 for (Int_t i=0; i<ns; i++) q+=fTRDslices[plane*ns + i];
1645 return fTRDslices[plane*ns + slice];
1649 //_______________________________________________________________________
1650 void AliESDtrack::SetTOFpid(const Double_t *p) {
1651 // Sets the probability of each particle type (in TOF)
1652 SetPIDValues(fTOFr,p,AliPID::kSPECIES);
1653 SetStatus(AliESDtrack::kTOFpid);
1656 //_______________________________________________________________________
1657 void AliESDtrack::SetTOFLabel(const Int_t *p) {
1659 for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
1662 //_______________________________________________________________________
1663 void AliESDtrack::GetTOFpid(Double_t *p) const {
1664 // Gets probabilities of each particle type (in TOF)
1665 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
1668 //_______________________________________________________________________
1669 void AliESDtrack::GetTOFLabel(Int_t *p) const {
1671 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
1674 //_______________________________________________________________________
1675 void AliESDtrack::GetTOFInfo(Float_t *info) const {
1677 for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
1680 //_______________________________________________________________________
1681 void AliESDtrack::SetTOFInfo(Float_t*info) {
1683 for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
1688 //_______________________________________________________________________
1689 void AliESDtrack::SetHMPIDpid(const Double_t *p) {
1690 // Sets the probability of each particle type (in HMPID)
1691 SetPIDValues(fHMPIDr,p,AliPID::kSPECIES);
1692 SetStatus(AliESDtrack::kHMPIDpid);
1695 //_______________________________________________________________________
1696 void AliESDtrack::GetHMPIDpid(Double_t *p) const {
1697 // Gets probabilities of each particle type (in HMPID)
1698 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fHMPIDr[i];
1703 //_______________________________________________________________________
1704 void AliESDtrack::SetESDpid(const Double_t *p) {
1705 // Sets the probability of each particle type for the ESD track
1706 SetPIDValues(fR,p,AliPID::kSPECIES);
1707 SetStatus(AliESDtrack::kESDpid);
1710 //_______________________________________________________________________
1711 void AliESDtrack::GetESDpid(Double_t *p) const {
1712 // Gets probability of each particle type for the ESD track
1713 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
1716 //_______________________________________________________________________
1717 Bool_t AliESDtrack::RelateToVertexTPC(const AliESDVertex *vtx,
1718 Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
1720 // Try to relate the TPC-only track parameters to the vertex "vtx",
1721 // if the (rough) transverse impact parameter is not bigger then "maxd".
1722 // Magnetic field is "b" (kG).
1724 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
1725 // b) The impact parameters and their covariance matrix are calculated.
1726 // c) An attempt to constrain the TPC-only params to the vertex is done.
1727 // The constrained params are returned via "cParam".
1729 // In the case of success, the returned value is kTRUE
1730 // otherwise, it's kFALSE)
1733 if (!fTPCInner) return kFALSE;
1734 if (!vtx) return kFALSE;
1736 Double_t dz[2],cov[3];
1737 if (!fTPCInner->PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
1745 Double_t covar[6]; vtx->GetCovMatrix(covar);
1746 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
1747 Double_t c[3]={covar[2],0.,covar[5]};
1749 Double_t chi2=GetPredictedChi2(p,c);
1750 if (chi2>kVeryBig) return kFALSE;
1754 if (!cParam) return kTRUE;
1756 *cParam = *fTPCInner;
1757 if (!cParam->Update(p,c)) return kFALSE;
1762 //_______________________________________________________________________
1763 Bool_t AliESDtrack::RelateToVertex(const AliESDVertex *vtx,
1764 Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
1766 // Try to relate this track to the vertex "vtx",
1767 // if the (rough) transverse impact parameter is not bigger then "maxd".
1768 // Magnetic field is "b" (kG).
1770 // a) The track gets extapolated to the DCA to the vertex.
1771 // b) The impact parameters and their covariance matrix are calculated.
1772 // c) An attempt to constrain this track to the vertex is done.
1773 // The constrained params are returned via "cParam".
1775 // In the case of success, the returned value is kTRUE
1776 // (otherwise, it's kFALSE)
1779 if (!vtx) return kFALSE;
1781 Double_t dz[2],cov[3];
1782 if (!PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
1790 Double_t covar[6]; vtx->GetCovMatrix(covar);
1791 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
1792 Double_t c[3]={covar[2],0.,covar[5]};
1794 Double_t chi2=GetPredictedChi2(p,c);
1795 if (chi2>kVeryBig) return kFALSE;
1800 //--- Could now these lines be removed ? ---
1802 fCp=new AliExternalTrackParam(*this);
1804 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
1805 //----------------------------------------
1808 if (!cParam) return kTRUE;
1811 if (!cParam->Update(p,c)) return kFALSE;
1816 //_______________________________________________________________________
1817 void AliESDtrack::Print(Option_t *) const {
1818 // Prints info on the track
1819 AliExternalTrackParam::Print();
1820 printf("ESD track info\n") ;
1821 Double_t p[AliPID::kSPECIESN] ;
1823 if( IsOn(kITSpid) ){
1824 printf("From ITS: ") ;
1826 for(index = 0 ; index < AliPID::kSPECIES; index++)
1827 printf("%f, ", p[index]) ;
1828 printf("\n signal = %f\n", GetITSsignal()) ;
1830 if( IsOn(kTPCpid) ){
1831 printf("From TPC: ") ;
1833 for(index = 0 ; index < AliPID::kSPECIES; index++)
1834 printf("%f, ", p[index]) ;
1835 printf("\n signal = %f\n", GetTPCsignal()) ;
1837 if( IsOn(kTRDpid) ){
1838 printf("From TRD: ") ;
1840 for(index = 0 ; index < AliPID::kSPECIES; index++)
1841 printf("%f, ", p[index]) ;
1842 printf("\n signal = %f\n", GetTRDsignal()) ;
1844 if( IsOn(kTOFpid) ){
1845 printf("From TOF: ") ;
1847 for(index = 0 ; index < AliPID::kSPECIES; index++)
1848 printf("%f, ", p[index]) ;
1849 printf("\n signal = %f\n", GetTOFsignal()) ;
1851 if( IsOn(kHMPIDpid) ){
1852 printf("From HMPID: ") ;
1854 for(index = 0 ; index < AliPID::kSPECIES; index++)
1855 printf("%f, ", p[index]) ;
1856 printf("\n signal = %f\n", GetHMPIDsignal()) ;
1862 // Draw functionality
1863 // Origin: Marian Ivanov, Marian.Ivanov@cern.ch
1865 void AliESDtrack::FillPolymarker(TPolyMarker3D *pol, Float_t magF, Float_t minR, Float_t maxR, Float_t stepR){
1867 // Fill points in the polymarker
1870 arrayRef.AddLast(new AliExternalTrackParam(*this));
1871 if (fIp) arrayRef.AddLast(new AliExternalTrackParam(*fIp));
1872 if (fOp) arrayRef.AddLast(new AliExternalTrackParam(*fOp));
1874 Double_t mpos[3]={0,0,0};
1875 Int_t entries=arrayRef.GetEntries();
1876 for (Int_t i=0;i<entries;i++){
1878 ((AliExternalTrackParam*)arrayRef.At(i))->GetXYZ(pos);
1879 mpos[0]+=pos[0]/entries;
1880 mpos[1]+=pos[1]/entries;
1881 mpos[2]+=pos[2]/entries;
1883 // Rotate to the mean position
1885 Float_t fi= TMath::ATan2(mpos[1],mpos[0]);
1886 for (Int_t i=0;i<entries;i++){
1887 Bool_t res = ((AliExternalTrackParam*)arrayRef.At(i))->Rotate(fi);
1888 if (!res) delete arrayRef.RemoveAt(i);
1891 for (Double_t r=minR; r<maxR; r+=stepR){
1893 Double_t mlpos[3]={0,0,0};
1894 for (Int_t i=0;i<entries;i++){
1895 Double_t point[3]={0,0,0};
1896 AliExternalTrackParam *param = ((AliExternalTrackParam*)arrayRef.At(i));
1897 if (!param) continue;
1898 if (param->GetXYZAt(r,magF,point)){
1899 Double_t weight = 1./(10.+(r-param->GetX())*(r-param->GetX()));
1901 mlpos[0]+=point[0]*weight;
1902 mlpos[1]+=point[1]*weight;
1903 mlpos[2]+=point[2]*weight;
1910 pol->SetPoint(counter,mlpos[0],mlpos[1], mlpos[2]);
1911 printf("xyz\t%f\t%f\t%f\n",mlpos[0], mlpos[1],mlpos[2]);