]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/ESD/AliESDtrack.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
add histograms to study EOverP and dEdx, add NLM cut
[u/mrichter/AliRoot.git] / STEER / ESD / AliESDtrack.cxx
CommitLineData
ae982df3 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
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 **************************************************************************/
ae982df3 15//-----------------------------------------------------------------
16// Implementation of the ESD track class
4427806c 17// ESD = Event Summary Data
15614b8b 18// This is the class to deal with during the phisics analysis of data
4427806c 19// Origin: Iouri Belikov, CERN
20// e-mail: Jouri.Belikov@cern.ch
4df45162 21//
22//
23//
24// What do you need to know before starting analysis
25// (by Marian Ivanov: marian.ivanov@cern.ch)
26//
27//
28// AliESDtrack:
29// 1. What is the AliESDtrack
30// 2. What informations do we store
31// 3. How to use the information for analysis
32//
33//
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.
38//
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.
42//
43// Kalman filter take into account additional effect which are
44// difficult to handle using global fit.
45// Effects:
46// a.) Multiple scattering
47// b.) Energy loss
48// c.) Non homogenous magnetic field
49//
50// In general case, following barrel detectors are contributing to
51// the Kalman track information:
52// a. TPC
53// b. ITS
54// c. TRD
55//
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.
62//
63//
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
68// functionality)
69// Snapshots:
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
82// Function:
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
86// function:
87// const AliExternalTrackParam *GetInnerParam() const { return fIp;}
88//
89// d. TPCinnerparam - contributors - TPC only
90// Contributors: TPC
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
94// to primary vertex
95// Optimal for primary, far from optimal for secondary tracks
96// Function:
97// const AliExternalTrackParam *GetTPCInnerParam() const {return fTPCInner;}
98//
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)
106// Usage:
107// a.) Tracking: Starting parameter for Refit inward
108// b.) Visualization
109// c.) QA
110// NOTICE: Should be not used for the physic analysis
111// Function:
112// const AliExternalTrackParam *GetOuterParam() const { return fOp;}
113//
ae982df3 114//-----------------------------------------------------------------
115
e1e6896f 116#include <TMath.h>
49edfa08 117#include <TParticle.h>
c180f65d 118#include <TDatabasePDG.h>
4c3dc2a0 119#include <TMatrixD.h>
ae982df3 120
49d13e89 121#include "AliESDVertex.h"
ae982df3 122#include "AliESDtrack.h"
95621324 123#include "AliESDEvent.h"
ae982df3 124#include "AliKalmanTrack.h"
4f6e22bd 125#include "AliVTrack.h"
5f7789fc 126#include "AliLog.h"
15e85efa 127#include "AliTrackPointArray.h"
0c19adf7 128#include "TPolyMarker3D.h"
4c3dc2a0 129#include "AliTrackerBase.h"
40b4e5ea 130#include "AliTPCdEdxInfo.h"
00a38d07 131#include "AliDetectorPID.h"
ae982df3 132
133ClassImp(AliESDtrack)
134
562dd0b4 135void SetPIDValues(Double_t * dest, const Double_t * src, Int_t n) {
d27bbc79 136 // This function copies "n" PID weights from "scr" to "dest"
137 // and normalizes their sum to 1 thus producing conditional probabilities.
138 // The negative weights are set to 0.
139 // In case all the weights are non-positive they are replaced by
140 // uniform probabilities
141
142 if (n<=0) return;
143
144 Float_t uniform = 1./(Float_t)n;
145
146 Float_t sum = 0;
147 for (Int_t i=0; i<n; i++)
148 if (src[i]>=0) {
149 sum+=src[i];
150 dest[i] = src[i];
151 }
152 else {
153 dest[i] = 0;
154 }
155
156 if(sum>0)
157 for (Int_t i=0; i<n; i++) dest[i] /= sum;
158 else
159 for (Int_t i=0; i<n; i++) dest[i] = uniform;
160}
161
ae982df3 162//_______________________________________________________________________
163AliESDtrack::AliESDtrack() :
c9ec41e8 164 AliExternalTrackParam(),
562dd0b4 165 fCp(0),
166 fIp(0),
167 fTPCInner(0),
168 fOp(0),
c38d443f 169 fHMPIDp(0),
59c31692 170 fFriendTrack(NULL),
9f638f03 171 fTPCFitMap(159),//number of padrows
562dd0b4 172 fTPCClusterMap(159),//number of padrows
173 fTPCSharedMap(159),//number of padrows
90e48c0c 174 fFlags(0),
90e48c0c 175 fID(0),
562dd0b4 176 fLabel(0),
177 fITSLabel(0),
178 fTPCLabel(0),
179 fTRDLabel(0),
ab37ab1e 180 fTOFCalChannel(-1),
ce3f4882 181 fTOFindex(-1),
562dd0b4 182 fHMPIDqn(0),
81aa7a0d 183 fHMPIDcluIdx(-1),
f1cedef3 184 fCaloIndex(kEMCALNoMatch),
562dd0b4 185 fHMPIDtrkTheta(0),
186 fHMPIDtrkPhi(0),
187 fHMPIDsignal(0),
90e48c0c 188 fTrackLength(0),
d7ddf1e9 189 fdTPC(0),fzTPC(0),
190 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
436dfe39 191 fCchi2TPC(0),
49d13e89 192 fD(0),fZ(0),
193 fCdd(0),fCdz(0),fCzz(0),
562dd0b4 194 fCchi2(0),
90e48c0c 195 fITSchi2(0),
90e48c0c 196 fTPCchi2(0),
949840f6 197 fTPCchi2Iter1(0),
562dd0b4 198 fTRDchi2(0),
199 fTOFchi2(0),
200 fHMPIDchi2(0),
b5b2b4db 201 fGlobalChi2(0),
562dd0b4 202 fITSsignal(0),
90e48c0c 203 fTPCsignal(0),
539a5a59 204 fTPCsignalTuned(0),
e1d4c1b5 205 fTPCsignalS(0),
40b4e5ea 206 fTPCdEdxInfo(0),
90e48c0c 207 fTRDsignal(0),
90e48c0c 208 fTRDQuality(0),
23d49657 209 fTRDBudget(0),
ab37ab1e 210 fTOFsignal(99999),
a2c30af1 211 fTOFsignalTuned(99999),
ab37ab1e 212 fTOFsignalToT(99999),
213 fTOFsignalRaw(99999),
214 fTOFsignalDz(999),
215 fTOFsignalDx(999),
216 fTOFdeltaBC(999),
217 fTOFl0l1(999),
f1cedef3 218 fCaloDx(0),
219 fCaloDz(0),
562dd0b4 220 fHMPIDtrkX(0),
221 fHMPIDtrkY(0),
222 fHMPIDmipX(0),
223 fHMPIDmipY(0),
224 fTPCncls(0),
225 fTPCnclsF(0),
226 fTPCsignalN(0),
949840f6 227 fTPCnclsIter1(0),
228 fTPCnclsFIter1(0),
562dd0b4 229 fITSncls(0),
230 fITSClusterMap(0),
25015f7a 231 fITSSharedMap(0),
562dd0b4 232 fTRDncls(0),
233 fTRDncls0(0),
ed15ef4f 234 fTRDntracklets(0),
4d302e42 235 fTRDNchamberdEdx(0),
236 fTRDNclusterdEdx(0),
6984f7c1 237 fTRDnSlices(0),
6dc21f57 238 fTRDslices(0x0),
95621324 239 fVertexID(-2),// -2 means an orphan track
4c3dc2a0 240 fESDEvent(0),
241 fCacheNCrossedRows(-10),
242 fCacheChi2TPCConstrainedVsGlobal(-10),
ed15417e 243 fCacheChi2TPCConstrainedVsGlobalVertex(0),
00a38d07 244 fDetectorPID(0x0),
ed15417e 245 fTrackPhiOnEMCal(-999),
a29b2a8a 246 fTrackEtaOnEMCal(-999),
247 fTrackPtOnEMCal(-999)
ae982df3 248{
249 //
250 // The default ESD constructor
251 //
ddfbc51a 252 if (!OnlineMode()) fFriendTrack=new AliESDfriendTrack();
253
254 Int_t i;
255 for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
256 for (i=0; i<AliPID::kSPECIES; i++) {
4a78b8c5 257 fTrackTime[i]=0.;
562dd0b4 258 fR[i]=0.;
259 fITSr[i]=0.;
260 fTPCr[i]=0.;
261 fTRDr[i]=0.;
262 fTOFr[i]=0.;
263 fHMPIDr[i]=0.;
2bad268c 264 }
ac2f7574 265
ddfbc51a 266 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
267 for (i=0; i<3; i++) { fV0Indexes[i]=0;}
268 for (i=0;i<kTRDnPlanes;i++) {
269 fTRDTimBin[i]=0;
270 }
271 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
272 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
273 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
274 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
275 for (i=0;i<12;i++) {fITSModule[i]=-1;}
c4d11b15 276}
277
59c31692 278bool AliESDtrack::fgkOnlineMode=false;
279
c4d11b15 280//_______________________________________________________________________
90e48c0c 281AliESDtrack::AliESDtrack(const AliESDtrack& track):
c9ec41e8 282 AliExternalTrackParam(track),
562dd0b4 283 fCp(0),
284 fIp(0),
285 fTPCInner(0),
286 fOp(0),
c38d443f 287 fHMPIDp(0),
562dd0b4 288 fFriendTrack(0),
9f638f03 289 fTPCFitMap(track.fTPCFitMap),
562dd0b4 290 fTPCClusterMap(track.fTPCClusterMap),
291 fTPCSharedMap(track.fTPCSharedMap),
90e48c0c 292 fFlags(track.fFlags),
90e48c0c 293 fID(track.fID),
562dd0b4 294 fLabel(track.fLabel),
295 fITSLabel(track.fITSLabel),
296 fTPCLabel(track.fTPCLabel),
297 fTRDLabel(track.fTRDLabel),
298 fTOFCalChannel(track.fTOFCalChannel),
299 fTOFindex(track.fTOFindex),
300 fHMPIDqn(track.fHMPIDqn),
301 fHMPIDcluIdx(track.fHMPIDcluIdx),
f1cedef3 302 fCaloIndex(track.fCaloIndex),
562dd0b4 303 fHMPIDtrkTheta(track.fHMPIDtrkTheta),
304 fHMPIDtrkPhi(track.fHMPIDtrkPhi),
305 fHMPIDsignal(track.fHMPIDsignal),
90e48c0c 306 fTrackLength(track.fTrackLength),
d7ddf1e9 307 fdTPC(track.fdTPC),fzTPC(track.fzTPC),
308 fCddTPC(track.fCddTPC),fCdzTPC(track.fCdzTPC),fCzzTPC(track.fCzzTPC),
436dfe39 309 fCchi2TPC(track.fCchi2TPC),
49d13e89 310 fD(track.fD),fZ(track.fZ),
311 fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
90e48c0c 312 fCchi2(track.fCchi2),
90e48c0c 313 fITSchi2(track.fITSchi2),
90e48c0c 314 fTPCchi2(track.fTPCchi2),
949840f6 315 fTPCchi2Iter1(track.fTPCchi2Iter1),
562dd0b4 316 fTRDchi2(track.fTRDchi2),
317 fTOFchi2(track.fTOFchi2),
318 fHMPIDchi2(track.fHMPIDchi2),
b5b2b4db 319 fGlobalChi2(track.fGlobalChi2),
562dd0b4 320 fITSsignal(track.fITSsignal),
90e48c0c 321 fTPCsignal(track.fTPCsignal),
539a5a59 322 fTPCsignalTuned(track.fTPCsignalTuned),
e1d4c1b5 323 fTPCsignalS(track.fTPCsignalS),
40b4e5ea 324 fTPCdEdxInfo(0),
90e48c0c 325 fTRDsignal(track.fTRDsignal),
90e48c0c 326 fTRDQuality(track.fTRDQuality),
23d49657 327 fTRDBudget(track.fTRDBudget),
90e48c0c 328 fTOFsignal(track.fTOFsignal),
a2c30af1 329 fTOFsignalTuned(track.fTOFsignalTuned),
85324138 330 fTOFsignalToT(track.fTOFsignalToT),
d321691a 331 fTOFsignalRaw(track.fTOFsignalRaw),
332 fTOFsignalDz(track.fTOFsignalDz),
a5d9ff0f 333 fTOFsignalDx(track.fTOFsignalDx),
d86081b1 334 fTOFdeltaBC(track.fTOFdeltaBC),
335 fTOFl0l1(track.fTOFl0l1),
f1cedef3 336 fCaloDx(track.fCaloDx),
337 fCaloDz(track.fCaloDz),
f4b3bbb7 338 fHMPIDtrkX(track.fHMPIDtrkX),
339 fHMPIDtrkY(track.fHMPIDtrkY),
340 fHMPIDmipX(track.fHMPIDmipX),
341 fHMPIDmipY(track.fHMPIDmipY),
562dd0b4 342 fTPCncls(track.fTPCncls),
343 fTPCnclsF(track.fTPCnclsF),
344 fTPCsignalN(track.fTPCsignalN),
949840f6 345 fTPCnclsIter1(track.fTPCnclsIter1),
346 fTPCnclsFIter1(track.fTPCnclsIter1),
562dd0b4 347 fITSncls(track.fITSncls),
348 fITSClusterMap(track.fITSClusterMap),
25015f7a 349 fITSSharedMap(track.fITSSharedMap),
562dd0b4 350 fTRDncls(track.fTRDncls),
351 fTRDncls0(track.fTRDncls0),
ed15ef4f 352 fTRDntracklets(track.fTRDntracklets),
4d302e42 353 fTRDNchamberdEdx(track.fTRDNchamberdEdx),
354 fTRDNclusterdEdx(track.fTRDNclusterdEdx),
6984f7c1 355 fTRDnSlices(track.fTRDnSlices),
6dc21f57 356 fTRDslices(0x0),
95621324 357 fVertexID(track.fVertexID),
4c3dc2a0 358 fESDEvent(track.fESDEvent),
359 fCacheNCrossedRows(track.fCacheNCrossedRows),
360 fCacheChi2TPCConstrainedVsGlobal(track.fCacheChi2TPCConstrainedVsGlobal),
ed15417e 361 fCacheChi2TPCConstrainedVsGlobalVertex(track.fCacheChi2TPCConstrainedVsGlobalVertex),
00a38d07 362 fDetectorPID(0x0),
ed15417e 363 fTrackPhiOnEMCal(track.fTrackPhiOnEMCal),
a29b2a8a 364 fTrackEtaOnEMCal(track.fTrackEtaOnEMCal),
365 fTrackPtOnEMCal(track.fTrackPtOnEMCal)
90e48c0c 366{
c4d11b15 367 //
368 //copy constructor
369 //
96a46057 370 for (Int_t i=kNITSchi2Std;i--;) fITSchi2Std[i] = track.fITSchi2Std[i];
ddfbc51a 371 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i]=track.fTrackTime[i];
372 for (Int_t i=0;i<AliPID::kSPECIES;i++) fR[i]=track.fR[i];
c4d11b15 373 //
ddfbc51a 374 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
c4d11b15 375 //
ddfbc51a 376 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[i];
377 for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=track.fITSdEdxSamples[i];}
378 for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
379 for (Int_t i=0; i<3;i++) { fKinkIndexes[i]=track.fKinkIndexes[i];}
380 for (Int_t i=0; i<3;i++) { fV0Indexes[i]=track.fV0Indexes[i];}
e546b023 381 //
ddfbc51a 382 for (Int_t i=0;i<kTRDnPlanes;i++) {
383 fTRDTimBin[i]=track.fTRDTimBin[i];
6984f7c1 384 }
385
ddfbc51a 386 if (fTRDnSlices) {
387 fTRDslices=new Double32_t[fTRDnSlices];
388 for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=track.fTRDslices[i];
e546b023 389 }
ddfbc51a 390
00a38d07 391 if (track.fDetectorPID) fDetectorPID = new AliDetectorPID(*track.fDetectorPID);
ddfbc51a 392
393 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
394 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
395 for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
396 for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
397 for (Int_t i=0;i<12;i++) fITSModule[i]=track.fITSModule[i];
398 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i]=track.fHMPIDr[i];
399
400 if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
401 if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
402 if (track.fTPCInner) fTPCInner=new AliExternalTrackParam(*track.fTPCInner);
403 if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
404 if (track.fHMPIDp) fHMPIDp=new AliExternalTrackParam(*track.fHMPIDp);
405 if (track.fTPCdEdxInfo) fTPCdEdxInfo = new AliTPCdEdxInfo(*track.fTPCdEdxInfo);
406
407
408 if (track.fFriendTrack) fFriendTrack=new AliESDfriendTrack(*(track.fFriendTrack));
ae982df3 409}
15e85efa 410
4f6e22bd 411//_______________________________________________________________________
412AliESDtrack::AliESDtrack(const AliVTrack *track) :
413 AliExternalTrackParam(track),
414 fCp(0),
415 fIp(0),
416 fTPCInner(0),
417 fOp(0),
c38d443f 418 fHMPIDp(0),
4f6e22bd 419 fFriendTrack(0),
9f638f03 420 fTPCFitMap(159),//number of padrows
4f6e22bd 421 fTPCClusterMap(159),//number of padrows
422 fTPCSharedMap(159),//number of padrows
423 fFlags(0),
424 fID(),
425 fLabel(0),
426 fITSLabel(0),
427 fTPCLabel(0),
428 fTRDLabel(0),
ab37ab1e 429 fTOFCalChannel(-1),
4f6e22bd 430 fTOFindex(-1),
431 fHMPIDqn(0),
81aa7a0d 432 fHMPIDcluIdx(-1),
f1cedef3 433 fCaloIndex(kEMCALNoMatch),
4f6e22bd 434 fHMPIDtrkTheta(0),
435 fHMPIDtrkPhi(0),
436 fHMPIDsignal(0),
437 fTrackLength(0),
438 fdTPC(0),fzTPC(0),
439 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
440 fCchi2TPC(0),
441 fD(0),fZ(0),
442 fCdd(0),fCdz(0),fCzz(0),
443 fCchi2(0),
444 fITSchi2(0),
445 fTPCchi2(0),
949840f6 446 fTPCchi2Iter1(0),
4f6e22bd 447 fTRDchi2(0),
448 fTOFchi2(0),
449 fHMPIDchi2(0),
b5b2b4db 450 fGlobalChi2(0),
4f6e22bd 451 fITSsignal(0),
452 fTPCsignal(0),
539a5a59 453 fTPCsignalTuned(0),
4f6e22bd 454 fTPCsignalS(0),
40b4e5ea 455 fTPCdEdxInfo(0),
4f6e22bd 456 fTRDsignal(0),
457 fTRDQuality(0),
458 fTRDBudget(0),
ab37ab1e 459 fTOFsignal(99999),
a2c30af1 460 fTOFsignalTuned(99999),
ab37ab1e 461 fTOFsignalToT(99999),
462 fTOFsignalRaw(99999),
463 fTOFsignalDz(999),
464 fTOFsignalDx(999),
465 fTOFdeltaBC(999),
466 fTOFl0l1(999),
f1cedef3 467 fCaloDx(0),
468 fCaloDz(0),
4f6e22bd 469 fHMPIDtrkX(0),
470 fHMPIDtrkY(0),
471 fHMPIDmipX(0),
472 fHMPIDmipY(0),
473 fTPCncls(0),
474 fTPCnclsF(0),
475 fTPCsignalN(0),
949840f6 476 fTPCnclsIter1(0),
477 fTPCnclsFIter1(0),
4f6e22bd 478 fITSncls(0),
479 fITSClusterMap(0),
25015f7a 480 fITSSharedMap(0),
4f6e22bd 481 fTRDncls(0),
482 fTRDncls0(0),
ed15ef4f 483 fTRDntracklets(0),
4d302e42 484 fTRDNchamberdEdx(0),
485 fTRDNclusterdEdx(0),
4f6e22bd 486 fTRDnSlices(0),
6dc21f57 487 fTRDslices(0x0),
95621324 488 fVertexID(-2), // -2 means an orphan track
4c3dc2a0 489 fESDEvent(0),
490 fCacheNCrossedRows(-10),
491 fCacheChi2TPCConstrainedVsGlobal(-10),
ed15417e 492 fCacheChi2TPCConstrainedVsGlobalVertex(0),
00a38d07 493 fDetectorPID(0x0),
ed15417e 494 fTrackPhiOnEMCal(-999),
a29b2a8a 495 fTrackEtaOnEMCal(-999),
496 fTrackPtOnEMCal(-999)
4f6e22bd 497{
498 //
610e3088 499 // ESD track from AliVTrack.
500 // This is not a copy constructor !
4f6e22bd 501 //
502
610e3088 503 if (track->InheritsFrom("AliExternalTrackParam")) {
504 AliError("This is not a copy constructor. Use AliESDtrack(const AliESDtrack &) !");
505 AliWarning("Calling the default constructor...");
506 AliESDtrack();
507 return;
508 }
509
4f6e22bd 510 // Reset all the arrays
ddfbc51a 511 Int_t i;
512 for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
513 for (i=0; i<AliPID::kSPECIES; i++) {
4f6e22bd 514 fTrackTime[i]=0.;
515 fR[i]=0.;
516 fITSr[i]=0.;
517 fTPCr[i]=0.;
518 fTRDr[i]=0.;
519 fTOFr[i]=0.;
520 fHMPIDr[i]=0.;
521 }
522
ddfbc51a 523 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
524 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
525 for (i=0;i<kTRDnPlanes;i++) {
526 fTRDTimBin[i]=0;
527 }
528 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
529 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
530 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
531 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
532 for (i=0;i<12;i++) {fITSModule[i]=-1;}
4f6e22bd 533
534 // Set the ID
535 SetID(track->GetID());
536
537 // Set ITS cluster map
538 fITSClusterMap=track->GetITSClusterMap();
25015f7a 539 fITSSharedMap=0;
4f6e22bd 540
d577eec9 541 fITSncls=0;
ddfbc51a 542 for(i=0; i<6; i++) {
543 if(HasPointOnITSLayer(i)) fITSncls++;
544 }
545
07cc7a48 546 // Set TPC ncls
547 fTPCncls=track->GetTPCNcls();
74ca66e3 548 fTPCnclsF=track->GetTPCNclsF();
549 // TPC cluster maps
550 const TBits* bmap = track->GetTPCClusterMapPtr();
551 if (bmap) SetTPCClusterMap(*bmap);
552 bmap = GetTPCFitMapPtr();
553 if (bmap) SetTPCFitMap(*bmap);
554 bmap = GetTPCSharedMapPtr();
555 if (bmap) SetTPCSharedMap(*bmap);
556 //
4f6e22bd 557 // Set the combined PID
558 const Double_t *pid = track->PID();
74ca66e3 559 if(pid) for (i=0; i<AliPID::kSPECIES; i++) fR[i]=pid[i];
560 //
561 // calo matched cluster id
562 SetEMCALcluster(track->GetEMCALcluster());
4f6e22bd 563 // AliESD track label
74ca66e3 564 //
565 // PID info
566 fITSsignal = track->GetITSsignal();
567 double itsdEdx[4];
568 track->GetITSdEdxSamples(itsdEdx);
569 SetITSdEdxSamples(itsdEdx);
570 //
be20337a 571 SetTPCsignal(track->GetTPCsignal(),fTPCsignalS,track->GetTPCsignalN()); // No signalS in AODPi
572 AliTPCdEdxInfo * dEdxInfo = track->GetTPCdEdxInfo();
573 if (dEdxInfo) SetTPCdEdxInfo(new AliTPCdEdxInfo(*dEdxInfo));
74ca66e3 574 //
6736efd5 575 SetTRDsignal(track->GetTRDsignal());
de8b2440 576 int ntrdsl = track->GetNumberOfTRDslices();
577 if (ntrdsl>0) {
be20337a 578 SetNumberOfTRDslices((ntrdsl+2)*kTRDnPlanes);
de8b2440 579 for (int ipl=kTRDnPlanes;ipl--;){
580 for (int isl=ntrdsl;isl--;) SetTRDslice(track->GetTRDslice(ipl,isl),ipl,isl);
581 Double_t sp, p = track->GetTRDmomentum(ipl, &sp);
582 SetTRDmomentum(p, ipl, &sp);
583 }
74ca66e3 584 }
585 //
586 fTRDncls = track->GetTRDncls();
587 fTRDntracklets &= 0xff & track->GetTRDntrackletsPID();
588 fTRDchi2 = track->GetTRDchi2();
589 //
590 SetTOFsignal(track->GetTOFsignal());
591 Double_t expt[AliPID::kSPECIES];
592 track->GetIntegratedTimes(expt);
593 SetIntegratedTimes(expt);
594 //
a29b2a8a 595 SetTrackPhiEtaPtOnEMCal(track->GetTrackPhiOnEMCal(),track->GetTrackEtaOnEMCal(),track->GetTrackPtOnEMCal());
74ca66e3 596 //
4f6e22bd 597 SetLabel(track->GetLabel());
39ca41b3 598 // Set the status
599 SetStatus(track->GetStatus());
4f6e22bd 600}
601
49edfa08 602//_______________________________________________________________________
603AliESDtrack::AliESDtrack(TParticle * part) :
604 AliExternalTrackParam(),
562dd0b4 605 fCp(0),
606 fIp(0),
607 fTPCInner(0),
608 fOp(0),
c38d443f 609 fHMPIDp(0),
562dd0b4 610 fFriendTrack(0),
9f638f03 611 fTPCFitMap(159),//number of padrows
562dd0b4 612 fTPCClusterMap(159),//number of padrows
613 fTPCSharedMap(159),//number of padrows
49edfa08 614 fFlags(0),
49edfa08 615 fID(0),
562dd0b4 616 fLabel(0),
617 fITSLabel(0),
618 fTPCLabel(0),
619 fTRDLabel(0),
ab37ab1e 620 fTOFCalChannel(-1),
ce3f4882 621 fTOFindex(-1),
562dd0b4 622 fHMPIDqn(0),
81aa7a0d 623 fHMPIDcluIdx(-1),
f1cedef3 624 fCaloIndex(kEMCALNoMatch),
562dd0b4 625 fHMPIDtrkTheta(0),
626 fHMPIDtrkPhi(0),
627 fHMPIDsignal(0),
49edfa08 628 fTrackLength(0),
d7ddf1e9 629 fdTPC(0),fzTPC(0),
630 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
436dfe39 631 fCchi2TPC(0),
49edfa08 632 fD(0),fZ(0),
633 fCdd(0),fCdz(0),fCzz(0),
562dd0b4 634 fCchi2(0),
49edfa08 635 fITSchi2(0),
49edfa08 636 fTPCchi2(0),
949840f6 637 fTPCchi2Iter1(0),
562dd0b4 638 fTRDchi2(0),
639 fTOFchi2(0),
640 fHMPIDchi2(0),
b5b2b4db 641 fGlobalChi2(0),
562dd0b4 642 fITSsignal(0),
49edfa08 643 fTPCsignal(0),
539a5a59 644 fTPCsignalTuned(0),
49edfa08 645 fTPCsignalS(0),
40b4e5ea 646 fTPCdEdxInfo(0),
49edfa08 647 fTRDsignal(0),
49edfa08 648 fTRDQuality(0),
649 fTRDBudget(0),
ab37ab1e 650 fTOFsignal(99999),
a2c30af1 651 fTOFsignalTuned(99999),
ab37ab1e 652 fTOFsignalToT(99999),
653 fTOFsignalRaw(99999),
654 fTOFsignalDz(999),
655 fTOFsignalDx(999),
656 fTOFdeltaBC(999),
657 fTOFl0l1(999),
f1cedef3 658 fCaloDx(0),
659 fCaloDz(0),
562dd0b4 660 fHMPIDtrkX(0),
661 fHMPIDtrkY(0),
662 fHMPIDmipX(0),
663 fHMPIDmipY(0),
664 fTPCncls(0),
665 fTPCnclsF(0),
666 fTPCsignalN(0),
949840f6 667 fTPCnclsIter1(0),
668 fTPCnclsFIter1(0),
562dd0b4 669 fITSncls(0),
670 fITSClusterMap(0),
25015f7a 671 fITSSharedMap(0),
562dd0b4 672 fTRDncls(0),
673 fTRDncls0(0),
ed15ef4f 674 fTRDntracklets(0),
4d302e42 675 fTRDNchamberdEdx(0),
676 fTRDNclusterdEdx(0),
6984f7c1 677 fTRDnSlices(0),
6dc21f57 678 fTRDslices(0x0),
95621324 679 fVertexID(-2), // -2 means an orphan track
4c3dc2a0 680 fESDEvent(0),
681 fCacheNCrossedRows(-10),
682 fCacheChi2TPCConstrainedVsGlobal(-10),
ed15417e 683 fCacheChi2TPCConstrainedVsGlobalVertex(0),
00a38d07 684 fDetectorPID(0x0),
ed15417e 685 fTrackPhiOnEMCal(-999),
a29b2a8a 686 fTrackEtaOnEMCal(-999),
687 fTrackPtOnEMCal(-999)
49edfa08 688{
689 //
690 // ESD track from TParticle
691 //
692
693 // Reset all the arrays
ddfbc51a 694 Int_t i;
695 for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
696 for (i=0; i<AliPID::kSPECIES; i++) {
49edfa08 697 fTrackTime[i]=0.;
698 fR[i]=0.;
699 fITSr[i]=0.;
700 fTPCr[i]=0.;
701 fTRDr[i]=0.;
702 fTOFr[i]=0.;
f4b3bbb7 703 fHMPIDr[i]=0.;
49edfa08 704 }
705
ddfbc51a 706 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
707 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
708 for (i=0;i<kTRDnPlanes;i++) {
709 fTRDTimBin[i]=0;
710 }
711 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
712 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
713 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
714 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
715 for (i=0;i<12;i++) {fITSModule[i]=-1;}
49edfa08 716
717 // Calculate the AliExternalTrackParam content
718
719 Double_t xref;
720 Double_t alpha;
721 Double_t param[5];
722 Double_t covar[15];
723
724 // Calculate alpha: the rotation angle of the corresponding local system (TPC sector)
725 alpha = part->Phi()*180./TMath::Pi();
726 if (alpha<0) alpha+= 360.;
727 if (alpha>360) alpha -= 360.;
728
729 Int_t sector = (Int_t)(alpha/20.);
730 alpha = 10. + 20.*sector;
731 alpha /= 180;
732 alpha *= TMath::Pi();
733
734 // Covariance matrix: no errors, the parameters are exact
ddfbc51a 735 for (i=0; i<15; i++) covar[i]=0.;
49edfa08 736
737 // Get the vertex of origin and the momentum
738 TVector3 ver(part->Vx(),part->Vy(),part->Vz());
739 TVector3 mom(part->Px(),part->Py(),part->Pz());
740
741 // Rotate to the local coordinate system (TPC sector)
742 ver.RotateZ(-alpha);
743 mom.RotateZ(-alpha);
744
745 // X of the referense plane
746 xref = ver.X();
747
748 Int_t pdgCode = part->GetPdgCode();
749
750 Double_t charge =
751 TDatabasePDG::Instance()->GetParticle(pdgCode)->Charge();
752
753 param[0] = ver.Y();
754 param[1] = ver.Z();
755 param[2] = TMath::Sin(mom.Phi());
756 param[3] = mom.Pz()/mom.Pt();
757 param[4] = TMath::Sign(1/mom.Pt(),charge);
758
759 // Set AliExternalTrackParam
760 Set(xref, alpha, param, covar);
761
762 // Set the PID
763 Int_t indexPID = 99;
764
765 switch (TMath::Abs(pdgCode)) {
766
767 case 11: // electron
768 indexPID = 0;
769 break;
770
771 case 13: // muon
772 indexPID = 1;
773 break;
774
775 case 211: // pion
776 indexPID = 2;
777 break;
778
779 case 321: // kaon
780 indexPID = 3;
781 break;
782
783 case 2212: // proton
784 indexPID = 4;
785 break;
786
787 default:
788 break;
789 }
790
791 // If the particle is not e,mu,pi,K or p the PID probabilities are set to 0
792 if (indexPID < AliPID::kSPECIES) {
793 fR[indexPID]=1.;
794 fITSr[indexPID]=1.;
795 fTPCr[indexPID]=1.;
796 fTRDr[indexPID]=1.;
797 fTOFr[indexPID]=1.;
f4b3bbb7 798 fHMPIDr[indexPID]=1.;
49edfa08 799
800 }
801 // AliESD track label
802 SetLabel(part->GetUniqueID());
803
804}
805
c4d11b15 806//_______________________________________________________________________
807AliESDtrack::~AliESDtrack(){
808 //
809 // This is destructor according Coding Conventrions
810 //
811 //printf("Delete track\n");
ddfbc51a 812 delete fIp;
813 delete fTPCInner;
814 delete fOp;
815 delete fHMPIDp;
816 delete fCp;
7b2679d9 817 delete fFriendTrack;
818 delete fTPCdEdxInfo;
ddfbc51a 819 if(fTRDnSlices)
820 delete[] fTRDslices;
b5732bf0 821
822 //Reset cached values - needed for TClonesArray in AliESDInputHandler
823 fCacheNCrossedRows = -10.;
824 fCacheChi2TPCConstrainedVsGlobal = -10.;
825 if(fCacheChi2TPCConstrainedVsGlobalVertex) fCacheChi2TPCConstrainedVsGlobalVertex = 0;
826
00a38d07 827 delete fDetectorPID;
ddfbc51a 828}
829
830AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source){
831
732a24fe 832
833 if(&source == this) return *this;
834 AliExternalTrackParam::operator=(source);
835
ddfbc51a 836
837 if(source.fCp){
838 // we have the trackparam: assign or copy construct
839 if(fCp)*fCp = *source.fCp;
840 else fCp = new AliExternalTrackParam(*source.fCp);
732a24fe 841 }
ddfbc51a 842 else{
843 // no track param delete the old one
7b2679d9 844 delete fCp;
ddfbc51a 845 fCp = 0;
732a24fe 846 }
ddfbc51a 847
848 if(source.fIp){
849 // we have the trackparam: assign or copy construct
850 if(fIp)*fIp = *source.fIp;
851 else fIp = new AliExternalTrackParam(*source.fIp);
732a24fe 852 }
ddfbc51a 853 else{
854 // no track param delete the old one
7b2679d9 855 delete fIp;
ddfbc51a 856 fIp = 0;
732a24fe 857 }
ddfbc51a 858
859
860 if(source.fTPCInner){
861 // we have the trackparam: assign or copy construct
862 if(fTPCInner) *fTPCInner = *source.fTPCInner;
863 else fTPCInner = new AliExternalTrackParam(*source.fTPCInner);
732a24fe 864 }
ddfbc51a 865 else{
866 // no track param delete the old one
7b2679d9 867 delete fTPCInner;
ddfbc51a 868 fTPCInner = 0;
40b4e5ea 869 }
ddfbc51a 870
871 if(source.fTPCdEdxInfo) {
872 if(fTPCdEdxInfo) *fTPCdEdxInfo = *source.fTPCdEdxInfo;
873 fTPCdEdxInfo = new AliTPCdEdxInfo(*source.fTPCdEdxInfo);
732a24fe 874 }
ddfbc51a 875
876 if(source.fOp){
877 // we have the trackparam: assign or copy construct
878 if(fOp) *fOp = *source.fOp;
879 else fOp = new AliExternalTrackParam(*source.fOp);
732a24fe 880 }
ddfbc51a 881 else{
882 // no track param delete the old one
7b2679d9 883 delete fOp;
ddfbc51a 884 fOp = 0;
c38d443f 885 }
ddfbc51a 886
887
888 if(source.fHMPIDp){
889 // we have the trackparam: assign or copy construct
890 if(fHMPIDp) *fHMPIDp = *source.fHMPIDp;
891 else fHMPIDp = new AliExternalTrackParam(*source.fHMPIDp);
c38d443f 892 }
ddfbc51a 893 else{
894 // no track param delete the old one
7b2679d9 895 delete fHMPIDp;
ddfbc51a 896 fHMPIDp = 0;
e546b023 897 }
ddfbc51a 898
732a24fe 899 // copy also the friend track
900 // use copy constructor
ddfbc51a 901 if(source.fFriendTrack){
902 // we have the trackparam: assign or copy construct
903 delete fFriendTrack; fFriendTrack=new AliESDfriendTrack(*source.fFriendTrack);
732a24fe 904 }
ddfbc51a 905 else{
906 // no track param delete the old one
907 delete fFriendTrack; fFriendTrack= 0;
908 }
909
910 fTPCFitMap = source.fTPCFitMap;
732a24fe 911 fTPCClusterMap = source.fTPCClusterMap;
912 fTPCSharedMap = source.fTPCSharedMap;
913 // the simple stuff
914 fFlags = source.fFlags;
915 fID = source.fID;
916 fLabel = source.fLabel;
917 fITSLabel = source.fITSLabel;
ddfbc51a 918 for(int i = 0; i< 12;++i){
919 fITSModule[i] = source.fITSModule[i];
920 }
732a24fe 921 fTPCLabel = source.fTPCLabel;
922 fTRDLabel = source.fTRDLabel;
ddfbc51a 923 for(int i = 0; i< 3;++i){
924 fTOFLabel[i] = source.fTOFLabel[i];
925 }
732a24fe 926 fTOFCalChannel = source.fTOFCalChannel;
927 fTOFindex = source.fTOFindex;
928 fHMPIDqn = source.fHMPIDqn;
929 fHMPIDcluIdx = source.fHMPIDcluIdx;
f1cedef3 930 fCaloIndex = source.fCaloIndex;
e400c4a6 931 for (int i=kNITSchi2Std;i--;) fITSchi2Std[i] = source.fITSchi2Std[i];
ddfbc51a 932 for(int i = 0; i< 3;++i){
732a24fe 933 fKinkIndexes[i] = source.fKinkIndexes[i];
934 fV0Indexes[i] = source.fV0Indexes[i];
935 }
ddfbc51a 936
937 for(int i = 0; i< AliPID::kSPECIES;++i){
732a24fe 938 fR[i] = source.fR[i];
939 fITSr[i] = source.fITSr[i];
940 fTPCr[i] = source.fTPCr[i];
941 fTRDr[i] = source.fTRDr[i];
942 fTOFr[i] = source.fTOFr[i];
943 fHMPIDr[i] = source.fHMPIDr[i];
944 fTrackTime[i] = source.fTrackTime[i];
945 }
ddfbc51a 946
732a24fe 947 fHMPIDtrkTheta = source.fHMPIDtrkTheta;
948 fHMPIDtrkPhi = source.fHMPIDtrkPhi;
949 fHMPIDsignal = source.fHMPIDsignal;
ddfbc51a 950
951
732a24fe 952 fTrackLength = source. fTrackLength;
d7ddf1e9 953 fdTPC = source.fdTPC;
954 fzTPC = source.fzTPC;
955 fCddTPC = source.fCddTPC;
956 fCdzTPC = source.fCdzTPC;
957 fCzzTPC = source.fCzzTPC;
436dfe39 958 fCchi2TPC = source.fCchi2TPC;
ddfbc51a 959
732a24fe 960 fD = source.fD;
961 fZ = source.fZ;
962 fCdd = source.fCdd;
963 fCdz = source.fCdz;
964 fCzz = source.fCzz;
732a24fe 965 fCchi2 = source.fCchi2;
ddfbc51a 966
732a24fe 967 fITSchi2 = source.fITSchi2;
968 fTPCchi2 = source.fTPCchi2;
949840f6 969 fTPCchi2Iter1 = source.fTPCchi2Iter1;
732a24fe 970 fTRDchi2 = source.fTRDchi2;
971 fTOFchi2 = source.fTOFchi2;
972 fHMPIDchi2 = source.fHMPIDchi2;
ddfbc51a 973
b5b2b4db 974 fGlobalChi2 = source.fGlobalChi2;
ddfbc51a 975
732a24fe 976 fITSsignal = source.fITSsignal;
ddfbc51a 977 for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=source.fITSdEdxSamples[i];}
732a24fe 978 fTPCsignal = source.fTPCsignal;
539a5a59 979 fTPCsignalTuned = source.fTPCsignalTuned;
732a24fe 980 fTPCsignalS = source.fTPCsignalS;
ddfbc51a 981 for(int i = 0; i< 4;++i){
982 fTPCPoints[i] = source.fTPCPoints[i];
983 }
732a24fe 984 fTRDsignal = source.fTRDsignal;
4d302e42 985 fTRDNchamberdEdx = source.fTRDNchamberdEdx;
986 fTRDNclusterdEdx = source.fTRDNclusterdEdx;
ddfbc51a 987
988 for(int i = 0;i < kTRDnPlanes;++i){
989 fTRDTimBin[i] = source.fTRDTimBin[i];
732a24fe 990 }
ddfbc51a 991
992 if(fTRDnSlices)
993 delete[] fTRDslices;
994 fTRDslices=0;
995 fTRDnSlices=source.fTRDnSlices;
6984f7c1 996 if (fTRDnSlices) {
ddfbc51a 997 fTRDslices=new Double32_t[fTRDnSlices];
998 for(int j = 0;j < fTRDnSlices;++j) fTRDslices[j] = source.fTRDslices[j];
6984f7c1 999 }
ddfbc51a 1000
732a24fe 1001 fTRDQuality = source.fTRDQuality;
1002 fTRDBudget = source.fTRDBudget;
1003 fTOFsignal = source.fTOFsignal;
a2c30af1 1004 fTOFsignalTuned = source.fTOFsignalTuned;
732a24fe 1005 fTOFsignalToT = source.fTOFsignalToT;
1006 fTOFsignalRaw = source.fTOFsignalRaw;
1007 fTOFsignalDz = source.fTOFsignalDz;
a5d9ff0f 1008 fTOFsignalDx = source.fTOFsignalDx;
d86081b1 1009 fTOFdeltaBC = source.fTOFdeltaBC;
1010 fTOFl0l1 = source.fTOFl0l1;
ddfbc51a 1011
1012 for(int i = 0;i<10;++i){
1013 fTOFInfo[i] = source.fTOFInfo[i];
1014 }
1015
732a24fe 1016 fHMPIDtrkX = source.fHMPIDtrkX;
1017 fHMPIDtrkY = source.fHMPIDtrkY;
1018 fHMPIDmipX = source.fHMPIDmipX;
1019 fHMPIDmipY = source.fHMPIDmipY;
1020
1021 fTPCncls = source.fTPCncls;
1022 fTPCnclsF = source.fTPCnclsF;
1023 fTPCsignalN = source.fTPCsignalN;
949840f6 1024 fTPCnclsIter1 = source.fTPCnclsIter1;
1025 fTPCnclsFIter1 = source.fTPCnclsFIter1;
732a24fe 1026
1027 fITSncls = source.fITSncls;
1028 fITSClusterMap = source.fITSClusterMap;
25015f7a 1029 fITSSharedMap = source.fITSSharedMap;
732a24fe 1030 fTRDncls = source.fTRDncls;
1031 fTRDncls0 = source.fTRDncls0;
ed15ef4f 1032 fTRDntracklets = source.fTRDntracklets;
6dc21f57 1033 fVertexID = source.fVertexID;
b5732bf0 1034
1035 fCacheNCrossedRows = source.fCacheNCrossedRows;
1036 fCacheChi2TPCConstrainedVsGlobal = source.fCacheChi2TPCConstrainedVsGlobal;
1037 fCacheChi2TPCConstrainedVsGlobalVertex = source.fCacheChi2TPCConstrainedVsGlobalVertex;
1038
00a38d07 1039 delete fDetectorPID;
1040 fDetectorPID=0x0;
1041 if (source.fDetectorPID) fDetectorPID = new AliDetectorPID(*source.fDetectorPID);
1042
ed15417e 1043 fTrackPhiOnEMCal= source.fTrackPhiOnEMCal;
1044 fTrackEtaOnEMCal= source.fTrackEtaOnEMCal;
a29b2a8a 1045 fTrackPtOnEMCal= source.fTrackPtOnEMCal;
ed15417e 1046
732a24fe 1047 return *this;
1048}
1049
ddfbc51a 1050
1051
732a24fe 1052void AliESDtrack::Copy(TObject &obj) const {
1053
1054 // this overwrites the virtual TOBject::Copy()
1055 // to allow run time copying without casting
1056 // in AliESDEvent
1057
1058 if(this==&obj)return;
1059 AliESDtrack *robj = dynamic_cast<AliESDtrack*>(&obj);
1060 if(!robj)return; // not an AliESDtrack
1061 *robj = *this;
1062
1063}
1064
ddfbc51a 1065
1066
00dce61a 1067void AliESDtrack::AddCalibObject(TObject * object){
1068 //
1069 // add calib object to the list
1070 //
ddfbc51a 1071 if (!fFriendTrack) fFriendTrack = new AliESDfriendTrack;
59c31692 1072 if (!fFriendTrack) return;
00dce61a 1073 fFriendTrack->AddCalibObject(object);
1074}
1075
1076TObject * AliESDtrack::GetCalibObject(Int_t index){
1077 //
1078 // return calib objct at given position
1079 //
1080 if (!fFriendTrack) return 0;
1081 return fFriendTrack->GetCalibObject(index);
1082}
1083
1084
f12d42ce 1085Bool_t AliESDtrack::FillTPCOnlyTrack(AliESDtrack &track){
b9ca886f 1086
1087 // Fills the information of the TPC-only first reconstruction pass
1088 // into the passed ESDtrack object. For consistency fTPCInner is also filled
1089 // again
1090
ddfbc51a 1091
1092
5b305f70 1093 // For data produced before r26675
1094 // RelateToVertexTPC was not properly called during reco
1095 // so you'll have to call it again, before FillTPCOnlyTrack
1096 // Float_t p[2],cov[3];
1097 // track->GetImpactParametersTPC(p,cov);
1098 // if(p[0]==0&&p[1]==0) // <- Default values
1099 // track->RelateToVertexTPC(esd->GetPrimaryVertexTPC(),esd->GetMagneticField(),kVeryBig);
1100
1101
ddfbc51a 1102 if(!fTPCInner)return kFALSE;
b9ca886f 1103
1104 // fill the TPC track params to the global track parameters
1105 track.Set(fTPCInner->GetX(),fTPCInner->GetAlpha(),fTPCInner->GetParameter(),fTPCInner->GetCovariance());
1106 track.fD = fdTPC;
1107 track.fZ = fzTPC;
1108 track.fCdd = fCddTPC;
1109 track.fCdz = fCdzTPC;
1110 track.fCzz = fCzzTPC;
ddfbc51a 1111
67ed91d3 1112 // copy the inner params
ddfbc51a 1113 if(track.fIp) *track.fIp = *fIp;
1114 else track.fIp = new AliExternalTrackParam(*fIp);
1115
b9ca886f 1116 // copy the TPCinner parameters
ddfbc51a 1117 if(track.fTPCInner) *track.fTPCInner = *fTPCInner;
1118 else track.fTPCInner = new AliExternalTrackParam(*fTPCInner);
b9ca886f 1119 track.fdTPC = fdTPC;
1120 track.fzTPC = fzTPC;
1121 track.fCddTPC = fCddTPC;
1122 track.fCdzTPC = fCdzTPC;
1123 track.fCzzTPC = fCzzTPC;
436dfe39 1124 track.fCchi2TPC = fCchi2TPC;
b9ca886f 1125
b9ca886f 1126 // copy all other TPC specific parameters
1127
1128 // replace label by TPC label
1129 track.fLabel = fTPCLabel;
1130 track.fTPCLabel = fTPCLabel;
1131
1132 track.fTPCchi2 = fTPCchi2;
949840f6 1133 track.fTPCchi2Iter1 = fTPCchi2Iter1;
b9ca886f 1134 track.fTPCsignal = fTPCsignal;
539a5a59 1135 track.fTPCsignalTuned = fTPCsignalTuned;
b9ca886f 1136 track.fTPCsignalS = fTPCsignalS;
ddfbc51a 1137 for(int i = 0;i<4;++i)track.fTPCPoints[i] = fTPCPoints[i];
b9ca886f 1138
1139 track.fTPCncls = fTPCncls;
1140 track.fTPCnclsF = fTPCnclsF;
1141 track.fTPCsignalN = fTPCsignalN;
949840f6 1142 track.fTPCnclsIter1 = fTPCnclsIter1;
1143 track.fTPCnclsFIter1 = fTPCnclsFIter1;
b9ca886f 1144
1145 // PID
ddfbc51a 1146 for(int i=0;i<AliPID::kSPECIES;++i){
b9ca886f 1147 track.fTPCr[i] = fTPCr[i];
1148 // combined PID is TPC only!
1149 track.fR[i] = fTPCr[i];
1150 }
9f638f03 1151 track.fTPCFitMap = fTPCFitMap;
b9ca886f 1152 track.fTPCClusterMap = fTPCClusterMap;
1153 track.fTPCSharedMap = fTPCSharedMap;
ddfbc51a 1154
1155
b9ca886f 1156 // reset the flags
1157 track.fFlags = kTPCin;
1158 track.fID = fID;
1159
b1cfce51 1160 track.fFlags |= fFlags & kTPCpid; //copy the TPCpid status flag
b9ca886f 1161
ddfbc51a 1162 for (Int_t i=0;i<3;i++) track.fKinkIndexes[i] = fKinkIndexes[i];
b9ca886f 1163
1164 return kTRUE;
ddfbc51a 1165
b9ca886f 1166}
1167
9559cbc4 1168//_______________________________________________________________________
1169void AliESDtrack::MakeMiniESDtrack(){
1170 // Resets everything except
1171 // fFlags: Reconstruction status flags
1172 // fLabel: Track label
1173 // fID: Unique ID of the track
d7ddf1e9 1174 // Impact parameter information
9559cbc4 1175 // fR[AliPID::kSPECIES]: combined "detector response probability"
8497bca0 1176 // Running track parameters in the base class (AliExternalTrackParam)
9559cbc4 1177
1178 fTrackLength = 0;
562dd0b4 1179
ddfbc51a 1180 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
1181
9559cbc4 1182 // Reset track parameters constrained to the primary vertex
ddfbc51a 1183 delete fCp;fCp = 0;
1184
9559cbc4 1185 // Reset track parameters at the inner wall of TPC
ddfbc51a 1186 delete fIp;fIp = 0;
1187 delete fTPCInner;fTPCInner=0;
9559cbc4 1188 // Reset track parameters at the inner wall of the TRD
ddfbc51a 1189 delete fOp;fOp = 0;
c38d443f 1190 // Reset track parameters at the HMPID
ddfbc51a 1191 delete fHMPIDp;fHMPIDp = 0;
1192
1193
9559cbc4 1194 // Reset ITS track related information
1195 fITSchi2 = 0;
9559cbc4 1196 fITSncls = 0;
62665e7f 1197 fITSClusterMap=0;
25015f7a 1198 fITSSharedMap=0;
9559cbc4 1199 fITSsignal = 0;
ddfbc51a 1200 for (Int_t i=0;i<4;i++) fITSdEdxSamples[i] = 0.;
1201 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
9559cbc4 1202 fITSLabel = 0;
9559cbc4 1203
1204 // Reset TPC related track information
1205 fTPCchi2 = 0;
949840f6 1206 fTPCchi2Iter1 = 0;
9559cbc4 1207 fTPCncls = 0;
e1d4c1b5 1208 fTPCnclsF = 0;
949840f6 1209 fTPCnclsIter1 = 0;
9f638f03 1210 fTPCnclsFIter1 = 0;
1211 fTPCFitMap = 0;
9559cbc4 1212 fTPCClusterMap = 0;
eb7f6854 1213 fTPCSharedMap = 0;
9559cbc4 1214 fTPCsignal= 0;
539a5a59 1215 fTPCsignalTuned= 0;
e1d4c1b5 1216 fTPCsignalS= 0;
1217 fTPCsignalN= 0;
ddfbc51a 1218 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=0;
9559cbc4 1219 fTPCLabel=0;
ddfbc51a 1220 for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
1221 for (Int_t i=0; i<3;i++) fKinkIndexes[i] = 0;
1222 for (Int_t i=0; i<3;i++) fV0Indexes[i] = 0;
9559cbc4 1223
1224 // Reset TRD related track information
1225 fTRDchi2 = 0;
1226 fTRDncls = 0;
1227 fTRDncls0 = 0;
9559cbc4 1228 fTRDsignal = 0;
4d302e42 1229 fTRDNchamberdEdx = 0;
1230 fTRDNclusterdEdx = 0;
1231
ddfbc51a 1232 for (Int_t i=0;i<kTRDnPlanes;i++) {
1233 fTRDTimBin[i] = 0;
1234 }
1235 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
9559cbc4 1236 fTRDLabel = 0;
9559cbc4 1237 fTRDQuality = 0;
ed15ef4f 1238 fTRDntracklets = 0;
ddfbc51a 1239 if(fTRDnSlices)
1240 delete[] fTRDslices;
1241 fTRDslices=0x0;
6984f7c1 1242 fTRDnSlices=0;
23d49657 1243 fTRDBudget = 0;
9559cbc4 1244
1245 // Reset TOF related track information
1246 fTOFchi2 = 0;
ce3f4882 1247 fTOFindex = -1;
ab37ab1e 1248 fTOFsignal = 99999;
1249 fTOFCalChannel = -1;
1250 fTOFsignalToT = 99999;
1251 fTOFsignalRaw = 99999;
1252 fTOFsignalDz = 999;
1253 fTOFsignalDx = 999;
1254 fTOFdeltaBC = 999;
1255 fTOFl0l1 = 999;
ddfbc51a 1256 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
1257 for (Int_t i=0;i<3;i++) fTOFLabel[i] = -1;
1258 for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
9559cbc4 1259
f4b3bbb7 1260 // Reset HMPID related track information
1261 fHMPIDchi2 = 0;
562dd0b4 1262 fHMPIDqn = 0;
81aa7a0d 1263 fHMPIDcluIdx = -1;
f4b3bbb7 1264 fHMPIDsignal = 0;
ddfbc51a 1265 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
562dd0b4 1266 fHMPIDtrkTheta = 0;
1267 fHMPIDtrkPhi = 0;
1268 fHMPIDtrkX = 0;
1269 fHMPIDtrkY = 0;
1270 fHMPIDmipX = 0;
1271 fHMPIDmipY = 0;
f1cedef3 1272 fCaloIndex = kEMCALNoMatch;
9559cbc4 1273
b5b2b4db 1274 // reset global track chi2
1275 fGlobalChi2 = 0;
1276
6dc21f57 1277 fVertexID = -2; // an orphan track
ddfbc51a 1278
1279 delete fFriendTrack; fFriendTrack = 0;
9559cbc4 1280}
ec729fb0 1281
bf7942ff 1282//_______________________________________________________________________
1cecd6e3 1283Int_t AliESDtrack::GetPID(Bool_t tpcOnly) const
bf7942ff 1284{
1285 // Returns the particle most probable id
ddfbc51a 1286 Int_t i;
1cecd6e3 1287 const Double32_t *prob = 0;
1288 if (tpcOnly) { // check if TPCpid is valid
1289 prob = fTPCr;
1290 for (i=0; i<AliPID::kSPECIES-1; i++) if (prob[i] != prob[i+1]) break;
1291 if (i == AliPID::kSPECIES-1) prob = 0; // not valid, try with combined pid
1292 }
1293 if (!prob) { // either requested TPCpid is not valid or comb.pid is requested
1294 prob = fR;
1295 for (i=0; i<AliPID::kSPECIES-1; i++) if (prob[i] != prob[i+1]) break;
1296 if (i == AliPID::kSPECIES-1) return AliPID::kPion; // If all the probabilities are equal, return the pion mass
1297 }
bf7942ff 1298 //
ae982df3 1299 Float_t max=0.;
1300 Int_t k=-1;
1cecd6e3 1301 for (i=0; i<AliPID::kSPECIES; i++) if (prob[i]>max) {k=i; max=prob[i];}
bf7942ff 1302 //
db3989b3 1303 if (k==0) { // dE/dx "crossing points" in the TPC
bf7942ff 1304 Double_t p=GetP();
1305 if ((p>0.38)&&(p<0.48))
1cecd6e3 1306 if (prob[0]<prob[3]*10.) return AliPID::kKaon;
bf7942ff 1307 if ((p>0.75)&&(p<0.85))
1cecd6e3 1308 if (prob[0]<prob[4]*10.) return AliPID::kProton;
bf7942ff 1309 return AliPID::kElectron;
db3989b3 1310 }
bf7942ff 1311 if (k==1) return AliPID::kMuon;
1312 if (k==2||k==-1) return AliPID::kPion;
1313 if (k==3) return AliPID::kKaon;
1314 if (k==4) return AliPID::kProton;
1315 AliWarning("Undefined PID !");
1316 return AliPID::kPion;
1317}
1318
1319//_______________________________________________________________________
1cecd6e3 1320Int_t AliESDtrack::GetTOFBunchCrossing(Double_t b, Bool_t pidTPConly) const
bf7942ff 1321{
1322 // Returns the number of bunch crossings after trigger (assuming 25ns spacing)
bf7942ff 1323 const double kSpacing = 25e3; // min interbanch spacing
1324 const double kShift = 0;
3f2db92f 1325 Int_t bcid = kTOFBCNA; // defualt one
a512bf97 1326 if (!IsOn(kTOFout) || !IsOn(kESDpid)) return bcid; // no info
1327 //
1328 double tdif = fTOFsignal;
1329 if (IsOn(kTIME)) { // integrated time info is there
1cecd6e3 1330 int pid = GetPID(pidTPConly);
a512bf97 1331 tdif -= fTrackTime[pid];
1332 }
1333 else { // assume integrated time info from TOF radius and momentum
1334 const double kRTOF = 385.;
1335 const double kCSpeed = 3.e-2; // cm/ps
1336 double p = GetP();
1337 if (p<0.01) return bcid;
1cecd6e3 1338 double m = GetMass(pidTPConly);
a512bf97 1339 double curv = GetC(b);
1340 double path = TMath::Abs(curv)>kAlmost0 ? // account for curvature
1341 2./curv*TMath::ASin(kRTOF*curv/2.)*TMath::Sqrt(1.+GetTgl()*GetTgl()) : kRTOF;
1342 tdif -= path/kCSpeed*TMath::Sqrt(1.+m*m/(p*p));
1343 }
bf7942ff 1344 bcid = TMath::Nint((tdif - kShift)/kSpacing);
1345 return bcid;
ae982df3 1346}
1347
6b5b49c9 1348//______________________________________________________________________________
1349Double_t AliESDtrack::M() const
1350{
2850a7f3 1351 // Returns the assumed mass
1352 // (the pion mass, if the particle can't be identified properly).
9be82450 1353 static Bool_t printerr=kTRUE;
1354 if (printerr) {
1355 AliWarning("WARNING !!! ... THIS WILL BE PRINTED JUST ONCE !!!");
1356 printerr = kFALSE;
1357 AliWarning("This is the ESD mass. Use it with care !");
1358 }
6b5b49c9 1359 return GetMass();
1360}
1361
aad8d435 1362//______________________________________________________________________________
1363Double_t AliESDtrack::E() const
1364{
1365 // Returns the energy of the particle given its assumed mass.
1366 // Assumes the pion mass if the particle can't be identified properly.
1367
1368 Double_t m = M();
1369 Double_t p = P();
1370 return TMath::Sqrt(p*p + m*m);
1371}
1372
1373//______________________________________________________________________________
1374Double_t AliESDtrack::Y() const
1375{
1376 // Returns the rapidity of a particle given its assumed mass.
1377 // Assumes the pion mass if the particle can't be identified properly.
1378
1379 Double_t e = E();
1380 Double_t pz = Pz();
e03e4544 1381 if (e != TMath::Abs(pz)) { // energy was not equal to pz
aad8d435 1382 return 0.5*TMath::Log((e+pz)/(e-pz));
1383 } else { // energy was equal to pz
1384 return -999.;
1385 }
1386}
1387
ae982df3 1388//_______________________________________________________________________
c9ec41e8 1389Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
ae982df3 1390 //
1391 // This function updates track's running parameters
1392 //
15614b8b 1393 Bool_t rc=kTRUE;
1394
9b859005 1395 SetStatus(flags);
1396 fLabel=t->GetLabel();
1397
1398 if (t->IsStartedTimeIntegral()) {
1399 SetStatus(kTIME);
ddfbc51a 1400 Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
9b859005 1401 SetIntegratedLength(t->GetIntegratedLength());
1402 }
1403
6c94f330 1404 Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
59c31692 1405 if (fFriendTrack) {
ddfbc51a 1406 if (flags==kITSout) fFriendTrack->SetITSOut(*t);
1407 if (flags==kTPCout) fFriendTrack->SetTPCOut(*t);
1408 if (flags==kTRDrefit) fFriendTrack->SetTRDIn(*t);
59c31692 1409 }
ddfbc51a 1410
ae982df3 1411 switch (flags) {
ddfbc51a 1412
6c3c2a50 1413 case kITSin:
1414 fITSchi2Std[0] = t->GetChi2();
1415 //
1416 case kITSout:
1417 fITSchi2Std[1] = t->GetChi2();
ddfbc51a 1418 case kITSrefit:
1419 {
6c3c2a50 1420 fITSchi2Std[2] = t->GetChi2();
48704648 1421 fITSClusterMap=0;
ae982df3 1422 fITSncls=t->GetNumberOfClusters();
59c31692 1423 if (fFriendTrack) {
ddfbc51a 1424 Int_t* indexITS = new Int_t[AliESDfriendTrack::kMaxITScluster];
1425 for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
6d3a7bbf 1426 indexITS[i]=t->GetClusterIndex(i);
ddfbc51a 1427
62665e7f 1428 if (i<fITSncls) {
6d3a7bbf 1429 Int_t l=(indexITS[i] & 0xf0000000) >> 28;
ddfbc51a 1430 SETBIT(fITSClusterMap,l);
62665e7f 1431 }
1432 }
ddfbc51a 1433 fFriendTrack->SetITSIndices(indexITS,AliESDfriendTrack::kMaxITScluster);
1434 delete [] indexITS;
1435 }
1436
ae982df3 1437 fITSchi2=t->GetChi2();
ae982df3 1438 fITSsignal=t->GetPIDsignal();
6e5b1b04 1439 fITSLabel = t->GetLabel();
57483eb1 1440 // keep in fOp the parameters outside ITS for ITS stand-alone tracks
1441 if (flags==kITSout) {
ddfbc51a 1442 if (!fOp) fOp=new AliExternalTrackParam(*t);
1443 else
1444 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1445 }
6d3a7bbf 1446 }
ae982df3 1447 break;
ddfbc51a 1448
9b859005 1449 case kTPCin: case kTPCrefit:
ddfbc51a 1450 {
6e5b1b04 1451 fTPCLabel = t->GetLabel();
949840f6 1452 if (flags==kTPCin) {
ddfbc51a 1453 fTPCInner=new AliExternalTrackParam(*t);
1454 fTPCnclsIter1=t->GetNumberOfClusters();
1455 fTPCchi2Iter1=t->GetChi2();
949840f6 1456 }
ddfbc51a 1457 if (!fIp) fIp=new AliExternalTrackParam(*t);
1458 else
1459 fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
6d3a7bbf 1460 }
5d6fb68d 1461 // Intentionally no break statement; need to set general TPC variables as well
9b859005 1462 case kTPCout:
ddfbc51a 1463 {
1d303a24 1464 if (flags & kTPCout){
ddfbc51a 1465 if (!fOp) fOp=new AliExternalTrackParam(*t);
1466 else
1467 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1d303a24 1468 }
e1d4c1b5 1469 fTPCncls=t->GetNumberOfClusters();
ae982df3 1470 fTPCchi2=t->GetChi2();
a866ac60 1471
5d6fb68d 1472 if (fFriendTrack) { // Copy cluster indices
ddfbc51a 1473 Int_t* indexTPC = new Int_t[AliESDfriendTrack::kMaxTPCcluster];
1474 for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)
1475 indexTPC[i]=t->GetClusterIndex(i);
5d6fb68d 1476 fFriendTrack->SetTPCIndices(indexTPC,AliESDfriendTrack::kMaxTPCcluster);
ddfbc51a 1477 delete [] indexTPC;
5d6fb68d 1478 }
ae982df3 1479 fTPCsignal=t->GetPIDsignal();
ddfbc51a 1480 }
ae982df3 1481 break;
ddfbc51a 1482
64130601 1483 case kTRDin: case kTRDrefit:
1484 break;
1485 case kTRDout:
ddfbc51a 1486 {
51ad6848 1487 fTRDLabel = t->GetLabel();
2f83b7a6 1488 fTRDchi2 = t->GetChi2();
1489 fTRDncls = t->GetNumberOfClusters();
59c31692 1490 if (fFriendTrack) {
ddfbc51a 1491 Int_t* indexTRD = new Int_t[AliESDfriendTrack::kMaxTRDcluster];
1492 for (Int_t i=0;i<AliESDfriendTrack::kMaxTRDcluster;i++) indexTRD[i]=-2;
1493 for (Int_t i=0;i<6;i++) indexTRD[i]=t->GetTrackletIndex(i);
6d3a7bbf 1494 fFriendTrack->SetTRDIndices(indexTRD,AliESDfriendTrack::kMaxTRDcluster);
ddfbc51a 1495 delete [] indexTRD;
59c31692 1496 }
ddfbc51a 1497
4d302e42 1498 //commented out by Xianguo
1499 //fTRDsignal=t->GetPIDsignal();
ddfbc51a 1500 }
79e94bf8 1501 break;
c4d11b15 1502 case kTRDbackup:
ddfbc51a 1503 if (!fOp) fOp=new AliExternalTrackParam(*t);
1504 else
1505 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
c4d11b15 1506 fTRDncls0 = t->GetNumberOfClusters();
1507 break;
1508 case kTOFin:
1509 break;
1510 case kTOFout:
1511 break;
d0862fea 1512 case kTRDStop:
1513 break;
c38d443f 1514 case kHMPIDout:
ddfbc51a 1515 if (!fHMPIDp) fHMPIDp=new AliExternalTrackParam(*t);
1516 else
1517 fHMPIDp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
c38d443f 1518 break;
ae982df3 1519 default:
5f7789fc 1520 AliError("Wrong flag !");
ae982df3 1521 return kFALSE;
1522 }
ddfbc51a 1523
15614b8b 1524 return rc;
ae982df3 1525}
1526
1527//_______________________________________________________________________
1528void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
1529 //---------------------------------------------------------------------
1530 // This function returns external representation of the track parameters
1531 //---------------------------------------------------------------------
c9ec41e8 1532 x=GetX();
ddfbc51a 1533 for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
15614b8b 1534}
1535
67c3dcbe 1536//_______________________________________________________________________
a866ac60 1537void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
67c3dcbe 1538 //---------------------------------------------------------------------
1539 // This function returns external representation of the cov. matrix
1540 //---------------------------------------------------------------------
ddfbc51a 1541 for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
67c3dcbe 1542}
1543
67c3dcbe 1544//_______________________________________________________________________
c0b978f0 1545Bool_t AliESDtrack::GetConstrainedExternalParameters
1546 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
67c3dcbe 1547 //---------------------------------------------------------------------
1548 // This function returns the constrained external track parameters
1549 //---------------------------------------------------------------------
c0b978f0 1550 if (!fCp) return kFALSE;
1551 alpha=fCp->GetAlpha();
c9ec41e8 1552 x=fCp->GetX();
ddfbc51a 1553 for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
c0b978f0 1554 return kTRUE;
67c3dcbe 1555}
c9ec41e8 1556
67c3dcbe 1557//_______________________________________________________________________
c0b978f0 1558Bool_t
67c3dcbe 1559AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
1560 //---------------------------------------------------------------------
1561 // This function returns the constrained external cov. matrix
1562 //---------------------------------------------------------------------
c0b978f0 1563 if (!fCp) return kFALSE;
ddfbc51a 1564 for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
c0b978f0 1565 return kTRUE;
67c3dcbe 1566}
1567
c0b978f0 1568Bool_t
1569AliESDtrack::GetInnerExternalParameters
1570 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1571 //---------------------------------------------------------------------
c9ec41e8 1572 // This function returns external representation of the track parameters
1573 // at the inner layer of TPC
9b859005 1574 //---------------------------------------------------------------------
c0b978f0 1575 if (!fIp) return kFALSE;
1576 alpha=fIp->GetAlpha();
c9ec41e8 1577 x=fIp->GetX();
ddfbc51a 1578 for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
c0b978f0 1579 return kTRUE;
9b859005 1580}
1581
c0b978f0 1582Bool_t
1583AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const {
c9ec41e8 1584 //---------------------------------------------------------------------
1585 // This function returns external representation of the cov. matrix
1586 // at the inner layer of TPC
1587 //---------------------------------------------------------------------
c0b978f0 1588 if (!fIp) return kFALSE;
ddfbc51a 1589 for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
c0b978f0 1590 return kTRUE;
9b859005 1591}
1592
d61ca12d 1593void
1594AliESDtrack::SetOuterParam(const AliExternalTrackParam *p, ULong_t flags) {
1595 //
1596 // This is a direct setter for the outer track parameters
1597 //
1598 SetStatus(flags);
1599 if (fOp) delete fOp;
1600 fOp=new AliExternalTrackParam(*p);
1601}
1602
c38d443f 1603void
1604AliESDtrack::SetOuterHmpParam(const AliExternalTrackParam *p, ULong_t flags) {
1605 //
1606 // This is a direct setter for the outer track parameters
1607 //
1608 SetStatus(flags);
ddfbc51a 1609 if (fHMPIDp) delete fHMPIDp;
1610 fHMPIDp=new AliExternalTrackParam(*p);
c38d443f 1611}
1612
c0b978f0 1613Bool_t
1614AliESDtrack::GetOuterExternalParameters
1615 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1616 //---------------------------------------------------------------------
c9ec41e8 1617 // This function returns external representation of the track parameters
1618 // at the inner layer of TRD
a866ac60 1619 //---------------------------------------------------------------------
c0b978f0 1620 if (!fOp) return kFALSE;
1621 alpha=fOp->GetAlpha();
c9ec41e8 1622 x=fOp->GetX();
ddfbc51a 1623 for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
c0b978f0 1624 return kTRUE;
a866ac60 1625}
c9ec41e8 1626
c38d443f 1627Bool_t
1628AliESDtrack::GetOuterHmpExternalParameters
1629 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1630 //---------------------------------------------------------------------
1631 // This function returns external representation of the track parameters
1632 // at the inner layer of TRD
1633 //---------------------------------------------------------------------
1634 if (!fHMPIDp) return kFALSE;
1635 alpha=fHMPIDp->GetAlpha();
1636 x=fHMPIDp->GetX();
ddfbc51a 1637 for (Int_t i=0; i<5; i++) p[i]=fHMPIDp->GetParameter()[i];
c38d443f 1638 return kTRUE;
1639}
1640
c0b978f0 1641Bool_t
1642AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
a866ac60 1643 //---------------------------------------------------------------------
c9ec41e8 1644 // This function returns external representation of the cov. matrix
1645 // at the inner layer of TRD
a866ac60 1646 //---------------------------------------------------------------------
c0b978f0 1647 if (!fOp) return kFALSE;
ddfbc51a 1648 for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
c0b978f0 1649 return kTRUE;
a866ac60 1650}
1651
c38d443f 1652Bool_t
1653AliESDtrack::GetOuterHmpExternalCovariance(Double_t cov[15]) const {
1654 //---------------------------------------------------------------------
1655 // This function returns external representation of the cov. matrix
1656 // at the inner layer of TRD
1657 //---------------------------------------------------------------------
1658 if (!fHMPIDp) return kFALSE;
ddfbc51a 1659 for (Int_t i=0; i<15; i++) cov[i]=fHMPIDp->GetCovariance()[i];
c38d443f 1660 return kTRUE;
1661}
1662
98937d93 1663Int_t AliESDtrack::GetNcls(Int_t idet) const
1664{
1665 // Get number of clusters by subdetector index
1666 //
1667 Int_t ncls = 0;
1668 switch(idet){
1669 case 0:
1670 ncls = fITSncls;
1671 break;
1672 case 1:
1673 ncls = fTPCncls;
1674 break;
1675 case 2:
1676 ncls = fTRDncls;
1677 break;
1678 case 3:
ce3f4882 1679 if (fTOFindex != -1)
98937d93 1680 ncls = 1;
1681 break;
81aa7a0d 1682 case 4: //PHOS
1683 break;
1684 case 5: //HMPID
1685 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1686 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1687 ncls = 1;
1688 }
1689 }
1690 break;
98937d93 1691 default:
1692 break;
1693 }
1694 return ncls;
1695}
1696
ef7253ac 1697Int_t AliESDtrack::GetClusters(Int_t idet, Int_t *idx) const
98937d93 1698{
1699 // Get cluster index array by subdetector index
1700 //
1701 Int_t ncls = 0;
1702 switch(idet){
1703 case 0:
1704 ncls = GetITSclusters(idx);
1705 break;
1706 case 1:
ef7253ac 1707 ncls = GetTPCclusters(idx);
98937d93 1708 break;
1709 case 2:
1710 ncls = GetTRDclusters(idx);
1711 break;
1712 case 3:
ce3f4882 1713 if (fTOFindex != -1) {
1714 idx[0] = fTOFindex;
98937d93 1715 ncls = 1;
1716 }
1717 break;
313af949 1718 case 4: //PHOS
1719 break;
1720 case 5:
81aa7a0d 1721 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1722 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1723 idx[0] = GetHMPIDcluIdx();
1724 ncls = 1;
1725 }
313af949 1726 }
1727 break;
1728 case 6: //EMCAL
1729 break;
98937d93 1730 default:
1731 break;
1732 }
1733 return ncls;
1734}
1735
ae982df3 1736//_______________________________________________________________________
1737void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
4427806c 1738 // Returns the array with integrated times for each particle hypothesis
ddfbc51a 1739 for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
ae982df3 1740}
1741
1742//_______________________________________________________________________
1743void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
4427806c 1744 // Sets the array with integrated times for each particle hypotesis
ddfbc51a 1745 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
ae982df3 1746}
1747
c630aafd 1748//_______________________________________________________________________
4427806c 1749void AliESDtrack::SetITSpid(const Double_t *p) {
1750 // Sets values for the probability of each particle type (in ITS)
d27bbc79 1751 SetPIDValues(fITSr,p,AliPID::kSPECIES);
c630aafd 1752 SetStatus(AliESDtrack::kITSpid);
1753}
1754
1755//_______________________________________________________________________
1756void AliESDtrack::GetITSpid(Double_t *p) const {
4427806c 1757 // Gets the probability of each particle type (in ITS)
ddfbc51a 1758 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
c630aafd 1759}
1760
ae982df3 1761//_______________________________________________________________________
562dd0b4 1762Char_t AliESDtrack::GetITSclusters(Int_t *idx) const {
ae982df3 1763 //---------------------------------------------------------------------
1764 // This function returns indices of the assgined ITS clusters
1765 //---------------------------------------------------------------------
59c31692 1766 if (idx && fFriendTrack) {
6d3a7bbf 1767 Int_t *index=fFriendTrack->GetITSindices();
ddfbc51a 1768 for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) {
6d3a7bbf 1769 if ( (i>=fITSncls) && (i<6) ) idx[i]=-1;
1770 else {
1771 if (index) {
1772 idx[i]=index[i];
1773 }
1774 else idx[i]= -2;
1775 }
1776 }
15e85efa 1777 }
ae982df3 1778 return fITSncls;
1779}
1780
89f1b176 1781//_______________________________________________________________________
1782Bool_t AliESDtrack::GetITSModuleIndexInfo(Int_t ilayer,Int_t &idet,Int_t &status,
1783 Float_t &xloc,Float_t &zloc) const {
1784 //----------------------------------------------------------------------
1785 // This function encodes in the module number also the status of cluster association
1786 // "status" can have the following values:
1787 // 1 "found" (cluster is associated),
1788 // 2 "dead" (module is dead from OCDB),
1789 // 3 "skipped" (module or layer forced to be skipped),
1790 // 4 "outinz" (track out of z acceptance),
1791 // 5 "nocls" (no clusters in the road),
1792 // 6 "norefit" (cluster rejected during refit),
1793 // 7 "deadzspd" (holes in z in SPD)
1794 // Also given are the coordinates of the crossing point of track and module
1795 // (in the local module ref. system)
1796 // WARNING: THIS METHOD HAS TO BE SYNCHRONIZED WITH AliITStrackV2::GetModuleIndexInfo()!
1797 //----------------------------------------------------------------------
1798
1799 if(fITSModule[ilayer]==-1) {
89f1b176 1800 idet = -1;
1801 status=0;
1802 xloc=-99.; zloc=-99.;
1803 return kFALSE;
1804 }
1805
1806 Int_t module = fITSModule[ilayer];
1807
1808 idet = Int_t(module/1000000);
1809
1810 module -= idet*1000000;
1811
1812 status = Int_t(module/100000);
1813
1814 module -= status*100000;
1815
1816 Int_t signs = Int_t(module/10000);
1817
1818 module-=signs*10000;
1819
1820 Int_t xInt = Int_t(module/100);
1821 module -= xInt*100;
1822
1823 Int_t zInt = module;
1824
1825 if(signs==1) { xInt*=1; zInt*=1; }
1826 if(signs==2) { xInt*=1; zInt*=-1; }
1827 if(signs==3) { xInt*=-1; zInt*=1; }
1828 if(signs==4) { xInt*=-1; zInt*=-1; }
1829
1830 xloc = 0.1*(Float_t)xInt;
1831 zloc = 0.1*(Float_t)zInt;
1832
1833 if(status==4) idet = -1;
1834
1835 return kTRUE;
1836}
1837
ae982df3 1838//_______________________________________________________________________
562dd0b4 1839UShort_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
ae982df3 1840 //---------------------------------------------------------------------
1841 // This function returns indices of the assgined ITS clusters
1842 //---------------------------------------------------------------------
59c31692 1843 if (idx && fFriendTrack) {
15e85efa 1844 Int_t *index=fFriendTrack->GetTPCindices();
6d3a7bbf 1845
1846 if (index){
ddfbc51a 1847 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
6d3a7bbf 1848 }
1849 else {
ddfbc51a 1850 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=-2;
6d3a7bbf 1851 }
15e85efa 1852 }
ae982df3 1853 return fTPCncls;
1854}
8c6a71ab 1855
4c3dc2a0 1856//_______________________________________________________________________
1857Float_t AliESDtrack::GetTPCCrossedRows() const
1858{
1859 // This function calls GetTPCClusterInfo with some default parameters which are used in the track selection and caches the outcome
1860 // because GetTPCClusterInfo is quite time-consuming
1861
1862 if (fCacheNCrossedRows > -1)
1863 return fCacheNCrossedRows;
1864
1865 fCacheNCrossedRows = GetTPCClusterInfo(2, 1);
1866 return fCacheNCrossedRows;
1867}
1868
6a6f0c1f 1869//_______________________________________________________________________
25f906db 1870Float_t AliESDtrack::GetTPCClusterInfo(Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1, Int_t bitType ) const
6a6f0c1f 1871{
1872 //
1873 // TPC cluster information
1874 // type 0: get fraction of found/findable clusters with neighbourhood definition
1875 // 1: findable clusters with neighbourhood definition
1876 // 2: found clusters
25f906db 1877 // bitType:
1878 // 0 - all cluster used
1879 // 1 - clusters used for the kalman update
6a6f0c1f 1880 // definition of findable clusters:
1881 // a cluster is defined as findable if there is another cluster
1882 // within +- nNeighbours pad rows. The idea is to overcome threshold
1883 // effects with a very simple algorithm.
1884 //
1885
6a6f0c1f 1886
1887 Int_t found=0;
1888 Int_t findable=0;
1889 Int_t last=-nNeighbours;
25f906db 1890 const TBits & clusterMap = (bitType%2==0) ? fTPCClusterMap : fTPCFitMap;
6a6f0c1f 1891
25f906db 1892 Int_t upperBound=clusterMap.GetNbits();
59c31692 1893 if (upperBound>row1) upperBound=row1;
ddfbc51a 1894 for (Int_t i=row0; i<upperBound; ++i){
6a6f0c1f 1895 //look to current row
25f906db 1896 if (clusterMap[i]) {
6a6f0c1f 1897 last=i;
1898 ++found;
1899 ++findable;
1900 continue;
1901 }
1902 //look to nNeighbours before
1903 if ((i-last)<=nNeighbours) {
1904 ++findable;
1905 continue;
1906 }
1907 //look to nNeighbours after
1908 for (Int_t j=i+1; j<i+1+nNeighbours; ++j){
25f906db 1909 if (clusterMap[j]){
6a6f0c1f 1910 ++findable;
1911 break;
1912 }
1913 }
1914 }
25f906db 1915 if (type==2) return found;
1916 if (type==1) return findable;
1917
1918 if (type==0){
1919 Float_t fraction=0;
1920 if (findable>0)
1921 fraction=(Float_t)found/(Float_t)findable;
1922 else
1923 fraction=0;
1924 return fraction;
1925 }
1926 return 0; // undefined type - default value
1927}
1928
1929//_______________________________________________________________________
1930Float_t AliESDtrack::GetTPCClusterDensity(Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1, Int_t bitType ) const
1931{
1932 //
1933 // TPC cluster density - only rows where signal before and after given row are used
1934 // - slower function
1935 // type 0: get fraction of found/findable clusters with neighbourhood definition
1936 // 1: findable clusters with neighbourhood definition
1937 // 2: found clusters
1938 // bitType:
1939 // 0 - all cluster used
1940 // 1 - clusters used for the kalman update
1941 // definition of findable clusters:
1942 // a cluster is defined as findable if there is another cluster
1943 // within +- nNeighbours pad rows. The idea is to overcome threshold
1944 // effects with a very simple algorithm.
1945 //
1946 Int_t found=0;
1947 Int_t findable=0;
1948 // Int_t last=-nNeighbours;
1949 const TBits & clusterMap = (bitType%2==0) ? fTPCClusterMap : fTPCFitMap;
1950 Int_t upperBound=clusterMap.GetNbits();
1951 if (upperBound>row1) upperBound=row1;
1952 for (Int_t i=row0; i<upperBound; ++i){
1953 Bool_t isUp=kFALSE;
1954 Bool_t isDown=kFALSE;
1955 for (Int_t idelta=1; idelta<=nNeighbours; idelta++){
1956 if (i-idelta>=0 && clusterMap[i-idelta]) isDown=kTRUE;
1957 if (i+idelta<upperBound && clusterMap[i+idelta]) isUp=kTRUE;
1958 }
1959 if (isUp&&isDown){
1960 ++findable;
1961 if (clusterMap[i]) ++found;
1962 }
1963 }
1964 if (type==2) return found;
82cc468e 1965 if (type==1) return findable;
1966
6a6f0c1f 1967 if (type==0){
82cc468e 1968 Float_t fraction=0;
1969 if (findable>0)
1970 fraction=(Float_t)found/(Float_t)findable;
1971 else
1972 fraction=0;
1973 return fraction;
1974 }
1975 return 0; // undefined type - default value
6a6f0c1f 1976}
1977
25f906db 1978
1979
1980
6a6f0c1f 1981//_______________________________________________________________________
562dd0b4 1982Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
81e97e0d 1983 //
1984 // GetDensity of the clusters on given region between row0 and row1
1985 // Dead zone effect takin into acoount
1986 //
59c31692 1987 if (!fFriendTrack) return 0.0;
81e97e0d 1988 Int_t good = 0;
1989 Int_t found = 0;
1990 //
15e85efa 1991 Int_t *index=fFriendTrack->GetTPCindices();
81e97e0d 1992 for (Int_t i=row0;i<=row1;i++){
15e85efa 1993 Int_t idx = index[i];
1994 if (idx!=-1) good++; // track outside of dead zone
1995 if (idx>0) found++;
81e97e0d 1996 }
1997 Float_t density=0.5;
a3061175 1998 if (good>TMath::Max((row1-row0)*0.5,0.0)) density = Float_t(found)/Float_t(good);
81e97e0d 1999 return density;
2000}
c84a5e9e 2001
8c6a71ab 2002//_______________________________________________________________________
2003void AliESDtrack::SetTPCpid(const Double_t *p) {
4427806c 2004 // Sets values for the probability of each particle type (in TPC)
d27bbc79 2005 SetPIDValues(fTPCr,p,AliPID::kSPECIES);
8c6a71ab 2006 SetStatus(AliESDtrack::kTPCpid);
2007}
2008
2009//_______________________________________________________________________
2010void AliESDtrack::GetTPCpid(Double_t *p) const {
4427806c 2011 // Gets the probability of each particle type (in TPC)
ddfbc51a 2012 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
8c6a71ab 2013}
2014
bb2ceb1f 2015//_______________________________________________________________________
562dd0b4 2016UChar_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
bb2ceb1f 2017 //---------------------------------------------------------------------
2018 // This function returns indices of the assgined TRD clusters
2019 //---------------------------------------------------------------------
59c31692 2020 if (idx && fFriendTrack) {
6d3a7bbf 2021 Int_t *index=fFriendTrack->GetTRDindices();
ddfbc51a 2022
2023 if (index) {
2024 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
2025 }
2026 else {
2027 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=-2;
2028 }
15e85efa 2029 }
bb2ceb1f 2030 return fTRDncls;
2031}
2032
5bc3e158 2033//_______________________________________________________________________
2034UChar_t AliESDtrack::GetTRDtracklets(Int_t *idx) const {
0ad488b0 2035//
2036// This function returns the number of TRD tracklets used in tracking
2037// and it fills the indices of these tracklets in the array "idx" as they
2038// are registered in the TRD track list.
2039//
2040// Caution :
2041// 1. The idx array has to be allocated with a size >= AliESDtrack::kTRDnPlanes
2042// 2. The idx array store not only the index but also the layer of the tracklet.
2043// Therefore tracks with TRD gaps contain default values for indices [-1]
2044
59c31692 2045 if (!fFriendTrack) return 0;
0ad488b0 2046 if (!idx) return GetTRDntracklets();
6d3a7bbf 2047 Int_t *index=fFriendTrack->GetTRDindices();
2048 Int_t n = 0;
ddfbc51a 2049 for (Int_t i=0; i<kTRDnPlanes; i++){
6d3a7bbf 2050 if (index){
2051 if(index[i]>=0) n++;
2052 idx[i]=index[i];
2053 }
2054 else idx[i] = -2;
5bc3e158 2055 }
0ad488b0 2056 return n;
5bc3e158 2057}
2058
c630aafd 2059//_______________________________________________________________________
2060void AliESDtrack::SetTRDpid(const Double_t *p) {
4427806c 2061 // Sets values for the probability of each particle type (in TRD)
d27bbc79 2062 SetPIDValues(fTRDr,p,AliPID::kSPECIES);
c630aafd 2063 SetStatus(AliESDtrack::kTRDpid);
2064}
2065
2066//_______________________________________________________________________
2067void AliESDtrack::GetTRDpid(Double_t *p) const {
4427806c 2068 // Gets the probability of each particle type (in TRD)
ddfbc51a 2069 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
c630aafd 2070}
2071
79e94bf8 2072//_______________________________________________________________________
2073void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
2074{
4427806c 2075 // Sets the probability of particle type iSpecies to p (in TRD)
79e94bf8 2076 fTRDr[iSpecies] = p;
2077}
2078
562dd0b4 2079Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
79e94bf8 2080{
4427806c 2081 // Returns the probability of particle type iSpecies (in TRD)
79e94bf8 2082 return fTRDr[iSpecies];
2083}
2084
fae4c212 2085//____________________________________________________
2086Int_t AliESDtrack::GetNumberOfTRDslices() const
2087{
2088 // built in backward compatibility
2089 Int_t idx = fTRDnSlices - (kTRDnPlanes<<1);
2090 return idx<18 ? fTRDnSlices/kTRDnPlanes : idx/kTRDnPlanes;
2091}
2092
2093//____________________________________________________
2094Double_t AliESDtrack::GetTRDmomentum(Int_t plane, Double_t *sp) const
2095{
2096//Returns momentum estimation and optional its error (sp)
2097// in TRD layer "plane".
2098
2099 if (!fTRDnSlices) {
ba8cee18 2100 AliDebug(2, "No TRD info allocated for this track.");
fae4c212 2101 return -1.;
2102 }
2103 if ((plane<0) || (plane>=kTRDnPlanes)) {
ba8cee18 2104 AliWarning(Form("Request for TRD plane[%d] outside range.", plane));
fae4c212 2105 return -1.;
2106 }
2107
2108 Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
2109 // Protection for backward compatibility
2110 if(idx<(GetNumberOfTRDslices()*kTRDnPlanes)) return -1.;
2111
2112 if(sp) (*sp) = fTRDslices[idx+kTRDnPlanes];
2113 return fTRDslices[idx];
2114}
2115
2116//____________________________________________________
2117Double_t AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
2118 //Gets the charge from the slice of the plane
2119
2120 if(!fTRDslices) {
2121 //AliError("No TRD slices allocated for this track !");
2122 return -1.;
2123 }
2124 if ((plane<0) || (plane>=kTRDnPlanes)) {
2125 AliError("Info for TRD plane not available !");
2126 return -1.;
2127 }
2128 Int_t ns=GetNumberOfTRDslices();
2129 if ((slice<-1) || (slice>=ns)) {
2130 //AliError("Wrong TRD slice !");
2131 return -1.;
2132 }
2133
2134 if(slice>=0) return fTRDslices[plane*ns + slice];
2135
2136 // return average of the dEdx measurements
2137 Double_t q=0.; Double32_t *s = &fTRDslices[plane*ns];
ddfbc51a 2138 for (Int_t i=0; i<ns; i++, s++) if((*s)>0.) q+=(*s);
fae4c212 2139 return q/ns;
2140}
2141
2142//____________________________________________________
6984f7c1 2143void AliESDtrack::SetNumberOfTRDslices(Int_t n) {
2144 //Sets the number of slices used for PID
fae4c212 2145 if (fTRDnSlices) return;
ddfbc51a 2146
fae4c212 2147 fTRDnSlices=n;
ddfbc51a 2148 fTRDslices=new Double32_t[fTRDnSlices];
2149
fae4c212 2150 // set-up correctly the allocated memory
2151 memset(fTRDslices, 0, n*sizeof(Double32_t));
ddfbc51a 2152 for (Int_t i=GetNumberOfTRDslices(); i--;) fTRDslices[i]=-1.;
6984f7c1 2153}
2154
fae4c212 2155//____________________________________________________
6984f7c1 2156void AliESDtrack::SetTRDslice(Double_t q, Int_t plane, Int_t slice) {
2157 //Sets the charge q in the slice of the plane
fae4c212 2158 if(!fTRDslices) {
6984f7c1 2159 AliError("No TRD slices allocated for this track !");
2160 return;
2161 }
6984f7c1 2162 if ((plane<0) || (plane>=kTRDnPlanes)) {
fae4c212 2163 AliError("Info for TRD plane not allocated !");
6984f7c1 2164 return;
2165 }
fae4c212 2166 Int_t ns=GetNumberOfTRDslices();
6984f7c1 2167 if ((slice<0) || (slice>=ns)) {
be20337a 2168 AliError(Form("Wrong TRD slice %d/%d, NSlices=%d",plane,slice,ns));
6984f7c1 2169 return;
2170 }
2171 Int_t n=plane*ns + slice;
2172 fTRDslices[n]=q;
2173}
2174
6984f7c1 2175
fae4c212 2176//____________________________________________________
2177void AliESDtrack::SetTRDmomentum(Double_t p, Int_t plane, Double_t *sp)
2178{
2179 if(!fTRDslices) {
2180 AliError("No TRD slices allocated for this track !");
2181 return;
6984f7c1 2182 }
fae4c212 2183 if ((plane<0) || (plane>=kTRDnPlanes)) {
2184 AliError("Info for TRD plane not allocated !");
2185 return;
6984f7c1 2186 }
2187
fae4c212 2188 Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
2189 // Protection for backward compatibility
2190 if(idx<GetNumberOfTRDslices()*kTRDnPlanes) return;
6984f7c1 2191
fae4c212 2192 if(sp) fTRDslices[idx+kTRDnPlanes] = (*sp);
2193 fTRDslices[idx] = p;
6984f7c1 2194}
2195
2196
c630aafd 2197//_______________________________________________________________________
2198void AliESDtrack::SetTOFpid(const Double_t *p) {
4427806c 2199 // Sets the probability of each particle type (in TOF)
d27bbc79 2200 SetPIDValues(fTOFr,p,AliPID::kSPECIES);
c630aafd 2201 SetStatus(AliESDtrack::kTOFpid);
2202}
2203
51ad6848 2204//_______________________________________________________________________
2205void AliESDtrack::SetTOFLabel(const Int_t *p) {
2206 // Sets (in TOF)
ddfbc51a 2207 for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
51ad6848 2208}
2209
c630aafd 2210//_______________________________________________________________________
2211void AliESDtrack::GetTOFpid(Double_t *p) const {
4427806c 2212 // Gets probabilities of each particle type (in TOF)
ddfbc51a 2213 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
c630aafd 2214}
2215
51ad6848 2216//_______________________________________________________________________
2217void AliESDtrack::GetTOFLabel(Int_t *p) const {
2218 // Gets (in TOF)
ddfbc51a 2219 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
51ad6848 2220}
2221
2222//_______________________________________________________________________
2223void AliESDtrack::GetTOFInfo(Float_t *info) const {
2224 // Gets (in TOF)
ddfbc51a 2225 for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
51ad6848 2226}
2227
2228//_______________________________________________________________________
2229void AliESDtrack::SetTOFInfo(Float_t*info) {
2230 // Gets (in TOF)
ddfbc51a 2231 for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
51ad6848 2232}
2233
4a78b8c5 2234
2235
4a78b8c5 2236//_______________________________________________________________________
f4b3bbb7 2237void AliESDtrack::SetHMPIDpid(const Double_t *p) {
2238 // Sets the probability of each particle type (in HMPID)
2239 SetPIDValues(fHMPIDr,p,AliPID::kSPECIES);
2240 SetStatus(AliESDtrack::kHMPIDpid);
4a78b8c5 2241}
2242
3876bdbf 2243//_______________________________________________________________________
ddfbc51a 2244void AliESDtrack::SetTPCdEdxInfo(AliTPCdEdxInfo * dEdxInfo){
2245 if(fTPCdEdxInfo) delete fTPCdEdxInfo;
3876bdbf 2246 fTPCdEdxInfo = dEdxInfo;
2247}
2248
4a78b8c5 2249//_______________________________________________________________________
f4b3bbb7 2250void AliESDtrack::GetHMPIDpid(Double_t *p) const {
2251 // Gets probabilities of each particle type (in HMPID)
ddfbc51a 2252 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fHMPIDr[i];
4a78b8c5 2253}
2254
ddfbc51a 2255
2256
8c6a71ab 2257//_______________________________________________________________________
2258void AliESDtrack::SetESDpid(const Double_t *p) {
4427806c 2259 // Sets the probability of each particle type for the ESD track
d27bbc79 2260 SetPIDValues(fR,p,AliPID::kSPECIES);
8c6a71ab 2261 SetStatus(AliESDtrack::kESDpid);
2262}
2263
2264//_______________________________________________________________________
2265void AliESDtrack::GetESDpid(Double_t *p) const {
4427806c 2266 // Gets probability of each particle type for the ESD track
ddfbc51a 2267 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
8c6a71ab 2268}
2269
d7ddf1e9 2270//_______________________________________________________________________
436dfe39 2271Bool_t AliESDtrack::RelateToVertexTPC(const AliESDVertex *vtx,
2272Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
d7ddf1e9 2273 //
436dfe39 2274 // Try to relate the TPC-only track parameters to the vertex "vtx",
d7ddf1e9 2275 // if the (rough) transverse impact parameter is not bigger then "maxd".
2276 // Magnetic field is "b" (kG).
2277 //
2278 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
2279 // b) The impact parameters and their covariance matrix are calculated.
436dfe39 2280 // c) An attempt to constrain the TPC-only params to the vertex is done.
2281 // The constrained params are returned via "cParam".
d7ddf1e9 2282 //
436dfe39 2283 // In the case of success, the returned value is kTRUE
2284 // otherwise, it's kFALSE)
2285 //
d7ddf1e9 2286
2287 if (!fTPCInner) return kFALSE;
2288 if (!vtx) return kFALSE;
2289
2290 Double_t dz[2],cov[3];
2291 if (!fTPCInner->PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
2292
2293 fdTPC = dz[0];
2294 fzTPC = dz[1];
2295 fCddTPC = cov[0];
2296 fCdzTPC = cov[1];
2297 fCzzTPC = cov[2];
2298
436dfe39 2299 Double_t covar[6]; vtx->GetCovMatrix(covar);
2300 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2301 Double_t c[3]={covar[2],0.,covar[5]};
2302
2303 Double_t chi2=GetPredictedChi2(p,c);
2304 if (chi2>kVeryBig) return kFALSE;
2305
2306 fCchi2TPC=chi2;
2307
2308 if (!cParam) return kTRUE;
2309
2310 *cParam = *fTPCInner;
2311 if (!cParam->Update(p,c)) return kFALSE;
2312
d7ddf1e9 2313 return kTRUE;
2314}
2315
266a0f9b 2316//_______________________________________________________________________
2317Bool_t AliESDtrack::RelateToVertexTPCBxByBz(const AliESDVertex *vtx,
2318Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2319 //
2320 // Try to relate the TPC-only track parameters to the vertex "vtx",
2321 // if the (rough) transverse impact parameter is not bigger then "maxd".
2322 //
2323 // All three components of the magnetic field ,"b[3]" (kG),
2324 // are taken into account.
2325 //
2326 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
2327 // b) The impact parameters and their covariance matrix are calculated.
2328 // c) An attempt to constrain the TPC-only params to the vertex is done.
2329 // The constrained params are returned via "cParam".
2330 //
2331 // In the case of success, the returned value is kTRUE
2332 // otherwise, it's kFALSE)
2333 //
2334
2335 if (!fTPCInner) return kFALSE;
2336 if (!vtx) return kFALSE;
2337
2338 Double_t dz[2],cov[3];
2339 if (!fTPCInner->PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2340
2341 fdTPC = dz[0];
2342 fzTPC = dz[1];
2343 fCddTPC = cov[0];
2344 fCdzTPC = cov[1];
2345 fCzzTPC = cov[2];
2346
2347 Double_t covar[6]; vtx->GetCovMatrix(covar);
2348 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2349 Double_t c[3]={covar[2],0.,covar[5]};
2350
2351 Double_t chi2=GetPredictedChi2(p,c);
2352 if (chi2>kVeryBig) return kFALSE;
2353
2354 fCchi2TPC=chi2;
2355
2356 if (!cParam) return kTRUE;
2357
2358 *cParam = *fTPCInner;
2359 if (!cParam->Update(p,c)) return kFALSE;
2360
2361 return kTRUE;
2362}
2363
49d13e89 2364//_______________________________________________________________________
436dfe39 2365Bool_t AliESDtrack::RelateToVertex(const AliESDVertex *vtx,
2366Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
49d13e89 2367 //
2368 // Try to relate this track to the vertex "vtx",
2369 // if the (rough) transverse impact parameter is not bigger then "maxd".
2370 // Magnetic field is "b" (kG).
2371 //
2372 // a) The track gets extapolated to the DCA to the vertex.
2373 // b) The impact parameters and their covariance matrix are calculated.
2374 // c) An attempt to constrain this track to the vertex is done.
436dfe39 2375 // The constrained params are returned via "cParam".
49d13e89 2376 //
436dfe39 2377 // In the case of success, the returned value is kTRUE
2378 // (otherwise, it's kFALSE)
49d13e89 2379 //
b5d34a4c 2380
2381 if (!vtx) return kFALSE;
2382
e99a34df 2383 Double_t dz[2],cov[3];
2384 if (!PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
2385
2386 fD = dz[0];
2387 fZ = dz[1];
2388 fCdd = cov[0];
2389 fCdz = cov[1];
2390 fCzz = cov[2];
49d13e89 2391
e99a34df 2392 Double_t covar[6]; vtx->GetCovMatrix(covar);
2393 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2394 Double_t c[3]={covar[2],0.,covar[5]};
3231f9e5 2395
e99a34df 2396 Double_t chi2=GetPredictedChi2(p,c);
436dfe39 2397 if (chi2>kVeryBig) return kFALSE;
2398
2399 fCchi2=chi2;
49d13e89 2400
436dfe39 2401
266a0f9b 2402 //--- Could now these lines be removed ? ---
2403 delete fCp;
2404 fCp=new AliExternalTrackParam(*this);
2405
2406 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
2407 //----------------------------------------
2408
2409 fVertexID = vtx->GetID();
2410
2411 if (!cParam) return kTRUE;
2412
2413 *cParam = *this;
2414 if (!cParam->Update(p,c)) return kFALSE;
2415
2416 return kTRUE;
2417}
2418
2419//_______________________________________________________________________
2420Bool_t AliESDtrack::RelateToVertexBxByBz(const AliESDVertex *vtx,
2421Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2422 //
2423 // Try to relate this track to the vertex "vtx",
2424 // if the (rough) transverse impact parameter is not bigger then "maxd".
2425 // Magnetic field is "b" (kG).
2426 //
2427 // a) The track gets extapolated to the DCA to the vertex.
2428 // b) The impact parameters and their covariance matrix are calculated.
2429 // c) An attempt to constrain this track to the vertex is done.
2430 // The constrained params are returned via "cParam".
2431 //
2432 // In the case of success, the returned value is kTRUE
2433 // (otherwise, it's kFALSE)
2434 //
2435
2436 if (!vtx) return kFALSE;
2437
2438 Double_t dz[2],cov[3];
2439 if (!PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2440
2441 fD = dz[0];
2442 fZ = dz[1];
2443 fCdd = cov[0];
2444 fCdz = cov[1];
2445 fCzz = cov[2];
2446
2447 Double_t covar[6]; vtx->GetCovMatrix(covar);
2448 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2449 Double_t c[3]={covar[2],0.,covar[5]};
2450
2451 Double_t chi2=GetPredictedChi2(p,c);
2452 if (chi2>kVeryBig) return kFALSE;
2453
2454 fCchi2=chi2;
2455
2456
436dfe39 2457 //--- Could now these lines be removed ? ---
e99a34df 2458 delete fCp;
2459 fCp=new AliExternalTrackParam(*this);
49d13e89 2460
e99a34df 2461 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
436dfe39 2462 //----------------------------------------
2463
6dc21f57 2464 fVertexID = vtx->GetID();
436dfe39 2465
2466 if (!cParam) return kTRUE;
2467
2468 *cParam = *this;
2469 if (!cParam->Update(p,c)) return kFALSE;
2470
49d13e89 2471 return kTRUE;
2472}
2473
ac2f7574 2474//_______________________________________________________________________
2475void AliESDtrack::Print(Option_t *) const {
2476 // Prints info on the track
b9ca886f 2477 AliExternalTrackParam::Print();
5f7789fc 2478 printf("ESD track info\n") ;
00a38d07 2479 Double_t p[AliPID::kSPECIES] ;
ac2f7574 2480 Int_t index = 0 ;
2481 if( IsOn(kITSpid) ){
2482 printf("From ITS: ") ;
2483 GetITSpid(p) ;
304864ab 2484 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2485 printf("%f, ", p[index]) ;
2486 printf("\n signal = %f\n", GetITSsignal()) ;
2487 }
2488 if( IsOn(kTPCpid) ){
2489 printf("From TPC: ") ;
2490 GetTPCpid(p) ;
304864ab 2491 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2492 printf("%f, ", p[index]) ;
2493 printf("\n signal = %f\n", GetTPCsignal()) ;
2494 }
2495 if( IsOn(kTRDpid) ){
2496 printf("From TRD: ") ;
2497 GetTRDpid(p) ;
304864ab 2498 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2499 printf("%f, ", p[index]) ;
6984f7c1 2500 printf("\n signal = %f\n", GetTRDsignal()) ;
4d302e42 2501 printf("\n NchamberdEdx = %d\n", GetTRDNchamberdEdx()) ;
2502 printf("\n NclusterdEdx = %d\n", GetTRDNclusterdEdx()) ;
ac2f7574 2503 }
2504 if( IsOn(kTOFpid) ){
2505 printf("From TOF: ") ;
2506 GetTOFpid(p) ;
304864ab 2507 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2508 printf("%f, ", p[index]) ;
2509 printf("\n signal = %f\n", GetTOFsignal()) ;
2510 }
f4b3bbb7 2511 if( IsOn(kHMPIDpid) ){
2512 printf("From HMPID: ") ;
2513 GetHMPIDpid(p) ;
304864ab 2514 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2515 printf("%f, ", p[index]) ;
f4b3bbb7 2516 printf("\n signal = %f\n", GetHMPIDsignal()) ;
ac2f7574 2517 }
ac2f7574 2518}
6c94f330 2519
0c19adf7 2520
2521//
2522// Draw functionality
2523// Origin: Marian Ivanov, Marian.Ivanov@cern.ch
2524//
2525void AliESDtrack::FillPolymarker(TPolyMarker3D *pol, Float_t magF, Float_t minR, Float_t maxR, Float_t stepR){
2526 //
2527 // Fill points in the polymarker
2528 //
2529 TObjArray arrayRef;
2530 arrayRef.AddLast(new AliExternalTrackParam(*this));
2531 if (fIp) arrayRef.AddLast(new AliExternalTrackParam(*fIp));
2532 if (fOp) arrayRef.AddLast(new AliExternalTrackParam(*fOp));
c38d443f 2533 if (fHMPIDp) arrayRef.AddLast(new AliExternalTrackParam(*fHMPIDp));
0c19adf7 2534 //
2535 Double_t mpos[3]={0,0,0};
2536 Int_t entries=arrayRef.GetEntries();
ddfbc51a 2537 for (Int_t i=0;i<entries;i++){
0c19adf7 2538 Double_t pos[3];
2539 ((AliExternalTrackParam*)arrayRef.At(i))->GetXYZ(pos);
2540 mpos[0]+=pos[0]/entries;
2541 mpos[1]+=pos[1]/entries;
2542 mpos[2]+=pos[2]/entries;
2543 }
2544 // Rotate to the mean position
2545 //
2546 Float_t fi= TMath::ATan2(mpos[1],mpos[0]);
2547 for (Int_t i=0;i<entries;i++){
2548 Bool_t res = ((AliExternalTrackParam*)arrayRef.At(i))->Rotate(fi);
2549 if (!res) delete arrayRef.RemoveAt(i);
2550 }
2551 Int_t counter=0;
2552 for (Double_t r=minR; r<maxR; r+=stepR){
2553 Double_t sweight=0;
2554 Double_t mlpos[3]={0,0,0};
2555 for (Int_t i=0;i<entries;i++){
2556 Double_t point[3]={0,0,0};
2557 AliExternalTrackParam *param = ((AliExternalTrackParam*)arrayRef.At(i));
2558 if (!param) continue;
2559 if (param->GetXYZAt(r,magF,point)){
2560 Double_t weight = 1./(10.+(r-param->GetX())*(r-param->GetX()));
2561 sweight+=weight;
2562 mlpos[0]+=point[0]*weight;
2563 mlpos[1]+=point[1]*weight;
2564 mlpos[2]+=point[2]*weight;
2565 }
2566 }
2567 if (sweight>0){
2568 mlpos[0]/=sweight;
2569 mlpos[1]/=sweight;
2570 mlpos[2]/=sweight;
2571 pol->SetPoint(counter,mlpos[0],mlpos[1], mlpos[2]);
047640da 2572 // printf("xyz\t%f\t%f\t%f\n",mlpos[0], mlpos[1],mlpos[2]);
0c19adf7 2573 counter++;
2574 }
2575 }
2576}
1d4882da 2577
2578//_______________________________________________________________________
2579void AliESDtrack::SetITSdEdxSamples(const Double_t s[4]) {
2580 //
2581 // Store the dE/dx samples measured by the two SSD and two SDD layers.
2582 // These samples are corrected for the track segment length.
2583 //
ddfbc51a 2584 for (Int_t i=0; i<4; i++) fITSdEdxSamples[i]=s[i];
1d4882da 2585}
2586
2587//_______________________________________________________________________
74ca66e3 2588void AliESDtrack::GetITSdEdxSamples(Double_t s[4]) const {
1d4882da 2589 //
2590 // Get the dE/dx samples measured by the two SSD and two SDD layers.
2591 // These samples are corrected for the track segment length.
2592 //
ddfbc51a 2593 for (Int_t i=0; i<4; i++) s[i]=fITSdEdxSamples[i];
1d4882da 2594}
949840f6 2595
2596
2597UShort_t AliESDtrack::GetTPCnclsS(Int_t i0,Int_t i1) const{
2598 //
beb01154 2599 // get number of shared TPC clusters
949840f6 2600 //
2601 return fTPCSharedMap.CountBits(i0)-fTPCSharedMap.CountBits(i1);
2602}
beb01154 2603
2604UShort_t AliESDtrack::GetTPCncls(Int_t i0,Int_t i1) const{
2605 //
2606 // get number of TPC clusters
2607 //
2608 return fTPCClusterMap.CountBits(i0)-fTPCClusterMap.CountBits(i1);
2609}
4c3dc2a0 2610
2611//____________________________________________________________________
2612Double_t AliESDtrack::GetChi2TPCConstrainedVsGlobal(const AliESDVertex* vtx) const
2613{
2614 // Calculates the chi2 between the TPC track (TPCinner) constrained to the primary vertex and the global track
2615 //
2616 // Returns -1 in case the calculation failed
2617 //
2618 // Value is cached as a non-persistent member.
2619 //
2620 // Code adapted from original code by GSI group (Jacek, Marian, Michael)
2621
2622 // cache, ignoring that a different vertex might be passed
2623 if (fCacheChi2TPCConstrainedVsGlobalVertex == vtx)
2624 return fCacheChi2TPCConstrainedVsGlobal;
2625
2626 fCacheChi2TPCConstrainedVsGlobal = -1;
2627 fCacheChi2TPCConstrainedVsGlobalVertex = vtx;
2628
2629 Double_t x[3];
2630 GetXYZ(x);
2631 Double_t b[3];
2632 AliTrackerBase::GetBxByBz(x,b);
2633
2634 if (!fTPCInner) {
2635 AliWarning("Could not get TPC Inner Param.");
2636 return fCacheChi2TPCConstrainedVsGlobal;
2637 }
2638
2639 // clone for constraining
ddfbc51a 2640 AliExternalTrackParam* tpcInnerC = new AliExternalTrackParam(*fTPCInner);
2641 if (!tpcInnerC) {
2642 AliWarning("Clone of TPCInnerParam failed.");
2643 return fCacheChi2TPCConstrainedVsGlobal;
2644 }
4c3dc2a0 2645
2646 // transform to the track reference frame
ddfbc51a 2647 Bool_t isOK = tpcInnerC->Rotate(GetAlpha());
2648 isOK &= tpcInnerC->PropagateTo(GetX(), b[2]);
4c3dc2a0 2649 if (!isOK) {
ddfbc51a 2650 delete tpcInnerC;
2651 tpcInnerC = 0;
4c3dc2a0 2652 AliWarning("Rotation/Propagation of track failed.") ;
2653 return fCacheChi2TPCConstrainedVsGlobal;
2654 }
2655
2656 // constrain TPCinner
ddfbc51a 2657 isOK = tpcInnerC->ConstrainToVertex(vtx, b);
4c3dc2a0 2658
2659 // transform to the track reference frame
ddfbc51a 2660 isOK &= tpcInnerC->Rotate(GetAlpha());
2661 isOK &= tpcInnerC->PropagateTo(GetX(), b[2]);
4c3dc2a0 2662
2663 if (!isOK) {
2664 AliWarning("ConstrainTPCInner failed.") ;
ddfbc51a 2665 delete tpcInnerC;
2666 tpcInnerC = 0;
4c3dc2a0 2667 return fCacheChi2TPCConstrainedVsGlobal;
2668 }
2669
2670 // calculate chi2 between vi and vj vectors
2671 // with covi and covj covariance matrices
2672 // chi2ij = (vi-vj)^(T)*(covi+covj)^(-1)*(vi-vj)
2673 TMatrixD deltaT(5,1);
2674 TMatrixD delta(1,5);
2675 TMatrixD covarM(5,5);
2676
ddfbc51a 2677 for (Int_t ipar=0; ipar<5; ipar++) {
2678 deltaT(ipar,0) = tpcInnerC->GetParameter()[ipar] - GetParameter()[ipar];
2679 delta(0,ipar) = tpcInnerC->GetParameter()[ipar] - GetParameter()[ipar];
4c3dc2a0 2680
2681 for (Int_t jpar=0; jpar<5; jpar++) {
2682 Int_t index = GetIndex(ipar,jpar);
ddfbc51a 2683 covarM(ipar,jpar) = GetCovariance()[index]+tpcInnerC->GetCovariance()[index];
4c3dc2a0 2684 }
2685 }
2686 // chi2 distance TPC constrained and TPC+ITS
2687 TMatrixD covarMInv = covarM.Invert();
2688 TMatrixD mat2 = covarMInv*deltaT;
2689 TMatrixD chi2 = delta*mat2;
ddfbc51a 2690
2691 delete tpcInnerC;
2692 tpcInnerC = 0;
2693
4c3dc2a0 2694 fCacheChi2TPCConstrainedVsGlobal = chi2(0,0);
2695 return fCacheChi2TPCConstrainedVsGlobal;
2696}
00a38d07 2697
2698void AliESDtrack::SetDetectorPID(const AliDetectorPID *pid)
2699{
2700 //
2701 // Set the detector PID
2702 //
2703 if (fDetectorPID) delete fDetectorPID;
2704 fDetectorPID=pid;
2705
2706}