]> 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
Mods in GetTOFBunchCrossing to account for new way of PID for tracking and TOF signal...
[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"
73178f8a 132#include "TTreeStream.h"
115179c6 133#include "TObjArray.h"
ae982df3 134
135ClassImp(AliESDtrack)
136
562dd0b4 137void SetPIDValues(Double_t * dest, const Double_t * src, Int_t n) {
d27bbc79 138 // This function copies "n" PID weights from "scr" to "dest"
139 // and normalizes their sum to 1 thus producing conditional probabilities.
140 // The negative weights are set to 0.
141 // In case all the weights are non-positive they are replaced by
142 // uniform probabilities
143
144 if (n<=0) return;
145
146 Float_t uniform = 1./(Float_t)n;
147
148 Float_t sum = 0;
149 for (Int_t i=0; i<n; i++)
150 if (src[i]>=0) {
151 sum+=src[i];
152 dest[i] = src[i];
153 }
154 else {
155 dest[i] = 0;
156 }
157
158 if(sum>0)
159 for (Int_t i=0; i<n; i++) dest[i] /= sum;
160 else
161 for (Int_t i=0; i<n; i++) dest[i] = uniform;
162}
163
ae982df3 164//_______________________________________________________________________
165AliESDtrack::AliESDtrack() :
c9ec41e8 166 AliExternalTrackParam(),
562dd0b4 167 fCp(0),
168 fIp(0),
169 fTPCInner(0),
170 fOp(0),
c38d443f 171 fHMPIDp(0),
59c31692 172 fFriendTrack(NULL),
9f638f03 173 fTPCFitMap(159),//number of padrows
562dd0b4 174 fTPCClusterMap(159),//number of padrows
175 fTPCSharedMap(159),//number of padrows
90e48c0c 176 fFlags(0),
90e48c0c 177 fID(0),
562dd0b4 178 fLabel(0),
179 fITSLabel(0),
180 fTPCLabel(0),
181 fTRDLabel(0),
115179c6 182 fTOFLabel(NULL),
ab37ab1e 183 fTOFCalChannel(-1),
ce3f4882 184 fTOFindex(-1),
562dd0b4 185 fHMPIDqn(0),
81aa7a0d 186 fHMPIDcluIdx(-1),
f1cedef3 187 fCaloIndex(kEMCALNoMatch),
a3314882 188 fR(0),
189 fITSr(0),
190 fTPCr(0),
191 fTRDr(0),
192 fTOFr(0),
193 fHMPIDr(0),
562dd0b4 194 fHMPIDtrkTheta(0),
195 fHMPIDtrkPhi(0),
196 fHMPIDsignal(0),
115179c6 197 fTrackTime(0),
90e48c0c 198 fTrackLength(0),
d7ddf1e9 199 fdTPC(0),fzTPC(0),
200 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
436dfe39 201 fCchi2TPC(0),
49d13e89 202 fD(0),fZ(0),
203 fCdd(0),fCdz(0),fCzz(0),
562dd0b4 204 fCchi2(0),
90e48c0c 205 fITSchi2(0),
90e48c0c 206 fTPCchi2(0),
949840f6 207 fTPCchi2Iter1(0),
562dd0b4 208 fTRDchi2(0),
209 fTOFchi2(0),
210 fHMPIDchi2(0),
b5b2b4db 211 fGlobalChi2(0),
562dd0b4 212 fITSsignal(0),
90e48c0c 213 fTPCsignal(0),
539a5a59 214 fTPCsignalTuned(0),
e1d4c1b5 215 fTPCsignalS(0),
40b4e5ea 216 fTPCdEdxInfo(0),
90e48c0c 217 fTRDsignal(0),
90e48c0c 218 fTRDQuality(0),
23d49657 219 fTRDBudget(0),
ab37ab1e 220 fTOFsignal(99999),
a2c30af1 221 fTOFsignalTuned(99999),
ab37ab1e 222 fTOFsignalToT(99999),
223 fTOFsignalRaw(99999),
224 fTOFsignalDz(999),
225 fTOFsignalDx(999),
226 fTOFdeltaBC(999),
227 fTOFl0l1(999),
f1cedef3 228 fCaloDx(0),
229 fCaloDz(0),
562dd0b4 230 fHMPIDtrkX(0),
231 fHMPIDtrkY(0),
232 fHMPIDmipX(0),
233 fHMPIDmipY(0),
234 fTPCncls(0),
235 fTPCnclsF(0),
236 fTPCsignalN(0),
949840f6 237 fTPCnclsIter1(0),
238 fTPCnclsFIter1(0),
562dd0b4 239 fITSncls(0),
240 fITSClusterMap(0),
25015f7a 241 fITSSharedMap(0),
562dd0b4 242 fTRDncls(0),
243 fTRDncls0(0),
ed15ef4f 244 fTRDntracklets(0),
4d302e42 245 fTRDNchamberdEdx(0),
246 fTRDNclusterdEdx(0),
6984f7c1 247 fTRDnSlices(0),
6dc21f57 248 fTRDslices(0x0),
95621324 249 fVertexID(-2),// -2 means an orphan track
a3314882 250 fPIDForTracking(AliPID::kPion),
4c3dc2a0 251 fESDEvent(0),
252 fCacheNCrossedRows(-10),
253 fCacheChi2TPCConstrainedVsGlobal(-10),
ed15417e 254 fCacheChi2TPCConstrainedVsGlobalVertex(0),
00a38d07 255 fDetectorPID(0x0),
ed15417e 256 fTrackPhiOnEMCal(-999),
a29b2a8a 257 fTrackEtaOnEMCal(-999),
115179c6 258 fTrackPtOnEMCal(-999),
259 fNtofClusters(0),
260 fTOFcluster(NULL)
ae982df3 261{
262 //
263 // The default ESD constructor
264 //
ddfbc51a 265 if (!OnlineMode()) fFriendTrack=new AliESDfriendTrack();
266
267 Int_t i;
268 for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
ac2f7574 269
ddfbc51a 270 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
271 for (i=0; i<3; i++) { fV0Indexes[i]=0;}
272 for (i=0;i<kTRDnPlanes;i++) {
273 fTRDTimBin[i]=0;
274 }
275 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
276 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
ddfbc51a 277 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
278 for (i=0;i<12;i++) {fITSModule[i]=-1;}
c4d11b15 279}
280
59c31692 281bool AliESDtrack::fgkOnlineMode=false;
282
c4d11b15 283//_______________________________________________________________________
90e48c0c 284AliESDtrack::AliESDtrack(const AliESDtrack& track):
c9ec41e8 285 AliExternalTrackParam(track),
562dd0b4 286 fCp(0),
287 fIp(0),
288 fTPCInner(0),
289 fOp(0),
c38d443f 290 fHMPIDp(0),
562dd0b4 291 fFriendTrack(0),
9f638f03 292 fTPCFitMap(track.fTPCFitMap),
562dd0b4 293 fTPCClusterMap(track.fTPCClusterMap),
294 fTPCSharedMap(track.fTPCSharedMap),
90e48c0c 295 fFlags(track.fFlags),
90e48c0c 296 fID(track.fID),
562dd0b4 297 fLabel(track.fLabel),
298 fITSLabel(track.fITSLabel),
299 fTPCLabel(track.fTPCLabel),
300 fTRDLabel(track.fTRDLabel),
115179c6 301 fTOFLabel(NULL),
562dd0b4 302 fTOFCalChannel(track.fTOFCalChannel),
303 fTOFindex(track.fTOFindex),
304 fHMPIDqn(track.fHMPIDqn),
305 fHMPIDcluIdx(track.fHMPIDcluIdx),
f1cedef3 306 fCaloIndex(track.fCaloIndex),
a3314882 307 fR(0),
308 fITSr(0),
309 fTPCr(0),
310 fTRDr(0),
311 fTOFr(0),
312 fHMPIDr(0),
562dd0b4 313 fHMPIDtrkTheta(track.fHMPIDtrkTheta),
314 fHMPIDtrkPhi(track.fHMPIDtrkPhi),
315 fHMPIDsignal(track.fHMPIDsignal),
115179c6 316 fTrackTime(NULL),
90e48c0c 317 fTrackLength(track.fTrackLength),
d7ddf1e9 318 fdTPC(track.fdTPC),fzTPC(track.fzTPC),
319 fCddTPC(track.fCddTPC),fCdzTPC(track.fCdzTPC),fCzzTPC(track.fCzzTPC),
436dfe39 320 fCchi2TPC(track.fCchi2TPC),
49d13e89 321 fD(track.fD),fZ(track.fZ),
322 fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
90e48c0c 323 fCchi2(track.fCchi2),
90e48c0c 324 fITSchi2(track.fITSchi2),
90e48c0c 325 fTPCchi2(track.fTPCchi2),
949840f6 326 fTPCchi2Iter1(track.fTPCchi2Iter1),
562dd0b4 327 fTRDchi2(track.fTRDchi2),
328 fTOFchi2(track.fTOFchi2),
329 fHMPIDchi2(track.fHMPIDchi2),
b5b2b4db 330 fGlobalChi2(track.fGlobalChi2),
562dd0b4 331 fITSsignal(track.fITSsignal),
90e48c0c 332 fTPCsignal(track.fTPCsignal),
539a5a59 333 fTPCsignalTuned(track.fTPCsignalTuned),
e1d4c1b5 334 fTPCsignalS(track.fTPCsignalS),
40b4e5ea 335 fTPCdEdxInfo(0),
90e48c0c 336 fTRDsignal(track.fTRDsignal),
90e48c0c 337 fTRDQuality(track.fTRDQuality),
23d49657 338 fTRDBudget(track.fTRDBudget),
90e48c0c 339 fTOFsignal(track.fTOFsignal),
a2c30af1 340 fTOFsignalTuned(track.fTOFsignalTuned),
85324138 341 fTOFsignalToT(track.fTOFsignalToT),
d321691a 342 fTOFsignalRaw(track.fTOFsignalRaw),
343 fTOFsignalDz(track.fTOFsignalDz),
a5d9ff0f 344 fTOFsignalDx(track.fTOFsignalDx),
d86081b1 345 fTOFdeltaBC(track.fTOFdeltaBC),
346 fTOFl0l1(track.fTOFl0l1),
f1cedef3 347 fCaloDx(track.fCaloDx),
348 fCaloDz(track.fCaloDz),
f4b3bbb7 349 fHMPIDtrkX(track.fHMPIDtrkX),
350 fHMPIDtrkY(track.fHMPIDtrkY),
351 fHMPIDmipX(track.fHMPIDmipX),
352 fHMPIDmipY(track.fHMPIDmipY),
562dd0b4 353 fTPCncls(track.fTPCncls),
354 fTPCnclsF(track.fTPCnclsF),
355 fTPCsignalN(track.fTPCsignalN),
949840f6 356 fTPCnclsIter1(track.fTPCnclsIter1),
357 fTPCnclsFIter1(track.fTPCnclsIter1),
562dd0b4 358 fITSncls(track.fITSncls),
359 fITSClusterMap(track.fITSClusterMap),
25015f7a 360 fITSSharedMap(track.fITSSharedMap),
562dd0b4 361 fTRDncls(track.fTRDncls),
362 fTRDncls0(track.fTRDncls0),
ed15ef4f 363 fTRDntracklets(track.fTRDntracklets),
4d302e42 364 fTRDNchamberdEdx(track.fTRDNchamberdEdx),
365 fTRDNclusterdEdx(track.fTRDNclusterdEdx),
6984f7c1 366 fTRDnSlices(track.fTRDnSlices),
6dc21f57 367 fTRDslices(0x0),
95621324 368 fVertexID(track.fVertexID),
a3314882 369 fPIDForTracking(AliPID::kPion),
4c3dc2a0 370 fESDEvent(track.fESDEvent),
371 fCacheNCrossedRows(track.fCacheNCrossedRows),
372 fCacheChi2TPCConstrainedVsGlobal(track.fCacheChi2TPCConstrainedVsGlobal),
ed15417e 373 fCacheChi2TPCConstrainedVsGlobalVertex(track.fCacheChi2TPCConstrainedVsGlobalVertex),
00a38d07 374 fDetectorPID(0x0),
ed15417e 375 fTrackPhiOnEMCal(track.fTrackPhiOnEMCal),
a29b2a8a 376 fTrackEtaOnEMCal(track.fTrackEtaOnEMCal),
115179c6 377 fTrackPtOnEMCal(track.fTrackPtOnEMCal),
378 fNtofClusters(track.fNtofClusters),
379 fTOFcluster(NULL)
90e48c0c 380{
c4d11b15 381 //
382 //copy constructor
383 //
96a46057 384 for (Int_t i=kNITSchi2Std;i--;) fITSchi2Std[i] = track.fITSchi2Std[i];
115179c6 385
386 if(track.fTrackTime){
387 fTrackTime = new Double32_t[AliPID::kSPECIESC];
388 for (Int_t i=0;i<AliPID::kSPECIESC;i++) fTrackTime[i]=track.fTrackTime[i];
389 }
390
a3314882 391 if (track.fR) {
392 fR = new Double32_t[AliPID::kSPECIES];
393 for (Int_t i=AliPID::kSPECIES;i--;) fR[i]=track.fR[i];
394 }
395 if (track.fITSr) {
396 fITSr = new Double32_t[AliPID::kSPECIES];
397 for (Int_t i=AliPID::kSPECIES;i--;) fITSr[i]=track.fITSr[i];
398 }
c4d11b15 399 //
a3314882 400 if (track.fTPCr) {
401 fTPCr = new Double32_t[AliPID::kSPECIES];
402 for (Int_t i=AliPID::kSPECIES;i--;) fTPCr[i]=track.fTPCr[i];
403 }
404
ddfbc51a 405 for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=track.fITSdEdxSamples[i];}
406 for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
407 for (Int_t i=0; i<3;i++) { fKinkIndexes[i]=track.fKinkIndexes[i];}
408 for (Int_t i=0; i<3;i++) { fV0Indexes[i]=track.fV0Indexes[i];}
e546b023 409 //
ddfbc51a 410 for (Int_t i=0;i<kTRDnPlanes;i++) {
411 fTRDTimBin[i]=track.fTRDTimBin[i];
6984f7c1 412 }
413
ddfbc51a 414 if (fTRDnSlices) {
415 fTRDslices=new Double32_t[fTRDnSlices];
416 for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=track.fTRDslices[i];
e546b023 417 }
ddfbc51a 418
00a38d07 419 if (track.fDetectorPID) fDetectorPID = new AliDetectorPID(*track.fDetectorPID);
ddfbc51a 420
a3314882 421 if (track.fTRDr) {
422 fTRDr = new Double32_t[AliPID::kSPECIES];
423 for (Int_t i=AliPID::kSPECIES;i--;) fTRDr[i]=track.fTRDr[i];
424 }
425
426 if (track.fTOFr) {
427 fTOFr = new Double32_t[AliPID::kSPECIES];
428 for (Int_t i=AliPID::kSPECIES;i--;) fTOFr[i]=track.fTOFr[i];
429 }
430
115179c6 431 if(track.fTOFLabel){
432 if(!fTOFLabel) fTOFLabel = new Int_t[3];
433 for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
434 }
435
ddfbc51a 436 for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
437 for (Int_t i=0;i<12;i++) fITSModule[i]=track.fITSModule[i];
a3314882 438
439 if (track.fHMPIDr) {
440 fHMPIDr = new Double32_t[AliPID::kSPECIES];
441 for (Int_t i=AliPID::kSPECIES;i--;) fHMPIDr[i]=track.fHMPIDr[i];
442 }
ddfbc51a 443
444 if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
445 if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
446 if (track.fTPCInner) fTPCInner=new AliExternalTrackParam(*track.fTPCInner);
447 if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
448 if (track.fHMPIDp) fHMPIDp=new AliExternalTrackParam(*track.fHMPIDp);
449 if (track.fTPCdEdxInfo) fTPCdEdxInfo = new AliTPCdEdxInfo(*track.fTPCdEdxInfo);
450
451
452 if (track.fFriendTrack) fFriendTrack=new AliESDfriendTrack(*(track.fFriendTrack));
115179c6 453
454 if(fNtofClusters > 0){
455 fTOFcluster = new Int_t[fNtofClusters];
456 for(Int_t i=0;i < fNtofClusters;i++) fTOFcluster[i] = track.fTOFcluster[i];
457 }
ae982df3 458}
15e85efa 459
4f6e22bd 460//_______________________________________________________________________
461AliESDtrack::AliESDtrack(const AliVTrack *track) :
462 AliExternalTrackParam(track),
463 fCp(0),
464 fIp(0),
465 fTPCInner(0),
466 fOp(0),
c38d443f 467 fHMPIDp(0),
4f6e22bd 468 fFriendTrack(0),
9f638f03 469 fTPCFitMap(159),//number of padrows
4f6e22bd 470 fTPCClusterMap(159),//number of padrows
471 fTPCSharedMap(159),//number of padrows
472 fFlags(0),
473 fID(),
474 fLabel(0),
475 fITSLabel(0),
476 fTPCLabel(0),
477 fTRDLabel(0),
115179c6 478 fTOFLabel(NULL),
ab37ab1e 479 fTOFCalChannel(-1),
4f6e22bd 480 fTOFindex(-1),
481 fHMPIDqn(0),
81aa7a0d 482 fHMPIDcluIdx(-1),
f1cedef3 483 fCaloIndex(kEMCALNoMatch),
a3314882 484 fR(0),
485 fITSr(0),
486 fTPCr(0),
487 fTRDr(0),
488 fTOFr(0),
489 fHMPIDr(0),
4f6e22bd 490 fHMPIDtrkTheta(0),
491 fHMPIDtrkPhi(0),
492 fHMPIDsignal(0),
115179c6 493 fTrackTime(NULL),
4f6e22bd 494 fTrackLength(0),
495 fdTPC(0),fzTPC(0),
496 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
497 fCchi2TPC(0),
498 fD(0),fZ(0),
499 fCdd(0),fCdz(0),fCzz(0),
500 fCchi2(0),
501 fITSchi2(0),
502 fTPCchi2(0),
949840f6 503 fTPCchi2Iter1(0),
4f6e22bd 504 fTRDchi2(0),
505 fTOFchi2(0),
506 fHMPIDchi2(0),
b5b2b4db 507 fGlobalChi2(0),
4f6e22bd 508 fITSsignal(0),
509 fTPCsignal(0),
539a5a59 510 fTPCsignalTuned(0),
4f6e22bd 511 fTPCsignalS(0),
40b4e5ea 512 fTPCdEdxInfo(0),
4f6e22bd 513 fTRDsignal(0),
514 fTRDQuality(0),
515 fTRDBudget(0),
ab37ab1e 516 fTOFsignal(99999),
a2c30af1 517 fTOFsignalTuned(99999),
ab37ab1e 518 fTOFsignalToT(99999),
519 fTOFsignalRaw(99999),
520 fTOFsignalDz(999),
521 fTOFsignalDx(999),
522 fTOFdeltaBC(999),
523 fTOFl0l1(999),
f1cedef3 524 fCaloDx(0),
525 fCaloDz(0),
4f6e22bd 526 fHMPIDtrkX(0),
527 fHMPIDtrkY(0),
528 fHMPIDmipX(0),
529 fHMPIDmipY(0),
530 fTPCncls(0),
531 fTPCnclsF(0),
532 fTPCsignalN(0),
949840f6 533 fTPCnclsIter1(0),
534 fTPCnclsFIter1(0),
4f6e22bd 535 fITSncls(0),
536 fITSClusterMap(0),
25015f7a 537 fITSSharedMap(0),
4f6e22bd 538 fTRDncls(0),
539 fTRDncls0(0),
ed15ef4f 540 fTRDntracklets(0),
4d302e42 541 fTRDNchamberdEdx(0),
542 fTRDNclusterdEdx(0),
4f6e22bd 543 fTRDnSlices(0),
6dc21f57 544 fTRDslices(0x0),
95621324 545 fVertexID(-2), // -2 means an orphan track
a3314882 546 fPIDForTracking(track->GetPIDForTracking()),
4c3dc2a0 547 fESDEvent(0),
548 fCacheNCrossedRows(-10),
549 fCacheChi2TPCConstrainedVsGlobal(-10),
ed15417e 550 fCacheChi2TPCConstrainedVsGlobalVertex(0),
00a38d07 551 fDetectorPID(0x0),
ed15417e 552 fTrackPhiOnEMCal(-999),
a29b2a8a 553 fTrackEtaOnEMCal(-999),
115179c6 554 fTrackPtOnEMCal(-999),
555 fNtofClusters(0),
556 fTOFcluster(NULL)
4f6e22bd 557{
558 //
610e3088 559 // ESD track from AliVTrack.
560 // This is not a copy constructor !
4f6e22bd 561 //
562
610e3088 563 if (track->InheritsFrom("AliExternalTrackParam")) {
564 AliError("This is not a copy constructor. Use AliESDtrack(const AliESDtrack &) !");
565 AliWarning("Calling the default constructor...");
566 AliESDtrack();
567 return;
568 }
569
4f6e22bd 570 // Reset all the arrays
ddfbc51a 571 Int_t i;
572 for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
4f6e22bd 573
ddfbc51a 574 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
575 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
576 for (i=0;i<kTRDnPlanes;i++) {
577 fTRDTimBin[i]=0;
578 }
579 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
580 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
ddfbc51a 581 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
582 for (i=0;i<12;i++) {fITSModule[i]=-1;}
4f6e22bd 583
4f6e22bd 584
585 // Set ITS cluster map
586 fITSClusterMap=track->GetITSClusterMap();
25015f7a 587 fITSSharedMap=0;
4f6e22bd 588
d577eec9 589 fITSncls=0;
ddfbc51a 590 for(i=0; i<6; i++) {
591 if(HasPointOnITSLayer(i)) fITSncls++;
592 }
593
07cc7a48 594 // Set TPC ncls
595 fTPCncls=track->GetTPCNcls();
74ca66e3 596 fTPCnclsF=track->GetTPCNclsF();
597 // TPC cluster maps
598 const TBits* bmap = track->GetTPCClusterMapPtr();
599 if (bmap) SetTPCClusterMap(*bmap);
600 bmap = GetTPCFitMapPtr();
601 if (bmap) SetTPCFitMap(*bmap);
602 bmap = GetTPCSharedMapPtr();
603 if (bmap) SetTPCSharedMap(*bmap);
604 //
4f6e22bd 605 // Set the combined PID
606 const Double_t *pid = track->PID();
a3314882 607 if(pid) {
608 fR = new Double32_t[AliPID::kSPECIES];
609 for (i=AliPID::kSPECIES; i--;) fR[i]=pid[i];
610 }
74ca66e3 611 //
612 // calo matched cluster id
613 SetEMCALcluster(track->GetEMCALcluster());
4f6e22bd 614 // AliESD track label
74ca66e3 615 //
616 // PID info
617 fITSsignal = track->GetITSsignal();
618 double itsdEdx[4];
619 track->GetITSdEdxSamples(itsdEdx);
620 SetITSdEdxSamples(itsdEdx);
621 //
be20337a 622 SetTPCsignal(track->GetTPCsignal(),fTPCsignalS,track->GetTPCsignalN()); // No signalS in AODPi
623 AliTPCdEdxInfo * dEdxInfo = track->GetTPCdEdxInfo();
624 if (dEdxInfo) SetTPCdEdxInfo(new AliTPCdEdxInfo(*dEdxInfo));
74ca66e3 625 //
6736efd5 626 SetTRDsignal(track->GetTRDsignal());
de8b2440 627 int ntrdsl = track->GetNumberOfTRDslices();
628 if (ntrdsl>0) {
be20337a 629 SetNumberOfTRDslices((ntrdsl+2)*kTRDnPlanes);
de8b2440 630 for (int ipl=kTRDnPlanes;ipl--;){
631 for (int isl=ntrdsl;isl--;) SetTRDslice(track->GetTRDslice(ipl,isl),ipl,isl);
632 Double_t sp, p = track->GetTRDmomentum(ipl, &sp);
633 SetTRDmomentum(p, ipl, &sp);
634 }
74ca66e3 635 }
636 //
637 fTRDncls = track->GetTRDncls();
638 fTRDntracklets &= 0xff & track->GetTRDntrackletsPID();
639 fTRDchi2 = track->GetTRDchi2();
640 //
641 SetTOFsignal(track->GetTOFsignal());
115179c6 642 Double_t expt[AliPID::kSPECIESC];
fc9b31a7 643 track->GetIntegratedTimes(expt,AliPID::kSPECIESC);
74ca66e3 644 SetIntegratedTimes(expt);
645 //
a29b2a8a 646 SetTrackPhiEtaPtOnEMCal(track->GetTrackPhiOnEMCal(),track->GetTrackEtaOnEMCal(),track->GetTrackPtOnEMCal());
74ca66e3 647 //
4f6e22bd 648 SetLabel(track->GetLabel());
39ca41b3 649 // Set the status
650 SetStatus(track->GetStatus());
49436743 651 //
652 // Set the ID
653 SetID(track->GetID());
654 //
4f6e22bd 655}
656
49edfa08 657//_______________________________________________________________________
658AliESDtrack::AliESDtrack(TParticle * part) :
659 AliExternalTrackParam(),
562dd0b4 660 fCp(0),
661 fIp(0),
662 fTPCInner(0),
663 fOp(0),
c38d443f 664 fHMPIDp(0),
562dd0b4 665 fFriendTrack(0),
9f638f03 666 fTPCFitMap(159),//number of padrows
562dd0b4 667 fTPCClusterMap(159),//number of padrows
668 fTPCSharedMap(159),//number of padrows
49edfa08 669 fFlags(0),
49edfa08 670 fID(0),
562dd0b4 671 fLabel(0),
672 fITSLabel(0),
673 fTPCLabel(0),
674 fTRDLabel(0),
115179c6 675 fTOFLabel(NULL),
ab37ab1e 676 fTOFCalChannel(-1),
ce3f4882 677 fTOFindex(-1),
562dd0b4 678 fHMPIDqn(0),
81aa7a0d 679 fHMPIDcluIdx(-1),
f1cedef3 680 fCaloIndex(kEMCALNoMatch),
a3314882 681 fR(0),
682 fITSr(0),
683 fTPCr(0),
684 fTRDr(0),
685 fTOFr(0),
686 fHMPIDr(0),
562dd0b4 687 fHMPIDtrkTheta(0),
688 fHMPIDtrkPhi(0),
689 fHMPIDsignal(0),
115179c6 690 fTrackTime(NULL),
49edfa08 691 fTrackLength(0),
d7ddf1e9 692 fdTPC(0),fzTPC(0),
693 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
436dfe39 694 fCchi2TPC(0),
49edfa08 695 fD(0),fZ(0),
696 fCdd(0),fCdz(0),fCzz(0),
562dd0b4 697 fCchi2(0),
49edfa08 698 fITSchi2(0),
49edfa08 699 fTPCchi2(0),
949840f6 700 fTPCchi2Iter1(0),
562dd0b4 701 fTRDchi2(0),
702 fTOFchi2(0),
703 fHMPIDchi2(0),
b5b2b4db 704 fGlobalChi2(0),
562dd0b4 705 fITSsignal(0),
49edfa08 706 fTPCsignal(0),
539a5a59 707 fTPCsignalTuned(0),
49edfa08 708 fTPCsignalS(0),
40b4e5ea 709 fTPCdEdxInfo(0),
49edfa08 710 fTRDsignal(0),
49edfa08 711 fTRDQuality(0),
712 fTRDBudget(0),
ab37ab1e 713 fTOFsignal(99999),
a2c30af1 714 fTOFsignalTuned(99999),
ab37ab1e 715 fTOFsignalToT(99999),
716 fTOFsignalRaw(99999),
717 fTOFsignalDz(999),
718 fTOFsignalDx(999),
719 fTOFdeltaBC(999),
720 fTOFl0l1(999),
f1cedef3 721 fCaloDx(0),
722 fCaloDz(0),
562dd0b4 723 fHMPIDtrkX(0),
724 fHMPIDtrkY(0),
725 fHMPIDmipX(0),
726 fHMPIDmipY(0),
727 fTPCncls(0),
728 fTPCnclsF(0),
729 fTPCsignalN(0),
949840f6 730 fTPCnclsIter1(0),
731 fTPCnclsFIter1(0),
562dd0b4 732 fITSncls(0),
733 fITSClusterMap(0),
25015f7a 734 fITSSharedMap(0),
562dd0b4 735 fTRDncls(0),
736 fTRDncls0(0),
ed15ef4f 737 fTRDntracklets(0),
4d302e42 738 fTRDNchamberdEdx(0),
739 fTRDNclusterdEdx(0),
6984f7c1 740 fTRDnSlices(0),
6dc21f57 741 fTRDslices(0x0),
95621324 742 fVertexID(-2), // -2 means an orphan track
a3314882 743 fPIDForTracking(AliPID::kPion),
4c3dc2a0 744 fESDEvent(0),
745 fCacheNCrossedRows(-10),
746 fCacheChi2TPCConstrainedVsGlobal(-10),
ed15417e 747 fCacheChi2TPCConstrainedVsGlobalVertex(0),
00a38d07 748 fDetectorPID(0x0),
ed15417e 749 fTrackPhiOnEMCal(-999),
a29b2a8a 750 fTrackEtaOnEMCal(-999),
115179c6 751 fTrackPtOnEMCal(-999),
752 fNtofClusters(0),
753 fTOFcluster(NULL)
49edfa08 754{
755 //
756 // ESD track from TParticle
757 //
758
759 // Reset all the arrays
ddfbc51a 760 Int_t i;
761 for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
49edfa08 762
ddfbc51a 763 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
764 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
765 for (i=0;i<kTRDnPlanes;i++) {
766 fTRDTimBin[i]=0;
767 }
768 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
769 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
ddfbc51a 770 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
771 for (i=0;i<12;i++) {fITSModule[i]=-1;}
49edfa08 772
773 // Calculate the AliExternalTrackParam content
774
775 Double_t xref;
776 Double_t alpha;
777 Double_t param[5];
778 Double_t covar[15];
779
780 // Calculate alpha: the rotation angle of the corresponding local system (TPC sector)
781 alpha = part->Phi()*180./TMath::Pi();
782 if (alpha<0) alpha+= 360.;
783 if (alpha>360) alpha -= 360.;
784
785 Int_t sector = (Int_t)(alpha/20.);
786 alpha = 10. + 20.*sector;
787 alpha /= 180;
788 alpha *= TMath::Pi();
789
790 // Covariance matrix: no errors, the parameters are exact
ddfbc51a 791 for (i=0; i<15; i++) covar[i]=0.;
49edfa08 792
793 // Get the vertex of origin and the momentum
794 TVector3 ver(part->Vx(),part->Vy(),part->Vz());
795 TVector3 mom(part->Px(),part->Py(),part->Pz());
796
797 // Rotate to the local coordinate system (TPC sector)
798 ver.RotateZ(-alpha);
799 mom.RotateZ(-alpha);
800
801 // X of the referense plane
802 xref = ver.X();
803
804 Int_t pdgCode = part->GetPdgCode();
805
806 Double_t charge =
807 TDatabasePDG::Instance()->GetParticle(pdgCode)->Charge();
808
809 param[0] = ver.Y();
810 param[1] = ver.Z();
811 param[2] = TMath::Sin(mom.Phi());
812 param[3] = mom.Pz()/mom.Pt();
813 param[4] = TMath::Sign(1/mom.Pt(),charge);
814
815 // Set AliExternalTrackParam
816 Set(xref, alpha, param, covar);
817
818 // Set the PID
819 Int_t indexPID = 99;
1d26da6d 820 if (pdgCode<0) pdgCode = -pdgCode;
a3314882 821 for (i=0;i<AliPID::kSPECIESC;i++) if (pdgCode==AliPID::ParticleCode(i)) {indexPID = i; break;}
49edfa08 822
10d99e43 823 if (indexPID < AliPID::kSPECIESC) fPIDForTracking = indexPID;
49edfa08 824
49edfa08 825 // AliESD track label
826 SetLabel(part->GetUniqueID());
827
828}
829
c4d11b15 830//_______________________________________________________________________
831AliESDtrack::~AliESDtrack(){
832 //
833 // This is destructor according Coding Conventrions
834 //
835 //printf("Delete track\n");
ddfbc51a 836 delete fIp;
837 delete fTPCInner;
838 delete fOp;
839 delete fHMPIDp;
840 delete fCp;
7b2679d9 841 delete fFriendTrack;
842 delete fTPCdEdxInfo;
ddfbc51a 843 if(fTRDnSlices)
844 delete[] fTRDslices;
b5732bf0 845
846 //Reset cached values - needed for TClonesArray in AliESDInputHandler
847 fCacheNCrossedRows = -10.;
848 fCacheChi2TPCConstrainedVsGlobal = -10.;
849 if(fCacheChi2TPCConstrainedVsGlobalVertex) fCacheChi2TPCConstrainedVsGlobalVertex = 0;
850
115179c6 851 if(fTOFcluster)
852 delete[] fTOFcluster;
853 fTOFcluster = NULL;
854 fNtofClusters=0;
855
00a38d07 856 delete fDetectorPID;
115179c6 857
a3314882 858 delete[] fR;
859 delete[] fITSr;
860 delete[] fTPCr;
861 delete[] fTRDr;
862 delete[] fTOFr;
863 delete[] fHMPIDr;
864 //
115179c6 865 if(fTrackTime) delete[] fTrackTime;
866 if(fTOFLabel) delete[] fTOFLabel;
ddfbc51a 867}
868
a3314882 869//_______________________________________________________________________
870AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source)
871{
872 // == operator
732a24fe 873
874 if(&source == this) return *this;
875 AliExternalTrackParam::operator=(source);
876
ddfbc51a 877
878 if(source.fCp){
879 // we have the trackparam: assign or copy construct
880 if(fCp)*fCp = *source.fCp;
881 else fCp = new AliExternalTrackParam(*source.fCp);
732a24fe 882 }
ddfbc51a 883 else{
884 // no track param delete the old one
7b2679d9 885 delete fCp;
ddfbc51a 886 fCp = 0;
732a24fe 887 }
ddfbc51a 888
889 if(source.fIp){
890 // we have the trackparam: assign or copy construct
891 if(fIp)*fIp = *source.fIp;
892 else fIp = new AliExternalTrackParam(*source.fIp);
732a24fe 893 }
ddfbc51a 894 else{
895 // no track param delete the old one
7b2679d9 896 delete fIp;
ddfbc51a 897 fIp = 0;
732a24fe 898 }
ddfbc51a 899
900
901 if(source.fTPCInner){
902 // we have the trackparam: assign or copy construct
903 if(fTPCInner) *fTPCInner = *source.fTPCInner;
904 else fTPCInner = new AliExternalTrackParam(*source.fTPCInner);
732a24fe 905 }
ddfbc51a 906 else{
907 // no track param delete the old one
7b2679d9 908 delete fTPCInner;
ddfbc51a 909 fTPCInner = 0;
40b4e5ea 910 }
ddfbc51a 911
912 if(source.fTPCdEdxInfo) {
913 if(fTPCdEdxInfo) *fTPCdEdxInfo = *source.fTPCdEdxInfo;
914 fTPCdEdxInfo = new AliTPCdEdxInfo(*source.fTPCdEdxInfo);
732a24fe 915 }
ddfbc51a 916
917 if(source.fOp){
918 // we have the trackparam: assign or copy construct
919 if(fOp) *fOp = *source.fOp;
920 else fOp = new AliExternalTrackParam(*source.fOp);
732a24fe 921 }
ddfbc51a 922 else{
923 // no track param delete the old one
7b2679d9 924 delete fOp;
ddfbc51a 925 fOp = 0;
c38d443f 926 }
ddfbc51a 927
928
929 if(source.fHMPIDp){
930 // we have the trackparam: assign or copy construct
931 if(fHMPIDp) *fHMPIDp = *source.fHMPIDp;
932 else fHMPIDp = new AliExternalTrackParam(*source.fHMPIDp);
c38d443f 933 }
ddfbc51a 934 else{
935 // no track param delete the old one
7b2679d9 936 delete fHMPIDp;
ddfbc51a 937 fHMPIDp = 0;
e546b023 938 }
ddfbc51a 939
732a24fe 940 // copy also the friend track
941 // use copy constructor
ddfbc51a 942 if(source.fFriendTrack){
943 // we have the trackparam: assign or copy construct
944 delete fFriendTrack; fFriendTrack=new AliESDfriendTrack(*source.fFriendTrack);
732a24fe 945 }
ddfbc51a 946 else{
947 // no track param delete the old one
948 delete fFriendTrack; fFriendTrack= 0;
949 }
950
951 fTPCFitMap = source.fTPCFitMap;
732a24fe 952 fTPCClusterMap = source.fTPCClusterMap;
953 fTPCSharedMap = source.fTPCSharedMap;
954 // the simple stuff
955 fFlags = source.fFlags;
956 fID = source.fID;
957 fLabel = source.fLabel;
958 fITSLabel = source.fITSLabel;
ddfbc51a 959 for(int i = 0; i< 12;++i){
960 fITSModule[i] = source.fITSModule[i];
961 }
732a24fe 962 fTPCLabel = source.fTPCLabel;
963 fTRDLabel = source.fTRDLabel;
115179c6 964 if(source.fTOFLabel){
965 if(!fTOFLabel) fTOFLabel = new Int_t[3];
966 for(int i = 0; i< 3;++i){
967 fTOFLabel[i] = source.fTOFLabel[i];
968 }
ddfbc51a 969 }
732a24fe 970 fTOFCalChannel = source.fTOFCalChannel;
971 fTOFindex = source.fTOFindex;
972 fHMPIDqn = source.fHMPIDqn;
973 fHMPIDcluIdx = source.fHMPIDcluIdx;
f1cedef3 974 fCaloIndex = source.fCaloIndex;
e400c4a6 975 for (int i=kNITSchi2Std;i--;) fITSchi2Std[i] = source.fITSchi2Std[i];
ddfbc51a 976 for(int i = 0; i< 3;++i){
732a24fe 977 fKinkIndexes[i] = source.fKinkIndexes[i];
978 fV0Indexes[i] = source.fV0Indexes[i];
979 }
ddfbc51a 980
a3314882 981 if (source.fR) {
982 if (!fR) fR = new Double32_t[AliPID::kSPECIES];
983 for (Int_t i=AliPID::kSPECIES;i--;) fR[i]=source.fR[i];
984 }
985 else {delete[] fR; fR = 0;}
986
987 if (source.fITSr) {
988 if (!fITSr) fITSr = new Double32_t[AliPID::kSPECIES];
989 for (Int_t i=AliPID::kSPECIES;i--;) fITSr[i]=source.fITSr[i];
990 }
991 else {delete[] fITSr; fITSr = 0;}
992 //
993 if (source.fTPCr) {
994 if (!fTPCr) fTPCr = new Double32_t[AliPID::kSPECIES];
995 for (Int_t i=AliPID::kSPECIES;i--;) fTPCr[i]=source.fTPCr[i];
996 }
997 else {delete[] fTPCr; fTPCr = 0;}
998
999 if (source.fTRDr) {
1000 if (!fTRDr) fTRDr = new Double32_t[AliPID::kSPECIES];
1001 for (Int_t i=AliPID::kSPECIES;i--;) fTRDr[i]=source.fTRDr[i];
1002 }
1003 else {delete[] fTRDr; fTRDr = 0;}
1004
1005 if (source.fTOFr) {
1006 if (!fTOFr) fTOFr = new Double32_t[AliPID::kSPECIES];
1007 for (Int_t i=AliPID::kSPECIES;i--;) fTOFr[i]=source.fTOFr[i];
1008 }
1009 else {delete[] fTOFr; fTOFr = 0;}
1010
1011 if (source.fHMPIDr) {
1012 if (!fHMPIDr) fHMPIDr = new Double32_t[AliPID::kSPECIES];
1013 for (Int_t i=AliPID::kSPECIES;i--;) fHMPIDr[i]=source.fHMPIDr[i];
732a24fe 1014 }
a3314882 1015 else {delete[] fHMPIDr; fHMPIDr = 0;}
1d26da6d 1016
a3314882 1017 fPIDForTracking = source.fPIDForTracking;
ddfbc51a 1018
732a24fe 1019 fHMPIDtrkTheta = source.fHMPIDtrkTheta;
1020 fHMPIDtrkPhi = source.fHMPIDtrkPhi;
1021 fHMPIDsignal = source.fHMPIDsignal;
ddfbc51a 1022
1023
115179c6 1024 if(fTrackTime){
1025 delete[] fTrackTime;
1026 }
1027 if(source.fTrackTime){
1028 fTrackTime = new Double32_t[AliPID::kSPECIESC];
1029 for(Int_t i=0;i < AliPID::kSPECIESC;i++)
1030 fTrackTime[i] = source.fTrackTime[i];
1031 }
1032
732a24fe 1033 fTrackLength = source. fTrackLength;
d7ddf1e9 1034 fdTPC = source.fdTPC;
1035 fzTPC = source.fzTPC;
1036 fCddTPC = source.fCddTPC;
1037 fCdzTPC = source.fCdzTPC;
1038 fCzzTPC = source.fCzzTPC;
436dfe39 1039 fCchi2TPC = source.fCchi2TPC;
ddfbc51a 1040
732a24fe 1041 fD = source.fD;
1042 fZ = source.fZ;
1043 fCdd = source.fCdd;
1044 fCdz = source.fCdz;
1045 fCzz = source.fCzz;
732a24fe 1046 fCchi2 = source.fCchi2;
ddfbc51a 1047
732a24fe 1048 fITSchi2 = source.fITSchi2;
1049 fTPCchi2 = source.fTPCchi2;
949840f6 1050 fTPCchi2Iter1 = source.fTPCchi2Iter1;
732a24fe 1051 fTRDchi2 = source.fTRDchi2;
1052 fTOFchi2 = source.fTOFchi2;
1053 fHMPIDchi2 = source.fHMPIDchi2;
ddfbc51a 1054
b5b2b4db 1055 fGlobalChi2 = source.fGlobalChi2;
ddfbc51a 1056
732a24fe 1057 fITSsignal = source.fITSsignal;
ddfbc51a 1058 for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=source.fITSdEdxSamples[i];}
732a24fe 1059 fTPCsignal = source.fTPCsignal;
539a5a59 1060 fTPCsignalTuned = source.fTPCsignalTuned;
732a24fe 1061 fTPCsignalS = source.fTPCsignalS;
ddfbc51a 1062 for(int i = 0; i< 4;++i){
1063 fTPCPoints[i] = source.fTPCPoints[i];
1064 }
732a24fe 1065 fTRDsignal = source.fTRDsignal;
4d302e42 1066 fTRDNchamberdEdx = source.fTRDNchamberdEdx;
1067 fTRDNclusterdEdx = source.fTRDNclusterdEdx;
ddfbc51a 1068
1069 for(int i = 0;i < kTRDnPlanes;++i){
1070 fTRDTimBin[i] = source.fTRDTimBin[i];
732a24fe 1071 }
ddfbc51a 1072
1073 if(fTRDnSlices)
1074 delete[] fTRDslices;
1075 fTRDslices=0;
1076 fTRDnSlices=source.fTRDnSlices;
6984f7c1 1077 if (fTRDnSlices) {
ddfbc51a 1078 fTRDslices=new Double32_t[fTRDnSlices];
1079 for(int j = 0;j < fTRDnSlices;++j) fTRDslices[j] = source.fTRDslices[j];
6984f7c1 1080 }
ddfbc51a 1081
732a24fe 1082 fTRDQuality = source.fTRDQuality;
1083 fTRDBudget = source.fTRDBudget;
1084 fTOFsignal = source.fTOFsignal;
a2c30af1 1085 fTOFsignalTuned = source.fTOFsignalTuned;
732a24fe 1086 fTOFsignalToT = source.fTOFsignalToT;
1087 fTOFsignalRaw = source.fTOFsignalRaw;
1088 fTOFsignalDz = source.fTOFsignalDz;
a5d9ff0f 1089 fTOFsignalDx = source.fTOFsignalDx;
d86081b1 1090 fTOFdeltaBC = source.fTOFdeltaBC;
1091 fTOFl0l1 = source.fTOFl0l1;
ddfbc51a 1092
1093 for(int i = 0;i<10;++i){
1094 fTOFInfo[i] = source.fTOFInfo[i];
1095 }
1096
732a24fe 1097 fHMPIDtrkX = source.fHMPIDtrkX;
1098 fHMPIDtrkY = source.fHMPIDtrkY;
1099 fHMPIDmipX = source.fHMPIDmipX;
1100 fHMPIDmipY = source.fHMPIDmipY;
1101
1102 fTPCncls = source.fTPCncls;
1103 fTPCnclsF = source.fTPCnclsF;
1104 fTPCsignalN = source.fTPCsignalN;
949840f6 1105 fTPCnclsIter1 = source.fTPCnclsIter1;
1106 fTPCnclsFIter1 = source.fTPCnclsFIter1;
732a24fe 1107
1108 fITSncls = source.fITSncls;
1109 fITSClusterMap = source.fITSClusterMap;
25015f7a 1110 fITSSharedMap = source.fITSSharedMap;
732a24fe 1111 fTRDncls = source.fTRDncls;
1112 fTRDncls0 = source.fTRDncls0;
ed15ef4f 1113 fTRDntracklets = source.fTRDntracklets;
6dc21f57 1114 fVertexID = source.fVertexID;
a3314882 1115 fPIDForTracking = source.fPIDForTracking;
b5732bf0 1116
1117 fCacheNCrossedRows = source.fCacheNCrossedRows;
1118 fCacheChi2TPCConstrainedVsGlobal = source.fCacheChi2TPCConstrainedVsGlobal;
1119 fCacheChi2TPCConstrainedVsGlobalVertex = source.fCacheChi2TPCConstrainedVsGlobalVertex;
1120
00a38d07 1121 delete fDetectorPID;
1122 fDetectorPID=0x0;
1123 if (source.fDetectorPID) fDetectorPID = new AliDetectorPID(*source.fDetectorPID);
1124
ed15417e 1125 fTrackPhiOnEMCal= source.fTrackPhiOnEMCal;
1126 fTrackEtaOnEMCal= source.fTrackEtaOnEMCal;
a29b2a8a 1127 fTrackPtOnEMCal= source.fTrackPtOnEMCal;
ed15417e 1128
115179c6 1129 if(fTOFcluster){
1130 delete[] fTOFcluster;
1131 }
1132 fNtofClusters = source.fNtofClusters;
1133 if(fNtofClusters > 0){
1134 fTOFcluster = new Int_t[fNtofClusters];
1135 for(Int_t i=0;i < fNtofClusters;i++) fTOFcluster[i] = source.fTOFcluster[i];
1136 }
1137
732a24fe 1138 return *this;
1139}
1140
ddfbc51a 1141
1142
732a24fe 1143void AliESDtrack::Copy(TObject &obj) const {
1144
1145 // this overwrites the virtual TOBject::Copy()
1146 // to allow run time copying without casting
1147 // in AliESDEvent
1148
1149 if(this==&obj)return;
1150 AliESDtrack *robj = dynamic_cast<AliESDtrack*>(&obj);
1151 if(!robj)return; // not an AliESDtrack
1152 *robj = *this;
1153
1154}
1155
ddfbc51a 1156
1157
00dce61a 1158void AliESDtrack::AddCalibObject(TObject * object){
1159 //
1160 // add calib object to the list
1161 //
ddfbc51a 1162 if (!fFriendTrack) fFriendTrack = new AliESDfriendTrack;
59c31692 1163 if (!fFriendTrack) return;
00dce61a 1164 fFriendTrack->AddCalibObject(object);
1165}
1166
1167TObject * AliESDtrack::GetCalibObject(Int_t index){
1168 //
1169 // return calib objct at given position
1170 //
1171 if (!fFriendTrack) return 0;
1172 return fFriendTrack->GetCalibObject(index);
1173}
1174
1175
f12d42ce 1176Bool_t AliESDtrack::FillTPCOnlyTrack(AliESDtrack &track){
b9ca886f 1177
1178 // Fills the information of the TPC-only first reconstruction pass
1179 // into the passed ESDtrack object. For consistency fTPCInner is also filled
1180 // again
1181
ddfbc51a 1182
1183
5b305f70 1184 // For data produced before r26675
1185 // RelateToVertexTPC was not properly called during reco
1186 // so you'll have to call it again, before FillTPCOnlyTrack
1187 // Float_t p[2],cov[3];
1188 // track->GetImpactParametersTPC(p,cov);
1189 // if(p[0]==0&&p[1]==0) // <- Default values
1190 // track->RelateToVertexTPC(esd->GetPrimaryVertexTPC(),esd->GetMagneticField(),kVeryBig);
1191
1192
ddfbc51a 1193 if(!fTPCInner)return kFALSE;
b9ca886f 1194
1195 // fill the TPC track params to the global track parameters
1196 track.Set(fTPCInner->GetX(),fTPCInner->GetAlpha(),fTPCInner->GetParameter(),fTPCInner->GetCovariance());
1197 track.fD = fdTPC;
1198 track.fZ = fzTPC;
1199 track.fCdd = fCddTPC;
1200 track.fCdz = fCdzTPC;
1201 track.fCzz = fCzzTPC;
ddfbc51a 1202
67ed91d3 1203 // copy the inner params
ddfbc51a 1204 if(track.fIp) *track.fIp = *fIp;
1205 else track.fIp = new AliExternalTrackParam(*fIp);
1206
b9ca886f 1207 // copy the TPCinner parameters
ddfbc51a 1208 if(track.fTPCInner) *track.fTPCInner = *fTPCInner;
1209 else track.fTPCInner = new AliExternalTrackParam(*fTPCInner);
b9ca886f 1210 track.fdTPC = fdTPC;
1211 track.fzTPC = fzTPC;
1212 track.fCddTPC = fCddTPC;
1213 track.fCdzTPC = fCdzTPC;
1214 track.fCzzTPC = fCzzTPC;
436dfe39 1215 track.fCchi2TPC = fCchi2TPC;
b9ca886f 1216
b9ca886f 1217 // copy all other TPC specific parameters
1218
1219 // replace label by TPC label
1220 track.fLabel = fTPCLabel;
1221 track.fTPCLabel = fTPCLabel;
1222
1223 track.fTPCchi2 = fTPCchi2;
949840f6 1224 track.fTPCchi2Iter1 = fTPCchi2Iter1;
b9ca886f 1225 track.fTPCsignal = fTPCsignal;
539a5a59 1226 track.fTPCsignalTuned = fTPCsignalTuned;
b9ca886f 1227 track.fTPCsignalS = fTPCsignalS;
ddfbc51a 1228 for(int i = 0;i<4;++i)track.fTPCPoints[i] = fTPCPoints[i];
b9ca886f 1229
1230 track.fTPCncls = fTPCncls;
1231 track.fTPCnclsF = fTPCnclsF;
1232 track.fTPCsignalN = fTPCsignalN;
949840f6 1233 track.fTPCnclsIter1 = fTPCnclsIter1;
1234 track.fTPCnclsFIter1 = fTPCnclsFIter1;
b9ca886f 1235
1236 // PID
a3314882 1237 if (fTPCr) {
1238 if (!track.fTPCr) track.fTPCr = new Double32_t[AliPID::kSPECIES];
1239 for(int i=AliPID::kSPECIES;i--;) track.fTPCr[i] = fTPCr[i];
b9ca886f 1240 }
a3314882 1241 //
1242 if (fR) {
1243 if (!track.fR) track.fR = new Double32_t[AliPID::kSPECIES];
1244 for(int i=AliPID::kSPECIES;i--;) track.fR[i] = fR[i];
1245 }
1246
9f638f03 1247 track.fTPCFitMap = fTPCFitMap;
b9ca886f 1248 track.fTPCClusterMap = fTPCClusterMap;
1249 track.fTPCSharedMap = fTPCSharedMap;
ddfbc51a 1250
1251
b9ca886f 1252 // reset the flags
1253 track.fFlags = kTPCin;
1254 track.fID = fID;
1255
b1cfce51 1256 track.fFlags |= fFlags & kTPCpid; //copy the TPCpid status flag
b9ca886f 1257
ddfbc51a 1258 for (Int_t i=0;i<3;i++) track.fKinkIndexes[i] = fKinkIndexes[i];
b9ca886f 1259
1260 return kTRUE;
ddfbc51a 1261
b9ca886f 1262}
1263
9559cbc4 1264//_______________________________________________________________________
1265void AliESDtrack::MakeMiniESDtrack(){
1266 // Resets everything except
1267 // fFlags: Reconstruction status flags
1268 // fLabel: Track label
1269 // fID: Unique ID of the track
d7ddf1e9 1270 // Impact parameter information
9559cbc4 1271 // fR[AliPID::kSPECIES]: combined "detector response probability"
8497bca0 1272 // Running track parameters in the base class (AliExternalTrackParam)
9559cbc4 1273
1274 fTrackLength = 0;
562dd0b4 1275
115179c6 1276 if(fTrackTime)
1277 for (Int_t i=0;i<AliPID::kSPECIESC;i++) fTrackTime[i] = 0;
ddfbc51a 1278
9559cbc4 1279 // Reset track parameters constrained to the primary vertex
ddfbc51a 1280 delete fCp;fCp = 0;
1281
9559cbc4 1282 // Reset track parameters at the inner wall of TPC
ddfbc51a 1283 delete fIp;fIp = 0;
1284 delete fTPCInner;fTPCInner=0;
9559cbc4 1285 // Reset track parameters at the inner wall of the TRD
ddfbc51a 1286 delete fOp;fOp = 0;
c38d443f 1287 // Reset track parameters at the HMPID
ddfbc51a 1288 delete fHMPIDp;fHMPIDp = 0;
1289
1290
9559cbc4 1291 // Reset ITS track related information
1292 fITSchi2 = 0;
9559cbc4 1293 fITSncls = 0;
62665e7f 1294 fITSClusterMap=0;
25015f7a 1295 fITSSharedMap=0;
9559cbc4 1296 fITSsignal = 0;
ddfbc51a 1297 for (Int_t i=0;i<4;i++) fITSdEdxSamples[i] = 0.;
a3314882 1298 if (fITSr) for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
9559cbc4 1299 fITSLabel = 0;
9559cbc4 1300
1301 // Reset TPC related track information
1302 fTPCchi2 = 0;
949840f6 1303 fTPCchi2Iter1 = 0;
9559cbc4 1304 fTPCncls = 0;
e1d4c1b5 1305 fTPCnclsF = 0;
949840f6 1306 fTPCnclsIter1 = 0;
9f638f03 1307 fTPCnclsFIter1 = 0;
1308 fTPCFitMap = 0;
9559cbc4 1309 fTPCClusterMap = 0;
eb7f6854 1310 fTPCSharedMap = 0;
9559cbc4 1311 fTPCsignal= 0;
539a5a59 1312 fTPCsignalTuned= 0;
e1d4c1b5 1313 fTPCsignalS= 0;
1314 fTPCsignalN= 0;
a3314882 1315 if (fTPCr) for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i] = 0;
9559cbc4 1316 fTPCLabel=0;
ddfbc51a 1317 for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
1318 for (Int_t i=0; i<3;i++) fKinkIndexes[i] = 0;
1319 for (Int_t i=0; i<3;i++) fV0Indexes[i] = 0;
9559cbc4 1320
1321 // Reset TRD related track information
1322 fTRDchi2 = 0;
1323 fTRDncls = 0;
1324 fTRDncls0 = 0;
9559cbc4 1325 fTRDsignal = 0;
4d302e42 1326 fTRDNchamberdEdx = 0;
1327 fTRDNclusterdEdx = 0;
1328
ddfbc51a 1329 for (Int_t i=0;i<kTRDnPlanes;i++) {
1330 fTRDTimBin[i] = 0;
1331 }
a3314882 1332 if (fTRDr) for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
9559cbc4 1333 fTRDLabel = 0;
9559cbc4 1334 fTRDQuality = 0;
ed15ef4f 1335 fTRDntracklets = 0;
ddfbc51a 1336 if(fTRDnSlices)
1337 delete[] fTRDslices;
1338 fTRDslices=0x0;
6984f7c1 1339 fTRDnSlices=0;
23d49657 1340 fTRDBudget = 0;
9559cbc4 1341
1342 // Reset TOF related track information
1343 fTOFchi2 = 0;
ce3f4882 1344 fTOFindex = -1;
ab37ab1e 1345 fTOFsignal = 99999;
1346 fTOFCalChannel = -1;
1347 fTOFsignalToT = 99999;
1348 fTOFsignalRaw = 99999;
1349 fTOFsignalDz = 999;
1350 fTOFsignalDx = 999;
1351 fTOFdeltaBC = 999;
1352 fTOFl0l1 = 999;
a3314882 1353 if (fTOFr) for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
ddfbc51a 1354 for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
9559cbc4 1355
f4b3bbb7 1356 // Reset HMPID related track information
1357 fHMPIDchi2 = 0;
562dd0b4 1358 fHMPIDqn = 0;
81aa7a0d 1359 fHMPIDcluIdx = -1;
f4b3bbb7 1360 fHMPIDsignal = 0;
a3314882 1361 if (fHMPIDr) for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
562dd0b4 1362 fHMPIDtrkTheta = 0;
1363 fHMPIDtrkPhi = 0;
1364 fHMPIDtrkX = 0;
1365 fHMPIDtrkY = 0;
1366 fHMPIDmipX = 0;
1367 fHMPIDmipY = 0;
f1cedef3 1368 fCaloIndex = kEMCALNoMatch;
9559cbc4 1369
b5b2b4db 1370 // reset global track chi2
1371 fGlobalChi2 = 0;
1372
6dc21f57 1373 fVertexID = -2; // an orphan track
a3314882 1374 fPIDForTracking = AliPID::kPion;
1375 //
ddfbc51a 1376 delete fFriendTrack; fFriendTrack = 0;
9559cbc4 1377}
ec729fb0 1378
bf7942ff 1379//_______________________________________________________________________
1cecd6e3 1380Int_t AliESDtrack::GetPID(Bool_t tpcOnly) const
bf7942ff 1381{
a3314882 1382 // Returns the particle most probable id. For backward compatibility first the prob. arrays
1383 // will be checked, but normally the GetPIDForTracking will be returned
ddfbc51a 1384 Int_t i;
1cecd6e3 1385 const Double32_t *prob = 0;
1386 if (tpcOnly) { // check if TPCpid is valid
a3314882 1387 if (!fTPCr) return GetPIDForTracking();
1cecd6e3 1388 prob = fTPCr;
1389 for (i=0; i<AliPID::kSPECIES-1; i++) if (prob[i] != prob[i+1]) break;
1390 if (i == AliPID::kSPECIES-1) prob = 0; // not valid, try with combined pid
1391 }
1392 if (!prob) { // either requested TPCpid is not valid or comb.pid is requested
a3314882 1393 if (!fR) return GetPIDForTracking();
1cecd6e3 1394 prob = fR;
1395 for (i=0; i<AliPID::kSPECIES-1; i++) if (prob[i] != prob[i+1]) break;
a3314882 1396 if (i == AliPID::kSPECIES-1) return GetPIDForTracking(); // If all the probabilities are equal, return the pion mass
1cecd6e3 1397 }
bf7942ff 1398 //
ae982df3 1399 Float_t max=0.;
1400 Int_t k=-1;
1cecd6e3 1401 for (i=0; i<AliPID::kSPECIES; i++) if (prob[i]>max) {k=i; max=prob[i];}
bf7942ff 1402 //
db3989b3 1403 if (k==0) { // dE/dx "crossing points" in the TPC
a3314882 1404 /*
bf7942ff 1405 Double_t p=GetP();
1406 if ((p>0.38)&&(p<0.48))
1cecd6e3 1407 if (prob[0]<prob[3]*10.) return AliPID::kKaon;
bf7942ff 1408 if ((p>0.75)&&(p<0.85))
1cecd6e3 1409 if (prob[0]<prob[4]*10.) return AliPID::kProton;
a3314882 1410 */
bf7942ff 1411 return AliPID::kElectron;
db3989b3 1412 }
bf7942ff 1413 if (k==1) return AliPID::kMuon;
1414 if (k==2||k==-1) return AliPID::kPion;
1415 if (k==3) return AliPID::kKaon;
1416 if (k==4) return AliPID::kProton;
a3314882 1417 // AliWarning("Undefined PID !");
1418 return GetPIDForTracking();
bf7942ff 1419}
1420
1421//_______________________________________________________________________
1cecd6e3 1422Int_t AliESDtrack::GetTOFBunchCrossing(Double_t b, Bool_t pidTPConly) const
bf7942ff 1423{
1424 // Returns the number of bunch crossings after trigger (assuming 25ns spacing)
bf7942ff 1425 const double kSpacing = 25e3; // min interbanch spacing
1426 const double kShift = 0;
3f2db92f 1427 Int_t bcid = kTOFBCNA; // defualt one
b46f82cf 1428 if (!IsOn(kTOFout)/* || !IsOn(kESDpid)*/) return bcid; // no info
a512bf97 1429 //
b46f82cf 1430 double tdif = GetTOFsignal();
a512bf97 1431 if (IsOn(kTIME)) { // integrated time info is there
1cecd6e3 1432 int pid = GetPID(pidTPConly);
fc9b31a7 1433 Double_t times[AliPID::kSPECIESC];
1434 // old esd has only AliPID::kSPECIES times
1435 GetIntegratedTimes(times,pid>=AliPID::kSPECIES ? AliPID::kSPECIESC : AliPID::kSPECIES);
115179c6 1436 tdif -= times[pid];
a512bf97 1437 }
1438 else { // assume integrated time info from TOF radius and momentum
1439 const double kRTOF = 385.;
1440 const double kCSpeed = 3.e-2; // cm/ps
1441 double p = GetP();
1442 if (p<0.01) return bcid;
1cecd6e3 1443 double m = GetMass(pidTPConly);
a512bf97 1444 double curv = GetC(b);
1445 double path = TMath::Abs(curv)>kAlmost0 ? // account for curvature
1446 2./curv*TMath::ASin(kRTOF*curv/2.)*TMath::Sqrt(1.+GetTgl()*GetTgl()) : kRTOF;
1447 tdif -= path/kCSpeed*TMath::Sqrt(1.+m*m/(p*p));
1448 }
bf7942ff 1449 bcid = TMath::Nint((tdif - kShift)/kSpacing);
1450 return bcid;
ae982df3 1451}
1452
6b5b49c9 1453//______________________________________________________________________________
1454Double_t AliESDtrack::M() const
1455{
2850a7f3 1456 // Returns the assumed mass
1457 // (the pion mass, if the particle can't be identified properly).
9be82450 1458 static Bool_t printerr=kTRUE;
1459 if (printerr) {
1460 AliWarning("WARNING !!! ... THIS WILL BE PRINTED JUST ONCE !!!");
1461 printerr = kFALSE;
1462 AliWarning("This is the ESD mass. Use it with care !");
1463 }
6b5b49c9 1464 return GetMass();
1465}
1466
aad8d435 1467//______________________________________________________________________________
1468Double_t AliESDtrack::E() const
1469{
1470 // Returns the energy of the particle given its assumed mass.
1471 // Assumes the pion mass if the particle can't be identified properly.
1472
1473 Double_t m = M();
1474 Double_t p = P();
1475 return TMath::Sqrt(p*p + m*m);
1476}
1477
1478//______________________________________________________________________________
1479Double_t AliESDtrack::Y() const
1480{
1481 // Returns the rapidity of a particle given its assumed mass.
1482 // Assumes the pion mass if the particle can't be identified properly.
1483
1484 Double_t e = E();
1485 Double_t pz = Pz();
e03e4544 1486 if (e != TMath::Abs(pz)) { // energy was not equal to pz
aad8d435 1487 return 0.5*TMath::Log((e+pz)/(e-pz));
1488 } else { // energy was equal to pz
1489 return -999.;
1490 }
1491}
1492
ae982df3 1493//_______________________________________________________________________
c9ec41e8 1494Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
ae982df3 1495 //
1496 // This function updates track's running parameters
1497 //
15614b8b 1498 Bool_t rc=kTRUE;
1499
9b859005 1500 SetStatus(flags);
1501 fLabel=t->GetLabel();
1502
1503 if (t->IsStartedTimeIntegral()) {
1504 SetStatus(kTIME);
fc9b31a7 1505 Double_t times[AliPID::kSPECIESC];
1506 t->GetIntegratedTimes(times);
1507 SetIntegratedTimes(times);
9b859005 1508 SetIntegratedLength(t->GetIntegratedLength());
1509 }
1510
6c94f330 1511 Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
59c31692 1512 if (fFriendTrack) {
ddfbc51a 1513 if (flags==kITSout) fFriendTrack->SetITSOut(*t);
1514 if (flags==kTPCout) fFriendTrack->SetTPCOut(*t);
1515 if (flags==kTRDrefit) fFriendTrack->SetTRDIn(*t);
59c31692 1516 }
ddfbc51a 1517
ae982df3 1518 switch (flags) {
ddfbc51a 1519
6c3c2a50 1520 case kITSin:
1521 fITSchi2Std[0] = t->GetChi2();
1522 //
1523 case kITSout:
1524 fITSchi2Std[1] = t->GetChi2();
ddfbc51a 1525 case kITSrefit:
1526 {
6c3c2a50 1527 fITSchi2Std[2] = t->GetChi2();
48704648 1528 fITSClusterMap=0;
ae982df3 1529 fITSncls=t->GetNumberOfClusters();
59c31692 1530 if (fFriendTrack) {
ddfbc51a 1531 Int_t* indexITS = new Int_t[AliESDfriendTrack::kMaxITScluster];
1532 for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
6d3a7bbf 1533 indexITS[i]=t->GetClusterIndex(i);
ddfbc51a 1534
62665e7f 1535 if (i<fITSncls) {
6d3a7bbf 1536 Int_t l=(indexITS[i] & 0xf0000000) >> 28;
ddfbc51a 1537 SETBIT(fITSClusterMap,l);
62665e7f 1538 }
1539 }
ddfbc51a 1540 fFriendTrack->SetITSIndices(indexITS,AliESDfriendTrack::kMaxITScluster);
1541 delete [] indexITS;
1542 }
1543
ae982df3 1544 fITSchi2=t->GetChi2();
ae982df3 1545 fITSsignal=t->GetPIDsignal();
6e5b1b04 1546 fITSLabel = t->GetLabel();
57483eb1 1547 // keep in fOp the parameters outside ITS for ITS stand-alone tracks
1548 if (flags==kITSout) {
ddfbc51a 1549 if (!fOp) fOp=new AliExternalTrackParam(*t);
1550 else
1551 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1552 }
6d3a7bbf 1553 }
ae982df3 1554 break;
ddfbc51a 1555
9b859005 1556 case kTPCin: case kTPCrefit:
ddfbc51a 1557 {
6e5b1b04 1558 fTPCLabel = t->GetLabel();
949840f6 1559 if (flags==kTPCin) {
ddfbc51a 1560 fTPCInner=new AliExternalTrackParam(*t);
1561 fTPCnclsIter1=t->GetNumberOfClusters();
1562 fTPCchi2Iter1=t->GetChi2();
949840f6 1563 }
ddfbc51a 1564 if (!fIp) fIp=new AliExternalTrackParam(*t);
1565 else
1566 fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
6d3a7bbf 1567 }
5d6fb68d 1568 // Intentionally no break statement; need to set general TPC variables as well
9b859005 1569 case kTPCout:
ddfbc51a 1570 {
1d303a24 1571 if (flags & kTPCout){
ddfbc51a 1572 if (!fOp) fOp=new AliExternalTrackParam(*t);
1573 else
1574 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1d303a24 1575 }
e1d4c1b5 1576 fTPCncls=t->GetNumberOfClusters();
ae982df3 1577 fTPCchi2=t->GetChi2();
a866ac60 1578
5d6fb68d 1579 if (fFriendTrack) { // Copy cluster indices
ddfbc51a 1580 Int_t* indexTPC = new Int_t[AliESDfriendTrack::kMaxTPCcluster];
1581 for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)
1582 indexTPC[i]=t->GetClusterIndex(i);
5d6fb68d 1583 fFriendTrack->SetTPCIndices(indexTPC,AliESDfriendTrack::kMaxTPCcluster);
ddfbc51a 1584 delete [] indexTPC;
5d6fb68d 1585 }
ae982df3 1586 fTPCsignal=t->GetPIDsignal();
ddfbc51a 1587 }
ae982df3 1588 break;
ddfbc51a 1589
64130601 1590 case kTRDin: case kTRDrefit:
1591 break;
1592 case kTRDout:
ddfbc51a 1593 {
51ad6848 1594 fTRDLabel = t->GetLabel();
2f83b7a6 1595 fTRDchi2 = t->GetChi2();
1596 fTRDncls = t->GetNumberOfClusters();
59c31692 1597 if (fFriendTrack) {
ddfbc51a 1598 Int_t* indexTRD = new Int_t[AliESDfriendTrack::kMaxTRDcluster];
1599 for (Int_t i=0;i<AliESDfriendTrack::kMaxTRDcluster;i++) indexTRD[i]=-2;
1600 for (Int_t i=0;i<6;i++) indexTRD[i]=t->GetTrackletIndex(i);
6d3a7bbf 1601 fFriendTrack->SetTRDIndices(indexTRD,AliESDfriendTrack::kMaxTRDcluster);
ddfbc51a 1602 delete [] indexTRD;
59c31692 1603 }
ddfbc51a 1604
4d302e42 1605 //commented out by Xianguo
1606 //fTRDsignal=t->GetPIDsignal();
ddfbc51a 1607 }
79e94bf8 1608 break;
c4d11b15 1609 case kTRDbackup:
ddfbc51a 1610 if (!fOp) fOp=new AliExternalTrackParam(*t);
1611 else
1612 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
c4d11b15 1613 fTRDncls0 = t->GetNumberOfClusters();
1614 break;
1615 case kTOFin:
1616 break;
1617 case kTOFout:
1618 break;
d0862fea 1619 case kTRDStop:
1620 break;
c38d443f 1621 case kHMPIDout:
ddfbc51a 1622 if (!fHMPIDp) fHMPIDp=new AliExternalTrackParam(*t);
1623 else
1624 fHMPIDp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
c38d443f 1625 break;
ae982df3 1626 default:
5f7789fc 1627 AliError("Wrong flag !");
ae982df3 1628 return kFALSE;
1629 }
ddfbc51a 1630
15614b8b 1631 return rc;
ae982df3 1632}
1633
1634//_______________________________________________________________________
1635void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
1636 //---------------------------------------------------------------------
1637 // This function returns external representation of the track parameters
1638 //---------------------------------------------------------------------
c9ec41e8 1639 x=GetX();
ddfbc51a 1640 for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
15614b8b 1641}
1642
67c3dcbe 1643//_______________________________________________________________________
a866ac60 1644void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
67c3dcbe 1645 //---------------------------------------------------------------------
1646 // This function returns external representation of the cov. matrix
1647 //---------------------------------------------------------------------
ddfbc51a 1648 for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
67c3dcbe 1649}
1650
67c3dcbe 1651//_______________________________________________________________________
c0b978f0 1652Bool_t AliESDtrack::GetConstrainedExternalParameters
1653 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
67c3dcbe 1654 //---------------------------------------------------------------------
1655 // This function returns the constrained external track parameters
1656 //---------------------------------------------------------------------
c0b978f0 1657 if (!fCp) return kFALSE;
1658 alpha=fCp->GetAlpha();
c9ec41e8 1659 x=fCp->GetX();
ddfbc51a 1660 for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
c0b978f0 1661 return kTRUE;
67c3dcbe 1662}
c9ec41e8 1663
67c3dcbe 1664//_______________________________________________________________________
c0b978f0 1665Bool_t
67c3dcbe 1666AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
1667 //---------------------------------------------------------------------
1668 // This function returns the constrained external cov. matrix
1669 //---------------------------------------------------------------------
c0b978f0 1670 if (!fCp) return kFALSE;
ddfbc51a 1671 for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
c0b978f0 1672 return kTRUE;
67c3dcbe 1673}
1674
c0b978f0 1675Bool_t
1676AliESDtrack::GetInnerExternalParameters
1677 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1678 //---------------------------------------------------------------------
c9ec41e8 1679 // This function returns external representation of the track parameters
1680 // at the inner layer of TPC
9b859005 1681 //---------------------------------------------------------------------
c0b978f0 1682 if (!fIp) return kFALSE;
1683 alpha=fIp->GetAlpha();
c9ec41e8 1684 x=fIp->GetX();
ddfbc51a 1685 for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
c0b978f0 1686 return kTRUE;
9b859005 1687}
1688
c0b978f0 1689Bool_t
1690AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const {
c9ec41e8 1691 //---------------------------------------------------------------------
1692 // This function returns external representation of the cov. matrix
1693 // at the inner layer of TPC
1694 //---------------------------------------------------------------------
c0b978f0 1695 if (!fIp) return kFALSE;
ddfbc51a 1696 for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
c0b978f0 1697 return kTRUE;
9b859005 1698}
1699
d61ca12d 1700void
1701AliESDtrack::SetOuterParam(const AliExternalTrackParam *p, ULong_t flags) {
1702 //
1703 // This is a direct setter for the outer track parameters
1704 //
1705 SetStatus(flags);
1706 if (fOp) delete fOp;
1707 fOp=new AliExternalTrackParam(*p);
1708}
1709
c38d443f 1710void
1711AliESDtrack::SetOuterHmpParam(const AliExternalTrackParam *p, ULong_t flags) {
1712 //
1713 // This is a direct setter for the outer track parameters
1714 //
1715 SetStatus(flags);
ddfbc51a 1716 if (fHMPIDp) delete fHMPIDp;
1717 fHMPIDp=new AliExternalTrackParam(*p);
c38d443f 1718}
1719
c0b978f0 1720Bool_t
1721AliESDtrack::GetOuterExternalParameters
1722 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1723 //---------------------------------------------------------------------
c9ec41e8 1724 // This function returns external representation of the track parameters
1725 // at the inner layer of TRD
a866ac60 1726 //---------------------------------------------------------------------
c0b978f0 1727 if (!fOp) return kFALSE;
1728 alpha=fOp->GetAlpha();
c9ec41e8 1729 x=fOp->GetX();
ddfbc51a 1730 for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
c0b978f0 1731 return kTRUE;
a866ac60 1732}
c9ec41e8 1733
c38d443f 1734Bool_t
1735AliESDtrack::GetOuterHmpExternalParameters
1736 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1737 //---------------------------------------------------------------------
1738 // This function returns external representation of the track parameters
1739 // at the inner layer of TRD
1740 //---------------------------------------------------------------------
1741 if (!fHMPIDp) return kFALSE;
1742 alpha=fHMPIDp->GetAlpha();
1743 x=fHMPIDp->GetX();
ddfbc51a 1744 for (Int_t i=0; i<5; i++) p[i]=fHMPIDp->GetParameter()[i];
c38d443f 1745 return kTRUE;
1746}
1747
c0b978f0 1748Bool_t
1749AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
a866ac60 1750 //---------------------------------------------------------------------
c9ec41e8 1751 // This function returns external representation of the cov. matrix
1752 // at the inner layer of TRD
a866ac60 1753 //---------------------------------------------------------------------
c0b978f0 1754 if (!fOp) return kFALSE;
ddfbc51a 1755 for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
c0b978f0 1756 return kTRUE;
a866ac60 1757}
1758
c38d443f 1759Bool_t
1760AliESDtrack::GetOuterHmpExternalCovariance(Double_t cov[15]) const {
1761 //---------------------------------------------------------------------
1762 // This function returns external representation of the cov. matrix
1763 // at the inner layer of TRD
1764 //---------------------------------------------------------------------
1765 if (!fHMPIDp) return kFALSE;
ddfbc51a 1766 for (Int_t i=0; i<15; i++) cov[i]=fHMPIDp->GetCovariance()[i];
c38d443f 1767 return kTRUE;
1768}
1769
98937d93 1770Int_t AliESDtrack::GetNcls(Int_t idet) const
1771{
1772 // Get number of clusters by subdetector index
1773 //
1774 Int_t ncls = 0;
1775 switch(idet){
1776 case 0:
1777 ncls = fITSncls;
1778 break;
1779 case 1:
1780 ncls = fTPCncls;
1781 break;
1782 case 2:
1783 ncls = fTRDncls;
1784 break;
1785 case 3:
ce3f4882 1786 if (fTOFindex != -1)
98937d93 1787 ncls = 1;
1788 break;
81aa7a0d 1789 case 4: //PHOS
1790 break;
1791 case 5: //HMPID
1792 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1793 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1794 ncls = 1;
1795 }
1796 }
1797 break;
98937d93 1798 default:
1799 break;
1800 }
1801 return ncls;
1802}
1803
ef7253ac 1804Int_t AliESDtrack::GetClusters(Int_t idet, Int_t *idx) const
98937d93 1805{
1806 // Get cluster index array by subdetector index
1807 //
1808 Int_t ncls = 0;
1809 switch(idet){
1810 case 0:
1811 ncls = GetITSclusters(idx);
1812 break;
1813 case 1:
ef7253ac 1814 ncls = GetTPCclusters(idx);
98937d93 1815 break;
1816 case 2:
1817 ncls = GetTRDclusters(idx);
1818 break;
1819 case 3:
ce3f4882 1820 if (fTOFindex != -1) {
1821 idx[0] = fTOFindex;
98937d93 1822 ncls = 1;
1823 }
1824 break;
313af949 1825 case 4: //PHOS
1826 break;
1827 case 5:
81aa7a0d 1828 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1829 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1830 idx[0] = GetHMPIDcluIdx();
1831 ncls = 1;
1832 }
313af949 1833 }
1834 break;
1835 case 6: //EMCAL
1836 break;
98937d93 1837 default:
1838 break;
1839 }
1840 return ncls;
1841}
1842
ae982df3 1843//_______________________________________________________________________
fc9b31a7 1844void AliESDtrack::GetIntegratedTimes(Double_t *times, Int_t nspec) const
1845{
1846 // get integrated time for requested N species
1847 if (nspec<1) return;
115179c6 1848 if(fNtofClusters>0 && GetESDEvent()){
49436743 1849 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
1850 AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
fc9b31a7 1851 //
1852 for(int i=tofcl->GetNMatchableTracks();i--;){
1853 if(tofcl->GetTrackIndex(i) == GetID()) {
1854 for (int j=nspec; j--;) times[j]=tofcl->GetIntegratedTime(j,i);
1855 return;
1856 }
115179c6 1857 }
1858 }
1859 else if(fNtofClusters>0)
1860 AliInfo("No AliESDEvent available here!\n");
1861
4427806c 1862 // Returns the array with integrated times for each particle hypothesis
115179c6 1863 if(fTrackTime)
fc9b31a7 1864 for (int i=nspec; i--;) times[i]=fTrackTime[i];
115179c6 1865 else
fc9b31a7 1866 for (int i=AliPID::kSPECIESC; i--;) times[i]=0.0;
1867 //
115179c6 1868}
1869//_______________________________________________________________________
1870Double_t AliESDtrack::GetIntegratedLength() const{
1871 Int_t index = -1;
1872 if(fNtofClusters>0 && GetESDEvent()){
49436743 1873 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
1874 AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
115179c6 1875
1876 for(Int_t i=0;i < tofcl->GetNMatchableTracks();i++){
1877 if(tofcl->GetTrackIndex(i) == GetID()) index = i;
1878 }
1879
1880 if(fNtofClusters>0 && index > -1)
1881 return tofcl->GetLength(index);
1882 }
1883 else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
1884
1885 return fTrackLength;
ae982df3 1886}
1887
1888//_______________________________________________________________________
fc9b31a7 1889void AliESDtrack::SetIntegratedTimes(const Double_t *times)
1890{
4427806c 1891 // Sets the array with integrated times for each particle hypotesis
fc9b31a7 1892 if(!fTrackTime) fTrackTime = new Double32_t[AliPID::kSPECIESC];
1893 for (int i=AliPID::kSPECIESC; i--;) fTrackTime[i]=times[i];
ae982df3 1894}
1895
c630aafd 1896//_______________________________________________________________________
fc9b31a7 1897void AliESDtrack::SetITSpid(const Double_t *p)
1898{
4427806c 1899 // Sets values for the probability of each particle type (in ITS)
a3314882 1900 if (!fITSr) fITSr = new Double32_t[AliPID::kSPECIESC];
d27bbc79 1901 SetPIDValues(fITSr,p,AliPID::kSPECIES);
c630aafd 1902 SetStatus(AliESDtrack::kITSpid);
1903}
1904
1905//_______________________________________________________________________
1906void AliESDtrack::GetITSpid(Double_t *p) const {
4427806c 1907 // Gets the probability of each particle type (in ITS)
a3314882 1908 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fITSr ? fITSr[i] : 0;
c630aafd 1909}
1910
ae982df3 1911//_______________________________________________________________________
562dd0b4 1912Char_t AliESDtrack::GetITSclusters(Int_t *idx) const {
ae982df3 1913 //---------------------------------------------------------------------
1914 // This function returns indices of the assgined ITS clusters
1915 //---------------------------------------------------------------------
59c31692 1916 if (idx && fFriendTrack) {
6d3a7bbf 1917 Int_t *index=fFriendTrack->GetITSindices();
ddfbc51a 1918 for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) {
6d3a7bbf 1919 if ( (i>=fITSncls) && (i<6) ) idx[i]=-1;
1920 else {
1921 if (index) {
1922 idx[i]=index[i];
1923 }
1924 else idx[i]= -2;
1925 }
1926 }
15e85efa 1927 }
ae982df3 1928 return fITSncls;
1929}
1930
89f1b176 1931//_______________________________________________________________________
1932Bool_t AliESDtrack::GetITSModuleIndexInfo(Int_t ilayer,Int_t &idet,Int_t &status,
1933 Float_t &xloc,Float_t &zloc) const {
1934 //----------------------------------------------------------------------
1935 // This function encodes in the module number also the status of cluster association
1936 // "status" can have the following values:
1937 // 1 "found" (cluster is associated),
1938 // 2 "dead" (module is dead from OCDB),
1939 // 3 "skipped" (module or layer forced to be skipped),
1940 // 4 "outinz" (track out of z acceptance),
1941 // 5 "nocls" (no clusters in the road),
1942 // 6 "norefit" (cluster rejected during refit),
1943 // 7 "deadzspd" (holes in z in SPD)
1944 // Also given are the coordinates of the crossing point of track and module
1945 // (in the local module ref. system)
1946 // WARNING: THIS METHOD HAS TO BE SYNCHRONIZED WITH AliITStrackV2::GetModuleIndexInfo()!
1947 //----------------------------------------------------------------------
1948
1949 if(fITSModule[ilayer]==-1) {
89f1b176 1950 idet = -1;
1951 status=0;
1952 xloc=-99.; zloc=-99.;
1953 return kFALSE;
1954 }
1955
1956 Int_t module = fITSModule[ilayer];
1957
1958 idet = Int_t(module/1000000);
1959
1960 module -= idet*1000000;
1961
1962 status = Int_t(module/100000);
1963
1964 module -= status*100000;
1965
1966 Int_t signs = Int_t(module/10000);
1967
1968 module-=signs*10000;
1969
1970 Int_t xInt = Int_t(module/100);
1971 module -= xInt*100;
1972
1973 Int_t zInt = module;
1974
1975 if(signs==1) { xInt*=1; zInt*=1; }
1976 if(signs==2) { xInt*=1; zInt*=-1; }
1977 if(signs==3) { xInt*=-1; zInt*=1; }
1978 if(signs==4) { xInt*=-1; zInt*=-1; }
1979
1980 xloc = 0.1*(Float_t)xInt;
1981 zloc = 0.1*(Float_t)zInt;
1982
1983 if(status==4) idet = -1;
1984
1985 return kTRUE;
1986}
1987
ae982df3 1988//_______________________________________________________________________
562dd0b4 1989UShort_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
ae982df3 1990 //---------------------------------------------------------------------
1991 // This function returns indices of the assgined ITS clusters
1992 //---------------------------------------------------------------------
59c31692 1993 if (idx && fFriendTrack) {
15e85efa 1994 Int_t *index=fFriendTrack->GetTPCindices();
6d3a7bbf 1995
1996 if (index){
ddfbc51a 1997 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
6d3a7bbf 1998 }
1999 else {
ddfbc51a 2000 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=-2;
6d3a7bbf 2001 }
15e85efa 2002 }
ae982df3 2003 return fTPCncls;
2004}
8c6a71ab 2005
4c3dc2a0 2006//_______________________________________________________________________
2007Float_t AliESDtrack::GetTPCCrossedRows() const
2008{
2009 // This function calls GetTPCClusterInfo with some default parameters which are used in the track selection and caches the outcome
2010 // because GetTPCClusterInfo is quite time-consuming
2011
2012 if (fCacheNCrossedRows > -1)
2013 return fCacheNCrossedRows;
2014
2015 fCacheNCrossedRows = GetTPCClusterInfo(2, 1);
2016 return fCacheNCrossedRows;
2017}
2018
6a6f0c1f 2019//_______________________________________________________________________
25f906db 2020Float_t AliESDtrack::GetTPCClusterInfo(Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1, Int_t bitType ) const
6a6f0c1f 2021{
2022 //
2023 // TPC cluster information
2024 // type 0: get fraction of found/findable clusters with neighbourhood definition
2025 // 1: findable clusters with neighbourhood definition
2026 // 2: found clusters
25f906db 2027 // bitType:
2028 // 0 - all cluster used
2029 // 1 - clusters used for the kalman update
6a6f0c1f 2030 // definition of findable clusters:
2031 // a cluster is defined as findable if there is another cluster
2032 // within +- nNeighbours pad rows. The idea is to overcome threshold
2033 // effects with a very simple algorithm.
2034 //
2035
6a6f0c1f 2036
2037 Int_t found=0;
2038 Int_t findable=0;
2039 Int_t last=-nNeighbours;
25f906db 2040 const TBits & clusterMap = (bitType%2==0) ? fTPCClusterMap : fTPCFitMap;
6a6f0c1f 2041
25f906db 2042 Int_t upperBound=clusterMap.GetNbits();
59c31692 2043 if (upperBound>row1) upperBound=row1;
ddfbc51a 2044 for (Int_t i=row0; i<upperBound; ++i){
6a6f0c1f 2045 //look to current row
25f906db 2046 if (clusterMap[i]) {
6a6f0c1f 2047 last=i;
2048 ++found;
2049 ++findable;
2050 continue;
2051 }
2052 //look to nNeighbours before
2053 if ((i-last)<=nNeighbours) {
2054 ++findable;
2055 continue;
2056 }
2057 //look to nNeighbours after
2058 for (Int_t j=i+1; j<i+1+nNeighbours; ++j){
25f906db 2059 if (clusterMap[j]){
6a6f0c1f 2060 ++findable;
2061 break;
2062 }
2063 }
2064 }
25f906db 2065 if (type==2) return found;
2066 if (type==1) return findable;
2067
2068 if (type==0){
2069 Float_t fraction=0;
2070 if (findable>0)
2071 fraction=(Float_t)found/(Float_t)findable;
2072 else
2073 fraction=0;
2074 return fraction;
2075 }
2076 return 0; // undefined type - default value
2077}
2078
2079//_______________________________________________________________________
2080Float_t AliESDtrack::GetTPCClusterDensity(Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1, Int_t bitType ) const
2081{
2082 //
2083 // TPC cluster density - only rows where signal before and after given row are used
2084 // - slower function
2085 // type 0: get fraction of found/findable clusters with neighbourhood definition
2086 // 1: findable clusters with neighbourhood definition
2087 // 2: found clusters
2088 // bitType:
2089 // 0 - all cluster used
2090 // 1 - clusters used for the kalman update
2091 // definition of findable clusters:
2092 // a cluster is defined as findable if there is another cluster
2093 // within +- nNeighbours pad rows. The idea is to overcome threshold
2094 // effects with a very simple algorithm.
2095 //
2096 Int_t found=0;
2097 Int_t findable=0;
2098 // Int_t last=-nNeighbours;
2099 const TBits & clusterMap = (bitType%2==0) ? fTPCClusterMap : fTPCFitMap;
2100 Int_t upperBound=clusterMap.GetNbits();
2101 if (upperBound>row1) upperBound=row1;
2102 for (Int_t i=row0; i<upperBound; ++i){
2103 Bool_t isUp=kFALSE;
2104 Bool_t isDown=kFALSE;
2105 for (Int_t idelta=1; idelta<=nNeighbours; idelta++){
2106 if (i-idelta>=0 && clusterMap[i-idelta]) isDown=kTRUE;
2107 if (i+idelta<upperBound && clusterMap[i+idelta]) isUp=kTRUE;
2108 }
2109 if (isUp&&isDown){
2110 ++findable;
2111 if (clusterMap[i]) ++found;
2112 }
2113 }
2114 if (type==2) return found;
82cc468e 2115 if (type==1) return findable;
2116
6a6f0c1f 2117 if (type==0){
82cc468e 2118 Float_t fraction=0;
2119 if (findable>0)
2120 fraction=(Float_t)found/(Float_t)findable;
2121 else
2122 fraction=0;
2123 return fraction;
2124 }
2125 return 0; // undefined type - default value
6a6f0c1f 2126}
2127
25f906db 2128
2129
2130
6a6f0c1f 2131//_______________________________________________________________________
562dd0b4 2132Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
81e97e0d 2133 //
2134 // GetDensity of the clusters on given region between row0 and row1
2135 // Dead zone effect takin into acoount
2136 //
59c31692 2137 if (!fFriendTrack) return 0.0;
81e97e0d 2138 Int_t good = 0;
2139 Int_t found = 0;
2140 //
15e85efa 2141 Int_t *index=fFriendTrack->GetTPCindices();
81e97e0d 2142 for (Int_t i=row0;i<=row1;i++){
15e85efa 2143 Int_t idx = index[i];
2144 if (idx!=-1) good++; // track outside of dead zone
2145 if (idx>0) found++;
81e97e0d 2146 }
2147 Float_t density=0.5;
a3061175 2148 if (good>TMath::Max((row1-row0)*0.5,0.0)) density = Float_t(found)/Float_t(good);
81e97e0d 2149 return density;
2150}
c84a5e9e 2151
8c6a71ab 2152//_______________________________________________________________________
2153void AliESDtrack::SetTPCpid(const Double_t *p) {
4427806c 2154 // Sets values for the probability of each particle type (in TPC)
a3314882 2155 if (!fTPCr) fTPCr = new Double32_t[AliPID::kSPECIES];
d27bbc79 2156 SetPIDValues(fTPCr,p,AliPID::kSPECIES);
8c6a71ab 2157 SetStatus(AliESDtrack::kTPCpid);
2158}
2159
2160//_______________________________________________________________________
2161void AliESDtrack::GetTPCpid(Double_t *p) const {
4427806c 2162 // Gets the probability of each particle type (in TPC)
a3314882 2163 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fTPCr ? fTPCr[i] : 0;
8c6a71ab 2164}
2165
bb2ceb1f 2166//_______________________________________________________________________
562dd0b4 2167UChar_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
bb2ceb1f 2168 //---------------------------------------------------------------------
2169 // This function returns indices of the assgined TRD clusters
2170 //---------------------------------------------------------------------
59c31692 2171 if (idx && fFriendTrack) {
6d3a7bbf 2172 Int_t *index=fFriendTrack->GetTRDindices();
ddfbc51a 2173
2174 if (index) {
2175 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
2176 }
2177 else {
2178 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=-2;
2179 }
15e85efa 2180 }
bb2ceb1f 2181 return fTRDncls;
2182}
2183
5bc3e158 2184//_______________________________________________________________________
2185UChar_t AliESDtrack::GetTRDtracklets(Int_t *idx) const {
0ad488b0 2186//
2187// This function returns the number of TRD tracklets used in tracking
2188// and it fills the indices of these tracklets in the array "idx" as they
2189// are registered in the TRD track list.
2190//
2191// Caution :
2192// 1. The idx array has to be allocated with a size >= AliESDtrack::kTRDnPlanes
2193// 2. The idx array store not only the index but also the layer of the tracklet.
2194// Therefore tracks with TRD gaps contain default values for indices [-1]
2195
59c31692 2196 if (!fFriendTrack) return 0;
0ad488b0 2197 if (!idx) return GetTRDntracklets();
6d3a7bbf 2198 Int_t *index=fFriendTrack->GetTRDindices();
2199 Int_t n = 0;
ddfbc51a 2200 for (Int_t i=0; i<kTRDnPlanes; i++){
6d3a7bbf 2201 if (index){
2202 if(index[i]>=0) n++;
2203 idx[i]=index[i];
2204 }
2205 else idx[i] = -2;
5bc3e158 2206 }
0ad488b0 2207 return n;
5bc3e158 2208}
2209
c630aafd 2210//_______________________________________________________________________
2211void AliESDtrack::SetTRDpid(const Double_t *p) {
4427806c 2212 // Sets values for the probability of each particle type (in TRD)
a3314882 2213 if (!fTRDr) fTRDr = new Double32_t[AliPID::kSPECIES];
d27bbc79 2214 SetPIDValues(fTRDr,p,AliPID::kSPECIES);
c630aafd 2215 SetStatus(AliESDtrack::kTRDpid);
2216}
2217
2218//_______________________________________________________________________
2219void AliESDtrack::GetTRDpid(Double_t *p) const {
4427806c 2220 // Gets the probability of each particle type (in TRD)
a3314882 2221 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fTRDr ? fTRDr[i]:0;
c630aafd 2222}
2223
79e94bf8 2224//_______________________________________________________________________
2225void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
2226{
4427806c 2227 // Sets the probability of particle type iSpecies to p (in TRD)
a3314882 2228 if (!fTRDr) {
2229 fTRDr = new Double32_t[AliPID::kSPECIES];
2230 for (Int_t i=AliPID::kSPECIES; i--;) fTRDr[i] = 0;
2231 }
79e94bf8 2232 fTRDr[iSpecies] = p;
2233}
2234
562dd0b4 2235Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
79e94bf8 2236{
4427806c 2237 // Returns the probability of particle type iSpecies (in TRD)
a3314882 2238 return fTRDr ? fTRDr[iSpecies] : 0;
79e94bf8 2239}
2240
fae4c212 2241//____________________________________________________
2242Int_t AliESDtrack::GetNumberOfTRDslices() const
2243{
2244 // built in backward compatibility
2245 Int_t idx = fTRDnSlices - (kTRDnPlanes<<1);
2246 return idx<18 ? fTRDnSlices/kTRDnPlanes : idx/kTRDnPlanes;
2247}
2248
2249//____________________________________________________
2250Double_t AliESDtrack::GetTRDmomentum(Int_t plane, Double_t *sp) const
2251{
2252//Returns momentum estimation and optional its error (sp)
2253// in TRD layer "plane".
2254
2255 if (!fTRDnSlices) {
ba8cee18 2256 AliDebug(2, "No TRD info allocated for this track.");
fae4c212 2257 return -1.;
2258 }
2259 if ((plane<0) || (plane>=kTRDnPlanes)) {
ba8cee18 2260 AliWarning(Form("Request for TRD plane[%d] outside range.", plane));
fae4c212 2261 return -1.;
2262 }
2263
2264 Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
2265 // Protection for backward compatibility
2266 if(idx<(GetNumberOfTRDslices()*kTRDnPlanes)) return -1.;
2267
2268 if(sp) (*sp) = fTRDslices[idx+kTRDnPlanes];
2269 return fTRDslices[idx];
2270}
2271
2272//____________________________________________________
2273Double_t AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
2274 //Gets the charge from the slice of the plane
2275
2276 if(!fTRDslices) {
2277 //AliError("No TRD slices allocated for this track !");
2278 return -1.;
2279 }
2280 if ((plane<0) || (plane>=kTRDnPlanes)) {
2281 AliError("Info for TRD plane not available !");
2282 return -1.;
2283 }
2284 Int_t ns=GetNumberOfTRDslices();
2285 if ((slice<-1) || (slice>=ns)) {
2286 //AliError("Wrong TRD slice !");
2287 return -1.;
2288 }
2289
2290 if(slice>=0) return fTRDslices[plane*ns + slice];
2291
2292 // return average of the dEdx measurements
2293 Double_t q=0.; Double32_t *s = &fTRDslices[plane*ns];
ddfbc51a 2294 for (Int_t i=0; i<ns; i++, s++) if((*s)>0.) q+=(*s);
fae4c212 2295 return q/ns;
2296}
2297
2298//____________________________________________________
6984f7c1 2299void AliESDtrack::SetNumberOfTRDslices(Int_t n) {
2300 //Sets the number of slices used for PID
fae4c212 2301 if (fTRDnSlices) return;
ddfbc51a 2302
fae4c212 2303 fTRDnSlices=n;
ddfbc51a 2304 fTRDslices=new Double32_t[fTRDnSlices];
2305
fae4c212 2306 // set-up correctly the allocated memory
2307 memset(fTRDslices, 0, n*sizeof(Double32_t));
ddfbc51a 2308 for (Int_t i=GetNumberOfTRDslices(); i--;) fTRDslices[i]=-1.;
6984f7c1 2309}
2310
fae4c212 2311//____________________________________________________
6984f7c1 2312void AliESDtrack::SetTRDslice(Double_t q, Int_t plane, Int_t slice) {
2313 //Sets the charge q in the slice of the plane
fae4c212 2314 if(!fTRDslices) {
6984f7c1 2315 AliError("No TRD slices allocated for this track !");
2316 return;
2317 }
6984f7c1 2318 if ((plane<0) || (plane>=kTRDnPlanes)) {
fae4c212 2319 AliError("Info for TRD plane not allocated !");
6984f7c1 2320 return;
2321 }
fae4c212 2322 Int_t ns=GetNumberOfTRDslices();
6984f7c1 2323 if ((slice<0) || (slice>=ns)) {
be20337a 2324 AliError(Form("Wrong TRD slice %d/%d, NSlices=%d",plane,slice,ns));
6984f7c1 2325 return;
2326 }
2327 Int_t n=plane*ns + slice;
2328 fTRDslices[n]=q;
2329}
2330
6984f7c1 2331
fae4c212 2332//____________________________________________________
2333void AliESDtrack::SetTRDmomentum(Double_t p, Int_t plane, Double_t *sp)
2334{
2335 if(!fTRDslices) {
2336 AliError("No TRD slices allocated for this track !");
2337 return;
6984f7c1 2338 }
fae4c212 2339 if ((plane<0) || (plane>=kTRDnPlanes)) {
2340 AliError("Info for TRD plane not allocated !");
2341 return;
6984f7c1 2342 }
2343
fae4c212 2344 Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
2345 // Protection for backward compatibility
2346 if(idx<GetNumberOfTRDslices()*kTRDnPlanes) return;
6984f7c1 2347
fae4c212 2348 if(sp) fTRDslices[idx+kTRDnPlanes] = (*sp);
2349 fTRDslices[idx] = p;
6984f7c1 2350}
2351
2352
c630aafd 2353//_______________________________________________________________________
2354void AliESDtrack::SetTOFpid(const Double_t *p) {
4427806c 2355 // Sets the probability of each particle type (in TOF)
a3314882 2356 if (!fTOFr) fTOFr = new Double32_t[AliPID::kSPECIES];
d27bbc79 2357 SetPIDValues(fTOFr,p,AliPID::kSPECIES);
c630aafd 2358 SetStatus(AliESDtrack::kTOFpid);
2359}
2360
51ad6848 2361//_______________________________________________________________________
2362void AliESDtrack::SetTOFLabel(const Int_t *p) {
2363 // Sets (in TOF)
115179c6 2364 if(!fTOFLabel) fTOFLabel = new Int_t[3];
ddfbc51a 2365 for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
51ad6848 2366}
2367
c630aafd 2368//_______________________________________________________________________
2369void AliESDtrack::GetTOFpid(Double_t *p) const {
4427806c 2370 // Gets probabilities of each particle type (in TOF)
a3314882 2371 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fTOFr ? fTOFr[i]:0;
c630aafd 2372}
2373
51ad6848 2374//_______________________________________________________________________
2375void AliESDtrack::GetTOFLabel(Int_t *p) const {
2376 // Gets (in TOF)
115179c6 2377 if(fNtofClusters>0){
49436743 2378 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
2379 AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
115179c6 2380
2381 for (Int_t i=0; i<3; i++) p[i]=tofcl->GetLabel(i);
2382 }
2383 else{
2384 if(fTOFLabel)
2385 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
2386 }
51ad6848 2387}
2388
2389//_______________________________________________________________________
2390void AliESDtrack::GetTOFInfo(Float_t *info) const {
2391 // Gets (in TOF)
ddfbc51a 2392 for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
51ad6848 2393}
2394
2395//_______________________________________________________________________
2396void AliESDtrack::SetTOFInfo(Float_t*info) {
2397 // Gets (in TOF)
ddfbc51a 2398 for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
51ad6848 2399}
2400
4a78b8c5 2401
2402
4a78b8c5 2403//_______________________________________________________________________
f4b3bbb7 2404void AliESDtrack::SetHMPIDpid(const Double_t *p) {
2405 // Sets the probability of each particle type (in HMPID)
a3314882 2406 if (!fHMPIDr) fHMPIDr = new Double32_t[AliPID::kSPECIES];
f4b3bbb7 2407 SetPIDValues(fHMPIDr,p,AliPID::kSPECIES);
2408 SetStatus(AliESDtrack::kHMPIDpid);
4a78b8c5 2409}
2410
3876bdbf 2411//_______________________________________________________________________
ddfbc51a 2412void AliESDtrack::SetTPCdEdxInfo(AliTPCdEdxInfo * dEdxInfo){
2413 if(fTPCdEdxInfo) delete fTPCdEdxInfo;
3876bdbf 2414 fTPCdEdxInfo = dEdxInfo;
2415}
2416
4a78b8c5 2417//_______________________________________________________________________
f4b3bbb7 2418void AliESDtrack::GetHMPIDpid(Double_t *p) const {
2419 // Gets probabilities of each particle type (in HMPID)
a3314882 2420 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fHMPIDr ? fHMPIDr[i]:0;
4a78b8c5 2421}
2422
ddfbc51a 2423
2424
8c6a71ab 2425//_______________________________________________________________________
2426void AliESDtrack::SetESDpid(const Double_t *p) {
4427806c 2427 // Sets the probability of each particle type for the ESD track
a3314882 2428 if (!fR) fR = new Double32_t[AliPID::kSPECIES];
d27bbc79 2429 SetPIDValues(fR,p,AliPID::kSPECIES);
8c6a71ab 2430 SetStatus(AliESDtrack::kESDpid);
2431}
2432
2433//_______________________________________________________________________
2434void AliESDtrack::GetESDpid(Double_t *p) const {
4427806c 2435 // Gets probability of each particle type for the ESD track
a3314882 2436 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fR ? fR[i]:0;
8c6a71ab 2437}
2438
d7ddf1e9 2439//_______________________________________________________________________
436dfe39 2440Bool_t AliESDtrack::RelateToVertexTPC(const AliESDVertex *vtx,
2441Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
d7ddf1e9 2442 //
436dfe39 2443 // Try to relate the TPC-only track parameters to the vertex "vtx",
d7ddf1e9 2444 // if the (rough) transverse impact parameter is not bigger then "maxd".
2445 // Magnetic field is "b" (kG).
2446 //
2447 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
2448 // b) The impact parameters and their covariance matrix are calculated.
436dfe39 2449 // c) An attempt to constrain the TPC-only params to the vertex is done.
2450 // The constrained params are returned via "cParam".
d7ddf1e9 2451 //
436dfe39 2452 // In the case of success, the returned value is kTRUE
2453 // otherwise, it's kFALSE)
2454 //
d7ddf1e9 2455
2456 if (!fTPCInner) return kFALSE;
2457 if (!vtx) return kFALSE;
2458
2459 Double_t dz[2],cov[3];
2460 if (!fTPCInner->PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
2461
2462 fdTPC = dz[0];
2463 fzTPC = dz[1];
2464 fCddTPC = cov[0];
2465 fCdzTPC = cov[1];
2466 fCzzTPC = cov[2];
2467
436dfe39 2468 Double_t covar[6]; vtx->GetCovMatrix(covar);
2469 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2470 Double_t c[3]={covar[2],0.,covar[5]};
2471
2472 Double_t chi2=GetPredictedChi2(p,c);
2473 if (chi2>kVeryBig) return kFALSE;
2474
2475 fCchi2TPC=chi2;
2476
2477 if (!cParam) return kTRUE;
2478
2479 *cParam = *fTPCInner;
2480 if (!cParam->Update(p,c)) return kFALSE;
2481
d7ddf1e9 2482 return kTRUE;
2483}
2484
266a0f9b 2485//_______________________________________________________________________
2486Bool_t AliESDtrack::RelateToVertexTPCBxByBz(const AliESDVertex *vtx,
2487Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2488 //
2489 // Try to relate the TPC-only track parameters to the vertex "vtx",
2490 // if the (rough) transverse impact parameter is not bigger then "maxd".
2491 //
2492 // All three components of the magnetic field ,"b[3]" (kG),
2493 // are taken into account.
2494 //
2495 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
2496 // b) The impact parameters and their covariance matrix are calculated.
2497 // c) An attempt to constrain the TPC-only params to the vertex is done.
2498 // The constrained params are returned via "cParam".
2499 //
2500 // In the case of success, the returned value is kTRUE
2501 // otherwise, it's kFALSE)
2502 //
2503
2504 if (!fTPCInner) return kFALSE;
2505 if (!vtx) return kFALSE;
2506
2507 Double_t dz[2],cov[3];
2508 if (!fTPCInner->PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2509
2510 fdTPC = dz[0];
2511 fzTPC = dz[1];
2512 fCddTPC = cov[0];
2513 fCdzTPC = cov[1];
2514 fCzzTPC = cov[2];
2515
2516 Double_t covar[6]; vtx->GetCovMatrix(covar);
2517 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2518 Double_t c[3]={covar[2],0.,covar[5]};
2519
2520 Double_t chi2=GetPredictedChi2(p,c);
2521 if (chi2>kVeryBig) return kFALSE;
2522
2523 fCchi2TPC=chi2;
2524
2525 if (!cParam) return kTRUE;
2526
2527 *cParam = *fTPCInner;
2528 if (!cParam->Update(p,c)) return kFALSE;
2529
2530 return kTRUE;
2531}
2532
49d13e89 2533//_______________________________________________________________________
436dfe39 2534Bool_t AliESDtrack::RelateToVertex(const AliESDVertex *vtx,
2535Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
49d13e89 2536 //
2537 // Try to relate this track to the vertex "vtx",
2538 // if the (rough) transverse impact parameter is not bigger then "maxd".
2539 // Magnetic field is "b" (kG).
2540 //
2541 // a) The track gets extapolated to the DCA to the vertex.
2542 // b) The impact parameters and their covariance matrix are calculated.
2543 // c) An attempt to constrain this track to the vertex is done.
436dfe39 2544 // The constrained params are returned via "cParam".
49d13e89 2545 //
436dfe39 2546 // In the case of success, the returned value is kTRUE
2547 // (otherwise, it's kFALSE)
49d13e89 2548 //
b5d34a4c 2549
2550 if (!vtx) return kFALSE;
2551
e99a34df 2552 Double_t dz[2],cov[3];
2553 if (!PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
2554
2555 fD = dz[0];
2556 fZ = dz[1];
2557 fCdd = cov[0];
2558 fCdz = cov[1];
2559 fCzz = cov[2];
49d13e89 2560
e99a34df 2561 Double_t covar[6]; vtx->GetCovMatrix(covar);
2562 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2563 Double_t c[3]={covar[2],0.,covar[5]};
3231f9e5 2564
e99a34df 2565 Double_t chi2=GetPredictedChi2(p,c);
436dfe39 2566 if (chi2>kVeryBig) return kFALSE;
2567
2568 fCchi2=chi2;
49d13e89 2569
436dfe39 2570
266a0f9b 2571 //--- Could now these lines be removed ? ---
2572 delete fCp;
2573 fCp=new AliExternalTrackParam(*this);
2574
2575 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
2576 //----------------------------------------
2577
2578 fVertexID = vtx->GetID();
2579
2580 if (!cParam) return kTRUE;
2581
2582 *cParam = *this;
2583 if (!cParam->Update(p,c)) return kFALSE;
2584
2585 return kTRUE;
2586}
2587
2588//_______________________________________________________________________
2589Bool_t AliESDtrack::RelateToVertexBxByBz(const AliESDVertex *vtx,
2590Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2591 //
2592 // Try to relate this track to the vertex "vtx",
2593 // if the (rough) transverse impact parameter is not bigger then "maxd".
2594 // Magnetic field is "b" (kG).
2595 //
2596 // a) The track gets extapolated to the DCA to the vertex.
2597 // b) The impact parameters and their covariance matrix are calculated.
2598 // c) An attempt to constrain this track to the vertex is done.
2599 // The constrained params are returned via "cParam".
2600 //
2601 // In the case of success, the returned value is kTRUE
2602 // (otherwise, it's kFALSE)
2603 //
2604
2605 if (!vtx) return kFALSE;
2606
2607 Double_t dz[2],cov[3];
2608 if (!PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2609
2610 fD = dz[0];
2611 fZ = dz[1];
2612 fCdd = cov[0];
2613 fCdz = cov[1];
2614 fCzz = cov[2];
2615
2616 Double_t covar[6]; vtx->GetCovMatrix(covar);
2617 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2618 Double_t c[3]={covar[2],0.,covar[5]};
2619
2620 Double_t chi2=GetPredictedChi2(p,c);
2621 if (chi2>kVeryBig) return kFALSE;
2622
2623 fCchi2=chi2;
2624
2625
436dfe39 2626 //--- Could now these lines be removed ? ---
e99a34df 2627 delete fCp;
2628 fCp=new AliExternalTrackParam(*this);
49d13e89 2629
e99a34df 2630 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
436dfe39 2631 //----------------------------------------
2632
6dc21f57 2633 fVertexID = vtx->GetID();
436dfe39 2634
2635 if (!cParam) return kTRUE;
2636
2637 *cParam = *this;
2638 if (!cParam->Update(p,c)) return kFALSE;
2639
49d13e89 2640 return kTRUE;
2641}
2642
ac2f7574 2643//_______________________________________________________________________
2644void AliESDtrack::Print(Option_t *) const {
2645 // Prints info on the track
b9ca886f 2646 AliExternalTrackParam::Print();
5f7789fc 2647 printf("ESD track info\n") ;
00a38d07 2648 Double_t p[AliPID::kSPECIES] ;
ac2f7574 2649 Int_t index = 0 ;
2650 if( IsOn(kITSpid) ){
2651 printf("From ITS: ") ;
2652 GetITSpid(p) ;
304864ab 2653 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2654 printf("%f, ", p[index]) ;
2655 printf("\n signal = %f\n", GetITSsignal()) ;
2656 }
2657 if( IsOn(kTPCpid) ){
2658 printf("From TPC: ") ;
2659 GetTPCpid(p) ;
304864ab 2660 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2661 printf("%f, ", p[index]) ;
2662 printf("\n signal = %f\n", GetTPCsignal()) ;
2663 }
2664 if( IsOn(kTRDpid) ){
2665 printf("From TRD: ") ;
2666 GetTRDpid(p) ;
304864ab 2667 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2668 printf("%f, ", p[index]) ;
6984f7c1 2669 printf("\n signal = %f\n", GetTRDsignal()) ;
4d302e42 2670 printf("\n NchamberdEdx = %d\n", GetTRDNchamberdEdx()) ;
2671 printf("\n NclusterdEdx = %d\n", GetTRDNclusterdEdx()) ;
ac2f7574 2672 }
2673 if( IsOn(kTOFpid) ){
2674 printf("From TOF: ") ;
2675 GetTOFpid(p) ;
304864ab 2676 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2677 printf("%f, ", p[index]) ;
2678 printf("\n signal = %f\n", GetTOFsignal()) ;
2679 }
f4b3bbb7 2680 if( IsOn(kHMPIDpid) ){
2681 printf("From HMPID: ") ;
2682 GetHMPIDpid(p) ;
304864ab 2683 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2684 printf("%f, ", p[index]) ;
f4b3bbb7 2685 printf("\n signal = %f\n", GetHMPIDsignal()) ;
ac2f7574 2686 }
ac2f7574 2687}
6c94f330 2688
0c19adf7 2689
2690//
2691// Draw functionality
2692// Origin: Marian Ivanov, Marian.Ivanov@cern.ch
2693//
2694void AliESDtrack::FillPolymarker(TPolyMarker3D *pol, Float_t magF, Float_t minR, Float_t maxR, Float_t stepR){
2695 //
2696 // Fill points in the polymarker
2697 //
2698 TObjArray arrayRef;
2699 arrayRef.AddLast(new AliExternalTrackParam(*this));
2700 if (fIp) arrayRef.AddLast(new AliExternalTrackParam(*fIp));
2701 if (fOp) arrayRef.AddLast(new AliExternalTrackParam(*fOp));
c38d443f 2702 if (fHMPIDp) arrayRef.AddLast(new AliExternalTrackParam(*fHMPIDp));
0c19adf7 2703 //
2704 Double_t mpos[3]={0,0,0};
2705 Int_t entries=arrayRef.GetEntries();
ddfbc51a 2706 for (Int_t i=0;i<entries;i++){
0c19adf7 2707 Double_t pos[3];
2708 ((AliExternalTrackParam*)arrayRef.At(i))->GetXYZ(pos);
2709 mpos[0]+=pos[0]/entries;
2710 mpos[1]+=pos[1]/entries;
2711 mpos[2]+=pos[2]/entries;
2712 }
2713 // Rotate to the mean position
2714 //
2715 Float_t fi= TMath::ATan2(mpos[1],mpos[0]);
2716 for (Int_t i=0;i<entries;i++){
2717 Bool_t res = ((AliExternalTrackParam*)arrayRef.At(i))->Rotate(fi);
2718 if (!res) delete arrayRef.RemoveAt(i);
2719 }
2720 Int_t counter=0;
2721 for (Double_t r=minR; r<maxR; r+=stepR){
2722 Double_t sweight=0;
2723 Double_t mlpos[3]={0,0,0};
2724 for (Int_t i=0;i<entries;i++){
2725 Double_t point[3]={0,0,0};
2726 AliExternalTrackParam *param = ((AliExternalTrackParam*)arrayRef.At(i));
2727 if (!param) continue;
2728 if (param->GetXYZAt(r,magF,point)){
2729 Double_t weight = 1./(10.+(r-param->GetX())*(r-param->GetX()));
2730 sweight+=weight;
2731 mlpos[0]+=point[0]*weight;
2732 mlpos[1]+=point[1]*weight;
2733 mlpos[2]+=point[2]*weight;
2734 }
2735 }
2736 if (sweight>0){
2737 mlpos[0]/=sweight;
2738 mlpos[1]/=sweight;
2739 mlpos[2]/=sweight;
2740 pol->SetPoint(counter,mlpos[0],mlpos[1], mlpos[2]);
047640da 2741 // printf("xyz\t%f\t%f\t%f\n",mlpos[0], mlpos[1],mlpos[2]);
0c19adf7 2742 counter++;
2743 }
2744 }
2745}
1d4882da 2746
2747//_______________________________________________________________________
2748void AliESDtrack::SetITSdEdxSamples(const Double_t s[4]) {
2749 //
2750 // Store the dE/dx samples measured by the two SSD and two SDD layers.
2751 // These samples are corrected for the track segment length.
2752 //
ddfbc51a 2753 for (Int_t i=0; i<4; i++) fITSdEdxSamples[i]=s[i];
1d4882da 2754}
2755
2756//_______________________________________________________________________
74ca66e3 2757void AliESDtrack::GetITSdEdxSamples(Double_t s[4]) const {
1d4882da 2758 //
2759 // Get the dE/dx samples measured by the two SSD and two SDD layers.
2760 // These samples are corrected for the track segment length.
2761 //
ddfbc51a 2762 for (Int_t i=0; i<4; i++) s[i]=fITSdEdxSamples[i];
1d4882da 2763}
949840f6 2764
2765
2766UShort_t AliESDtrack::GetTPCnclsS(Int_t i0,Int_t i1) const{
2767 //
beb01154 2768 // get number of shared TPC clusters
949840f6 2769 //
2770 return fTPCSharedMap.CountBits(i0)-fTPCSharedMap.CountBits(i1);
2771}
beb01154 2772
2773UShort_t AliESDtrack::GetTPCncls(Int_t i0,Int_t i1) const{
2774 //
2775 // get number of TPC clusters
2776 //
2777 return fTPCClusterMap.CountBits(i0)-fTPCClusterMap.CountBits(i1);
2778}
4c3dc2a0 2779
2780//____________________________________________________________________
2781Double_t AliESDtrack::GetChi2TPCConstrainedVsGlobal(const AliESDVertex* vtx) const
2782{
2783 // Calculates the chi2 between the TPC track (TPCinner) constrained to the primary vertex and the global track
2784 //
2785 // Returns -1 in case the calculation failed
2786 //
2787 // Value is cached as a non-persistent member.
2788 //
2789 // Code adapted from original code by GSI group (Jacek, Marian, Michael)
2790
2791 // cache, ignoring that a different vertex might be passed
2792 if (fCacheChi2TPCConstrainedVsGlobalVertex == vtx)
2793 return fCacheChi2TPCConstrainedVsGlobal;
2794
2795 fCacheChi2TPCConstrainedVsGlobal = -1;
2796 fCacheChi2TPCConstrainedVsGlobalVertex = vtx;
2797
2798 Double_t x[3];
2799 GetXYZ(x);
2800 Double_t b[3];
2801 AliTrackerBase::GetBxByBz(x,b);
2802
2803 if (!fTPCInner) {
2804 AliWarning("Could not get TPC Inner Param.");
2805 return fCacheChi2TPCConstrainedVsGlobal;
2806 }
2807
2808 // clone for constraining
ddfbc51a 2809 AliExternalTrackParam* tpcInnerC = new AliExternalTrackParam(*fTPCInner);
2810 if (!tpcInnerC) {
2811 AliWarning("Clone of TPCInnerParam failed.");
2812 return fCacheChi2TPCConstrainedVsGlobal;
2813 }
4c3dc2a0 2814
2815 // transform to the track reference frame
ddfbc51a 2816 Bool_t isOK = tpcInnerC->Rotate(GetAlpha());
2817 isOK &= tpcInnerC->PropagateTo(GetX(), b[2]);
4c3dc2a0 2818 if (!isOK) {
ddfbc51a 2819 delete tpcInnerC;
2820 tpcInnerC = 0;
4c3dc2a0 2821 AliWarning("Rotation/Propagation of track failed.") ;
2822 return fCacheChi2TPCConstrainedVsGlobal;
2823 }
2824
2825 // constrain TPCinner
ddfbc51a 2826 isOK = tpcInnerC->ConstrainToVertex(vtx, b);
4c3dc2a0 2827
2828 // transform to the track reference frame
ddfbc51a 2829 isOK &= tpcInnerC->Rotate(GetAlpha());
2830 isOK &= tpcInnerC->PropagateTo(GetX(), b[2]);
4c3dc2a0 2831
2832 if (!isOK) {
2833 AliWarning("ConstrainTPCInner failed.") ;
ddfbc51a 2834 delete tpcInnerC;
2835 tpcInnerC = 0;
4c3dc2a0 2836 return fCacheChi2TPCConstrainedVsGlobal;
2837 }
2838
2839 // calculate chi2 between vi and vj vectors
2840 // with covi and covj covariance matrices
2841 // chi2ij = (vi-vj)^(T)*(covi+covj)^(-1)*(vi-vj)
2842 TMatrixD deltaT(5,1);
2843 TMatrixD delta(1,5);
2844 TMatrixD covarM(5,5);
2845
ddfbc51a 2846 for (Int_t ipar=0; ipar<5; ipar++) {
2847 deltaT(ipar,0) = tpcInnerC->GetParameter()[ipar] - GetParameter()[ipar];
2848 delta(0,ipar) = tpcInnerC->GetParameter()[ipar] - GetParameter()[ipar];
4c3dc2a0 2849
2850 for (Int_t jpar=0; jpar<5; jpar++) {
2851 Int_t index = GetIndex(ipar,jpar);
ddfbc51a 2852 covarM(ipar,jpar) = GetCovariance()[index]+tpcInnerC->GetCovariance()[index];
4c3dc2a0 2853 }
2854 }
2855 // chi2 distance TPC constrained and TPC+ITS
2856 TMatrixD covarMInv = covarM.Invert();
2857 TMatrixD mat2 = covarMInv*deltaT;
2858 TMatrixD chi2 = delta*mat2;
ddfbc51a 2859
2860 delete tpcInnerC;
2861 tpcInnerC = 0;
2862
4c3dc2a0 2863 fCacheChi2TPCConstrainedVsGlobal = chi2(0,0);
2864 return fCacheChi2TPCConstrainedVsGlobal;
2865}
00a38d07 2866
2867void AliESDtrack::SetDetectorPID(const AliDetectorPID *pid)
2868{
2869 //
2870 // Set the detector PID
2871 //
2872 if (fDetectorPID) delete fDetectorPID;
2873 fDetectorPID=pid;
2874
2875}
73178f8a 2876
08b7c4be 2877Double_t AliESDtrack::GetLengthInActiveZone( Int_t mode, Double_t deltaY, Double_t deltaZ, Double_t bz, Double_t exbPhi , TTreeSRedirector * pcstream) const {
73178f8a 2878 //
2879 // Input parameters:
2880 // mode - type of external track parameters
2881 // deltaY - user defined "dead region" in cm
2882 // deltaZ - user defined "active region" in cm (250 cm drift lenght - 14 cm L1 delay
2883 // bz - magnetic field
2884 // exbPhi - optional rotation due to the ExB effect
2885 // return value:
2886 // the length of the track in cm in "active volume" of the TPC
2887 //
2888 if (mode==0) return GetLengthInActiveZone(this, deltaY,deltaZ,bz, exbPhi,pcstream);
2889 if (mode==1) return GetLengthInActiveZone(fIp, deltaY,deltaZ,bz, exbPhi,pcstream);
2890 if (mode==2) return GetLengthInActiveZone(fOp, deltaY,deltaZ,bz, exbPhi,pcstream);
2891 return 0;
2892}
2893
e0a0dd3c 2894Double_t AliESDtrack::GetLengthInActiveZone(const AliExternalTrackParam *paramT, Double_t deltaY, Double_t deltaZ, Double_t bz, Double_t exbPhi , TTreeSRedirector * pcstream) {
73178f8a 2895 //
2896 // Numerical code to calculate the length of the track in active region of the TPC
2897 // ( can be speed up if somebody wants to invest time - analysical version shoult be possible)
2898 //
2899 // Input parameters:
2900 // paramT - external track parameters
2901 // deltaY - user defined "dead region" in cm
2902 // deltaZ - user defined "active region" in cm (250 cm drift lenght - 14 cm L1 delay
2903 // bz - magnetic field
2904 // exbPhi - optional rotation due to the ExB effect
2905 // return value:
2906 // the length of the track in cm in "active volume" of the TPC
2907 //
2908 const Double_t rIn=85;
2909 const Double_t rOut=245;
2910 Double_t xyz[3], pxyz[3];
2911 if (paramT->GetXYZAt(rIn,bz,xyz)){
2912 paramT->GetPxPyPzAt(rIn,bz,pxyz);
2913 }else{
2914 paramT->GetXYZ(xyz);
2915 paramT->GetPxPyPz(pxyz);
2916 }
2917 //
2918 Double_t dca = -paramT->GetD(0,0,bz); // get impact parameter distance to point (0,0)
2919 Double_t radius= TMath::Abs(1/paramT->GetC(bz)); //
2920 Double_t sign = paramT->GetSign();
2921 Double_t R0 = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]); // radius at current point
2922 Double_t phiR0 = TMath::ATan2(xyz[1],xyz[0]); // angle of given point
2923 Double_t dPhiR0= -TMath::ASin((dca*dca-2*dca*radius*sign+R0*R0)/(2*R0*(dca-radius*sign)));
2924 Double_t phi0 = phiR0-(dPhiR0); // global phi offset to be added
2925 //
2926 //
2927 AliExternalTrackParam paramR=(*paramT);
2928 Double_t length=0;
2929 for (Double_t R=rIn; R<=rOut; R++){
2930 Double_t sinPhi=(dca*dca-2*dca*radius*sign+R*R)/(2*R*(dca-radius*sign));
2931 if (TMath::Abs(sinPhi)>=1) continue;
2932 Double_t dphi = -TMath::ASin(sinPhi);
2933 Double_t phi = phi0+dphi; // global phi
2934 Int_t sector = TMath::Nint(9*phi/(TMath::Pi()));
2935 Double_t dPhiEdge = phi-(sector*TMath::Pi()/9)+exbPhi; // distance to sector boundary in rphi
2936 Double_t dX = R*TMath::Cos(phi)-xyz[0];
2937 Double_t dY = R*TMath::Sin(phi)-xyz[1];
2938 Double_t deltaPhi = 2*TMath::ASin(0.5*TMath::Sqrt(dX*dX+dY*dY)/radius);
2939 Double_t z = xyz[2]+deltaPhi*radius*paramT->GetTgl();
2940 if (TMath::Abs(dPhiEdge*R)>deltaY && TMath::Abs(z)<deltaZ){
2941 length++;
2942 }
2943 // Double_t deltaZ= dphi*radius;
2944 if (pcstream){
2945 //should we keep debug possibility ?
08b7c4be 2946 AliExternalTrackParam paramTcopy=(*paramT);
73178f8a 2947 paramR.Rotate(phi);
2948 paramR.PropagateTo(R,bz);
2949 (*pcstream)<<"debugEdge"<<
2950 "R="<<R<< // radius
2951 "dphiEdge="<<dPhiEdge<< // distance to edge
2952 "phi0="<<phi0<< // phi0 -phi at the track initial position
2953 "phi="<<phi<< //
2954 "z="<<z<<
08b7c4be 2955 "pT.="<<&paramTcopy<<
73178f8a 2956 "pR.="<<&paramR<<
2957 "\n";
2958 }
2959 }
2960 return length;
2961}
115179c6 2962
a3314882 2963Double_t AliESDtrack::GetMassForTracking() const
2964{
10d99e43 2965 int pid = fPIDForTracking;
2966 if (pid<AliPID::kPion) pid = AliPID::kPion;
2967 double m = AliPID::ParticleMass(pid);
a3314882 2968 return (fPIDForTracking==AliPID::kHe3 || fPIDForTracking==AliPID::kAlpha) ? -m : m;
2969}
2970
49436743 2971
bbd0b659 2972void AliESDtrack::SetTOFclusterArray(Int_t /*ncluster*/,Int_t */*TOFcluster*/){
115179c6 2973 AliInfo("Method has to be implemented!");
2974// fNtofClusters=ncluster;
2975// if(TOFcluster == fTOFcluster) return;
2976// if(fTOFcluster){ // reset previous content
2977// delete[] fTOFcluster;
2978// fTOFcluster = NULL;
2979// fNtofClusters=0;
2980// }
2981
2982// if(ncluster){ // set new content
2983// fTOFcluster = new Int_t[fNtofClusters];
2984// for(Int_t i=0;i < fNtofClusters;i++) fTOFcluster[i] = TOFcluster[i];
2985// }
2986// else
2987// fTOFcluster = 0;
2988}
2989
49436743 2990//____________________________________________
2991void AliESDtrack::SuppressTOFMatches()
2992{
2993 // remove reference to this track from TOF clusters
2994 if (!fNtofClusters || !GetESDEvent()) return;
2995 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
2996 for (;fNtofClusters--;) {
2997 AliESDTOFCluster* clTOF = (AliESDTOFCluster*)tofclArray->At(fTOFcluster[fNtofClusters]);
2998 clTOF->SuppressMatchedTrack(GetID());
2999 if (!clTOF->GetNMatchableTracks()) { // remove this cluster
3000 int last = tofclArray->GetEntriesFast()-1;
3001 AliESDTOFCluster* clTOFL = (AliESDTOFCluster*)tofclArray->At(last);
3002 if (last != fTOFcluster[fNtofClusters]) {
3003 *clTOF = *clTOFL; // move last cluster to the place of eliminated one
3004 // fix the references on this cluster
3005 clTOF->FixSelfReferences(last,fTOFcluster[fNtofClusters]);
3006 }
3007 tofclArray->RemoveAt(last);
3008 }
3009 }
3010}
3011
3012//____________________________________________
3013void AliESDtrack::ReplaceTOFTrackID(int oldID, int newID)
3014{
3015 // replace the ID in TOF clusters references to this track
3016 if (!fNtofClusters || !GetESDEvent()) return;
3017 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
3018 for (int it=fNtofClusters;it--;) {
3019 AliESDTOFCluster* clTOF = (AliESDTOFCluster*)tofclArray->At(fTOFcluster[it]);
3020 clTOF->ReplaceMatchedTrackID(oldID,newID);
3021 }
3022}
3023
3024//____________________________________________
3025void AliESDtrack::ReplaceTOFClusterID(int oldID, int newID)
3026{
3027 // replace the referenc on TOF cluster oldID by newID
3028 if (!fNtofClusters || !GetESDEvent()) return;
3029 for (int it=fNtofClusters;it--;) {
3030 if (fTOFcluster[it] == oldID) {
3031 fTOFcluster[it] = newID;
3032 return;
3033 }
3034 }
3035}
3036
3037//____________________________________________
3038void AliESDtrack::ReplaceTOFMatchID(int oldID, int newID)
3039{
3040 // replace in the ESDTOFCluster associated with this track the id of the corresponding
3041 // ESDTOFMatch from oldID to newID
3042 if (!fNtofClusters || !GetESDEvent()) return;
3043 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
3044 for (int it=fNtofClusters;it--;) {
3045 AliESDTOFCluster* clTOF = (AliESDTOFCluster*)tofclArray->At(fTOFcluster[it]);
3046 clTOF->ReplaceMatchID(oldID,newID);
3047 }
3048}
3049
3050//____________________________________________
3051void AliESDtrack::AddTOFcluster(Int_t icl)
3052{
115179c6 3053 fNtofClusters++;
3054
3055 Int_t *old = fTOFcluster;
3056 fTOFcluster = new Int_t[fNtofClusters];
3057
3058 for(Int_t i=0;i < fNtofClusters-1;i++) fTOFcluster[i] = old[i];
3059 fTOFcluster[fNtofClusters-1] = icl;
3060
402a013d 3061 if(fNtofClusters-1) delete[] old; // delete previous content
115179c6 3062
3063}
3064
49436743 3065//____________________________________________
3066Double_t AliESDtrack::GetTOFsignal() const
3067{
115179c6 3068 if(fNtofClusters>0 && GetESDEvent()){
49436743 3069 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
3070 AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
115179c6 3071
3072 return tofcl->GetTime();
3073 }
3074 else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
3075
3076 return fTOFsignal;
3077}
3078
49436743 3079//____________________________________________
115179c6 3080Double_t AliESDtrack::GetTOFsignalToT() const
3081{
3082 if(fNtofClusters>0 && GetESDEvent()){
49436743 3083 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
3084 AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
115179c6 3085
3086 return tofcl->GetTOT();
3087 }
3088 else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
3089
3090 return fTOFsignalToT;
3091}
3092
49436743 3093//____________________________________________
115179c6 3094Double_t AliESDtrack::GetTOFsignalRaw() const
3095{
3096 if(fNtofClusters>0 && GetESDEvent()){
49436743 3097 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
3098 AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
115179c6 3099
3100 return tofcl->GetTimeRaw();
3101 }
3102 else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
3103
3104 return fTOFsignalRaw;
3105}
3106
49436743 3107//____________________________________________
115179c6 3108Double_t AliESDtrack::GetTOFsignalDz() const
3109{
3110
49436743 3111 AliESDTOFCluster *tofcl;
115179c6 3112
3113 Int_t index = -1;
3114 if(fNtofClusters>0 && GetESDEvent()){
49436743 3115 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
3116 tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
115179c6 3117
3118 for(Int_t i=0;i < tofcl->GetNMatchableTracks();i++){
3119 if(tofcl->GetTrackIndex(i) == GetID()) index = i;
3120 }
3121 }
3122 else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
3123
3124 if(fNtofClusters>0 && index > -1){
3125 return tofcl->GetDz(index);
3126 }
3127 return fTOFsignalDz;
3128}
3129
49436743 3130//____________________________________________
115179c6 3131Double_t AliESDtrack::GetTOFsignalDx() const
3132{
49436743 3133 AliESDTOFCluster *tofcl;
115179c6 3134
3135 Int_t index = -1;
3136 if(fNtofClusters>0 && GetESDEvent()){
49436743 3137 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
3138 tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
115179c6 3139 for(Int_t i=0;i < tofcl->GetNMatchableTracks();i++){
3140 if(tofcl->GetTrackIndex(i) == GetID()) index = i;
3141 }
3142 }
3143 else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
3144 if(fNtofClusters>0 && index > -1){
3145 return tofcl->GetDx(index);
3146 }
3147 return fTOFsignalDx;
3148}
3149
49436743 3150//____________________________________________
115179c6 3151Short_t AliESDtrack::GetTOFDeltaBC() const
3152{
3153 if(fNtofClusters>0 && GetESDEvent()){
49436743 3154 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
3155 AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
115179c6 3156 return tofcl->GetDeltaBC();
3157 }
3158 else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
3159
3160 return fTOFdeltaBC;
3161}
3162
49436743 3163//____________________________________________
115179c6 3164Short_t AliESDtrack::GetTOFL0L1() const
3165{
3166 if(fNtofClusters>0 && GetESDEvent()){
49436743 3167 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
3168 AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
115179c6 3169
3170 return tofcl->GetL0L1Latency();
3171 }
3172 else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
3173
3174 return fTOFl0l1;
3175}
3176
49436743 3177//____________________________________________
115179c6 3178Int_t AliESDtrack::GetTOFCalChannel() const
3179{
3180 if(fNtofClusters>0 && GetESDEvent()){
49436743 3181 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
3182 AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
115179c6 3183
86f831c3 3184 return tofcl->GetTOFchannel();
115179c6 3185 }
3186 else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
3187
3188 return fTOFCalChannel;
3189}
3190
49436743 3191//____________________________________________
115179c6 3192Int_t AliESDtrack::GetTOFcluster() const
3193{
3194 if(fNtofClusters>0 && GetESDEvent()){
49436743 3195 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
3196 AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
115179c6 3197
3dd93705 3198 return tofcl->GetClusterIndex();
115179c6 3199 }
3200 else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
3201
3202 return fTOFindex;
3203}
3204
49436743 3205//____________________________________________
115179c6 3206Int_t AliESDtrack::GetTOFclusterN() const
3207{
3208 return fNtofClusters;
3209}
3210
49436743 3211//____________________________________________
115179c6 3212Bool_t AliESDtrack::IsTOFHitAlreadyMatched() const{
3213 if(fNtofClusters>0 && GetESDEvent()){
49436743 3214 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
3215 AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
115179c6 3216
3217 if (tofcl->GetNMatchableTracks() > 1)
3218 return kTRUE;
3219 }
3220 else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
3221
3222 return kFALSE;
3223}
3224
49436743 3225//____________________________________________
115179c6 3226void AliESDtrack::ReMapTOFcluster(Int_t ncl,Int_t *mapping){
3227 for(Int_t i=0;i<fNtofClusters;i++){
3228 if(fTOFcluster[i]<ncl && fTOFcluster[i]>-1)
3229 fTOFcluster[i] = mapping[fTOFcluster[i]];
3230 else
3231 AliInfo(Form("TOF cluster re-mapping in AliESDtrack: out of range (%i > %i)\n",fTOFcluster[i],ncl));
3232 }
3233}
3234
49436743 3235//____________________________________________
115179c6 3236void AliESDtrack::SortTOFcluster(){
49436743 3237 TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
115179c6 3238
3239 for(Int_t i=0;i<fNtofClusters-1;i++){
3240 for(Int_t j=i+1;j<fNtofClusters;j++){
49436743 3241 AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[i]);
115179c6 3242 Int_t index1 = -1;
3243 for(Int_t it=0;it < tofcl->GetNMatchableTracks();it++){
3244 if(tofcl->GetTrackIndex(it) == GetID()) index1 = it;
3245 }
3246 Double_t timedist1 = 10000;
3247 for(Int_t isp=0; isp< AliPID::kSPECIESC;isp++){
3248 Double_t timec = TMath::Abs(tofcl->GetTime() - tofcl->GetIntegratedTime(isp));
3249 if(timec < timedist1) timedist1 = timec;
3250 }
3251 timedist1 *= 0.03; // in cm
3252 Double_t radius1 = tofcl->GetDx(index1)*tofcl->GetDx(index1) + tofcl->GetDz(index1)*tofcl->GetDz(index1) + timedist1*timedist1;
3253
49436743 3254 AliESDTOFCluster *tofcl2 = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[j]);
115179c6 3255 Int_t index2 = -1;
3256 for(Int_t it=0;it < tofcl2->GetNMatchableTracks();it++){
3257 if(tofcl2->GetTrackIndex(it) == GetID()) index2 = it;
3258 }
3259 if(index1 == -1 || index2 == -1){
3260 }
3261 Double_t timedist2 = 10000;
3262 for(Int_t isp=0; isp< AliPID::kSPECIESC;isp++){
3263 Double_t timec = TMath::Abs(tofcl2->GetTime() - tofcl2->GetIntegratedTime(isp));
3264 if(timec < timedist2) timedist2 = timec;
3265 }
3266 timedist2 *= 0.03; // in cm
3267 Double_t radius2 = tofcl2->GetDx(index2)*tofcl2->GetDx(index2) + tofcl2->GetDz(index2)*tofcl2->GetDz(index2) + timedist2*timedist2;
3268
3269 if(radius2 < radius1){
3270 Int_t change = fTOFcluster[i];
3271 fTOFcluster[i] = fTOFcluster[j];
3272 fTOFcluster[j] = change;
3273 }
3274 }
3275 }
3276}
42fcc729 3277
49436743 3278//____________________________________________
42fcc729 3279const AliTOFHeader* AliESDtrack::GetTOFHeader() const {
3280 return fESDEvent->GetTOFHeader();
3281}
d3929eb3 3282
49436743 3283//___________________________________________
3284void AliESDtrack::SetID(Short_t id)
3285{
3286 // set track ID taking care about dependencies
3287 if (fNtofClusters) ReplaceTOFTrackID(fID,id);
3288 fID=id;
3289}
30235f51 3290
d3929eb3 3291
3292Double_t AliESDtrack::GetdEdxInfo(Int_t regionID, Int_t calibID, Int_t qID, Int_t valueID){
3293 //
3294 // Interface to get the calibrated dEdx information
3295 // For details of arguments and return values see
3296 // AliTPCdEdxInfo::GetdEdxInfo(Int_t regionID, Int_t calibID, Int_t valueID)
3297 //
3298 if (!fTPCdEdxInfo) return 0;
3299 if (!fIp) return 0;
3300 return fTPCdEdxInfo->GetdEdxInfo(fIp, regionID, calibID, qID, valueID);
3301}