]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/AliESDtrack.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Do not reset a zero pointer to MC info
[u/mrichter/AliRoot.git] / STEER / 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>
ae982df3 119
49d13e89 120#include "AliESDVertex.h"
ae982df3 121#include "AliESDtrack.h"
95621324 122#include "AliESDEvent.h"
ae982df3 123#include "AliKalmanTrack.h"
4f6e22bd 124#include "AliVTrack.h"
5f7789fc 125#include "AliLog.h"
15e85efa 126#include "AliTrackPointArray.h"
0c19adf7 127#include "TPolyMarker3D.h"
ae982df3 128
129ClassImp(AliESDtrack)
130
562dd0b4 131void SetPIDValues(Double_t * dest, const Double_t * src, Int_t n) {
d27bbc79 132 // This function copies "n" PID weights from "scr" to "dest"
133 // and normalizes their sum to 1 thus producing conditional probabilities.
134 // The negative weights are set to 0.
135 // In case all the weights are non-positive they are replaced by
136 // uniform probabilities
137
138 if (n<=0) return;
139
140 Float_t uniform = 1./(Float_t)n;
141
142 Float_t sum = 0;
143 for (Int_t i=0; i<n; i++)
144 if (src[i]>=0) {
145 sum+=src[i];
146 dest[i] = src[i];
147 }
148 else {
149 dest[i] = 0;
150 }
151
152 if(sum>0)
153 for (Int_t i=0; i<n; i++) dest[i] /= sum;
154 else
155 for (Int_t i=0; i<n; i++) dest[i] = uniform;
156}
157
ae982df3 158//_______________________________________________________________________
159AliESDtrack::AliESDtrack() :
c9ec41e8 160 AliExternalTrackParam(),
562dd0b4 161 fCp(0),
162 fIp(0),
163 fTPCInner(0),
164 fOp(0),
c38d443f 165 fHMPIDp(0),
562dd0b4 166 fFriendTrack(new AliESDfriendTrack()),
167 fTPCClusterMap(159),//number of padrows
168 fTPCSharedMap(159),//number of padrows
90e48c0c 169 fFlags(0),
90e48c0c 170 fID(0),
562dd0b4 171 fLabel(0),
172 fITSLabel(0),
173 fTPCLabel(0),
174 fTRDLabel(0),
ab37ab1e 175 fTOFCalChannel(-1),
ce3f4882 176 fTOFindex(-1),
562dd0b4 177 fHMPIDqn(0),
81aa7a0d 178 fHMPIDcluIdx(-1),
f1cedef3 179 fCaloIndex(kEMCALNoMatch),
562dd0b4 180 fHMPIDtrkTheta(0),
181 fHMPIDtrkPhi(0),
182 fHMPIDsignal(0),
90e48c0c 183 fTrackLength(0),
d7ddf1e9 184 fdTPC(0),fzTPC(0),
185 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
436dfe39 186 fCchi2TPC(0),
49d13e89 187 fD(0),fZ(0),
188 fCdd(0),fCdz(0),fCzz(0),
562dd0b4 189 fCchi2(0),
90e48c0c 190 fITSchi2(0),
90e48c0c 191 fTPCchi2(0),
949840f6 192 fTPCchi2Iter1(0),
562dd0b4 193 fTRDchi2(0),
194 fTOFchi2(0),
195 fHMPIDchi2(0),
b5b2b4db 196 fGlobalChi2(0),
562dd0b4 197 fITSsignal(0),
90e48c0c 198 fTPCsignal(0),
e1d4c1b5 199 fTPCsignalS(0),
90e48c0c 200 fTRDsignal(0),
90e48c0c 201 fTRDQuality(0),
23d49657 202 fTRDBudget(0),
ab37ab1e 203 fTOFsignal(99999),
204 fTOFsignalToT(99999),
205 fTOFsignalRaw(99999),
206 fTOFsignalDz(999),
207 fTOFsignalDx(999),
208 fTOFdeltaBC(999),
209 fTOFl0l1(999),
f1cedef3 210 fCaloDx(0),
211 fCaloDz(0),
562dd0b4 212 fHMPIDtrkX(0),
213 fHMPIDtrkY(0),
214 fHMPIDmipX(0),
215 fHMPIDmipY(0),
216 fTPCncls(0),
217 fTPCnclsF(0),
218 fTPCsignalN(0),
949840f6 219 fTPCnclsIter1(0),
220 fTPCnclsFIter1(0),
562dd0b4 221 fITSncls(0),
222 fITSClusterMap(0),
223 fTRDncls(0),
224 fTRDncls0(0),
ed15ef4f 225 fTRDntracklets(0),
6984f7c1 226 fTRDnSlices(0),
6dc21f57 227 fTRDslices(0x0),
95621324 228 fVertexID(-2),// -2 means an orphan track
229 fESDEvent(0)
ae982df3 230{
231 //
232 // The default ESD constructor
233 //
6984f7c1 234 Int_t i;
6238d7a9 235 for (i=0; i<AliPID::kSPECIES; i++) {
4a78b8c5 236 fTrackTime[i]=0.;
562dd0b4 237 fR[i]=0.;
238 fITSr[i]=0.;
239 fTPCr[i]=0.;
240 fTRDr[i]=0.;
241 fTOFr[i]=0.;
242 fHMPIDr[i]=0.;
2bad268c 243 }
ac2f7574 244
ef7253ac 245 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
562dd0b4 246 for (i=0; i<3; i++) { fV0Indexes[i]=0;}
6984f7c1 247 for (i=0;i<kTRDnPlanes;i++) {
562dd0b4 248 fTRDTimBin[i]=0;
6d45eaef 249 }
1d4882da 250 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
562dd0b4 251 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
ab37ab1e 252 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
562dd0b4 253 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
89f1b176 254 for (i=0;i<12;i++) {fITSModule[i]=-1;}
c4d11b15 255}
256
257//_______________________________________________________________________
90e48c0c 258AliESDtrack::AliESDtrack(const AliESDtrack& track):
c9ec41e8 259 AliExternalTrackParam(track),
562dd0b4 260 fCp(0),
261 fIp(0),
262 fTPCInner(0),
263 fOp(0),
c38d443f 264 fHMPIDp(0),
562dd0b4 265 fFriendTrack(0),
266 fTPCClusterMap(track.fTPCClusterMap),
267 fTPCSharedMap(track.fTPCSharedMap),
90e48c0c 268 fFlags(track.fFlags),
90e48c0c 269 fID(track.fID),
562dd0b4 270 fLabel(track.fLabel),
271 fITSLabel(track.fITSLabel),
272 fTPCLabel(track.fTPCLabel),
273 fTRDLabel(track.fTRDLabel),
274 fTOFCalChannel(track.fTOFCalChannel),
275 fTOFindex(track.fTOFindex),
276 fHMPIDqn(track.fHMPIDqn),
277 fHMPIDcluIdx(track.fHMPIDcluIdx),
f1cedef3 278 fCaloIndex(track.fCaloIndex),
562dd0b4 279 fHMPIDtrkTheta(track.fHMPIDtrkTheta),
280 fHMPIDtrkPhi(track.fHMPIDtrkPhi),
281 fHMPIDsignal(track.fHMPIDsignal),
90e48c0c 282 fTrackLength(track.fTrackLength),
d7ddf1e9 283 fdTPC(track.fdTPC),fzTPC(track.fzTPC),
284 fCddTPC(track.fCddTPC),fCdzTPC(track.fCdzTPC),fCzzTPC(track.fCzzTPC),
436dfe39 285 fCchi2TPC(track.fCchi2TPC),
49d13e89 286 fD(track.fD),fZ(track.fZ),
287 fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
90e48c0c 288 fCchi2(track.fCchi2),
90e48c0c 289 fITSchi2(track.fITSchi2),
90e48c0c 290 fTPCchi2(track.fTPCchi2),
949840f6 291 fTPCchi2Iter1(track.fTPCchi2Iter1),
562dd0b4 292 fTRDchi2(track.fTRDchi2),
293 fTOFchi2(track.fTOFchi2),
294 fHMPIDchi2(track.fHMPIDchi2),
b5b2b4db 295 fGlobalChi2(track.fGlobalChi2),
562dd0b4 296 fITSsignal(track.fITSsignal),
90e48c0c 297 fTPCsignal(track.fTPCsignal),
e1d4c1b5 298 fTPCsignalS(track.fTPCsignalS),
90e48c0c 299 fTRDsignal(track.fTRDsignal),
90e48c0c 300 fTRDQuality(track.fTRDQuality),
23d49657 301 fTRDBudget(track.fTRDBudget),
90e48c0c 302 fTOFsignal(track.fTOFsignal),
85324138 303 fTOFsignalToT(track.fTOFsignalToT),
d321691a 304 fTOFsignalRaw(track.fTOFsignalRaw),
305 fTOFsignalDz(track.fTOFsignalDz),
a5d9ff0f 306 fTOFsignalDx(track.fTOFsignalDx),
d86081b1 307 fTOFdeltaBC(track.fTOFdeltaBC),
308 fTOFl0l1(track.fTOFl0l1),
f1cedef3 309 fCaloDx(track.fCaloDx),
310 fCaloDz(track.fCaloDz),
f4b3bbb7 311 fHMPIDtrkX(track.fHMPIDtrkX),
312 fHMPIDtrkY(track.fHMPIDtrkY),
313 fHMPIDmipX(track.fHMPIDmipX),
314 fHMPIDmipY(track.fHMPIDmipY),
562dd0b4 315 fTPCncls(track.fTPCncls),
316 fTPCnclsF(track.fTPCnclsF),
317 fTPCsignalN(track.fTPCsignalN),
949840f6 318 fTPCnclsIter1(track.fTPCnclsIter1),
319 fTPCnclsFIter1(track.fTPCnclsIter1),
562dd0b4 320 fITSncls(track.fITSncls),
321 fITSClusterMap(track.fITSClusterMap),
322 fTRDncls(track.fTRDncls),
323 fTRDncls0(track.fTRDncls0),
ed15ef4f 324 fTRDntracklets(track.fTRDntracklets),
6984f7c1 325 fTRDnSlices(track.fTRDnSlices),
6dc21f57 326 fTRDslices(0x0),
95621324 327 fVertexID(track.fVertexID),
328 fESDEvent(track.fESDEvent)
90e48c0c 329{
c4d11b15 330 //
331 //copy constructor
332 //
ef7253ac 333 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i]=track.fTrackTime[i];
334 for (Int_t i=0;i<AliPID::kSPECIES;i++) fR[i]=track.fR[i];
c4d11b15 335 //
304864ab 336 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
c4d11b15 337 //
304864ab 338 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[i];
1d4882da 339 for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=track.fITSdEdxSamples[i];}
51ad6848 340 for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
341 for (Int_t i=0; i<3;i++) { fKinkIndexes[i]=track.fKinkIndexes[i];}
342 for (Int_t i=0; i<3;i++) { fV0Indexes[i]=track.fV0Indexes[i];}
c4d11b15 343 //
6984f7c1 344 for (Int_t i=0;i<kTRDnPlanes;i++) {
6d45eaef 345 fTRDTimBin[i]=track.fTRDTimBin[i];
eab5961e 346 }
6984f7c1 347
348 if (fTRDnSlices) {
349 fTRDslices=new Double32_t[fTRDnSlices];
350 for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=track.fTRDslices[i];
351 }
352
304864ab 353 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
304864ab 354 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
51ad6848 355 for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
356 for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
89f1b176 357 for (Int_t i=0;i<12;i++) fITSModule[i]=track.fITSModule[i];
f4b3bbb7 358 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i]=track.fHMPIDr[i];
c9ec41e8 359
360 if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
361 if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
4aeb9470 362 if (track.fTPCInner) fTPCInner=new AliExternalTrackParam(*track.fTPCInner);
c9ec41e8 363 if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
c38d443f 364 if (track.fHMPIDp) fHMPIDp=new AliExternalTrackParam(*track.fHMPIDp);
365
8497bca0 366 if (track.fFriendTrack) fFriendTrack=new AliESDfriendTrack(*(track.fFriendTrack));
ae982df3 367}
15e85efa 368
4f6e22bd 369//_______________________________________________________________________
370AliESDtrack::AliESDtrack(const AliVTrack *track) :
371 AliExternalTrackParam(track),
372 fCp(0),
373 fIp(0),
374 fTPCInner(0),
375 fOp(0),
c38d443f 376 fHMPIDp(0),
4f6e22bd 377 fFriendTrack(0),
378 fTPCClusterMap(159),//number of padrows
379 fTPCSharedMap(159),//number of padrows
380 fFlags(0),
381 fID(),
382 fLabel(0),
383 fITSLabel(0),
384 fTPCLabel(0),
385 fTRDLabel(0),
ab37ab1e 386 fTOFCalChannel(-1),
4f6e22bd 387 fTOFindex(-1),
388 fHMPIDqn(0),
81aa7a0d 389 fHMPIDcluIdx(-1),
f1cedef3 390 fCaloIndex(kEMCALNoMatch),
4f6e22bd 391 fHMPIDtrkTheta(0),
392 fHMPIDtrkPhi(0),
393 fHMPIDsignal(0),
394 fTrackLength(0),
395 fdTPC(0),fzTPC(0),
396 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
397 fCchi2TPC(0),
398 fD(0),fZ(0),
399 fCdd(0),fCdz(0),fCzz(0),
400 fCchi2(0),
401 fITSchi2(0),
402 fTPCchi2(0),
949840f6 403 fTPCchi2Iter1(0),
4f6e22bd 404 fTRDchi2(0),
405 fTOFchi2(0),
406 fHMPIDchi2(0),
b5b2b4db 407 fGlobalChi2(0),
4f6e22bd 408 fITSsignal(0),
409 fTPCsignal(0),
410 fTPCsignalS(0),
411 fTRDsignal(0),
412 fTRDQuality(0),
413 fTRDBudget(0),
ab37ab1e 414 fTOFsignal(99999),
415 fTOFsignalToT(99999),
416 fTOFsignalRaw(99999),
417 fTOFsignalDz(999),
418 fTOFsignalDx(999),
419 fTOFdeltaBC(999),
420 fTOFl0l1(999),
f1cedef3 421 fCaloDx(0),
422 fCaloDz(0),
4f6e22bd 423 fHMPIDtrkX(0),
424 fHMPIDtrkY(0),
425 fHMPIDmipX(0),
426 fHMPIDmipY(0),
427 fTPCncls(0),
428 fTPCnclsF(0),
429 fTPCsignalN(0),
949840f6 430 fTPCnclsIter1(0),
431 fTPCnclsFIter1(0),
4f6e22bd 432 fITSncls(0),
433 fITSClusterMap(0),
434 fTRDncls(0),
435 fTRDncls0(0),
ed15ef4f 436 fTRDntracklets(0),
4f6e22bd 437 fTRDnSlices(0),
6dc21f57 438 fTRDslices(0x0),
95621324 439 fVertexID(-2), // -2 means an orphan track
440 fESDEvent(0)
4f6e22bd 441{
442 //
610e3088 443 // ESD track from AliVTrack.
444 // This is not a copy constructor !
4f6e22bd 445 //
446
610e3088 447 if (track->InheritsFrom("AliExternalTrackParam")) {
448 AliError("This is not a copy constructor. Use AliESDtrack(const AliESDtrack &) !");
449 AliWarning("Calling the default constructor...");
450 AliESDtrack();
451 return;
452 }
453
4f6e22bd 454 // Reset all the arrays
455 Int_t i;
456 for (i=0; i<AliPID::kSPECIES; i++) {
457 fTrackTime[i]=0.;
458 fR[i]=0.;
459 fITSr[i]=0.;
460 fTPCr[i]=0.;
461 fTRDr[i]=0.;
462 fTOFr[i]=0.;
463 fHMPIDr[i]=0.;
464 }
465
466 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
467 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
468 for (i=0;i<kTRDnPlanes;i++) {
469 fTRDTimBin[i]=0;
470 }
1d4882da 471 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
4f6e22bd 472 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
ab37ab1e 473 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
4f6e22bd 474 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
475 for (i=0;i<12;i++) {fITSModule[i]=-1;}
476
477 // Set the ID
478 SetID(track->GetID());
479
480 // Set ITS cluster map
481 fITSClusterMap=track->GetITSClusterMap();
482
d577eec9 483 fITSncls=0;
484 for(i=0; i<6; i++) {
485 if(HasPointOnITSLayer(i)) fITSncls++;
486 }
487
4f6e22bd 488 // Set the combined PID
489 const Double_t *pid = track->PID();
67be2d29 490 if(pid){
491 for (i=0; i<AliPID::kSPECIES; i++) fR[i]=pid[i];
492 }
4f6e22bd 493 // AliESD track label
494 SetLabel(track->GetLabel());
39ca41b3 495 // Set the status
496 SetStatus(track->GetStatus());
4f6e22bd 497}
498
49edfa08 499//_______________________________________________________________________
500AliESDtrack::AliESDtrack(TParticle * part) :
501 AliExternalTrackParam(),
562dd0b4 502 fCp(0),
503 fIp(0),
504 fTPCInner(0),
505 fOp(0),
c38d443f 506 fHMPIDp(0),
562dd0b4 507 fFriendTrack(0),
508 fTPCClusterMap(159),//number of padrows
509 fTPCSharedMap(159),//number of padrows
49edfa08 510 fFlags(0),
49edfa08 511 fID(0),
562dd0b4 512 fLabel(0),
513 fITSLabel(0),
514 fTPCLabel(0),
515 fTRDLabel(0),
ab37ab1e 516 fTOFCalChannel(-1),
ce3f4882 517 fTOFindex(-1),
562dd0b4 518 fHMPIDqn(0),
81aa7a0d 519 fHMPIDcluIdx(-1),
f1cedef3 520 fCaloIndex(kEMCALNoMatch),
562dd0b4 521 fHMPIDtrkTheta(0),
522 fHMPIDtrkPhi(0),
523 fHMPIDsignal(0),
49edfa08 524 fTrackLength(0),
d7ddf1e9 525 fdTPC(0),fzTPC(0),
526 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
436dfe39 527 fCchi2TPC(0),
49edfa08 528 fD(0),fZ(0),
529 fCdd(0),fCdz(0),fCzz(0),
562dd0b4 530 fCchi2(0),
49edfa08 531 fITSchi2(0),
49edfa08 532 fTPCchi2(0),
949840f6 533 fTPCchi2Iter1(0),
562dd0b4 534 fTRDchi2(0),
535 fTOFchi2(0),
536 fHMPIDchi2(0),
b5b2b4db 537 fGlobalChi2(0),
562dd0b4 538 fITSsignal(0),
49edfa08 539 fTPCsignal(0),
49edfa08 540 fTPCsignalS(0),
49edfa08 541 fTRDsignal(0),
49edfa08 542 fTRDQuality(0),
543 fTRDBudget(0),
ab37ab1e 544 fTOFsignal(99999),
545 fTOFsignalToT(99999),
546 fTOFsignalRaw(99999),
547 fTOFsignalDz(999),
548 fTOFsignalDx(999),
549 fTOFdeltaBC(999),
550 fTOFl0l1(999),
f1cedef3 551 fCaloDx(0),
552 fCaloDz(0),
562dd0b4 553 fHMPIDtrkX(0),
554 fHMPIDtrkY(0),
555 fHMPIDmipX(0),
556 fHMPIDmipY(0),
557 fTPCncls(0),
558 fTPCnclsF(0),
559 fTPCsignalN(0),
949840f6 560 fTPCnclsIter1(0),
561 fTPCnclsFIter1(0),
562dd0b4 562 fITSncls(0),
563 fITSClusterMap(0),
564 fTRDncls(0),
565 fTRDncls0(0),
ed15ef4f 566 fTRDntracklets(0),
6984f7c1 567 fTRDnSlices(0),
6dc21f57 568 fTRDslices(0x0),
95621324 569 fVertexID(-2), // -2 means an orphan track
570 fESDEvent(0)
49edfa08 571{
572 //
573 // ESD track from TParticle
574 //
575
576 // Reset all the arrays
6984f7c1 577 Int_t i;
49edfa08 578 for (i=0; i<AliPID::kSPECIES; i++) {
579 fTrackTime[i]=0.;
580 fR[i]=0.;
581 fITSr[i]=0.;
582 fTPCr[i]=0.;
583 fTRDr[i]=0.;
584 fTOFr[i]=0.;
f4b3bbb7 585 fHMPIDr[i]=0.;
49edfa08 586 }
587
588 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
589 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
6984f7c1 590 for (i=0;i<kTRDnPlanes;i++) {
562dd0b4 591 fTRDTimBin[i]=0;
49edfa08 592 }
1d4882da 593 for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
562dd0b4 594 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
ab37ab1e 595 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
562dd0b4 596 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
89f1b176 597 for (i=0;i<12;i++) {fITSModule[i]=-1;}
49edfa08 598
599 // Calculate the AliExternalTrackParam content
600
601 Double_t xref;
602 Double_t alpha;
603 Double_t param[5];
604 Double_t covar[15];
605
606 // Calculate alpha: the rotation angle of the corresponding local system (TPC sector)
607 alpha = part->Phi()*180./TMath::Pi();
608 if (alpha<0) alpha+= 360.;
609 if (alpha>360) alpha -= 360.;
610
611 Int_t sector = (Int_t)(alpha/20.);
612 alpha = 10. + 20.*sector;
613 alpha /= 180;
614 alpha *= TMath::Pi();
615
616 // Covariance matrix: no errors, the parameters are exact
6c27b212 617 for (i=0; i<15; i++) covar[i]=0.;
49edfa08 618
619 // Get the vertex of origin and the momentum
620 TVector3 ver(part->Vx(),part->Vy(),part->Vz());
621 TVector3 mom(part->Px(),part->Py(),part->Pz());
622
623 // Rotate to the local coordinate system (TPC sector)
624 ver.RotateZ(-alpha);
625 mom.RotateZ(-alpha);
626
627 // X of the referense plane
628 xref = ver.X();
629
630 Int_t pdgCode = part->GetPdgCode();
631
632 Double_t charge =
633 TDatabasePDG::Instance()->GetParticle(pdgCode)->Charge();
634
635 param[0] = ver.Y();
636 param[1] = ver.Z();
637 param[2] = TMath::Sin(mom.Phi());
638 param[3] = mom.Pz()/mom.Pt();
639 param[4] = TMath::Sign(1/mom.Pt(),charge);
640
641 // Set AliExternalTrackParam
642 Set(xref, alpha, param, covar);
643
644 // Set the PID
645 Int_t indexPID = 99;
646
647 switch (TMath::Abs(pdgCode)) {
648
649 case 11: // electron
650 indexPID = 0;
651 break;
652
653 case 13: // muon
654 indexPID = 1;
655 break;
656
657 case 211: // pion
658 indexPID = 2;
659 break;
660
661 case 321: // kaon
662 indexPID = 3;
663 break;
664
665 case 2212: // proton
666 indexPID = 4;
667 break;
668
669 default:
670 break;
671 }
672
673 // If the particle is not e,mu,pi,K or p the PID probabilities are set to 0
674 if (indexPID < AliPID::kSPECIES) {
675 fR[indexPID]=1.;
676 fITSr[indexPID]=1.;
677 fTPCr[indexPID]=1.;
678 fTRDr[indexPID]=1.;
679 fTOFr[indexPID]=1.;
f4b3bbb7 680 fHMPIDr[indexPID]=1.;
49edfa08 681
682 }
683 // AliESD track label
684 SetLabel(part->GetUniqueID());
685
686}
687
c4d11b15 688//_______________________________________________________________________
689AliESDtrack::~AliESDtrack(){
690 //
691 // This is destructor according Coding Conventrions
692 //
693 //printf("Delete track\n");
c9ec41e8 694 delete fIp;
4aeb9470 695 delete fTPCInner;
c9ec41e8 696 delete fOp;
c38d443f 697 delete fHMPIDp;
c9ec41e8 698 delete fCp;
15e85efa 699 delete fFriendTrack;
6984f7c1 700 if(fTRDnSlices)
701 delete[] fTRDslices;
c4d11b15 702}
ae982df3 703
732a24fe 704AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source){
705
706
707 if(&source == this) return *this;
708 AliExternalTrackParam::operator=(source);
709
710
711 if(source.fCp){
712 // we have the trackparam: assign or copy construct
713 if(fCp)*fCp = *source.fCp;
714 else fCp = new AliExternalTrackParam(*source.fCp);
715 }
716 else{
717 // no track param delete the old one
718 if(fCp)delete fCp;
719 fCp = 0;
720 }
721
722 if(source.fIp){
723 // we have the trackparam: assign or copy construct
724 if(fIp)*fIp = *source.fIp;
725 else fIp = new AliExternalTrackParam(*source.fIp);
726 }
727 else{
728 // no track param delete the old one
729 if(fIp)delete fIp;
730 fIp = 0;
731 }
732
733
734 if(source.fTPCInner){
735 // we have the trackparam: assign or copy construct
736 if(fTPCInner) *fTPCInner = *source.fTPCInner;
737 else fTPCInner = new AliExternalTrackParam(*source.fTPCInner);
738 }
739 else{
740 // no track param delete the old one
741 if(fTPCInner)delete fTPCInner;
742 fTPCInner = 0;
743 }
744
745
746 if(source.fOp){
747 // we have the trackparam: assign or copy construct
748 if(fOp) *fOp = *source.fOp;
749 else fOp = new AliExternalTrackParam(*source.fOp);
750 }
751 else{
752 // no track param delete the old one
753 if(fOp)delete fOp;
754 fOp = 0;
755 }
756
c38d443f 757
758 if(source.fHMPIDp){
759 // we have the trackparam: assign or copy construct
b01794e9 760 if(fHMPIDp) *fHMPIDp = *source.fHMPIDp;
c38d443f 761 else fHMPIDp = new AliExternalTrackParam(*source.fHMPIDp);
762 }
763 else{
764 // no track param delete the old one
765 if(fHMPIDp)delete fHMPIDp;
766 fHMPIDp = 0;
767 }
768
769
732a24fe 770 // copy also the friend track
771 // use copy constructor
772 if(source.fFriendTrack){
773 // we have the trackparam: assign or copy construct
774 delete fFriendTrack; fFriendTrack=new AliESDfriendTrack(*source.fFriendTrack);
775 }
776 else{
777 // no track param delete the old one
778 delete fFriendTrack; fFriendTrack= 0;
779 }
780
781 fTPCClusterMap = source.fTPCClusterMap;
782 fTPCSharedMap = source.fTPCSharedMap;
783 // the simple stuff
784 fFlags = source.fFlags;
785 fID = source.fID;
786 fLabel = source.fLabel;
787 fITSLabel = source.fITSLabel;
788 for(int i = 0; i< 12;++i){
789 fITSModule[i] = source.fITSModule[i];
790 }
791 fTPCLabel = source.fTPCLabel;
792 fTRDLabel = source.fTRDLabel;
793 for(int i = 0; i< 3;++i){
794 fTOFLabel[i] = source.fTOFLabel[i];
795 }
796 fTOFCalChannel = source.fTOFCalChannel;
797 fTOFindex = source.fTOFindex;
798 fHMPIDqn = source.fHMPIDqn;
799 fHMPIDcluIdx = source.fHMPIDcluIdx;
f1cedef3 800 fCaloIndex = source.fCaloIndex;
732a24fe 801
802 for(int i = 0; i< 3;++i){
803 fKinkIndexes[i] = source.fKinkIndexes[i];
804 fV0Indexes[i] = source.fV0Indexes[i];
805 }
806
807 for(int i = 0; i< AliPID::kSPECIES;++i){
808 fR[i] = source.fR[i];
809 fITSr[i] = source.fITSr[i];
810 fTPCr[i] = source.fTPCr[i];
811 fTRDr[i] = source.fTRDr[i];
812 fTOFr[i] = source.fTOFr[i];
813 fHMPIDr[i] = source.fHMPIDr[i];
814 fTrackTime[i] = source.fTrackTime[i];
815 }
816
817 fHMPIDtrkTheta = source.fHMPIDtrkTheta;
818 fHMPIDtrkPhi = source.fHMPIDtrkPhi;
819 fHMPIDsignal = source.fHMPIDsignal;
820
821
822 fTrackLength = source. fTrackLength;
d7ddf1e9 823 fdTPC = source.fdTPC;
824 fzTPC = source.fzTPC;
825 fCddTPC = source.fCddTPC;
826 fCdzTPC = source.fCdzTPC;
827 fCzzTPC = source.fCzzTPC;
436dfe39 828 fCchi2TPC = source.fCchi2TPC;
829
732a24fe 830 fD = source.fD;
831 fZ = source.fZ;
832 fCdd = source.fCdd;
833 fCdz = source.fCdz;
834 fCzz = source.fCzz;
732a24fe 835 fCchi2 = source.fCchi2;
436dfe39 836
732a24fe 837 fITSchi2 = source.fITSchi2;
838 fTPCchi2 = source.fTPCchi2;
949840f6 839 fTPCchi2Iter1 = source.fTPCchi2Iter1;
732a24fe 840 fTRDchi2 = source.fTRDchi2;
841 fTOFchi2 = source.fTOFchi2;
842 fHMPIDchi2 = source.fHMPIDchi2;
843
b5b2b4db 844 fGlobalChi2 = source.fGlobalChi2;
732a24fe 845
846 fITSsignal = source.fITSsignal;
1d4882da 847 for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=source.fITSdEdxSamples[i];}
732a24fe 848 fTPCsignal = source.fTPCsignal;
849 fTPCsignalS = source.fTPCsignalS;
850 for(int i = 0; i< 4;++i){
851 fTPCPoints[i] = source.fTPCPoints[i];
852 }
853 fTRDsignal = source.fTRDsignal;
854
6984f7c1 855 for(int i = 0;i < kTRDnPlanes;++i){
732a24fe 856 fTRDTimBin[i] = source.fTRDTimBin[i];
732a24fe 857 }
6984f7c1 858
859 if(fTRDnSlices)
860 delete[] fTRDslices;
861 fTRDslices=0;
862 fTRDnSlices=source.fTRDnSlices;
863 if (fTRDnSlices) {
864 fTRDslices=new Double32_t[fTRDnSlices];
865 for(int j = 0;j < fTRDnSlices;++j) fTRDslices[j] = source.fTRDslices[j];
866 }
867
732a24fe 868 fTRDQuality = source.fTRDQuality;
869 fTRDBudget = source.fTRDBudget;
870 fTOFsignal = source.fTOFsignal;
871 fTOFsignalToT = source.fTOFsignalToT;
872 fTOFsignalRaw = source.fTOFsignalRaw;
873 fTOFsignalDz = source.fTOFsignalDz;
a5d9ff0f 874 fTOFsignalDx = source.fTOFsignalDx;
d86081b1 875 fTOFdeltaBC = source.fTOFdeltaBC;
876 fTOFl0l1 = source.fTOFl0l1;
877
732a24fe 878 for(int i = 0;i<10;++i){
879 fTOFInfo[i] = source.fTOFInfo[i];
880 }
881
882 fHMPIDtrkX = source.fHMPIDtrkX;
883 fHMPIDtrkY = source.fHMPIDtrkY;
884 fHMPIDmipX = source.fHMPIDmipX;
885 fHMPIDmipY = source.fHMPIDmipY;
886
887 fTPCncls = source.fTPCncls;
888 fTPCnclsF = source.fTPCnclsF;
889 fTPCsignalN = source.fTPCsignalN;
949840f6 890 fTPCnclsIter1 = source.fTPCnclsIter1;
891 fTPCnclsFIter1 = source.fTPCnclsFIter1;
732a24fe 892
893 fITSncls = source.fITSncls;
894 fITSClusterMap = source.fITSClusterMap;
895 fTRDncls = source.fTRDncls;
896 fTRDncls0 = source.fTRDncls0;
ed15ef4f 897 fTRDntracklets = source.fTRDntracklets;
6dc21f57 898 fVertexID = source.fVertexID;
732a24fe 899 return *this;
900}
901
902
903
904void AliESDtrack::Copy(TObject &obj) const {
905
906 // this overwrites the virtual TOBject::Copy()
907 // to allow run time copying without casting
908 // in AliESDEvent
909
910 if(this==&obj)return;
911 AliESDtrack *robj = dynamic_cast<AliESDtrack*>(&obj);
912 if(!robj)return; // not an AliESDtrack
913 *robj = *this;
914
915}
916
917
918
00dce61a 919void AliESDtrack::AddCalibObject(TObject * object){
920 //
921 // add calib object to the list
922 //
923 if (!fFriendTrack) fFriendTrack = new AliESDfriendTrack;
924 fFriendTrack->AddCalibObject(object);
925}
926
927TObject * AliESDtrack::GetCalibObject(Int_t index){
928 //
929 // return calib objct at given position
930 //
931 if (!fFriendTrack) return 0;
932 return fFriendTrack->GetCalibObject(index);
933}
934
935
f12d42ce 936Bool_t AliESDtrack::FillTPCOnlyTrack(AliESDtrack &track){
b9ca886f 937
938 // Fills the information of the TPC-only first reconstruction pass
939 // into the passed ESDtrack object. For consistency fTPCInner is also filled
940 // again
941
5b305f70 942
943
944 // For data produced before r26675
945 // RelateToVertexTPC was not properly called during reco
946 // so you'll have to call it again, before FillTPCOnlyTrack
947 // Float_t p[2],cov[3];
948 // track->GetImpactParametersTPC(p,cov);
949 // if(p[0]==0&&p[1]==0) // <- Default values
950 // track->RelateToVertexTPC(esd->GetPrimaryVertexTPC(),esd->GetMagneticField(),kVeryBig);
951
952
b9ca886f 953 if(!fTPCInner)return kFALSE;
954
955 // fill the TPC track params to the global track parameters
956 track.Set(fTPCInner->GetX(),fTPCInner->GetAlpha(),fTPCInner->GetParameter(),fTPCInner->GetCovariance());
957 track.fD = fdTPC;
958 track.fZ = fzTPC;
959 track.fCdd = fCddTPC;
960 track.fCdz = fCdzTPC;
961 track.fCzz = fCzzTPC;
962
963 // copy the TPCinner parameters
964 if(track.fTPCInner) *track.fTPCInner = *fTPCInner;
965 else track.fTPCInner = new AliExternalTrackParam(*fTPCInner);
966 track.fdTPC = fdTPC;
967 track.fzTPC = fzTPC;
968 track.fCddTPC = fCddTPC;
969 track.fCdzTPC = fCdzTPC;
970 track.fCzzTPC = fCzzTPC;
436dfe39 971 track.fCchi2TPC = fCchi2TPC;
b9ca886f 972
973
974 // copy all other TPC specific parameters
975
976 // replace label by TPC label
977 track.fLabel = fTPCLabel;
978 track.fTPCLabel = fTPCLabel;
979
980 track.fTPCchi2 = fTPCchi2;
949840f6 981 track.fTPCchi2Iter1 = fTPCchi2Iter1;
b9ca886f 982 track.fTPCsignal = fTPCsignal;
983 track.fTPCsignalS = fTPCsignalS;
984 for(int i = 0;i<4;++i)track.fTPCPoints[i] = fTPCPoints[i];
985
986 track.fTPCncls = fTPCncls;
987 track.fTPCnclsF = fTPCnclsF;
988 track.fTPCsignalN = fTPCsignalN;
949840f6 989 track.fTPCnclsIter1 = fTPCnclsIter1;
990 track.fTPCnclsFIter1 = fTPCnclsFIter1;
b9ca886f 991
992 // PID
993 for(int i=0;i<AliPID::kSPECIES;++i){
994 track.fTPCr[i] = fTPCr[i];
995 // combined PID is TPC only!
996 track.fR[i] = fTPCr[i];
997 }
998 track.fTPCClusterMap = fTPCClusterMap;
999 track.fTPCSharedMap = fTPCSharedMap;
1000
1001
1002 // reset the flags
1003 track.fFlags = kTPCin;
1004 track.fID = fID;
1005
b1cfce51 1006 track.fFlags |= fFlags & kTPCpid; //copy the TPCpid status flag
b9ca886f 1007
1008 for (Int_t i=0;i<3;i++) track.fKinkIndexes[i] = fKinkIndexes[i];
1009
1010 return kTRUE;
1011
1012}
1013
9559cbc4 1014//_______________________________________________________________________
1015void AliESDtrack::MakeMiniESDtrack(){
1016 // Resets everything except
1017 // fFlags: Reconstruction status flags
1018 // fLabel: Track label
1019 // fID: Unique ID of the track
d7ddf1e9 1020 // Impact parameter information
9559cbc4 1021 // fR[AliPID::kSPECIES]: combined "detector response probability"
8497bca0 1022 // Running track parameters in the base class (AliExternalTrackParam)
9559cbc4 1023
1024 fTrackLength = 0;
562dd0b4 1025
9559cbc4 1026 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
9559cbc4 1027
1028 // Reset track parameters constrained to the primary vertex
562dd0b4 1029 delete fCp;fCp = 0;
9559cbc4 1030
1031 // Reset track parameters at the inner wall of TPC
562dd0b4 1032 delete fIp;fIp = 0;
1033 delete fTPCInner;fTPCInner=0;
9559cbc4 1034 // Reset track parameters at the inner wall of the TRD
562dd0b4 1035 delete fOp;fOp = 0;
c38d443f 1036 // Reset track parameters at the HMPID
1037 delete fHMPIDp;fHMPIDp = 0;
562dd0b4 1038
9559cbc4 1039
1040 // Reset ITS track related information
1041 fITSchi2 = 0;
9559cbc4 1042 fITSncls = 0;
62665e7f 1043 fITSClusterMap=0;
9559cbc4 1044 fITSsignal = 0;
1d4882da 1045 for (Int_t i=0;i<4;i++) fITSdEdxSamples[i] = 0.;
ef7253ac 1046 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
9559cbc4 1047 fITSLabel = 0;
9559cbc4 1048
1049 // Reset TPC related track information
1050 fTPCchi2 = 0;
949840f6 1051 fTPCchi2Iter1 = 0;
9559cbc4 1052 fTPCncls = 0;
e1d4c1b5 1053 fTPCnclsF = 0;
949840f6 1054 fTPCnclsIter1 = 0;
1055 fTPCnclsFIter1 = 0;
9559cbc4 1056 fTPCClusterMap = 0;
eb7f6854 1057 fTPCSharedMap = 0;
9559cbc4 1058 fTPCsignal= 0;
e1d4c1b5 1059 fTPCsignalS= 0;
1060 fTPCsignalN= 0;
9559cbc4 1061 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=0;
1062 fTPCLabel=0;
1063 for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
1064 for (Int_t i=0; i<3;i++) fKinkIndexes[i] = 0;
1065 for (Int_t i=0; i<3;i++) fV0Indexes[i] = 0;
1066
1067 // Reset TRD related track information
1068 fTRDchi2 = 0;
1069 fTRDncls = 0;
1070 fTRDncls0 = 0;
9559cbc4 1071 fTRDsignal = 0;
6984f7c1 1072 for (Int_t i=0;i<kTRDnPlanes;i++) {
6d45eaef 1073 fTRDTimBin[i] = 0;
9559cbc4 1074 }
1075 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
1076 fTRDLabel = 0;
9559cbc4 1077 fTRDQuality = 0;
ed15ef4f 1078 fTRDntracklets = 0;
6984f7c1 1079 if(fTRDnSlices)
1080 delete[] fTRDslices;
1081 fTRDslices=0x0;
1082 fTRDnSlices=0;
23d49657 1083 fTRDBudget = 0;
9559cbc4 1084
1085 // Reset TOF related track information
1086 fTOFchi2 = 0;
ce3f4882 1087 fTOFindex = -1;
ab37ab1e 1088 fTOFsignal = 99999;
1089 fTOFCalChannel = -1;
1090 fTOFsignalToT = 99999;
1091 fTOFsignalRaw = 99999;
1092 fTOFsignalDz = 999;
1093 fTOFsignalDx = 999;
1094 fTOFdeltaBC = 999;
1095 fTOFl0l1 = 999;
9559cbc4 1096 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
ab37ab1e 1097 for (Int_t i=0;i<3;i++) fTOFLabel[i] = -1;
9559cbc4 1098 for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
1099
f4b3bbb7 1100 // Reset HMPID related track information
1101 fHMPIDchi2 = 0;
562dd0b4 1102 fHMPIDqn = 0;
81aa7a0d 1103 fHMPIDcluIdx = -1;
f4b3bbb7 1104 fHMPIDsignal = 0;
1105 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
562dd0b4 1106 fHMPIDtrkTheta = 0;
1107 fHMPIDtrkPhi = 0;
1108 fHMPIDtrkX = 0;
1109 fHMPIDtrkY = 0;
1110 fHMPIDmipX = 0;
1111 fHMPIDmipY = 0;
f1cedef3 1112 fCaloIndex = kEMCALNoMatch;
9559cbc4 1113
b5b2b4db 1114 // reset global track chi2
1115 fGlobalChi2 = 0;
1116
6dc21f57 1117 fVertexID = -2; // an orphan track
1118
15e85efa 1119 delete fFriendTrack; fFriendTrack = 0;
9559cbc4 1120}
ae982df3 1121//_______________________________________________________________________
4a78b8c5 1122Double_t AliESDtrack::GetMass() const {
4427806c 1123 // Returns the mass of the most probable particle type
ec729fb0 1124
1125 Int_t i;
1126 for (i=0; i<AliPID::kSPECIES-1; i++) {
1127 if (fR[i] != fR[i+1]) break;
1128 }
1129 // If all the probabilities are equal, return the pion mass
1130 if (i == AliPID::kSPECIES-1) return AliPID::ParticleMass(AliPID::kPion);
1131
ae982df3 1132 Float_t max=0.;
1133 Int_t k=-1;
ec729fb0 1134 for (i=0; i<AliPID::kSPECIES; i++) {
ae982df3 1135 if (fR[i]>max) {k=i; max=fR[i];}
1136 }
db3989b3 1137 if (k==0) { // dE/dx "crossing points" in the TPC
1138 Double_t p=GetP();
1139 if ((p>0.38)&&(p<0.48))
304864ab 1140 if (fR[0]<fR[3]*10.) return AliPID::ParticleMass(AliPID::kKaon);
db3989b3 1141 if ((p>0.75)&&(p<0.85))
304864ab 1142 if (fR[0]<fR[4]*10.) return AliPID::ParticleMass(AliPID::kProton);
db3989b3 1143 return 0.00051;
1144 }
304864ab 1145 if (k==1) return AliPID::ParticleMass(AliPID::kMuon);
1146 if (k==2||k==-1) return AliPID::ParticleMass(AliPID::kPion);
1147 if (k==3) return AliPID::ParticleMass(AliPID::kKaon);
1148 if (k==4) return AliPID::ParticleMass(AliPID::kProton);
5f7789fc 1149 AliWarning("Undefined mass !");
304864ab 1150 return AliPID::ParticleMass(AliPID::kPion);
ae982df3 1151}
1152
aad8d435 1153//______________________________________________________________________________
1154Double_t AliESDtrack::E() const
1155{
1156 // Returns the energy of the particle given its assumed mass.
1157 // Assumes the pion mass if the particle can't be identified properly.
1158
1159 Double_t m = M();
1160 Double_t p = P();
1161 return TMath::Sqrt(p*p + m*m);
1162}
1163
1164//______________________________________________________________________________
1165Double_t AliESDtrack::Y() const
1166{
1167 // Returns the rapidity of a particle given its assumed mass.
1168 // Assumes the pion mass if the particle can't be identified properly.
1169
1170 Double_t e = E();
1171 Double_t pz = Pz();
e03e4544 1172 if (e != TMath::Abs(pz)) { // energy was not equal to pz
aad8d435 1173 return 0.5*TMath::Log((e+pz)/(e-pz));
1174 } else { // energy was equal to pz
1175 return -999.;
1176 }
1177}
1178
ae982df3 1179//_______________________________________________________________________
c9ec41e8 1180Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
ae982df3 1181 //
1182 // This function updates track's running parameters
1183 //
15614b8b 1184 Bool_t rc=kTRUE;
1185
9b859005 1186 SetStatus(flags);
1187 fLabel=t->GetLabel();
1188
1189 if (t->IsStartedTimeIntegral()) {
1190 SetStatus(kTIME);
1191 Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
1192 SetIntegratedLength(t->GetIntegratedLength());
1193 }
1194
6c94f330 1195 Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
ded25cc6 1196 if (flags==kITSout) fFriendTrack->SetITSOut(*t);
1197 if (flags==kTPCout) fFriendTrack->SetTPCOut(*t);
fae4c212 1198 if (flags==kTRDrefit) fFriendTrack->SetTRDIn(*t);
e1d4c1b5 1199
ae982df3 1200 switch (flags) {
ad2f1f2b 1201
9b859005 1202 case kITSin: case kITSout: case kITSrefit:
6d3a7bbf 1203 {
48704648 1204 fITSClusterMap=0;
ae982df3 1205 fITSncls=t->GetNumberOfClusters();
6d3a7bbf 1206 Int_t* indexITS = new Int_t[AliESDfriendTrack::kMaxITScluster];
62665e7f 1207 for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
6d3a7bbf 1208 indexITS[i]=t->GetClusterIndex(i);
1209
62665e7f 1210 if (i<fITSncls) {
6d3a7bbf 1211 Int_t l=(indexITS[i] & 0xf0000000) >> 28;
62665e7f 1212 SETBIT(fITSClusterMap,l);
1213 }
1214 }
6d3a7bbf 1215 fFriendTrack->SetITSIndices(indexITS,AliESDfriendTrack::kMaxITScluster);
1216 delete [] indexITS;
1217
ae982df3 1218 fITSchi2=t->GetChi2();
ae982df3 1219 fITSsignal=t->GetPIDsignal();
6e5b1b04 1220 fITSLabel = t->GetLabel();
57483eb1 1221 // keep in fOp the parameters outside ITS for ITS stand-alone tracks
1222 if (flags==kITSout) {
1223 if (!fOp) fOp=new AliExternalTrackParam(*t);
1224 else
1225 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
ded25cc6 1226 }
6d3a7bbf 1227 }
ae982df3 1228 break;
ad2f1f2b 1229
9b859005 1230 case kTPCin: case kTPCrefit:
6d3a7bbf 1231 {
6e5b1b04 1232 fTPCLabel = t->GetLabel();
949840f6 1233 if (flags==kTPCin) {
1234 fTPCInner=new AliExternalTrackParam(*t);
1235 fTPCnclsIter1=t->GetNumberOfClusters();
1236 fTPCchi2Iter1=t->GetChi2();
1237 }
c9ec41e8 1238 if (!fIp) fIp=new AliExternalTrackParam(*t);
6c94f330 1239 else
1240 fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
6d3a7bbf 1241 }
9b859005 1242 case kTPCout:
6d3a7bbf 1243 {
1244 Int_t* indexTPC = new Int_t[AliESDfriendTrack::kMaxTPCcluster];
1d303a24 1245 if (flags & kTPCout){
1246 if (!fOp) fOp=new AliExternalTrackParam(*t);
6c94f330 1247 else
1248 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1d303a24 1249 }
e1d4c1b5 1250 fTPCncls=t->GetNumberOfClusters();
ae982df3 1251 fTPCchi2=t->GetChi2();
a866ac60 1252
1253 {//prevrow must be declared in separate namespace, otherwise compiler cries:
1254 //"jump to case label crosses initialization of `Int_t prevrow'"
1255 Int_t prevrow = -1;
6e5b1b04 1256 // for (Int_t i=0;i<fTPCncls;i++)
15e85efa 1257 for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)
a866ac60 1258 {
6d3a7bbf 1259 indexTPC[i]=t->GetClusterIndex(i);
1260 Int_t idx = indexTPC[i];
a866ac60 1261
15e85efa 1262 if (idx<0) continue;
9fe5b2ff 1263
a866ac60 1264 // Piotr's Cluster Map for HBT
1265 // ### please change accordingly if cluster array is changing
1266 // to "New TPC Tracking" style (with gaps in array)
a866ac60 1267 Int_t sect = (idx&0xff000000)>>24;
1268 Int_t row = (idx&0x00ff0000)>>16;
1269 if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
1270
1271 fTPCClusterMap.SetBitNumber(row,kTRUE);
1272
1273 //Fill the gap between previous row and this row with 0 bits
1274 //In case ### pleas change it as well - just set bit 0 in case there
1275 //is no associated clusters for current "i"
1276 if (prevrow < 0)
1277 {
1278 prevrow = row;//if previous bit was not assigned yet == this is the first one
1279 }
1280 else
1281 { //we don't know the order (inner to outer or reverse)
1282 //just to be save in case it is going to change
1283 Int_t n = 0, m = 0;
1284 if (prevrow < row)
1285 {
1286 n = prevrow;
1287 m = row;
1288 }
1289 else
1290 {
1291 n = row;
1292 m = prevrow;
1293 }
1294
1295 for (Int_t j = n+1; j < m; j++)
1296 {
1297 fTPCClusterMap.SetBitNumber(j,kFALSE);
1298 }
1299 prevrow = row;
1300 }
1301 // End Of Piotr's Cluster Map for HBT
1302 }
6d3a7bbf 1303 fFriendTrack->SetTPCIndices(indexTPC,AliESDfriendTrack::kMaxTPCcluster);
1304 delete [] indexTPC;
1305
a866ac60 1306 }
ae982df3 1307 fTPCsignal=t->GetPIDsignal();
6d3a7bbf 1308 }
ae982df3 1309 break;
9b859005 1310
64130601 1311 case kTRDin: case kTRDrefit:
1312 break;
1313 case kTRDout:
6d3a7bbf 1314 {
51ad6848 1315 fTRDLabel = t->GetLabel();
2f83b7a6 1316 fTRDchi2 = t->GetChi2();
1317 fTRDncls = t->GetNumberOfClusters();
6d3a7bbf 1318 Int_t* indexTRD = new Int_t[AliESDfriendTrack::kMaxTRDcluster];
1319 for (Int_t i=0;i<AliESDfriendTrack::kMaxTRDcluster;i++) indexTRD[i]=-2;
1320 for (Int_t i=0;i<6;i++) indexTRD[i]=t->GetTrackletIndex(i);
1321 fFriendTrack->SetTRDIndices(indexTRD,AliESDfriendTrack::kMaxTRDcluster);
1322 delete [] indexTRD;
1323
5bc3e158 1324
79e94bf8 1325 fTRDsignal=t->GetPIDsignal();
6d3a7bbf 1326 }
79e94bf8 1327 break;
c4d11b15 1328 case kTRDbackup:
c9ec41e8 1329 if (!fOp) fOp=new AliExternalTrackParam(*t);
6c94f330 1330 else
1331 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
c4d11b15 1332 fTRDncls0 = t->GetNumberOfClusters();
1333 break;
1334 case kTOFin:
1335 break;
1336 case kTOFout:
1337 break;
d0862fea 1338 case kTRDStop:
1339 break;
c38d443f 1340 case kHMPIDout:
1341 if (!fHMPIDp) fHMPIDp=new AliExternalTrackParam(*t);
1342 else
1343 fHMPIDp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1344 break;
ae982df3 1345 default:
5f7789fc 1346 AliError("Wrong flag !");
ae982df3 1347 return kFALSE;
1348 }
1349
15614b8b 1350 return rc;
ae982df3 1351}
1352
1353//_______________________________________________________________________
1354void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
1355 //---------------------------------------------------------------------
1356 // This function returns external representation of the track parameters
1357 //---------------------------------------------------------------------
c9ec41e8 1358 x=GetX();
1359 for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
15614b8b 1360}
1361
67c3dcbe 1362//_______________________________________________________________________
a866ac60 1363void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
67c3dcbe 1364 //---------------------------------------------------------------------
1365 // This function returns external representation of the cov. matrix
1366 //---------------------------------------------------------------------
c9ec41e8 1367 for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
67c3dcbe 1368}
1369
67c3dcbe 1370//_______________________________________________________________________
c0b978f0 1371Bool_t AliESDtrack::GetConstrainedExternalParameters
1372 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
67c3dcbe 1373 //---------------------------------------------------------------------
1374 // This function returns the constrained external track parameters
1375 //---------------------------------------------------------------------
c0b978f0 1376 if (!fCp) return kFALSE;
1377 alpha=fCp->GetAlpha();
c9ec41e8 1378 x=fCp->GetX();
1379 for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
c0b978f0 1380 return kTRUE;
67c3dcbe 1381}
c9ec41e8 1382
67c3dcbe 1383//_______________________________________________________________________
c0b978f0 1384Bool_t
67c3dcbe 1385AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
1386 //---------------------------------------------------------------------
1387 // This function returns the constrained external cov. matrix
1388 //---------------------------------------------------------------------
c0b978f0 1389 if (!fCp) return kFALSE;
c9ec41e8 1390 for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
c0b978f0 1391 return kTRUE;
67c3dcbe 1392}
1393
c0b978f0 1394Bool_t
1395AliESDtrack::GetInnerExternalParameters
1396 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1397 //---------------------------------------------------------------------
c9ec41e8 1398 // This function returns external representation of the track parameters
1399 // at the inner layer of TPC
9b859005 1400 //---------------------------------------------------------------------
c0b978f0 1401 if (!fIp) return kFALSE;
1402 alpha=fIp->GetAlpha();
c9ec41e8 1403 x=fIp->GetX();
1404 for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
c0b978f0 1405 return kTRUE;
9b859005 1406}
1407
c0b978f0 1408Bool_t
1409AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const {
c9ec41e8 1410 //---------------------------------------------------------------------
1411 // This function returns external representation of the cov. matrix
1412 // at the inner layer of TPC
1413 //---------------------------------------------------------------------
c0b978f0 1414 if (!fIp) return kFALSE;
c9ec41e8 1415 for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
c0b978f0 1416 return kTRUE;
9b859005 1417}
1418
d61ca12d 1419void
1420AliESDtrack::SetOuterParam(const AliExternalTrackParam *p, ULong_t flags) {
1421 //
1422 // This is a direct setter for the outer track parameters
1423 //
1424 SetStatus(flags);
1425 if (fOp) delete fOp;
1426 fOp=new AliExternalTrackParam(*p);
1427}
1428
c38d443f 1429void
1430AliESDtrack::SetOuterHmpParam(const AliExternalTrackParam *p, ULong_t flags) {
1431 //
1432 // This is a direct setter for the outer track parameters
1433 //
1434 SetStatus(flags);
1435 if (fHMPIDp) delete fHMPIDp;
1436 fHMPIDp=new AliExternalTrackParam(*p);
1437}
1438
c0b978f0 1439Bool_t
1440AliESDtrack::GetOuterExternalParameters
1441 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1442 //---------------------------------------------------------------------
c9ec41e8 1443 // This function returns external representation of the track parameters
1444 // at the inner layer of TRD
a866ac60 1445 //---------------------------------------------------------------------
c0b978f0 1446 if (!fOp) return kFALSE;
1447 alpha=fOp->GetAlpha();
c9ec41e8 1448 x=fOp->GetX();
1449 for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
c0b978f0 1450 return kTRUE;
a866ac60 1451}
c9ec41e8 1452
c38d443f 1453Bool_t
1454AliESDtrack::GetOuterHmpExternalParameters
1455 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1456 //---------------------------------------------------------------------
1457 // This function returns external representation of the track parameters
1458 // at the inner layer of TRD
1459 //---------------------------------------------------------------------
1460 if (!fHMPIDp) return kFALSE;
1461 alpha=fHMPIDp->GetAlpha();
1462 x=fHMPIDp->GetX();
1463 for (Int_t i=0; i<5; i++) p[i]=fHMPIDp->GetParameter()[i];
1464 return kTRUE;
1465}
1466
c0b978f0 1467Bool_t
1468AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
a866ac60 1469 //---------------------------------------------------------------------
c9ec41e8 1470 // This function returns external representation of the cov. matrix
1471 // at the inner layer of TRD
a866ac60 1472 //---------------------------------------------------------------------
c0b978f0 1473 if (!fOp) return kFALSE;
c9ec41e8 1474 for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
c0b978f0 1475 return kTRUE;
a866ac60 1476}
1477
c38d443f 1478Bool_t
1479AliESDtrack::GetOuterHmpExternalCovariance(Double_t cov[15]) const {
1480 //---------------------------------------------------------------------
1481 // This function returns external representation of the cov. matrix
1482 // at the inner layer of TRD
1483 //---------------------------------------------------------------------
1484 if (!fHMPIDp) return kFALSE;
1485 for (Int_t i=0; i<15; i++) cov[i]=fHMPIDp->GetCovariance()[i];
1486 return kTRUE;
1487}
1488
98937d93 1489Int_t AliESDtrack::GetNcls(Int_t idet) const
1490{
1491 // Get number of clusters by subdetector index
1492 //
1493 Int_t ncls = 0;
1494 switch(idet){
1495 case 0:
1496 ncls = fITSncls;
1497 break;
1498 case 1:
1499 ncls = fTPCncls;
1500 break;
1501 case 2:
1502 ncls = fTRDncls;
1503 break;
1504 case 3:
ce3f4882 1505 if (fTOFindex != -1)
98937d93 1506 ncls = 1;
1507 break;
81aa7a0d 1508 case 4: //PHOS
1509 break;
1510 case 5: //HMPID
1511 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1512 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1513 ncls = 1;
1514 }
1515 }
1516 break;
98937d93 1517 default:
1518 break;
1519 }
1520 return ncls;
1521}
1522
ef7253ac 1523Int_t AliESDtrack::GetClusters(Int_t idet, Int_t *idx) const
98937d93 1524{
1525 // Get cluster index array by subdetector index
1526 //
1527 Int_t ncls = 0;
1528 switch(idet){
1529 case 0:
1530 ncls = GetITSclusters(idx);
1531 break;
1532 case 1:
ef7253ac 1533 ncls = GetTPCclusters(idx);
98937d93 1534 break;
1535 case 2:
1536 ncls = GetTRDclusters(idx);
1537 break;
1538 case 3:
ce3f4882 1539 if (fTOFindex != -1) {
1540 idx[0] = fTOFindex;
98937d93 1541 ncls = 1;
1542 }
1543 break;
313af949 1544 case 4: //PHOS
1545 break;
1546 case 5:
81aa7a0d 1547 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1548 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1549 idx[0] = GetHMPIDcluIdx();
1550 ncls = 1;
1551 }
313af949 1552 }
1553 break;
1554 case 6: //EMCAL
1555 break;
98937d93 1556 default:
1557 break;
1558 }
1559 return ncls;
1560}
1561
ae982df3 1562//_______________________________________________________________________
1563void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
4427806c 1564 // Returns the array with integrated times for each particle hypothesis
304864ab 1565 for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
ae982df3 1566}
1567
1568//_______________________________________________________________________
1569void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
4427806c 1570 // Sets the array with integrated times for each particle hypotesis
304864ab 1571 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
ae982df3 1572}
1573
c630aafd 1574//_______________________________________________________________________
4427806c 1575void AliESDtrack::SetITSpid(const Double_t *p) {
1576 // Sets values for the probability of each particle type (in ITS)
d27bbc79 1577 SetPIDValues(fITSr,p,AliPID::kSPECIES);
c630aafd 1578 SetStatus(AliESDtrack::kITSpid);
1579}
1580
1581//_______________________________________________________________________
1582void AliESDtrack::GetITSpid(Double_t *p) const {
4427806c 1583 // Gets the probability of each particle type (in ITS)
304864ab 1584 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
c630aafd 1585}
1586
ae982df3 1587//_______________________________________________________________________
562dd0b4 1588Char_t AliESDtrack::GetITSclusters(Int_t *idx) const {
ae982df3 1589 //---------------------------------------------------------------------
1590 // This function returns indices of the assgined ITS clusters
1591 //---------------------------------------------------------------------
6d3a7bbf 1592 if (idx) {
1593 Int_t *index=fFriendTrack->GetITSindices();
1594 for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) {
1595 if ( (i>=fITSncls) && (i<6) ) idx[i]=-1;
1596 else {
1597 if (index) {
1598 idx[i]=index[i];
1599 }
1600 else idx[i]= -2;
1601 }
1602 }
15e85efa 1603 }
ae982df3 1604 return fITSncls;
1605}
1606
89f1b176 1607//_______________________________________________________________________
1608Bool_t AliESDtrack::GetITSModuleIndexInfo(Int_t ilayer,Int_t &idet,Int_t &status,
1609 Float_t &xloc,Float_t &zloc) const {
1610 //----------------------------------------------------------------------
1611 // This function encodes in the module number also the status of cluster association
1612 // "status" can have the following values:
1613 // 1 "found" (cluster is associated),
1614 // 2 "dead" (module is dead from OCDB),
1615 // 3 "skipped" (module or layer forced to be skipped),
1616 // 4 "outinz" (track out of z acceptance),
1617 // 5 "nocls" (no clusters in the road),
1618 // 6 "norefit" (cluster rejected during refit),
1619 // 7 "deadzspd" (holes in z in SPD)
1620 // Also given are the coordinates of the crossing point of track and module
1621 // (in the local module ref. system)
1622 // WARNING: THIS METHOD HAS TO BE SYNCHRONIZED WITH AliITStrackV2::GetModuleIndexInfo()!
1623 //----------------------------------------------------------------------
1624
1625 if(fITSModule[ilayer]==-1) {
89f1b176 1626 idet = -1;
1627 status=0;
1628 xloc=-99.; zloc=-99.;
1629 return kFALSE;
1630 }
1631
1632 Int_t module = fITSModule[ilayer];
1633
1634 idet = Int_t(module/1000000);
1635
1636 module -= idet*1000000;
1637
1638 status = Int_t(module/100000);
1639
1640 module -= status*100000;
1641
1642 Int_t signs = Int_t(module/10000);
1643
1644 module-=signs*10000;
1645
1646 Int_t xInt = Int_t(module/100);
1647 module -= xInt*100;
1648
1649 Int_t zInt = module;
1650
1651 if(signs==1) { xInt*=1; zInt*=1; }
1652 if(signs==2) { xInt*=1; zInt*=-1; }
1653 if(signs==3) { xInt*=-1; zInt*=1; }
1654 if(signs==4) { xInt*=-1; zInt*=-1; }
1655
1656 xloc = 0.1*(Float_t)xInt;
1657 zloc = 0.1*(Float_t)zInt;
1658
1659 if(status==4) idet = -1;
1660
1661 return kTRUE;
1662}
1663
ae982df3 1664//_______________________________________________________________________
562dd0b4 1665UShort_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
ae982df3 1666 //---------------------------------------------------------------------
1667 // This function returns indices of the assgined ITS clusters
1668 //---------------------------------------------------------------------
6d3a7bbf 1669 if (idx) {
15e85efa 1670 Int_t *index=fFriendTrack->GetTPCindices();
6d3a7bbf 1671
1672 if (index){
1673 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
1674 }
1675 else {
1676 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=-2;
1677 }
15e85efa 1678 }
ae982df3 1679 return fTPCncls;
1680}
8c6a71ab 1681
562dd0b4 1682Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
81e97e0d 1683 //
1684 // GetDensity of the clusters on given region between row0 and row1
1685 // Dead zone effect takin into acoount
1686 //
1687 Int_t good = 0;
1688 Int_t found = 0;
1689 //
15e85efa 1690 Int_t *index=fFriendTrack->GetTPCindices();
81e97e0d 1691 for (Int_t i=row0;i<=row1;i++){
15e85efa 1692 Int_t idx = index[i];
1693 if (idx!=-1) good++; // track outside of dead zone
1694 if (idx>0) found++;
81e97e0d 1695 }
1696 Float_t density=0.5;
1697 if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
1698 return density;
1699}
c84a5e9e 1700
8c6a71ab 1701//_______________________________________________________________________
1702void AliESDtrack::SetTPCpid(const Double_t *p) {
4427806c 1703 // Sets values for the probability of each particle type (in TPC)
d27bbc79 1704 SetPIDValues(fTPCr,p,AliPID::kSPECIES);
8c6a71ab 1705 SetStatus(AliESDtrack::kTPCpid);
1706}
1707
1708//_______________________________________________________________________
1709void AliESDtrack::GetTPCpid(Double_t *p) const {
4427806c 1710 // Gets the probability of each particle type (in TPC)
304864ab 1711 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
8c6a71ab 1712}
1713
bb2ceb1f 1714//_______________________________________________________________________
562dd0b4 1715UChar_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
bb2ceb1f 1716 //---------------------------------------------------------------------
1717 // This function returns indices of the assgined TRD clusters
1718 //---------------------------------------------------------------------
6d3a7bbf 1719 if (idx) {
1720 Int_t *index=fFriendTrack->GetTRDindices();
1721
1722 if (index) {
1723 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
1724 }
1725 else {
1726 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=-2;
1727 }
15e85efa 1728 }
bb2ceb1f 1729 return fTRDncls;
1730}
1731
5bc3e158 1732//_______________________________________________________________________
1733UChar_t AliESDtrack::GetTRDtracklets(Int_t *idx) const {
0ad488b0 1734//
1735// This function returns the number of TRD tracklets used in tracking
1736// and it fills the indices of these tracklets in the array "idx" as they
1737// are registered in the TRD track list.
1738//
1739// Caution :
1740// 1. The idx array has to be allocated with a size >= AliESDtrack::kTRDnPlanes
1741// 2. The idx array store not only the index but also the layer of the tracklet.
1742// Therefore tracks with TRD gaps contain default values for indices [-1]
1743
1744 if (!idx) return GetTRDntracklets();
6d3a7bbf 1745 Int_t *index=fFriendTrack->GetTRDindices();
1746 Int_t n = 0;
0ad488b0 1747 for (Int_t i=0; i<kTRDnPlanes; i++){
6d3a7bbf 1748 if (index){
1749 if(index[i]>=0) n++;
1750 idx[i]=index[i];
1751 }
1752 else idx[i] = -2;
5bc3e158 1753 }
0ad488b0 1754 return n;
5bc3e158 1755}
1756
c630aafd 1757//_______________________________________________________________________
1758void AliESDtrack::SetTRDpid(const Double_t *p) {
4427806c 1759 // Sets values for the probability of each particle type (in TRD)
d27bbc79 1760 SetPIDValues(fTRDr,p,AliPID::kSPECIES);
c630aafd 1761 SetStatus(AliESDtrack::kTRDpid);
1762}
1763
1764//_______________________________________________________________________
1765void AliESDtrack::GetTRDpid(Double_t *p) const {
4427806c 1766 // Gets the probability of each particle type (in TRD)
304864ab 1767 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
c630aafd 1768}
1769
79e94bf8 1770//_______________________________________________________________________
1771void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
1772{
4427806c 1773 // Sets the probability of particle type iSpecies to p (in TRD)
79e94bf8 1774 fTRDr[iSpecies] = p;
1775}
1776
562dd0b4 1777Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
79e94bf8 1778{
4427806c 1779 // Returns the probability of particle type iSpecies (in TRD)
79e94bf8 1780 return fTRDr[iSpecies];
1781}
1782
fae4c212 1783//____________________________________________________
1784Int_t AliESDtrack::GetNumberOfTRDslices() const
1785{
1786 // built in backward compatibility
1787 Int_t idx = fTRDnSlices - (kTRDnPlanes<<1);
1788 return idx<18 ? fTRDnSlices/kTRDnPlanes : idx/kTRDnPlanes;
1789}
1790
1791//____________________________________________________
1792Double_t AliESDtrack::GetTRDmomentum(Int_t plane, Double_t *sp) const
1793{
1794//Returns momentum estimation and optional its error (sp)
1795// in TRD layer "plane".
1796
1797 if (!fTRDnSlices) {
95621324 1798 AliError("No TRD info allocated for this track !");
fae4c212 1799 return -1.;
1800 }
1801 if ((plane<0) || (plane>=kTRDnPlanes)) {
1802 AliError("Info for TRD plane not available!");
1803 return -1.;
1804 }
1805
1806 Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
1807 // Protection for backward compatibility
1808 if(idx<(GetNumberOfTRDslices()*kTRDnPlanes)) return -1.;
1809
1810 if(sp) (*sp) = fTRDslices[idx+kTRDnPlanes];
1811 return fTRDslices[idx];
1812}
1813
1814//____________________________________________________
1815Double_t AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
1816 //Gets the charge from the slice of the plane
1817
1818 if(!fTRDslices) {
1819 //AliError("No TRD slices allocated for this track !");
1820 return -1.;
1821 }
1822 if ((plane<0) || (plane>=kTRDnPlanes)) {
1823 AliError("Info for TRD plane not available !");
1824 return -1.;
1825 }
1826 Int_t ns=GetNumberOfTRDslices();
1827 if ((slice<-1) || (slice>=ns)) {
1828 //AliError("Wrong TRD slice !");
1829 return -1.;
1830 }
1831
1832 if(slice>=0) return fTRDslices[plane*ns + slice];
1833
1834 // return average of the dEdx measurements
1835 Double_t q=0.; Double32_t *s = &fTRDslices[plane*ns];
1836 for (Int_t i=0; i<ns; i++, s++) if((*s)>0.) q+=(*s);
1837 return q/ns;
1838}
1839
1840//____________________________________________________
6984f7c1 1841void AliESDtrack::SetNumberOfTRDslices(Int_t n) {
1842 //Sets the number of slices used for PID
fae4c212 1843 if (fTRDnSlices) return;
1844
1845 fTRDnSlices=n;
6984f7c1 1846 fTRDslices=new Double32_t[fTRDnSlices];
fae4c212 1847
1848 // set-up correctly the allocated memory
1849 memset(fTRDslices, 0, n*sizeof(Double32_t));
1850 for (Int_t i=GetNumberOfTRDslices(); i--;) fTRDslices[i]=-1.;
6984f7c1 1851}
1852
fae4c212 1853//____________________________________________________
6984f7c1 1854void AliESDtrack::SetTRDslice(Double_t q, Int_t plane, Int_t slice) {
1855 //Sets the charge q in the slice of the plane
fae4c212 1856 if(!fTRDslices) {
6984f7c1 1857 AliError("No TRD slices allocated for this track !");
1858 return;
1859 }
6984f7c1 1860 if ((plane<0) || (plane>=kTRDnPlanes)) {
fae4c212 1861 AliError("Info for TRD plane not allocated !");
6984f7c1 1862 return;
1863 }
fae4c212 1864 Int_t ns=GetNumberOfTRDslices();
6984f7c1 1865 if ((slice<0) || (slice>=ns)) {
1866 AliError("Wrong TRD slice !");
1867 return;
1868 }
1869 Int_t n=plane*ns + slice;
1870 fTRDslices[n]=q;
1871}
1872
6984f7c1 1873
fae4c212 1874//____________________________________________________
1875void AliESDtrack::SetTRDmomentum(Double_t p, Int_t plane, Double_t *sp)
1876{
1877 if(!fTRDslices) {
1878 AliError("No TRD slices allocated for this track !");
1879 return;
6984f7c1 1880 }
fae4c212 1881 if ((plane<0) || (plane>=kTRDnPlanes)) {
1882 AliError("Info for TRD plane not allocated !");
1883 return;
6984f7c1 1884 }
1885
fae4c212 1886 Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
1887 // Protection for backward compatibility
1888 if(idx<GetNumberOfTRDslices()*kTRDnPlanes) return;
6984f7c1 1889
fae4c212 1890 if(sp) fTRDslices[idx+kTRDnPlanes] = (*sp);
1891 fTRDslices[idx] = p;
6984f7c1 1892}
1893
1894
c630aafd 1895//_______________________________________________________________________
1896void AliESDtrack::SetTOFpid(const Double_t *p) {
4427806c 1897 // Sets the probability of each particle type (in TOF)
d27bbc79 1898 SetPIDValues(fTOFr,p,AliPID::kSPECIES);
c630aafd 1899 SetStatus(AliESDtrack::kTOFpid);
1900}
1901
51ad6848 1902//_______________________________________________________________________
1903void AliESDtrack::SetTOFLabel(const Int_t *p) {
1904 // Sets (in TOF)
1905 for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
1906}
1907
c630aafd 1908//_______________________________________________________________________
1909void AliESDtrack::GetTOFpid(Double_t *p) const {
4427806c 1910 // Gets probabilities of each particle type (in TOF)
304864ab 1911 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
c630aafd 1912}
1913
51ad6848 1914//_______________________________________________________________________
1915void AliESDtrack::GetTOFLabel(Int_t *p) const {
1916 // Gets (in TOF)
1917 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
1918}
1919
1920//_______________________________________________________________________
1921void AliESDtrack::GetTOFInfo(Float_t *info) const {
1922 // Gets (in TOF)
1923 for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
1924}
1925
1926//_______________________________________________________________________
1927void AliESDtrack::SetTOFInfo(Float_t*info) {
1928 // Gets (in TOF)
1929 for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
1930}
1931
4a78b8c5 1932
1933
4a78b8c5 1934//_______________________________________________________________________
f4b3bbb7 1935void AliESDtrack::SetHMPIDpid(const Double_t *p) {
1936 // Sets the probability of each particle type (in HMPID)
1937 SetPIDValues(fHMPIDr,p,AliPID::kSPECIES);
1938 SetStatus(AliESDtrack::kHMPIDpid);
4a78b8c5 1939}
1940
1941//_______________________________________________________________________
f4b3bbb7 1942void AliESDtrack::GetHMPIDpid(Double_t *p) const {
1943 // Gets probabilities of each particle type (in HMPID)
1944 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fHMPIDr[i];
4a78b8c5 1945}
1946
1947
1948
8c6a71ab 1949//_______________________________________________________________________
1950void AliESDtrack::SetESDpid(const Double_t *p) {
4427806c 1951 // Sets the probability of each particle type for the ESD track
d27bbc79 1952 SetPIDValues(fR,p,AliPID::kSPECIES);
8c6a71ab 1953 SetStatus(AliESDtrack::kESDpid);
1954}
1955
1956//_______________________________________________________________________
1957void AliESDtrack::GetESDpid(Double_t *p) const {
4427806c 1958 // Gets probability of each particle type for the ESD track
304864ab 1959 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
8c6a71ab 1960}
1961
d7ddf1e9 1962//_______________________________________________________________________
436dfe39 1963Bool_t AliESDtrack::RelateToVertexTPC(const AliESDVertex *vtx,
1964Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
d7ddf1e9 1965 //
436dfe39 1966 // Try to relate the TPC-only track parameters to the vertex "vtx",
d7ddf1e9 1967 // if the (rough) transverse impact parameter is not bigger then "maxd".
1968 // Magnetic field is "b" (kG).
1969 //
1970 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
1971 // b) The impact parameters and their covariance matrix are calculated.
436dfe39 1972 // c) An attempt to constrain the TPC-only params to the vertex is done.
1973 // The constrained params are returned via "cParam".
d7ddf1e9 1974 //
436dfe39 1975 // In the case of success, the returned value is kTRUE
1976 // otherwise, it's kFALSE)
1977 //
d7ddf1e9 1978
1979 if (!fTPCInner) return kFALSE;
1980 if (!vtx) return kFALSE;
1981
1982 Double_t dz[2],cov[3];
1983 if (!fTPCInner->PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
1984
1985 fdTPC = dz[0];
1986 fzTPC = dz[1];
1987 fCddTPC = cov[0];
1988 fCdzTPC = cov[1];
1989 fCzzTPC = cov[2];
1990
436dfe39 1991 Double_t covar[6]; vtx->GetCovMatrix(covar);
1992 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
1993 Double_t c[3]={covar[2],0.,covar[5]};
1994
1995 Double_t chi2=GetPredictedChi2(p,c);
1996 if (chi2>kVeryBig) return kFALSE;
1997
1998 fCchi2TPC=chi2;
1999
2000 if (!cParam) return kTRUE;
2001
2002 *cParam = *fTPCInner;
2003 if (!cParam->Update(p,c)) return kFALSE;
2004
d7ddf1e9 2005 return kTRUE;
2006}
2007
266a0f9b 2008//_______________________________________________________________________
2009Bool_t AliESDtrack::RelateToVertexTPCBxByBz(const AliESDVertex *vtx,
2010Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2011 //
2012 // Try to relate the TPC-only track parameters to the vertex "vtx",
2013 // if the (rough) transverse impact parameter is not bigger then "maxd".
2014 //
2015 // All three components of the magnetic field ,"b[3]" (kG),
2016 // are taken into account.
2017 //
2018 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
2019 // b) The impact parameters and their covariance matrix are calculated.
2020 // c) An attempt to constrain the TPC-only params to the vertex is done.
2021 // The constrained params are returned via "cParam".
2022 //
2023 // In the case of success, the returned value is kTRUE
2024 // otherwise, it's kFALSE)
2025 //
2026
2027 if (!fTPCInner) return kFALSE;
2028 if (!vtx) return kFALSE;
2029
2030 Double_t dz[2],cov[3];
2031 if (!fTPCInner->PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2032
2033 fdTPC = dz[0];
2034 fzTPC = dz[1];
2035 fCddTPC = cov[0];
2036 fCdzTPC = cov[1];
2037 fCzzTPC = cov[2];
2038
2039 Double_t covar[6]; vtx->GetCovMatrix(covar);
2040 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2041 Double_t c[3]={covar[2],0.,covar[5]};
2042
2043 Double_t chi2=GetPredictedChi2(p,c);
2044 if (chi2>kVeryBig) return kFALSE;
2045
2046 fCchi2TPC=chi2;
2047
2048 if (!cParam) return kTRUE;
2049
2050 *cParam = *fTPCInner;
2051 if (!cParam->Update(p,c)) return kFALSE;
2052
2053 return kTRUE;
2054}
2055
49d13e89 2056//_______________________________________________________________________
436dfe39 2057Bool_t AliESDtrack::RelateToVertex(const AliESDVertex *vtx,
2058Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
49d13e89 2059 //
2060 // Try to relate this track to the vertex "vtx",
2061 // if the (rough) transverse impact parameter is not bigger then "maxd".
2062 // Magnetic field is "b" (kG).
2063 //
2064 // a) The track gets extapolated to the DCA to the vertex.
2065 // b) The impact parameters and their covariance matrix are calculated.
2066 // c) An attempt to constrain this track to the vertex is done.
436dfe39 2067 // The constrained params are returned via "cParam".
49d13e89 2068 //
436dfe39 2069 // In the case of success, the returned value is kTRUE
2070 // (otherwise, it's kFALSE)
49d13e89 2071 //
b5d34a4c 2072
2073 if (!vtx) return kFALSE;
2074
e99a34df 2075 Double_t dz[2],cov[3];
2076 if (!PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
2077
2078 fD = dz[0];
2079 fZ = dz[1];
2080 fCdd = cov[0];
2081 fCdz = cov[1];
2082 fCzz = cov[2];
49d13e89 2083
e99a34df 2084 Double_t covar[6]; vtx->GetCovMatrix(covar);
2085 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2086 Double_t c[3]={covar[2],0.,covar[5]};
3231f9e5 2087
e99a34df 2088 Double_t chi2=GetPredictedChi2(p,c);
436dfe39 2089 if (chi2>kVeryBig) return kFALSE;
2090
2091 fCchi2=chi2;
49d13e89 2092
436dfe39 2093
266a0f9b 2094 //--- Could now these lines be removed ? ---
2095 delete fCp;
2096 fCp=new AliExternalTrackParam(*this);
2097
2098 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
2099 //----------------------------------------
2100
2101 fVertexID = vtx->GetID();
2102
2103 if (!cParam) return kTRUE;
2104
2105 *cParam = *this;
2106 if (!cParam->Update(p,c)) return kFALSE;
2107
2108 return kTRUE;
2109}
2110
2111//_______________________________________________________________________
2112Bool_t AliESDtrack::RelateToVertexBxByBz(const AliESDVertex *vtx,
2113Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2114 //
2115 // Try to relate this track to the vertex "vtx",
2116 // if the (rough) transverse impact parameter is not bigger then "maxd".
2117 // Magnetic field is "b" (kG).
2118 //
2119 // a) The track gets extapolated to the DCA to the vertex.
2120 // b) The impact parameters and their covariance matrix are calculated.
2121 // c) An attempt to constrain this track to the vertex is done.
2122 // The constrained params are returned via "cParam".
2123 //
2124 // In the case of success, the returned value is kTRUE
2125 // (otherwise, it's kFALSE)
2126 //
2127
2128 if (!vtx) return kFALSE;
2129
2130 Double_t dz[2],cov[3];
2131 if (!PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2132
2133 fD = dz[0];
2134 fZ = dz[1];
2135 fCdd = cov[0];
2136 fCdz = cov[1];
2137 fCzz = cov[2];
2138
2139 Double_t covar[6]; vtx->GetCovMatrix(covar);
2140 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2141 Double_t c[3]={covar[2],0.,covar[5]};
2142
2143 Double_t chi2=GetPredictedChi2(p,c);
2144 if (chi2>kVeryBig) return kFALSE;
2145
2146 fCchi2=chi2;
2147
2148
436dfe39 2149 //--- Could now these lines be removed ? ---
e99a34df 2150 delete fCp;
2151 fCp=new AliExternalTrackParam(*this);
49d13e89 2152
e99a34df 2153 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
436dfe39 2154 //----------------------------------------
2155
6dc21f57 2156 fVertexID = vtx->GetID();
436dfe39 2157
2158 if (!cParam) return kTRUE;
2159
2160 *cParam = *this;
2161 if (!cParam->Update(p,c)) return kFALSE;
2162
49d13e89 2163 return kTRUE;
2164}
2165
ac2f7574 2166//_______________________________________________________________________
2167void AliESDtrack::Print(Option_t *) const {
2168 // Prints info on the track
b9ca886f 2169 AliExternalTrackParam::Print();
5f7789fc 2170 printf("ESD track info\n") ;
304864ab 2171 Double_t p[AliPID::kSPECIESN] ;
ac2f7574 2172 Int_t index = 0 ;
2173 if( IsOn(kITSpid) ){
2174 printf("From ITS: ") ;
2175 GetITSpid(p) ;
304864ab 2176 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2177 printf("%f, ", p[index]) ;
2178 printf("\n signal = %f\n", GetITSsignal()) ;
2179 }
2180 if( IsOn(kTPCpid) ){
2181 printf("From TPC: ") ;
2182 GetTPCpid(p) ;
304864ab 2183 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2184 printf("%f, ", p[index]) ;
2185 printf("\n signal = %f\n", GetTPCsignal()) ;
2186 }
2187 if( IsOn(kTRDpid) ){
2188 printf("From TRD: ") ;
2189 GetTRDpid(p) ;
304864ab 2190 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2191 printf("%f, ", p[index]) ;
6984f7c1 2192 printf("\n signal = %f\n", GetTRDsignal()) ;
ac2f7574 2193 }
2194 if( IsOn(kTOFpid) ){
2195 printf("From TOF: ") ;
2196 GetTOFpid(p) ;
304864ab 2197 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2198 printf("%f, ", p[index]) ;
2199 printf("\n signal = %f\n", GetTOFsignal()) ;
2200 }
f4b3bbb7 2201 if( IsOn(kHMPIDpid) ){
2202 printf("From HMPID: ") ;
2203 GetHMPIDpid(p) ;
304864ab 2204 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2205 printf("%f, ", p[index]) ;
f4b3bbb7 2206 printf("\n signal = %f\n", GetHMPIDsignal()) ;
ac2f7574 2207 }
ac2f7574 2208}
6c94f330 2209
0c19adf7 2210
2211//
2212// Draw functionality
2213// Origin: Marian Ivanov, Marian.Ivanov@cern.ch
2214//
2215void AliESDtrack::FillPolymarker(TPolyMarker3D *pol, Float_t magF, Float_t minR, Float_t maxR, Float_t stepR){
2216 //
2217 // Fill points in the polymarker
2218 //
2219 TObjArray arrayRef;
2220 arrayRef.AddLast(new AliExternalTrackParam(*this));
2221 if (fIp) arrayRef.AddLast(new AliExternalTrackParam(*fIp));
2222 if (fOp) arrayRef.AddLast(new AliExternalTrackParam(*fOp));
c38d443f 2223 if (fHMPIDp) arrayRef.AddLast(new AliExternalTrackParam(*fHMPIDp));
0c19adf7 2224 //
2225 Double_t mpos[3]={0,0,0};
2226 Int_t entries=arrayRef.GetEntries();
2227 for (Int_t i=0;i<entries;i++){
2228 Double_t pos[3];
2229 ((AliExternalTrackParam*)arrayRef.At(i))->GetXYZ(pos);
2230 mpos[0]+=pos[0]/entries;
2231 mpos[1]+=pos[1]/entries;
2232 mpos[2]+=pos[2]/entries;
2233 }
2234 // Rotate to the mean position
2235 //
2236 Float_t fi= TMath::ATan2(mpos[1],mpos[0]);
2237 for (Int_t i=0;i<entries;i++){
2238 Bool_t res = ((AliExternalTrackParam*)arrayRef.At(i))->Rotate(fi);
2239 if (!res) delete arrayRef.RemoveAt(i);
2240 }
2241 Int_t counter=0;
2242 for (Double_t r=minR; r<maxR; r+=stepR){
2243 Double_t sweight=0;
2244 Double_t mlpos[3]={0,0,0};
2245 for (Int_t i=0;i<entries;i++){
2246 Double_t point[3]={0,0,0};
2247 AliExternalTrackParam *param = ((AliExternalTrackParam*)arrayRef.At(i));
2248 if (!param) continue;
2249 if (param->GetXYZAt(r,magF,point)){
2250 Double_t weight = 1./(10.+(r-param->GetX())*(r-param->GetX()));
2251 sweight+=weight;
2252 mlpos[0]+=point[0]*weight;
2253 mlpos[1]+=point[1]*weight;
2254 mlpos[2]+=point[2]*weight;
2255 }
2256 }
2257 if (sweight>0){
2258 mlpos[0]/=sweight;
2259 mlpos[1]/=sweight;
2260 mlpos[2]/=sweight;
2261 pol->SetPoint(counter,mlpos[0],mlpos[1], mlpos[2]);
2262 printf("xyz\t%f\t%f\t%f\n",mlpos[0], mlpos[1],mlpos[2]);
2263 counter++;
2264 }
2265 }
2266}
1d4882da 2267
2268//_______________________________________________________________________
2269void AliESDtrack::SetITSdEdxSamples(const Double_t s[4]) {
2270 //
2271 // Store the dE/dx samples measured by the two SSD and two SDD layers.
2272 // These samples are corrected for the track segment length.
2273 //
2274 for (Int_t i=0; i<4; i++) fITSdEdxSamples[i]=s[i];
2275}
2276
2277//_______________________________________________________________________
2278void AliESDtrack::GetITSdEdxSamples(Double_t *s) const {
2279 //
2280 // Get the dE/dx samples measured by the two SSD and two SDD layers.
2281 // These samples are corrected for the track segment length.
2282 //
2283 for (Int_t i=0; i<4; i++) s[i]=fITSdEdxSamples[i];
2284}
949840f6 2285
2286
2287UShort_t AliESDtrack::GetTPCnclsS(Int_t i0,Int_t i1) const{
2288 //
2289 // get number of shared clusters
2290 //
2291 return fTPCSharedMap.CountBits(i0)-fTPCSharedMap.CountBits(i1);
2292}