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