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>
119 #include <TMatrixD.h>
121 #include "AliESDVertex.h"
122 #include "AliESDtrack.h"
123 #include "AliESDEvent.h"
124 #include "AliKalmanTrack.h"
125 #include "AliVTrack.h"
127 #include "AliTrackPointArray.h"
128 #include "TPolyMarker3D.h"
129 #include "AliTrackerBase.h"
131 ClassImp(AliESDtrack)
133 void SetPIDValues(Double_t * dest, const Double_t * src, Int_t n) {
134 // This function copies "n" PID weights from "scr" to "dest"
135 // and normalizes their sum to 1 thus producing conditional probabilities.
136 // The negative weights are set to 0.
137 // In case all the weights are non-positive they are replaced by
138 // uniform probabilities
142 Float_t uniform = 1./(Float_t)n;
145 for (Int_t i=0; i<n; i++)
155 for (Int_t i=0; i<n; i++) dest[i] /= sum;
157 for (Int_t i=0; i<n; i++) dest[i] = uniform;
160 //_______________________________________________________________________
161 AliESDtrack::AliESDtrack() :
162 AliExternalTrackParam(),
169 fTPCClusterMap(159),//number of padrows
170 fTPCSharedMap(159),//number of padrows
181 fCaloIndex(kEMCALNoMatch),
187 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
190 fCdd(0),fCdz(0),fCzz(0),
206 fTOFsignalToT(99999),
207 fTOFsignalRaw(99999),
231 fVertexID(-2),// -2 means an orphan track
233 fCacheNCrossedRows(-10),
234 fCacheChi2TPCConstrainedVsGlobal(-10),
235 fCacheChi2TPCConstrainedVsGlobalVertex(0)
238 // The default ESD constructor
240 if (!OnlineMode()) fFriendTrack=new AliESDfriendTrack();
243 for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
244 for (i=0; i<AliPID::kSPECIES; i++) {
254 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
255 for (i=0; i<3; i++) { fV0Indexes[i]=0;}
256 for (i=0;i<kTRDnPlanes;i++) {
259 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
260 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
261 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
262 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
263 for (i=0;i<12;i++) {fITSModule[i]=-1;}
266 bool AliESDtrack::fgkOnlineMode=false;
268 //_______________________________________________________________________
269 AliESDtrack::AliESDtrack(const AliESDtrack& track):
270 AliExternalTrackParam(track),
277 fTPCClusterMap(track.fTPCClusterMap),
278 fTPCSharedMap(track.fTPCSharedMap),
279 fFlags(track.fFlags),
281 fLabel(track.fLabel),
282 fITSLabel(track.fITSLabel),
283 fTPCLabel(track.fTPCLabel),
284 fTRDLabel(track.fTRDLabel),
285 fTOFCalChannel(track.fTOFCalChannel),
286 fTOFindex(track.fTOFindex),
287 fHMPIDqn(track.fHMPIDqn),
288 fHMPIDcluIdx(track.fHMPIDcluIdx),
289 fCaloIndex(track.fCaloIndex),
290 fHMPIDtrkTheta(track.fHMPIDtrkTheta),
291 fHMPIDtrkPhi(track.fHMPIDtrkPhi),
292 fHMPIDsignal(track.fHMPIDsignal),
293 fTrackLength(track.fTrackLength),
294 fdTPC(track.fdTPC),fzTPC(track.fzTPC),
295 fCddTPC(track.fCddTPC),fCdzTPC(track.fCdzTPC),fCzzTPC(track.fCzzTPC),
296 fCchi2TPC(track.fCchi2TPC),
297 fD(track.fD),fZ(track.fZ),
298 fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
299 fCchi2(track.fCchi2),
300 fITSchi2(track.fITSchi2),
301 fTPCchi2(track.fTPCchi2),
302 fTPCchi2Iter1(track.fTPCchi2Iter1),
303 fTRDchi2(track.fTRDchi2),
304 fTOFchi2(track.fTOFchi2),
305 fHMPIDchi2(track.fHMPIDchi2),
306 fGlobalChi2(track.fGlobalChi2),
307 fITSsignal(track.fITSsignal),
308 fTPCsignal(track.fTPCsignal),
309 fTPCsignalS(track.fTPCsignalS),
310 fTRDsignal(track.fTRDsignal),
311 fTRDQuality(track.fTRDQuality),
312 fTRDBudget(track.fTRDBudget),
313 fTOFsignal(track.fTOFsignal),
314 fTOFsignalToT(track.fTOFsignalToT),
315 fTOFsignalRaw(track.fTOFsignalRaw),
316 fTOFsignalDz(track.fTOFsignalDz),
317 fTOFsignalDx(track.fTOFsignalDx),
318 fTOFdeltaBC(track.fTOFdeltaBC),
319 fTOFl0l1(track.fTOFl0l1),
320 fCaloDx(track.fCaloDx),
321 fCaloDz(track.fCaloDz),
322 fHMPIDtrkX(track.fHMPIDtrkX),
323 fHMPIDtrkY(track.fHMPIDtrkY),
324 fHMPIDmipX(track.fHMPIDmipX),
325 fHMPIDmipY(track.fHMPIDmipY),
326 fTPCncls(track.fTPCncls),
327 fTPCnclsF(track.fTPCnclsF),
328 fTPCsignalN(track.fTPCsignalN),
329 fTPCnclsIter1(track.fTPCnclsIter1),
330 fTPCnclsFIter1(track.fTPCnclsIter1),
331 fITSncls(track.fITSncls),
332 fITSClusterMap(track.fITSClusterMap),
333 fITSSharedMap(track.fITSSharedMap),
334 fTRDncls(track.fTRDncls),
335 fTRDncls0(track.fTRDncls0),
336 fTRDntracklets(track.fTRDntracklets),
337 fTRDnSlices(track.fTRDnSlices),
339 fVertexID(track.fVertexID),
340 fESDEvent(track.fESDEvent),
341 fCacheNCrossedRows(track.fCacheNCrossedRows),
342 fCacheChi2TPCConstrainedVsGlobal(track.fCacheChi2TPCConstrainedVsGlobal),
343 fCacheChi2TPCConstrainedVsGlobalVertex(track.fCacheChi2TPCConstrainedVsGlobalVertex)
348 for (Int_t i=kNITSchi2Std;i--;) fITSchi2Std[i] = track.fTrackTime[i];
349 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i]=track.fTrackTime[i];
350 for (Int_t i=0;i<AliPID::kSPECIES;i++) fR[i]=track.fR[i];
352 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
354 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[i];
355 for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=track.fITSdEdxSamples[i];}
356 for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
357 for (Int_t i=0; i<3;i++) { fKinkIndexes[i]=track.fKinkIndexes[i];}
358 for (Int_t i=0; i<3;i++) { fV0Indexes[i]=track.fV0Indexes[i];}
360 for (Int_t i=0;i<kTRDnPlanes;i++) {
361 fTRDTimBin[i]=track.fTRDTimBin[i];
365 fTRDslices=new Double32_t[fTRDnSlices];
366 for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=track.fTRDslices[i];
369 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
370 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
371 for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
372 for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
373 for (Int_t i=0;i<12;i++) fITSModule[i]=track.fITSModule[i];
374 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i]=track.fHMPIDr[i];
376 if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
377 if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
378 if (track.fTPCInner) fTPCInner=new AliExternalTrackParam(*track.fTPCInner);
379 if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
380 if (track.fHMPIDp) fHMPIDp=new AliExternalTrackParam(*track.fHMPIDp);
382 if (track.fFriendTrack) fFriendTrack=new AliESDfriendTrack(*(track.fFriendTrack));
385 //_______________________________________________________________________
386 AliESDtrack::AliESDtrack(const AliVTrack *track) :
387 AliExternalTrackParam(track),
394 fTPCClusterMap(159),//number of padrows
395 fTPCSharedMap(159),//number of padrows
406 fCaloIndex(kEMCALNoMatch),
412 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
415 fCdd(0),fCdz(0),fCzz(0),
431 fTOFsignalToT(99999),
432 fTOFsignalRaw(99999),
456 fVertexID(-2), // -2 means an orphan track
458 fCacheNCrossedRows(-10),
459 fCacheChi2TPCConstrainedVsGlobal(-10),
460 fCacheChi2TPCConstrainedVsGlobalVertex(0)
463 // ESD track from AliVTrack.
464 // This is not a copy constructor !
467 if (track->InheritsFrom("AliExternalTrackParam")) {
468 AliError("This is not a copy constructor. Use AliESDtrack(const AliESDtrack &) !");
469 AliWarning("Calling the default constructor...");
474 // Reset all the arrays
476 for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
477 for (i=0; i<AliPID::kSPECIES; i++) {
487 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
488 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
489 for (i=0;i<kTRDnPlanes;i++) {
492 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
493 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
494 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
495 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
496 for (i=0;i<12;i++) {fITSModule[i]=-1;}
499 SetID(track->GetID());
501 // Set ITS cluster map
502 fITSClusterMap=track->GetITSClusterMap();
507 if(HasPointOnITSLayer(i)) fITSncls++;
511 fTPCncls=track->GetTPCNcls();
514 // Set the combined PID
515 const Double_t *pid = track->PID();
517 for (i=0; i<AliPID::kSPECIES; i++) fR[i]=pid[i];
519 // AliESD track label
520 SetLabel(track->GetLabel());
522 SetStatus(track->GetStatus());
525 //_______________________________________________________________________
526 AliESDtrack::AliESDtrack(TParticle * part) :
527 AliExternalTrackParam(),
534 fTPCClusterMap(159),//number of padrows
535 fTPCSharedMap(159),//number of padrows
546 fCaloIndex(kEMCALNoMatch),
552 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
555 fCdd(0),fCdz(0),fCzz(0),
571 fTOFsignalToT(99999),
572 fTOFsignalRaw(99999),
596 fVertexID(-2), // -2 means an orphan track
598 fCacheNCrossedRows(-10),
599 fCacheChi2TPCConstrainedVsGlobal(-10),
600 fCacheChi2TPCConstrainedVsGlobalVertex(0)
603 // ESD track from TParticle
606 // Reset all the arrays
608 for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
609 for (i=0; i<AliPID::kSPECIES; i++) {
619 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
620 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
621 for (i=0;i<kTRDnPlanes;i++) {
624 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
625 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
626 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
627 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
628 for (i=0;i<12;i++) {fITSModule[i]=-1;}
630 // Calculate the AliExternalTrackParam content
637 // Calculate alpha: the rotation angle of the corresponding local system (TPC sector)
638 alpha = part->Phi()*180./TMath::Pi();
639 if (alpha<0) alpha+= 360.;
640 if (alpha>360) alpha -= 360.;
642 Int_t sector = (Int_t)(alpha/20.);
643 alpha = 10. + 20.*sector;
645 alpha *= TMath::Pi();
647 // Covariance matrix: no errors, the parameters are exact
648 for (i=0; i<15; i++) covar[i]=0.;
650 // Get the vertex of origin and the momentum
651 TVector3 ver(part->Vx(),part->Vy(),part->Vz());
652 TVector3 mom(part->Px(),part->Py(),part->Pz());
654 // Rotate to the local coordinate system (TPC sector)
658 // X of the referense plane
661 Int_t pdgCode = part->GetPdgCode();
664 TDatabasePDG::Instance()->GetParticle(pdgCode)->Charge();
668 param[2] = TMath::Sin(mom.Phi());
669 param[3] = mom.Pz()/mom.Pt();
670 param[4] = TMath::Sign(1/mom.Pt(),charge);
672 // Set AliExternalTrackParam
673 Set(xref, alpha, param, covar);
678 switch (TMath::Abs(pdgCode)) {
704 // If the particle is not e,mu,pi,K or p the PID probabilities are set to 0
705 if (indexPID < AliPID::kSPECIES) {
711 fHMPIDr[indexPID]=1.;
714 // AliESD track label
715 SetLabel(part->GetUniqueID());
719 //_______________________________________________________________________
720 AliESDtrack::~AliESDtrack(){
722 // This is destructor according Coding Conventrions
724 //printf("Delete track\n");
730 if (fFriendTrack) delete fFriendTrack;
736 AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source){
739 if(&source == this) return *this;
740 AliExternalTrackParam::operator=(source);
744 // we have the trackparam: assign or copy construct
745 if(fCp)*fCp = *source.fCp;
746 else fCp = new AliExternalTrackParam(*source.fCp);
749 // no track param delete the old one
755 // we have the trackparam: assign or copy construct
756 if(fIp)*fIp = *source.fIp;
757 else fIp = new AliExternalTrackParam(*source.fIp);
760 // no track param delete the old one
766 if(source.fTPCInner){
767 // we have the trackparam: assign or copy construct
768 if(fTPCInner) *fTPCInner = *source.fTPCInner;
769 else fTPCInner = new AliExternalTrackParam(*source.fTPCInner);
772 // no track param delete the old one
773 if(fTPCInner)delete fTPCInner;
779 // we have the trackparam: assign or copy construct
780 if(fOp) *fOp = *source.fOp;
781 else fOp = new AliExternalTrackParam(*source.fOp);
784 // no track param delete the old one
791 // we have the trackparam: assign or copy construct
792 if(fHMPIDp) *fHMPIDp = *source.fHMPIDp;
793 else fHMPIDp = new AliExternalTrackParam(*source.fHMPIDp);
796 // no track param delete the old one
797 if(fHMPIDp)delete fHMPIDp;
802 // copy also the friend track
803 // use copy constructor
804 if(source.fFriendTrack){
805 // we have the trackparam: assign or copy construct
806 delete fFriendTrack; fFriendTrack=new AliESDfriendTrack(*source.fFriendTrack);
809 // no track param delete the old one
810 delete fFriendTrack; fFriendTrack= 0;
813 fTPCClusterMap = source.fTPCClusterMap;
814 fTPCSharedMap = source.fTPCSharedMap;
816 fFlags = source.fFlags;
818 fLabel = source.fLabel;
819 fITSLabel = source.fITSLabel;
820 for(int i = 0; i< 12;++i){
821 fITSModule[i] = source.fITSModule[i];
823 fTPCLabel = source.fTPCLabel;
824 fTRDLabel = source.fTRDLabel;
825 for(int i = 0; i< 3;++i){
826 fTOFLabel[i] = source.fTOFLabel[i];
828 fTOFCalChannel = source.fTOFCalChannel;
829 fTOFindex = source.fTOFindex;
830 fHMPIDqn = source.fHMPIDqn;
831 fHMPIDcluIdx = source.fHMPIDcluIdx;
832 fCaloIndex = source.fCaloIndex;
833 for (int i=kNITSchi2Std;i--;) fITSchi2Std[i] = source.fITSchi2Std[i];
834 for(int i = 0; i< 3;++i){
835 fKinkIndexes[i] = source.fKinkIndexes[i];
836 fV0Indexes[i] = source.fV0Indexes[i];
839 for(int i = 0; i< AliPID::kSPECIES;++i){
840 fR[i] = source.fR[i];
841 fITSr[i] = source.fITSr[i];
842 fTPCr[i] = source.fTPCr[i];
843 fTRDr[i] = source.fTRDr[i];
844 fTOFr[i] = source.fTOFr[i];
845 fHMPIDr[i] = source.fHMPIDr[i];
846 fTrackTime[i] = source.fTrackTime[i];
849 fHMPIDtrkTheta = source.fHMPIDtrkTheta;
850 fHMPIDtrkPhi = source.fHMPIDtrkPhi;
851 fHMPIDsignal = source.fHMPIDsignal;
854 fTrackLength = source. fTrackLength;
855 fdTPC = source.fdTPC;
856 fzTPC = source.fzTPC;
857 fCddTPC = source.fCddTPC;
858 fCdzTPC = source.fCdzTPC;
859 fCzzTPC = source.fCzzTPC;
860 fCchi2TPC = source.fCchi2TPC;
867 fCchi2 = source.fCchi2;
869 fITSchi2 = source.fITSchi2;
870 fTPCchi2 = source.fTPCchi2;
871 fTPCchi2Iter1 = source.fTPCchi2Iter1;
872 fTRDchi2 = source.fTRDchi2;
873 fTOFchi2 = source.fTOFchi2;
874 fHMPIDchi2 = source.fHMPIDchi2;
876 fGlobalChi2 = source.fGlobalChi2;
878 fITSsignal = source.fITSsignal;
879 for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=source.fITSdEdxSamples[i];}
880 fTPCsignal = source.fTPCsignal;
881 fTPCsignalS = source.fTPCsignalS;
882 for(int i = 0; i< 4;++i){
883 fTPCPoints[i] = source.fTPCPoints[i];
885 fTRDsignal = source.fTRDsignal;
887 for(int i = 0;i < kTRDnPlanes;++i){
888 fTRDTimBin[i] = source.fTRDTimBin[i];
894 fTRDnSlices=source.fTRDnSlices;
896 fTRDslices=new Double32_t[fTRDnSlices];
897 for(int j = 0;j < fTRDnSlices;++j) fTRDslices[j] = source.fTRDslices[j];
900 fTRDQuality = source.fTRDQuality;
901 fTRDBudget = source.fTRDBudget;
902 fTOFsignal = source.fTOFsignal;
903 fTOFsignalToT = source.fTOFsignalToT;
904 fTOFsignalRaw = source.fTOFsignalRaw;
905 fTOFsignalDz = source.fTOFsignalDz;
906 fTOFsignalDx = source.fTOFsignalDx;
907 fTOFdeltaBC = source.fTOFdeltaBC;
908 fTOFl0l1 = source.fTOFl0l1;
910 for(int i = 0;i<10;++i){
911 fTOFInfo[i] = source.fTOFInfo[i];
914 fHMPIDtrkX = source.fHMPIDtrkX;
915 fHMPIDtrkY = source.fHMPIDtrkY;
916 fHMPIDmipX = source.fHMPIDmipX;
917 fHMPIDmipY = source.fHMPIDmipY;
919 fTPCncls = source.fTPCncls;
920 fTPCnclsF = source.fTPCnclsF;
921 fTPCsignalN = source.fTPCsignalN;
922 fTPCnclsIter1 = source.fTPCnclsIter1;
923 fTPCnclsFIter1 = source.fTPCnclsFIter1;
925 fITSncls = source.fITSncls;
926 fITSClusterMap = source.fITSClusterMap;
927 fITSSharedMap = source.fITSSharedMap;
928 fTRDncls = source.fTRDncls;
929 fTRDncls0 = source.fTRDncls0;
930 fTRDntracklets = source.fTRDntracklets;
931 fVertexID = source.fVertexID;
937 void AliESDtrack::Copy(TObject &obj) const {
939 // this overwrites the virtual TOBject::Copy()
940 // to allow run time copying without casting
943 if(this==&obj)return;
944 AliESDtrack *robj = dynamic_cast<AliESDtrack*>(&obj);
945 if(!robj)return; // not an AliESDtrack
952 void AliESDtrack::AddCalibObject(TObject * object){
954 // add calib object to the list
956 if (!fFriendTrack) fFriendTrack = new AliESDfriendTrack;
957 if (!fFriendTrack) return;
958 fFriendTrack->AddCalibObject(object);
961 TObject * AliESDtrack::GetCalibObject(Int_t index){
963 // return calib objct at given position
965 if (!fFriendTrack) return 0;
966 return fFriendTrack->GetCalibObject(index);
970 Bool_t AliESDtrack::FillTPCOnlyTrack(AliESDtrack &track){
972 // Fills the information of the TPC-only first reconstruction pass
973 // into the passed ESDtrack object. For consistency fTPCInner is also filled
978 // For data produced before r26675
979 // RelateToVertexTPC was not properly called during reco
980 // so you'll have to call it again, before FillTPCOnlyTrack
981 // Float_t p[2],cov[3];
982 // track->GetImpactParametersTPC(p,cov);
983 // if(p[0]==0&&p[1]==0) // <- Default values
984 // track->RelateToVertexTPC(esd->GetPrimaryVertexTPC(),esd->GetMagneticField(),kVeryBig);
987 if(!fTPCInner)return kFALSE;
989 // fill the TPC track params to the global track parameters
990 track.Set(fTPCInner->GetX(),fTPCInner->GetAlpha(),fTPCInner->GetParameter(),fTPCInner->GetCovariance());
993 track.fCdd = fCddTPC;
994 track.fCdz = fCdzTPC;
995 track.fCzz = fCzzTPC;
997 // copy the inner params
998 if(track.fIp) *track.fIp = *fIp;
999 else track.fIp = new AliExternalTrackParam(*fIp);
1001 // copy the TPCinner parameters
1002 if(track.fTPCInner) *track.fTPCInner = *fTPCInner;
1003 else track.fTPCInner = new AliExternalTrackParam(*fTPCInner);
1004 track.fdTPC = fdTPC;
1005 track.fzTPC = fzTPC;
1006 track.fCddTPC = fCddTPC;
1007 track.fCdzTPC = fCdzTPC;
1008 track.fCzzTPC = fCzzTPC;
1009 track.fCchi2TPC = fCchi2TPC;
1011 // copy all other TPC specific parameters
1013 // replace label by TPC label
1014 track.fLabel = fTPCLabel;
1015 track.fTPCLabel = fTPCLabel;
1017 track.fTPCchi2 = fTPCchi2;
1018 track.fTPCchi2Iter1 = fTPCchi2Iter1;
1019 track.fTPCsignal = fTPCsignal;
1020 track.fTPCsignalS = fTPCsignalS;
1021 for(int i = 0;i<4;++i)track.fTPCPoints[i] = fTPCPoints[i];
1023 track.fTPCncls = fTPCncls;
1024 track.fTPCnclsF = fTPCnclsF;
1025 track.fTPCsignalN = fTPCsignalN;
1026 track.fTPCnclsIter1 = fTPCnclsIter1;
1027 track.fTPCnclsFIter1 = fTPCnclsFIter1;
1030 for(int i=0;i<AliPID::kSPECIES;++i){
1031 track.fTPCr[i] = fTPCr[i];
1032 // combined PID is TPC only!
1033 track.fR[i] = fTPCr[i];
1035 track.fTPCClusterMap = fTPCClusterMap;
1036 track.fTPCSharedMap = fTPCSharedMap;
1040 track.fFlags = kTPCin;
1043 track.fFlags |= fFlags & kTPCpid; //copy the TPCpid status flag
1045 for (Int_t i=0;i<3;i++) track.fKinkIndexes[i] = fKinkIndexes[i];
1051 //_______________________________________________________________________
1052 void AliESDtrack::MakeMiniESDtrack(){
1053 // Resets everything except
1054 // fFlags: Reconstruction status flags
1055 // fLabel: Track label
1056 // fID: Unique ID of the track
1057 // Impact parameter information
1058 // fR[AliPID::kSPECIES]: combined "detector response probability"
1059 // Running track parameters in the base class (AliExternalTrackParam)
1063 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
1065 // Reset track parameters constrained to the primary vertex
1068 // Reset track parameters at the inner wall of TPC
1070 delete fTPCInner;fTPCInner=0;
1071 // Reset track parameters at the inner wall of the TRD
1073 // Reset track parameters at the HMPID
1074 delete fHMPIDp;fHMPIDp = 0;
1077 // Reset ITS track related information
1083 for (Int_t i=0;i<4;i++) fITSdEdxSamples[i] = 0.;
1084 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
1087 // Reset TPC related track information
1099 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=0;
1101 for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
1102 for (Int_t i=0; i<3;i++) fKinkIndexes[i] = 0;
1103 for (Int_t i=0; i<3;i++) fV0Indexes[i] = 0;
1105 // Reset TRD related track information
1110 for (Int_t i=0;i<kTRDnPlanes;i++) {
1113 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
1118 delete[] fTRDslices;
1123 // Reset TOF related track information
1127 fTOFCalChannel = -1;
1128 fTOFsignalToT = 99999;
1129 fTOFsignalRaw = 99999;
1134 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
1135 for (Int_t i=0;i<3;i++) fTOFLabel[i] = -1;
1136 for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
1138 // Reset HMPID related track information
1143 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
1150 fCaloIndex = kEMCALNoMatch;
1152 // reset global track chi2
1155 fVertexID = -2; // an orphan track
1157 delete fFriendTrack; fFriendTrack = 0;
1160 //_______________________________________________________________________
1161 Int_t AliESDtrack::GetPID() const
1163 // Returns the particle most probable id
1165 for (i=0; i<AliPID::kSPECIES-1; i++) if (fR[i] != fR[i+1]) break;
1167 if (i == AliPID::kSPECIES-1) return AliPID::kPion; // If all the probabilities are equal, return the pion mass
1171 for (i=0; i<AliPID::kSPECIES; i++) if (fR[i]>max) {k=i; max=fR[i];}
1173 if (k==0) { // dE/dx "crossing points" in the TPC
1175 if ((p>0.38)&&(p<0.48))
1176 if (fR[0]<fR[3]*10.) return AliPID::kKaon;
1177 if ((p>0.75)&&(p<0.85))
1178 if (fR[0]<fR[4]*10.) return AliPID::kProton;
1179 return AliPID::kElectron;
1181 if (k==1) return AliPID::kMuon;
1182 if (k==2||k==-1) return AliPID::kPion;
1183 if (k==3) return AliPID::kKaon;
1184 if (k==4) return AliPID::kProton;
1185 AliWarning("Undefined PID !");
1186 return AliPID::kPion;
1189 //_______________________________________________________________________
1190 Int_t AliESDtrack::GetTOFBunchCrossing(Double_t b) const
1192 // Returns the number of bunch crossings after trigger (assuming 25ns spacing)
1193 const double kSpacing = 25e3; // min interbanch spacing
1194 const double kShift = 0;
1195 Int_t bcid = kTOFBCNA; // defualt one
1196 if (!IsOn(kTOFout) || !IsOn(kESDpid)) return bcid; // no info
1198 double tdif = fTOFsignal;
1199 if (IsOn(kTIME)) { // integrated time info is there
1201 tdif -= fTrackTime[pid];
1203 else { // assume integrated time info from TOF radius and momentum
1204 const double kRTOF = 385.;
1205 const double kCSpeed = 3.e-2; // cm/ps
1207 if (p<0.01) return bcid;
1208 double m = GetMass();
1209 double curv = GetC(b);
1210 double path = TMath::Abs(curv)>kAlmost0 ? // account for curvature
1211 2./curv*TMath::ASin(kRTOF*curv/2.)*TMath::Sqrt(1.+GetTgl()*GetTgl()) : kRTOF;
1212 tdif -= path/kCSpeed*TMath::Sqrt(1.+m*m/(p*p));
1214 bcid = TMath::Nint((tdif - kShift)/kSpacing);
1218 //______________________________________________________________________________
1219 Double_t AliESDtrack::M() const
1221 // Returns the assumed mass
1222 // (the pion mass, if the particle can't be identified properly).
1223 static Bool_t printerr=kTRUE;
1225 AliWarning("WARNING !!! ... THIS WILL BE PRINTED JUST ONCE !!!");
1227 AliWarning("This is the ESD mass. Use it with care !");
1232 //______________________________________________________________________________
1233 Double_t AliESDtrack::E() const
1235 // Returns the energy of the particle given its assumed mass.
1236 // Assumes the pion mass if the particle can't be identified properly.
1240 return TMath::Sqrt(p*p + m*m);
1243 //______________________________________________________________________________
1244 Double_t AliESDtrack::Y() const
1246 // Returns the rapidity of a particle given its assumed mass.
1247 // Assumes the pion mass if the particle can't be identified properly.
1251 if (e != TMath::Abs(pz)) { // energy was not equal to pz
1252 return 0.5*TMath::Log((e+pz)/(e-pz));
1253 } else { // energy was equal to pz
1258 //_______________________________________________________________________
1259 Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
1261 // This function updates track's running parameters
1266 fLabel=t->GetLabel();
1268 if (t->IsStartedTimeIntegral()) {
1270 Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
1271 SetIntegratedLength(t->GetIntegratedLength());
1274 Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1276 if (flags==kITSout) fFriendTrack->SetITSOut(*t);
1277 if (flags==kTPCout) fFriendTrack->SetTPCOut(*t);
1278 if (flags==kTRDrefit) fFriendTrack->SetTRDIn(*t);
1284 fITSchi2Std[0] = t->GetChi2();
1287 fITSchi2Std[1] = t->GetChi2();
1290 fITSchi2Std[2] = t->GetChi2();
1292 fITSncls=t->GetNumberOfClusters();
1294 Int_t* indexITS = new Int_t[AliESDfriendTrack::kMaxITScluster];
1295 for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
1296 indexITS[i]=t->GetClusterIndex(i);
1299 Int_t l=(indexITS[i] & 0xf0000000) >> 28;
1300 SETBIT(fITSClusterMap,l);
1303 fFriendTrack->SetITSIndices(indexITS,AliESDfriendTrack::kMaxITScluster);
1307 fITSchi2=t->GetChi2();
1308 fITSsignal=t->GetPIDsignal();
1309 fITSLabel = t->GetLabel();
1310 // keep in fOp the parameters outside ITS for ITS stand-alone tracks
1311 if (flags==kITSout) {
1312 if (!fOp) fOp=new AliExternalTrackParam(*t);
1314 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1319 case kTPCin: case kTPCrefit:
1321 fTPCLabel = t->GetLabel();
1322 if (flags==kTPCin) {
1323 fTPCInner=new AliExternalTrackParam(*t);
1324 fTPCnclsIter1=t->GetNumberOfClusters();
1325 fTPCchi2Iter1=t->GetChi2();
1327 if (!fIp) fIp=new AliExternalTrackParam(*t);
1329 fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1331 // Intentionally no break statement; need to set general TPC variables as well
1334 if (flags & kTPCout){
1335 if (!fOp) fOp=new AliExternalTrackParam(*t);
1337 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1339 fTPCncls=t->GetNumberOfClusters();
1340 fTPCchi2=t->GetChi2();
1342 if (fFriendTrack) { // Copy cluster indices
1343 Int_t* indexTPC = new Int_t[AliESDfriendTrack::kMaxTPCcluster];
1344 for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)
1345 indexTPC[i]=t->GetClusterIndex(i);
1346 fFriendTrack->SetTPCIndices(indexTPC,AliESDfriendTrack::kMaxTPCcluster);
1349 fTPCsignal=t->GetPIDsignal();
1353 case kTRDin: case kTRDrefit:
1357 fTRDLabel = t->GetLabel();
1358 fTRDchi2 = t->GetChi2();
1359 fTRDncls = t->GetNumberOfClusters();
1361 Int_t* indexTRD = new Int_t[AliESDfriendTrack::kMaxTRDcluster];
1362 for (Int_t i=0;i<AliESDfriendTrack::kMaxTRDcluster;i++) indexTRD[i]=-2;
1363 for (Int_t i=0;i<6;i++) indexTRD[i]=t->GetTrackletIndex(i);
1364 fFriendTrack->SetTRDIndices(indexTRD,AliESDfriendTrack::kMaxTRDcluster);
1368 fTRDsignal=t->GetPIDsignal();
1372 if (!fOp) fOp=new AliExternalTrackParam(*t);
1374 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1375 fTRDncls0 = t->GetNumberOfClusters();
1384 if (!fHMPIDp) fHMPIDp=new AliExternalTrackParam(*t);
1386 fHMPIDp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1389 AliError("Wrong flag !");
1396 //_______________________________________________________________________
1397 void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
1398 //---------------------------------------------------------------------
1399 // This function returns external representation of the track parameters
1400 //---------------------------------------------------------------------
1402 for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
1405 //_______________________________________________________________________
1406 void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
1407 //---------------------------------------------------------------------
1408 // This function returns external representation of the cov. matrix
1409 //---------------------------------------------------------------------
1410 for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
1413 //_______________________________________________________________________
1414 Bool_t AliESDtrack::GetConstrainedExternalParameters
1415 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1416 //---------------------------------------------------------------------
1417 // This function returns the constrained external track parameters
1418 //---------------------------------------------------------------------
1419 if (!fCp) return kFALSE;
1420 alpha=fCp->GetAlpha();
1422 for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
1426 //_______________________________________________________________________
1428 AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
1429 //---------------------------------------------------------------------
1430 // This function returns the constrained external cov. matrix
1431 //---------------------------------------------------------------------
1432 if (!fCp) return kFALSE;
1433 for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
1438 AliESDtrack::GetInnerExternalParameters
1439 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1440 //---------------------------------------------------------------------
1441 // This function returns external representation of the track parameters
1442 // at the inner layer of TPC
1443 //---------------------------------------------------------------------
1444 if (!fIp) return kFALSE;
1445 alpha=fIp->GetAlpha();
1447 for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
1452 AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const {
1453 //---------------------------------------------------------------------
1454 // This function returns external representation of the cov. matrix
1455 // at the inner layer of TPC
1456 //---------------------------------------------------------------------
1457 if (!fIp) return kFALSE;
1458 for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
1463 AliESDtrack::SetOuterParam(const AliExternalTrackParam *p, ULong_t flags) {
1465 // This is a direct setter for the outer track parameters
1468 if (fOp) delete fOp;
1469 fOp=new AliExternalTrackParam(*p);
1473 AliESDtrack::SetOuterHmpParam(const AliExternalTrackParam *p, ULong_t flags) {
1475 // This is a direct setter for the outer track parameters
1478 if (fHMPIDp) delete fHMPIDp;
1479 fHMPIDp=new AliExternalTrackParam(*p);
1483 AliESDtrack::GetOuterExternalParameters
1484 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1485 //---------------------------------------------------------------------
1486 // This function returns external representation of the track parameters
1487 // at the inner layer of TRD
1488 //---------------------------------------------------------------------
1489 if (!fOp) return kFALSE;
1490 alpha=fOp->GetAlpha();
1492 for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
1497 AliESDtrack::GetOuterHmpExternalParameters
1498 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1499 //---------------------------------------------------------------------
1500 // This function returns external representation of the track parameters
1501 // at the inner layer of TRD
1502 //---------------------------------------------------------------------
1503 if (!fHMPIDp) return kFALSE;
1504 alpha=fHMPIDp->GetAlpha();
1506 for (Int_t i=0; i<5; i++) p[i]=fHMPIDp->GetParameter()[i];
1511 AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
1512 //---------------------------------------------------------------------
1513 // This function returns external representation of the cov. matrix
1514 // at the inner layer of TRD
1515 //---------------------------------------------------------------------
1516 if (!fOp) return kFALSE;
1517 for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
1522 AliESDtrack::GetOuterHmpExternalCovariance(Double_t cov[15]) const {
1523 //---------------------------------------------------------------------
1524 // This function returns external representation of the cov. matrix
1525 // at the inner layer of TRD
1526 //---------------------------------------------------------------------
1527 if (!fHMPIDp) return kFALSE;
1528 for (Int_t i=0; i<15; i++) cov[i]=fHMPIDp->GetCovariance()[i];
1532 Int_t AliESDtrack::GetNcls(Int_t idet) const
1534 // Get number of clusters by subdetector index
1548 if (fTOFindex != -1)
1554 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1555 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1566 Int_t AliESDtrack::GetClusters(Int_t idet, Int_t *idx) const
1568 // Get cluster index array by subdetector index
1573 ncls = GetITSclusters(idx);
1576 ncls = GetTPCclusters(idx);
1579 ncls = GetTRDclusters(idx);
1582 if (fTOFindex != -1) {
1590 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1591 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1592 idx[0] = GetHMPIDcluIdx();
1605 //_______________________________________________________________________
1606 void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
1607 // Returns the array with integrated times for each particle hypothesis
1608 for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
1611 //_______________________________________________________________________
1612 void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
1613 // Sets the array with integrated times for each particle hypotesis
1614 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
1617 //_______________________________________________________________________
1618 void AliESDtrack::SetITSpid(const Double_t *p) {
1619 // Sets values for the probability of each particle type (in ITS)
1620 SetPIDValues(fITSr,p,AliPID::kSPECIES);
1621 SetStatus(AliESDtrack::kITSpid);
1624 //_______________________________________________________________________
1625 void AliESDtrack::GetITSpid(Double_t *p) const {
1626 // Gets the probability of each particle type (in ITS)
1627 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
1630 //_______________________________________________________________________
1631 Char_t AliESDtrack::GetITSclusters(Int_t *idx) const {
1632 //---------------------------------------------------------------------
1633 // This function returns indices of the assgined ITS clusters
1634 //---------------------------------------------------------------------
1635 if (idx && fFriendTrack) {
1636 Int_t *index=fFriendTrack->GetITSindices();
1637 for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) {
1638 if ( (i>=fITSncls) && (i<6) ) idx[i]=-1;
1650 //_______________________________________________________________________
1651 Bool_t AliESDtrack::GetITSModuleIndexInfo(Int_t ilayer,Int_t &idet,Int_t &status,
1652 Float_t &xloc,Float_t &zloc) const {
1653 //----------------------------------------------------------------------
1654 // This function encodes in the module number also the status of cluster association
1655 // "status" can have the following values:
1656 // 1 "found" (cluster is associated),
1657 // 2 "dead" (module is dead from OCDB),
1658 // 3 "skipped" (module or layer forced to be skipped),
1659 // 4 "outinz" (track out of z acceptance),
1660 // 5 "nocls" (no clusters in the road),
1661 // 6 "norefit" (cluster rejected during refit),
1662 // 7 "deadzspd" (holes in z in SPD)
1663 // Also given are the coordinates of the crossing point of track and module
1664 // (in the local module ref. system)
1665 // WARNING: THIS METHOD HAS TO BE SYNCHRONIZED WITH AliITStrackV2::GetModuleIndexInfo()!
1666 //----------------------------------------------------------------------
1668 if(fITSModule[ilayer]==-1) {
1671 xloc=-99.; zloc=-99.;
1675 Int_t module = fITSModule[ilayer];
1677 idet = Int_t(module/1000000);
1679 module -= idet*1000000;
1681 status = Int_t(module/100000);
1683 module -= status*100000;
1685 Int_t signs = Int_t(module/10000);
1687 module-=signs*10000;
1689 Int_t xInt = Int_t(module/100);
1692 Int_t zInt = module;
1694 if(signs==1) { xInt*=1; zInt*=1; }
1695 if(signs==2) { xInt*=1; zInt*=-1; }
1696 if(signs==3) { xInt*=-1; zInt*=1; }
1697 if(signs==4) { xInt*=-1; zInt*=-1; }
1699 xloc = 0.1*(Float_t)xInt;
1700 zloc = 0.1*(Float_t)zInt;
1702 if(status==4) idet = -1;
1707 //_______________________________________________________________________
1708 UShort_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
1709 //---------------------------------------------------------------------
1710 // This function returns indices of the assgined ITS clusters
1711 //---------------------------------------------------------------------
1712 if (idx && fFriendTrack) {
1713 Int_t *index=fFriendTrack->GetTPCindices();
1716 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
1719 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=-2;
1725 //_______________________________________________________________________
1726 Float_t AliESDtrack::GetTPCCrossedRows() const
1728 // This function calls GetTPCClusterInfo with some default parameters which are used in the track selection and caches the outcome
1729 // because GetTPCClusterInfo is quite time-consuming
1731 if (fCacheNCrossedRows > -1)
1732 return fCacheNCrossedRows;
1734 fCacheNCrossedRows = GetTPCClusterInfo(2, 1);
1735 return fCacheNCrossedRows;
1738 //_______________________________________________________________________
1739 Float_t AliESDtrack::GetTPCClusterInfo(Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1) const
1742 // TPC cluster information
1743 // type 0: get fraction of found/findable clusters with neighbourhood definition
1744 // 1: findable clusters with neighbourhood definition
1745 // 2: found clusters
1747 // definition of findable clusters:
1748 // a cluster is defined as findable if there is another cluster
1749 // within +- nNeighbours pad rows. The idea is to overcome threshold
1750 // effects with a very simple algorithm.
1753 if (type==2) return fTPCClusterMap.CountBits();
1757 Int_t last=-nNeighbours;
1759 Int_t upperBound=fTPCClusterMap.GetNbits();
1760 if (upperBound>row1) upperBound=row1;
1761 for (Int_t i=row0; i<upperBound; ++i){
1762 //look to current row
1763 if (fTPCClusterMap[i]) {
1769 //look to nNeighbours before
1770 if ((i-last)<=nNeighbours) {
1774 //look to nNeighbours after
1775 for (Int_t j=i+1; j<i+1+nNeighbours; ++j){
1776 if (fTPCClusterMap[j]){
1782 if (type==1) return findable;
1787 fraction=(Float_t)found/(Float_t)findable;
1792 return 0; // undefined type - default value
1795 //_______________________________________________________________________
1796 Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
1798 // GetDensity of the clusters on given region between row0 and row1
1799 // Dead zone effect takin into acoount
1801 if (!fFriendTrack) return 0.0;
1805 Int_t *index=fFriendTrack->GetTPCindices();
1806 for (Int_t i=row0;i<=row1;i++){
1807 Int_t idx = index[i];
1808 if (idx!=-1) good++; // track outside of dead zone
1811 Float_t density=0.5;
1812 if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
1816 //_______________________________________________________________________
1817 void AliESDtrack::SetTPCpid(const Double_t *p) {
1818 // Sets values for the probability of each particle type (in TPC)
1819 SetPIDValues(fTPCr,p,AliPID::kSPECIES);
1820 SetStatus(AliESDtrack::kTPCpid);
1823 //_______________________________________________________________________
1824 void AliESDtrack::GetTPCpid(Double_t *p) const {
1825 // Gets the probability of each particle type (in TPC)
1826 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
1829 //_______________________________________________________________________
1830 UChar_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
1831 //---------------------------------------------------------------------
1832 // This function returns indices of the assgined TRD clusters
1833 //---------------------------------------------------------------------
1834 if (idx && fFriendTrack) {
1835 Int_t *index=fFriendTrack->GetTRDindices();
1838 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
1841 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=-2;
1847 //_______________________________________________________________________
1848 UChar_t AliESDtrack::GetTRDtracklets(Int_t *idx) const {
1850 // This function returns the number of TRD tracklets used in tracking
1851 // and it fills the indices of these tracklets in the array "idx" as they
1852 // are registered in the TRD track list.
1855 // 1. The idx array has to be allocated with a size >= AliESDtrack::kTRDnPlanes
1856 // 2. The idx array store not only the index but also the layer of the tracklet.
1857 // Therefore tracks with TRD gaps contain default values for indices [-1]
1859 if (!fFriendTrack) return 0;
1860 if (!idx) return GetTRDntracklets();
1861 Int_t *index=fFriendTrack->GetTRDindices();
1863 for (Int_t i=0; i<kTRDnPlanes; i++){
1865 if(index[i]>=0) n++;
1873 //_______________________________________________________________________
1874 void AliESDtrack::SetTRDpid(const Double_t *p) {
1875 // Sets values for the probability of each particle type (in TRD)
1876 SetPIDValues(fTRDr,p,AliPID::kSPECIES);
1877 SetStatus(AliESDtrack::kTRDpid);
1880 //_______________________________________________________________________
1881 void AliESDtrack::GetTRDpid(Double_t *p) const {
1882 // Gets the probability of each particle type (in TRD)
1883 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
1886 //_______________________________________________________________________
1887 void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
1889 // Sets the probability of particle type iSpecies to p (in TRD)
1890 fTRDr[iSpecies] = p;
1893 Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
1895 // Returns the probability of particle type iSpecies (in TRD)
1896 return fTRDr[iSpecies];
1899 //____________________________________________________
1900 Int_t AliESDtrack::GetNumberOfTRDslices() const
1902 // built in backward compatibility
1903 Int_t idx = fTRDnSlices - (kTRDnPlanes<<1);
1904 return idx<18 ? fTRDnSlices/kTRDnPlanes : idx/kTRDnPlanes;
1907 //____________________________________________________
1908 Double_t AliESDtrack::GetTRDmomentum(Int_t plane, Double_t *sp) const
1910 //Returns momentum estimation and optional its error (sp)
1911 // in TRD layer "plane".
1914 AliDebug(2, "No TRD info allocated for this track.");
1917 if ((plane<0) || (plane>=kTRDnPlanes)) {
1918 AliWarning(Form("Request for TRD plane[%d] outside range.", plane));
1922 Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
1923 // Protection for backward compatibility
1924 if(idx<(GetNumberOfTRDslices()*kTRDnPlanes)) return -1.;
1926 if(sp) (*sp) = fTRDslices[idx+kTRDnPlanes];
1927 return fTRDslices[idx];
1930 //____________________________________________________
1931 Double_t AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
1932 //Gets the charge from the slice of the plane
1935 //AliError("No TRD slices allocated for this track !");
1938 if ((plane<0) || (plane>=kTRDnPlanes)) {
1939 AliError("Info for TRD plane not available !");
1942 Int_t ns=GetNumberOfTRDslices();
1943 if ((slice<-1) || (slice>=ns)) {
1944 //AliError("Wrong TRD slice !");
1948 if(slice>=0) return fTRDslices[plane*ns + slice];
1950 // return average of the dEdx measurements
1951 Double_t q=0.; Double32_t *s = &fTRDslices[plane*ns];
1952 for (Int_t i=0; i<ns; i++, s++) if((*s)>0.) q+=(*s);
1956 //____________________________________________________
1957 void AliESDtrack::SetNumberOfTRDslices(Int_t n) {
1958 //Sets the number of slices used for PID
1959 if (fTRDnSlices) return;
1962 fTRDslices=new Double32_t[fTRDnSlices];
1964 // set-up correctly the allocated memory
1965 memset(fTRDslices, 0, n*sizeof(Double32_t));
1966 for (Int_t i=GetNumberOfTRDslices(); i--;) fTRDslices[i]=-1.;
1969 //____________________________________________________
1970 void AliESDtrack::SetTRDslice(Double_t q, Int_t plane, Int_t slice) {
1971 //Sets the charge q in the slice of the plane
1973 AliError("No TRD slices allocated for this track !");
1976 if ((plane<0) || (plane>=kTRDnPlanes)) {
1977 AliError("Info for TRD plane not allocated !");
1980 Int_t ns=GetNumberOfTRDslices();
1981 if ((slice<0) || (slice>=ns)) {
1982 AliError("Wrong TRD slice !");
1985 Int_t n=plane*ns + slice;
1990 //____________________________________________________
1991 void AliESDtrack::SetTRDmomentum(Double_t p, Int_t plane, Double_t *sp)
1994 AliError("No TRD slices allocated for this track !");
1997 if ((plane<0) || (plane>=kTRDnPlanes)) {
1998 AliError("Info for TRD plane not allocated !");
2002 Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
2003 // Protection for backward compatibility
2004 if(idx<GetNumberOfTRDslices()*kTRDnPlanes) return;
2006 if(sp) fTRDslices[idx+kTRDnPlanes] = (*sp);
2007 fTRDslices[idx] = p;
2011 //_______________________________________________________________________
2012 void AliESDtrack::SetTOFpid(const Double_t *p) {
2013 // Sets the probability of each particle type (in TOF)
2014 SetPIDValues(fTOFr,p,AliPID::kSPECIES);
2015 SetStatus(AliESDtrack::kTOFpid);
2018 //_______________________________________________________________________
2019 void AliESDtrack::SetTOFLabel(const Int_t *p) {
2021 for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
2024 //_______________________________________________________________________
2025 void AliESDtrack::GetTOFpid(Double_t *p) const {
2026 // Gets probabilities of each particle type (in TOF)
2027 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
2030 //_______________________________________________________________________
2031 void AliESDtrack::GetTOFLabel(Int_t *p) const {
2033 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
2036 //_______________________________________________________________________
2037 void AliESDtrack::GetTOFInfo(Float_t *info) const {
2039 for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
2042 //_______________________________________________________________________
2043 void AliESDtrack::SetTOFInfo(Float_t*info) {
2045 for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
2050 //_______________________________________________________________________
2051 void AliESDtrack::SetHMPIDpid(const Double_t *p) {
2052 // Sets the probability of each particle type (in HMPID)
2053 SetPIDValues(fHMPIDr,p,AliPID::kSPECIES);
2054 SetStatus(AliESDtrack::kHMPIDpid);
2057 //_______________________________________________________________________
2058 void AliESDtrack::GetHMPIDpid(Double_t *p) const {
2059 // Gets probabilities of each particle type (in HMPID)
2060 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fHMPIDr[i];
2065 //_______________________________________________________________________
2066 void AliESDtrack::SetESDpid(const Double_t *p) {
2067 // Sets the probability of each particle type for the ESD track
2068 SetPIDValues(fR,p,AliPID::kSPECIES);
2069 SetStatus(AliESDtrack::kESDpid);
2072 //_______________________________________________________________________
2073 void AliESDtrack::GetESDpid(Double_t *p) const {
2074 // Gets probability of each particle type for the ESD track
2075 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
2078 //_______________________________________________________________________
2079 Bool_t AliESDtrack::RelateToVertexTPC(const AliESDVertex *vtx,
2080 Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
2082 // Try to relate the TPC-only track parameters to the vertex "vtx",
2083 // if the (rough) transverse impact parameter is not bigger then "maxd".
2084 // Magnetic field is "b" (kG).
2086 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
2087 // b) The impact parameters and their covariance matrix are calculated.
2088 // c) An attempt to constrain the TPC-only params to the vertex is done.
2089 // The constrained params are returned via "cParam".
2091 // In the case of success, the returned value is kTRUE
2092 // otherwise, it's kFALSE)
2095 if (!fTPCInner) return kFALSE;
2096 if (!vtx) return kFALSE;
2098 Double_t dz[2],cov[3];
2099 if (!fTPCInner->PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
2107 Double_t covar[6]; vtx->GetCovMatrix(covar);
2108 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2109 Double_t c[3]={covar[2],0.,covar[5]};
2111 Double_t chi2=GetPredictedChi2(p,c);
2112 if (chi2>kVeryBig) return kFALSE;
2116 if (!cParam) return kTRUE;
2118 *cParam = *fTPCInner;
2119 if (!cParam->Update(p,c)) return kFALSE;
2124 //_______________________________________________________________________
2125 Bool_t AliESDtrack::RelateToVertexTPCBxByBz(const AliESDVertex *vtx,
2126 Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2128 // Try to relate the TPC-only track parameters to the vertex "vtx",
2129 // if the (rough) transverse impact parameter is not bigger then "maxd".
2131 // All three components of the magnetic field ,"b[3]" (kG),
2132 // are taken into account.
2134 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
2135 // b) The impact parameters and their covariance matrix are calculated.
2136 // c) An attempt to constrain the TPC-only params to the vertex is done.
2137 // The constrained params are returned via "cParam".
2139 // In the case of success, the returned value is kTRUE
2140 // otherwise, it's kFALSE)
2143 if (!fTPCInner) return kFALSE;
2144 if (!vtx) return kFALSE;
2146 Double_t dz[2],cov[3];
2147 if (!fTPCInner->PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2155 Double_t covar[6]; vtx->GetCovMatrix(covar);
2156 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2157 Double_t c[3]={covar[2],0.,covar[5]};
2159 Double_t chi2=GetPredictedChi2(p,c);
2160 if (chi2>kVeryBig) return kFALSE;
2164 if (!cParam) return kTRUE;
2166 *cParam = *fTPCInner;
2167 if (!cParam->Update(p,c)) return kFALSE;
2172 //_______________________________________________________________________
2173 Bool_t AliESDtrack::RelateToVertex(const AliESDVertex *vtx,
2174 Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
2176 // Try to relate this track to the vertex "vtx",
2177 // if the (rough) transverse impact parameter is not bigger then "maxd".
2178 // Magnetic field is "b" (kG).
2180 // a) The track gets extapolated to the DCA to the vertex.
2181 // b) The impact parameters and their covariance matrix are calculated.
2182 // c) An attempt to constrain this track to the vertex is done.
2183 // The constrained params are returned via "cParam".
2185 // In the case of success, the returned value is kTRUE
2186 // (otherwise, it's kFALSE)
2189 if (!vtx) return kFALSE;
2191 Double_t dz[2],cov[3];
2192 if (!PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
2200 Double_t covar[6]; vtx->GetCovMatrix(covar);
2201 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2202 Double_t c[3]={covar[2],0.,covar[5]};
2204 Double_t chi2=GetPredictedChi2(p,c);
2205 if (chi2>kVeryBig) return kFALSE;
2210 //--- Could now these lines be removed ? ---
2212 fCp=new AliExternalTrackParam(*this);
2214 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
2215 //----------------------------------------
2217 fVertexID = vtx->GetID();
2219 if (!cParam) return kTRUE;
2222 if (!cParam->Update(p,c)) return kFALSE;
2227 //_______________________________________________________________________
2228 Bool_t AliESDtrack::RelateToVertexBxByBz(const AliESDVertex *vtx,
2229 Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2231 // Try to relate this track to the vertex "vtx",
2232 // if the (rough) transverse impact parameter is not bigger then "maxd".
2233 // Magnetic field is "b" (kG).
2235 // a) The track gets extapolated to the DCA to the vertex.
2236 // b) The impact parameters and their covariance matrix are calculated.
2237 // c) An attempt to constrain this track to the vertex is done.
2238 // The constrained params are returned via "cParam".
2240 // In the case of success, the returned value is kTRUE
2241 // (otherwise, it's kFALSE)
2244 if (!vtx) return kFALSE;
2246 Double_t dz[2],cov[3];
2247 if (!PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2255 Double_t covar[6]; vtx->GetCovMatrix(covar);
2256 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2257 Double_t c[3]={covar[2],0.,covar[5]};
2259 Double_t chi2=GetPredictedChi2(p,c);
2260 if (chi2>kVeryBig) return kFALSE;
2265 //--- Could now these lines be removed ? ---
2267 fCp=new AliExternalTrackParam(*this);
2269 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
2270 //----------------------------------------
2272 fVertexID = vtx->GetID();
2274 if (!cParam) return kTRUE;
2277 if (!cParam->Update(p,c)) return kFALSE;
2282 //_______________________________________________________________________
2283 void AliESDtrack::Print(Option_t *) const {
2284 // Prints info on the track
2285 AliExternalTrackParam::Print();
2286 printf("ESD track info\n") ;
2287 Double_t p[AliPID::kSPECIESN] ;
2289 if( IsOn(kITSpid) ){
2290 printf("From ITS: ") ;
2292 for(index = 0 ; index < AliPID::kSPECIES; index++)
2293 printf("%f, ", p[index]) ;
2294 printf("\n signal = %f\n", GetITSsignal()) ;
2296 if( IsOn(kTPCpid) ){
2297 printf("From TPC: ") ;
2299 for(index = 0 ; index < AliPID::kSPECIES; index++)
2300 printf("%f, ", p[index]) ;
2301 printf("\n signal = %f\n", GetTPCsignal()) ;
2303 if( IsOn(kTRDpid) ){
2304 printf("From TRD: ") ;
2306 for(index = 0 ; index < AliPID::kSPECIES; index++)
2307 printf("%f, ", p[index]) ;
2308 printf("\n signal = %f\n", GetTRDsignal()) ;
2310 if( IsOn(kTOFpid) ){
2311 printf("From TOF: ") ;
2313 for(index = 0 ; index < AliPID::kSPECIES; index++)
2314 printf("%f, ", p[index]) ;
2315 printf("\n signal = %f\n", GetTOFsignal()) ;
2317 if( IsOn(kHMPIDpid) ){
2318 printf("From HMPID: ") ;
2320 for(index = 0 ; index < AliPID::kSPECIES; index++)
2321 printf("%f, ", p[index]) ;
2322 printf("\n signal = %f\n", GetHMPIDsignal()) ;
2328 // Draw functionality
2329 // Origin: Marian Ivanov, Marian.Ivanov@cern.ch
2331 void AliESDtrack::FillPolymarker(TPolyMarker3D *pol, Float_t magF, Float_t minR, Float_t maxR, Float_t stepR){
2333 // Fill points in the polymarker
2336 arrayRef.AddLast(new AliExternalTrackParam(*this));
2337 if (fIp) arrayRef.AddLast(new AliExternalTrackParam(*fIp));
2338 if (fOp) arrayRef.AddLast(new AliExternalTrackParam(*fOp));
2339 if (fHMPIDp) arrayRef.AddLast(new AliExternalTrackParam(*fHMPIDp));
2341 Double_t mpos[3]={0,0,0};
2342 Int_t entries=arrayRef.GetEntries();
2343 for (Int_t i=0;i<entries;i++){
2345 ((AliExternalTrackParam*)arrayRef.At(i))->GetXYZ(pos);
2346 mpos[0]+=pos[0]/entries;
2347 mpos[1]+=pos[1]/entries;
2348 mpos[2]+=pos[2]/entries;
2350 // Rotate to the mean position
2352 Float_t fi= TMath::ATan2(mpos[1],mpos[0]);
2353 for (Int_t i=0;i<entries;i++){
2354 Bool_t res = ((AliExternalTrackParam*)arrayRef.At(i))->Rotate(fi);
2355 if (!res) delete arrayRef.RemoveAt(i);
2358 for (Double_t r=minR; r<maxR; r+=stepR){
2360 Double_t mlpos[3]={0,0,0};
2361 for (Int_t i=0;i<entries;i++){
2362 Double_t point[3]={0,0,0};
2363 AliExternalTrackParam *param = ((AliExternalTrackParam*)arrayRef.At(i));
2364 if (!param) continue;
2365 if (param->GetXYZAt(r,magF,point)){
2366 Double_t weight = 1./(10.+(r-param->GetX())*(r-param->GetX()));
2368 mlpos[0]+=point[0]*weight;
2369 mlpos[1]+=point[1]*weight;
2370 mlpos[2]+=point[2]*weight;
2377 pol->SetPoint(counter,mlpos[0],mlpos[1], mlpos[2]);
2378 // printf("xyz\t%f\t%f\t%f\n",mlpos[0], mlpos[1],mlpos[2]);
2384 //_______________________________________________________________________
2385 void AliESDtrack::SetITSdEdxSamples(const Double_t s[4]) {
2387 // Store the dE/dx samples measured by the two SSD and two SDD layers.
2388 // These samples are corrected for the track segment length.
2390 for (Int_t i=0; i<4; i++) fITSdEdxSamples[i]=s[i];
2393 //_______________________________________________________________________
2394 void AliESDtrack::GetITSdEdxSamples(Double_t *s) const {
2396 // Get the dE/dx samples measured by the two SSD and two SDD layers.
2397 // These samples are corrected for the track segment length.
2399 for (Int_t i=0; i<4; i++) s[i]=fITSdEdxSamples[i];
2403 UShort_t AliESDtrack::GetTPCnclsS(Int_t i0,Int_t i1) const{
2405 // get number of shared TPC clusters
2407 return fTPCSharedMap.CountBits(i0)-fTPCSharedMap.CountBits(i1);
2410 UShort_t AliESDtrack::GetTPCncls(Int_t i0,Int_t i1) const{
2412 // get number of TPC clusters
2414 return fTPCClusterMap.CountBits(i0)-fTPCClusterMap.CountBits(i1);
2417 //____________________________________________________________________
2418 Double_t AliESDtrack::GetChi2TPCConstrainedVsGlobal(const AliESDVertex* vtx) const
2420 // Calculates the chi2 between the TPC track (TPCinner) constrained to the primary vertex and the global track
2422 // Returns -1 in case the calculation failed
2424 // Value is cached as a non-persistent member.
2426 // Code adapted from original code by GSI group (Jacek, Marian, Michael)
2428 // cache, ignoring that a different vertex might be passed
2429 if (fCacheChi2TPCConstrainedVsGlobalVertex == vtx)
2430 return fCacheChi2TPCConstrainedVsGlobal;
2432 fCacheChi2TPCConstrainedVsGlobal = -1;
2433 fCacheChi2TPCConstrainedVsGlobalVertex = vtx;
2438 AliTrackerBase::GetBxByBz(x,b);
2441 AliWarning("Could not get TPC Inner Param.");
2442 return fCacheChi2TPCConstrainedVsGlobal;
2445 // clone for constraining
2446 AliExternalTrackParam* tpcInnerC = new AliExternalTrackParam(*fTPCInner);
2448 AliWarning("Clone of TPCInnerParam failed.");
2449 return fCacheChi2TPCConstrainedVsGlobal;
2452 // transform to the track reference frame
2453 Bool_t isOK = tpcInnerC->Rotate(GetAlpha());
2454 isOK &= tpcInnerC->PropagateTo(GetX(), b[2]);
2458 AliWarning("Rotation/Propagation of track failed.") ;
2459 return fCacheChi2TPCConstrainedVsGlobal;
2462 // constrain TPCinner
2463 isOK = tpcInnerC->ConstrainToVertex(vtx, b);
2465 // transform to the track reference frame
2466 isOK &= tpcInnerC->Rotate(GetAlpha());
2467 isOK &= tpcInnerC->PropagateTo(GetX(), b[2]);
2470 AliWarning("ConstrainTPCInner failed.") ;
2473 return fCacheChi2TPCConstrainedVsGlobal;
2476 // calculate chi2 between vi and vj vectors
2477 // with covi and covj covariance matrices
2478 // chi2ij = (vi-vj)^(T)*(covi+covj)^(-1)*(vi-vj)
2479 TMatrixD deltaT(5,1);
2480 TMatrixD delta(1,5);
2481 TMatrixD covarM(5,5);
2483 for (Int_t ipar=0; ipar<5; ipar++) {
2484 deltaT(ipar,0) = tpcInnerC->GetParameter()[ipar] - GetParameter()[ipar];
2485 delta(0,ipar) = tpcInnerC->GetParameter()[ipar] - GetParameter()[ipar];
2487 for (Int_t jpar=0; jpar<5; jpar++) {
2488 Int_t index = GetIndex(ipar,jpar);
2489 covarM(ipar,jpar) = GetCovariance()[index]+tpcInnerC->GetCovariance()[index];
2492 // chi2 distance TPC constrained and TPC+ITS
2493 TMatrixD covarMInv = covarM.Invert();
2494 TMatrixD mat2 = covarMInv*deltaT;
2495 TMatrixD chi2 = delta*mat2;
2500 fCacheChi2TPCConstrainedVsGlobal = chi2(0,0);
2501 return fCacheChi2TPCConstrainedVsGlobal;