]> 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
removerd double filling of histogram
[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
6b5b49c9 1153//______________________________________________________________________________
1154Double_t AliESDtrack::M() const
1155{
2850a7f3 1156 // Returns the assumed mass
1157 // (the pion mass, if the particle can't be identified properly).
6b5b49c9 1158
1159 AliWarning("This is the ESD mass. Use it with care !");
1160 return GetMass();
1161}
1162
aad8d435 1163//______________________________________________________________________________
1164Double_t AliESDtrack::E() const
1165{
1166 // Returns the energy of the particle given its assumed mass.
1167 // Assumes the pion mass if the particle can't be identified properly.
1168
1169 Double_t m = M();
1170 Double_t p = P();
1171 return TMath::Sqrt(p*p + m*m);
1172}
1173
1174//______________________________________________________________________________
1175Double_t AliESDtrack::Y() const
1176{
1177 // Returns the rapidity of a particle given its assumed mass.
1178 // Assumes the pion mass if the particle can't be identified properly.
1179
1180 Double_t e = E();
1181 Double_t pz = Pz();
e03e4544 1182 if (e != TMath::Abs(pz)) { // energy was not equal to pz
aad8d435 1183 return 0.5*TMath::Log((e+pz)/(e-pz));
1184 } else { // energy was equal to pz
1185 return -999.;
1186 }
1187}
1188
ae982df3 1189//_______________________________________________________________________
c9ec41e8 1190Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
ae982df3 1191 //
1192 // This function updates track's running parameters
1193 //
15614b8b 1194 Bool_t rc=kTRUE;
1195
9b859005 1196 SetStatus(flags);
1197 fLabel=t->GetLabel();
1198
1199 if (t->IsStartedTimeIntegral()) {
1200 SetStatus(kTIME);
1201 Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
1202 SetIntegratedLength(t->GetIntegratedLength());
1203 }
1204
6c94f330 1205 Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
ded25cc6 1206 if (flags==kITSout) fFriendTrack->SetITSOut(*t);
1207 if (flags==kTPCout) fFriendTrack->SetTPCOut(*t);
fae4c212 1208 if (flags==kTRDrefit) fFriendTrack->SetTRDIn(*t);
e1d4c1b5 1209
ae982df3 1210 switch (flags) {
ad2f1f2b 1211
9b859005 1212 case kITSin: case kITSout: case kITSrefit:
6d3a7bbf 1213 {
48704648 1214 fITSClusterMap=0;
ae982df3 1215 fITSncls=t->GetNumberOfClusters();
6d3a7bbf 1216 Int_t* indexITS = new Int_t[AliESDfriendTrack::kMaxITScluster];
62665e7f 1217 for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
6d3a7bbf 1218 indexITS[i]=t->GetClusterIndex(i);
1219
62665e7f 1220 if (i<fITSncls) {
6d3a7bbf 1221 Int_t l=(indexITS[i] & 0xf0000000) >> 28;
62665e7f 1222 SETBIT(fITSClusterMap,l);
1223 }
1224 }
6d3a7bbf 1225 fFriendTrack->SetITSIndices(indexITS,AliESDfriendTrack::kMaxITScluster);
1226 delete [] indexITS;
1227
ae982df3 1228 fITSchi2=t->GetChi2();
ae982df3 1229 fITSsignal=t->GetPIDsignal();
6e5b1b04 1230 fITSLabel = t->GetLabel();
57483eb1 1231 // keep in fOp the parameters outside ITS for ITS stand-alone tracks
1232 if (flags==kITSout) {
1233 if (!fOp) fOp=new AliExternalTrackParam(*t);
1234 else
1235 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
ded25cc6 1236 }
6d3a7bbf 1237 }
ae982df3 1238 break;
ad2f1f2b 1239
9b859005 1240 case kTPCin: case kTPCrefit:
6d3a7bbf 1241 {
6e5b1b04 1242 fTPCLabel = t->GetLabel();
949840f6 1243 if (flags==kTPCin) {
1244 fTPCInner=new AliExternalTrackParam(*t);
1245 fTPCnclsIter1=t->GetNumberOfClusters();
1246 fTPCchi2Iter1=t->GetChi2();
1247 }
c9ec41e8 1248 if (!fIp) fIp=new AliExternalTrackParam(*t);
6c94f330 1249 else
1250 fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
6d3a7bbf 1251 }
9b859005 1252 case kTPCout:
6d3a7bbf 1253 {
1254 Int_t* indexTPC = new Int_t[AliESDfriendTrack::kMaxTPCcluster];
1d303a24 1255 if (flags & kTPCout){
1256 if (!fOp) fOp=new AliExternalTrackParam(*t);
6c94f330 1257 else
1258 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1d303a24 1259 }
e1d4c1b5 1260 fTPCncls=t->GetNumberOfClusters();
ae982df3 1261 fTPCchi2=t->GetChi2();
a866ac60 1262
1263 {//prevrow must be declared in separate namespace, otherwise compiler cries:
1264 //"jump to case label crosses initialization of `Int_t prevrow'"
1265 Int_t prevrow = -1;
6e5b1b04 1266 // for (Int_t i=0;i<fTPCncls;i++)
15e85efa 1267 for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)
a866ac60 1268 {
6d3a7bbf 1269 indexTPC[i]=t->GetClusterIndex(i);
1270 Int_t idx = indexTPC[i];
a866ac60 1271
15e85efa 1272 if (idx<0) continue;
9fe5b2ff 1273
a866ac60 1274 // Piotr's Cluster Map for HBT
1275 // ### please change accordingly if cluster array is changing
1276 // to "New TPC Tracking" style (with gaps in array)
a866ac60 1277 Int_t sect = (idx&0xff000000)>>24;
1278 Int_t row = (idx&0x00ff0000)>>16;
1279 if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
1280
1281 fTPCClusterMap.SetBitNumber(row,kTRUE);
1282
1283 //Fill the gap between previous row and this row with 0 bits
1284 //In case ### pleas change it as well - just set bit 0 in case there
1285 //is no associated clusters for current "i"
1286 if (prevrow < 0)
1287 {
1288 prevrow = row;//if previous bit was not assigned yet == this is the first one
1289 }
1290 else
1291 { //we don't know the order (inner to outer or reverse)
1292 //just to be save in case it is going to change
1293 Int_t n = 0, m = 0;
1294 if (prevrow < row)
1295 {
1296 n = prevrow;
1297 m = row;
1298 }
1299 else
1300 {
1301 n = row;
1302 m = prevrow;
1303 }
1304
1305 for (Int_t j = n+1; j < m; j++)
1306 {
1307 fTPCClusterMap.SetBitNumber(j,kFALSE);
1308 }
1309 prevrow = row;
1310 }
1311 // End Of Piotr's Cluster Map for HBT
1312 }
6d3a7bbf 1313 fFriendTrack->SetTPCIndices(indexTPC,AliESDfriendTrack::kMaxTPCcluster);
1314 delete [] indexTPC;
1315
a866ac60 1316 }
ae982df3 1317 fTPCsignal=t->GetPIDsignal();
6d3a7bbf 1318 }
ae982df3 1319 break;
9b859005 1320
64130601 1321 case kTRDin: case kTRDrefit:
1322 break;
1323 case kTRDout:
6d3a7bbf 1324 {
51ad6848 1325 fTRDLabel = t->GetLabel();
2f83b7a6 1326 fTRDchi2 = t->GetChi2();
1327 fTRDncls = t->GetNumberOfClusters();
6d3a7bbf 1328 Int_t* indexTRD = new Int_t[AliESDfriendTrack::kMaxTRDcluster];
1329 for (Int_t i=0;i<AliESDfriendTrack::kMaxTRDcluster;i++) indexTRD[i]=-2;
1330 for (Int_t i=0;i<6;i++) indexTRD[i]=t->GetTrackletIndex(i);
1331 fFriendTrack->SetTRDIndices(indexTRD,AliESDfriendTrack::kMaxTRDcluster);
1332 delete [] indexTRD;
1333
5bc3e158 1334
79e94bf8 1335 fTRDsignal=t->GetPIDsignal();
6d3a7bbf 1336 }
79e94bf8 1337 break;
c4d11b15 1338 case kTRDbackup:
c9ec41e8 1339 if (!fOp) fOp=new AliExternalTrackParam(*t);
6c94f330 1340 else
1341 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
c4d11b15 1342 fTRDncls0 = t->GetNumberOfClusters();
1343 break;
1344 case kTOFin:
1345 break;
1346 case kTOFout:
1347 break;
d0862fea 1348 case kTRDStop:
1349 break;
c38d443f 1350 case kHMPIDout:
1351 if (!fHMPIDp) fHMPIDp=new AliExternalTrackParam(*t);
1352 else
1353 fHMPIDp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1354 break;
ae982df3 1355 default:
5f7789fc 1356 AliError("Wrong flag !");
ae982df3 1357 return kFALSE;
1358 }
1359
15614b8b 1360 return rc;
ae982df3 1361}
1362
1363//_______________________________________________________________________
1364void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
1365 //---------------------------------------------------------------------
1366 // This function returns external representation of the track parameters
1367 //---------------------------------------------------------------------
c9ec41e8 1368 x=GetX();
1369 for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
15614b8b 1370}
1371
67c3dcbe 1372//_______________________________________________________________________
a866ac60 1373void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
67c3dcbe 1374 //---------------------------------------------------------------------
1375 // This function returns external representation of the cov. matrix
1376 //---------------------------------------------------------------------
c9ec41e8 1377 for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
67c3dcbe 1378}
1379
67c3dcbe 1380//_______________________________________________________________________
c0b978f0 1381Bool_t AliESDtrack::GetConstrainedExternalParameters
1382 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
67c3dcbe 1383 //---------------------------------------------------------------------
1384 // This function returns the constrained external track parameters
1385 //---------------------------------------------------------------------
c0b978f0 1386 if (!fCp) return kFALSE;
1387 alpha=fCp->GetAlpha();
c9ec41e8 1388 x=fCp->GetX();
1389 for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
c0b978f0 1390 return kTRUE;
67c3dcbe 1391}
c9ec41e8 1392
67c3dcbe 1393//_______________________________________________________________________
c0b978f0 1394Bool_t
67c3dcbe 1395AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
1396 //---------------------------------------------------------------------
1397 // This function returns the constrained external cov. matrix
1398 //---------------------------------------------------------------------
c0b978f0 1399 if (!fCp) return kFALSE;
c9ec41e8 1400 for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
c0b978f0 1401 return kTRUE;
67c3dcbe 1402}
1403
c0b978f0 1404Bool_t
1405AliESDtrack::GetInnerExternalParameters
1406 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1407 //---------------------------------------------------------------------
c9ec41e8 1408 // This function returns external representation of the track parameters
1409 // at the inner layer of TPC
9b859005 1410 //---------------------------------------------------------------------
c0b978f0 1411 if (!fIp) return kFALSE;
1412 alpha=fIp->GetAlpha();
c9ec41e8 1413 x=fIp->GetX();
1414 for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
c0b978f0 1415 return kTRUE;
9b859005 1416}
1417
c0b978f0 1418Bool_t
1419AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const {
c9ec41e8 1420 //---------------------------------------------------------------------
1421 // This function returns external representation of the cov. matrix
1422 // at the inner layer of TPC
1423 //---------------------------------------------------------------------
c0b978f0 1424 if (!fIp) return kFALSE;
c9ec41e8 1425 for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
c0b978f0 1426 return kTRUE;
9b859005 1427}
1428
d61ca12d 1429void
1430AliESDtrack::SetOuterParam(const AliExternalTrackParam *p, ULong_t flags) {
1431 //
1432 // This is a direct setter for the outer track parameters
1433 //
1434 SetStatus(flags);
1435 if (fOp) delete fOp;
1436 fOp=new AliExternalTrackParam(*p);
1437}
1438
c38d443f 1439void
1440AliESDtrack::SetOuterHmpParam(const AliExternalTrackParam *p, ULong_t flags) {
1441 //
1442 // This is a direct setter for the outer track parameters
1443 //
1444 SetStatus(flags);
1445 if (fHMPIDp) delete fHMPIDp;
1446 fHMPIDp=new AliExternalTrackParam(*p);
1447}
1448
c0b978f0 1449Bool_t
1450AliESDtrack::GetOuterExternalParameters
1451 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1452 //---------------------------------------------------------------------
c9ec41e8 1453 // This function returns external representation of the track parameters
1454 // at the inner layer of TRD
a866ac60 1455 //---------------------------------------------------------------------
c0b978f0 1456 if (!fOp) return kFALSE;
1457 alpha=fOp->GetAlpha();
c9ec41e8 1458 x=fOp->GetX();
1459 for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
c0b978f0 1460 return kTRUE;
a866ac60 1461}
c9ec41e8 1462
c38d443f 1463Bool_t
1464AliESDtrack::GetOuterHmpExternalParameters
1465 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1466 //---------------------------------------------------------------------
1467 // This function returns external representation of the track parameters
1468 // at the inner layer of TRD
1469 //---------------------------------------------------------------------
1470 if (!fHMPIDp) return kFALSE;
1471 alpha=fHMPIDp->GetAlpha();
1472 x=fHMPIDp->GetX();
1473 for (Int_t i=0; i<5; i++) p[i]=fHMPIDp->GetParameter()[i];
1474 return kTRUE;
1475}
1476
c0b978f0 1477Bool_t
1478AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
a866ac60 1479 //---------------------------------------------------------------------
c9ec41e8 1480 // This function returns external representation of the cov. matrix
1481 // at the inner layer of TRD
a866ac60 1482 //---------------------------------------------------------------------
c0b978f0 1483 if (!fOp) return kFALSE;
c9ec41e8 1484 for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
c0b978f0 1485 return kTRUE;
a866ac60 1486}
1487
c38d443f 1488Bool_t
1489AliESDtrack::GetOuterHmpExternalCovariance(Double_t cov[15]) const {
1490 //---------------------------------------------------------------------
1491 // This function returns external representation of the cov. matrix
1492 // at the inner layer of TRD
1493 //---------------------------------------------------------------------
1494 if (!fHMPIDp) return kFALSE;
1495 for (Int_t i=0; i<15; i++) cov[i]=fHMPIDp->GetCovariance()[i];
1496 return kTRUE;
1497}
1498
98937d93 1499Int_t AliESDtrack::GetNcls(Int_t idet) const
1500{
1501 // Get number of clusters by subdetector index
1502 //
1503 Int_t ncls = 0;
1504 switch(idet){
1505 case 0:
1506 ncls = fITSncls;
1507 break;
1508 case 1:
1509 ncls = fTPCncls;
1510 break;
1511 case 2:
1512 ncls = fTRDncls;
1513 break;
1514 case 3:
ce3f4882 1515 if (fTOFindex != -1)
98937d93 1516 ncls = 1;
1517 break;
81aa7a0d 1518 case 4: //PHOS
1519 break;
1520 case 5: //HMPID
1521 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1522 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1523 ncls = 1;
1524 }
1525 }
1526 break;
98937d93 1527 default:
1528 break;
1529 }
1530 return ncls;
1531}
1532
ef7253ac 1533Int_t AliESDtrack::GetClusters(Int_t idet, Int_t *idx) const
98937d93 1534{
1535 // Get cluster index array by subdetector index
1536 //
1537 Int_t ncls = 0;
1538 switch(idet){
1539 case 0:
1540 ncls = GetITSclusters(idx);
1541 break;
1542 case 1:
ef7253ac 1543 ncls = GetTPCclusters(idx);
98937d93 1544 break;
1545 case 2:
1546 ncls = GetTRDclusters(idx);
1547 break;
1548 case 3:
ce3f4882 1549 if (fTOFindex != -1) {
1550 idx[0] = fTOFindex;
98937d93 1551 ncls = 1;
1552 }
1553 break;
313af949 1554 case 4: //PHOS
1555 break;
1556 case 5:
81aa7a0d 1557 if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1558 if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1559 idx[0] = GetHMPIDcluIdx();
1560 ncls = 1;
1561 }
313af949 1562 }
1563 break;
1564 case 6: //EMCAL
1565 break;
98937d93 1566 default:
1567 break;
1568 }
1569 return ncls;
1570}
1571
ae982df3 1572//_______________________________________________________________________
1573void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
4427806c 1574 // Returns the array with integrated times for each particle hypothesis
304864ab 1575 for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
ae982df3 1576}
1577
1578//_______________________________________________________________________
1579void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
4427806c 1580 // Sets the array with integrated times for each particle hypotesis
304864ab 1581 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
ae982df3 1582}
1583
c630aafd 1584//_______________________________________________________________________
4427806c 1585void AliESDtrack::SetITSpid(const Double_t *p) {
1586 // Sets values for the probability of each particle type (in ITS)
d27bbc79 1587 SetPIDValues(fITSr,p,AliPID::kSPECIES);
c630aafd 1588 SetStatus(AliESDtrack::kITSpid);
1589}
1590
1591//_______________________________________________________________________
1592void AliESDtrack::GetITSpid(Double_t *p) const {
4427806c 1593 // Gets the probability of each particle type (in ITS)
304864ab 1594 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
c630aafd 1595}
1596
ae982df3 1597//_______________________________________________________________________
562dd0b4 1598Char_t AliESDtrack::GetITSclusters(Int_t *idx) const {
ae982df3 1599 //---------------------------------------------------------------------
1600 // This function returns indices of the assgined ITS clusters
1601 //---------------------------------------------------------------------
6d3a7bbf 1602 if (idx) {
1603 Int_t *index=fFriendTrack->GetITSindices();
1604 for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) {
1605 if ( (i>=fITSncls) && (i<6) ) idx[i]=-1;
1606 else {
1607 if (index) {
1608 idx[i]=index[i];
1609 }
1610 else idx[i]= -2;
1611 }
1612 }
15e85efa 1613 }
ae982df3 1614 return fITSncls;
1615}
1616
89f1b176 1617//_______________________________________________________________________
1618Bool_t AliESDtrack::GetITSModuleIndexInfo(Int_t ilayer,Int_t &idet,Int_t &status,
1619 Float_t &xloc,Float_t &zloc) const {
1620 //----------------------------------------------------------------------
1621 // This function encodes in the module number also the status of cluster association
1622 // "status" can have the following values:
1623 // 1 "found" (cluster is associated),
1624 // 2 "dead" (module is dead from OCDB),
1625 // 3 "skipped" (module or layer forced to be skipped),
1626 // 4 "outinz" (track out of z acceptance),
1627 // 5 "nocls" (no clusters in the road),
1628 // 6 "norefit" (cluster rejected during refit),
1629 // 7 "deadzspd" (holes in z in SPD)
1630 // Also given are the coordinates of the crossing point of track and module
1631 // (in the local module ref. system)
1632 // WARNING: THIS METHOD HAS TO BE SYNCHRONIZED WITH AliITStrackV2::GetModuleIndexInfo()!
1633 //----------------------------------------------------------------------
1634
1635 if(fITSModule[ilayer]==-1) {
89f1b176 1636 idet = -1;
1637 status=0;
1638 xloc=-99.; zloc=-99.;
1639 return kFALSE;
1640 }
1641
1642 Int_t module = fITSModule[ilayer];
1643
1644 idet = Int_t(module/1000000);
1645
1646 module -= idet*1000000;
1647
1648 status = Int_t(module/100000);
1649
1650 module -= status*100000;
1651
1652 Int_t signs = Int_t(module/10000);
1653
1654 module-=signs*10000;
1655
1656 Int_t xInt = Int_t(module/100);
1657 module -= xInt*100;
1658
1659 Int_t zInt = module;
1660
1661 if(signs==1) { xInt*=1; zInt*=1; }
1662 if(signs==2) { xInt*=1; zInt*=-1; }
1663 if(signs==3) { xInt*=-1; zInt*=1; }
1664 if(signs==4) { xInt*=-1; zInt*=-1; }
1665
1666 xloc = 0.1*(Float_t)xInt;
1667 zloc = 0.1*(Float_t)zInt;
1668
1669 if(status==4) idet = -1;
1670
1671 return kTRUE;
1672}
1673
ae982df3 1674//_______________________________________________________________________
562dd0b4 1675UShort_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
ae982df3 1676 //---------------------------------------------------------------------
1677 // This function returns indices of the assgined ITS clusters
1678 //---------------------------------------------------------------------
6d3a7bbf 1679 if (idx) {
15e85efa 1680 Int_t *index=fFriendTrack->GetTPCindices();
6d3a7bbf 1681
1682 if (index){
1683 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
1684 }
1685 else {
1686 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=-2;
1687 }
15e85efa 1688 }
ae982df3 1689 return fTPCncls;
1690}
8c6a71ab 1691
562dd0b4 1692Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
81e97e0d 1693 //
1694 // GetDensity of the clusters on given region between row0 and row1
1695 // Dead zone effect takin into acoount
1696 //
1697 Int_t good = 0;
1698 Int_t found = 0;
1699 //
15e85efa 1700 Int_t *index=fFriendTrack->GetTPCindices();
81e97e0d 1701 for (Int_t i=row0;i<=row1;i++){
15e85efa 1702 Int_t idx = index[i];
1703 if (idx!=-1) good++; // track outside of dead zone
1704 if (idx>0) found++;
81e97e0d 1705 }
1706 Float_t density=0.5;
1707 if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
1708 return density;
1709}
c84a5e9e 1710
8c6a71ab 1711//_______________________________________________________________________
1712void AliESDtrack::SetTPCpid(const Double_t *p) {
4427806c 1713 // Sets values for the probability of each particle type (in TPC)
d27bbc79 1714 SetPIDValues(fTPCr,p,AliPID::kSPECIES);
8c6a71ab 1715 SetStatus(AliESDtrack::kTPCpid);
1716}
1717
1718//_______________________________________________________________________
1719void AliESDtrack::GetTPCpid(Double_t *p) const {
4427806c 1720 // Gets the probability of each particle type (in TPC)
304864ab 1721 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
8c6a71ab 1722}
1723
bb2ceb1f 1724//_______________________________________________________________________
562dd0b4 1725UChar_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
bb2ceb1f 1726 //---------------------------------------------------------------------
1727 // This function returns indices of the assgined TRD clusters
1728 //---------------------------------------------------------------------
6d3a7bbf 1729 if (idx) {
1730 Int_t *index=fFriendTrack->GetTRDindices();
1731
1732 if (index) {
1733 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
1734 }
1735 else {
1736 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=-2;
1737 }
15e85efa 1738 }
bb2ceb1f 1739 return fTRDncls;
1740}
1741
5bc3e158 1742//_______________________________________________________________________
1743UChar_t AliESDtrack::GetTRDtracklets(Int_t *idx) const {
0ad488b0 1744//
1745// This function returns the number of TRD tracklets used in tracking
1746// and it fills the indices of these tracklets in the array "idx" as they
1747// are registered in the TRD track list.
1748//
1749// Caution :
1750// 1. The idx array has to be allocated with a size >= AliESDtrack::kTRDnPlanes
1751// 2. The idx array store not only the index but also the layer of the tracklet.
1752// Therefore tracks with TRD gaps contain default values for indices [-1]
1753
1754 if (!idx) return GetTRDntracklets();
6d3a7bbf 1755 Int_t *index=fFriendTrack->GetTRDindices();
1756 Int_t n = 0;
0ad488b0 1757 for (Int_t i=0; i<kTRDnPlanes; i++){
6d3a7bbf 1758 if (index){
1759 if(index[i]>=0) n++;
1760 idx[i]=index[i];
1761 }
1762 else idx[i] = -2;
5bc3e158 1763 }
0ad488b0 1764 return n;
5bc3e158 1765}
1766
c630aafd 1767//_______________________________________________________________________
1768void AliESDtrack::SetTRDpid(const Double_t *p) {
4427806c 1769 // Sets values for the probability of each particle type (in TRD)
d27bbc79 1770 SetPIDValues(fTRDr,p,AliPID::kSPECIES);
c630aafd 1771 SetStatus(AliESDtrack::kTRDpid);
1772}
1773
1774//_______________________________________________________________________
1775void AliESDtrack::GetTRDpid(Double_t *p) const {
4427806c 1776 // Gets the probability of each particle type (in TRD)
304864ab 1777 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
c630aafd 1778}
1779
79e94bf8 1780//_______________________________________________________________________
1781void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
1782{
4427806c 1783 // Sets the probability of particle type iSpecies to p (in TRD)
79e94bf8 1784 fTRDr[iSpecies] = p;
1785}
1786
562dd0b4 1787Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
79e94bf8 1788{
4427806c 1789 // Returns the probability of particle type iSpecies (in TRD)
79e94bf8 1790 return fTRDr[iSpecies];
1791}
1792
fae4c212 1793//____________________________________________________
1794Int_t AliESDtrack::GetNumberOfTRDslices() const
1795{
1796 // built in backward compatibility
1797 Int_t idx = fTRDnSlices - (kTRDnPlanes<<1);
1798 return idx<18 ? fTRDnSlices/kTRDnPlanes : idx/kTRDnPlanes;
1799}
1800
1801//____________________________________________________
1802Double_t AliESDtrack::GetTRDmomentum(Int_t plane, Double_t *sp) const
1803{
1804//Returns momentum estimation and optional its error (sp)
1805// in TRD layer "plane".
1806
1807 if (!fTRDnSlices) {
95621324 1808 AliError("No TRD info allocated for this track !");
fae4c212 1809 return -1.;
1810 }
1811 if ((plane<0) || (plane>=kTRDnPlanes)) {
1812 AliError("Info for TRD plane not available!");
1813 return -1.;
1814 }
1815
1816 Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
1817 // Protection for backward compatibility
1818 if(idx<(GetNumberOfTRDslices()*kTRDnPlanes)) return -1.;
1819
1820 if(sp) (*sp) = fTRDslices[idx+kTRDnPlanes];
1821 return fTRDslices[idx];
1822}
1823
1824//____________________________________________________
1825Double_t AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
1826 //Gets the charge from the slice of the plane
1827
1828 if(!fTRDslices) {
1829 //AliError("No TRD slices allocated for this track !");
1830 return -1.;
1831 }
1832 if ((plane<0) || (plane>=kTRDnPlanes)) {
1833 AliError("Info for TRD plane not available !");
1834 return -1.;
1835 }
1836 Int_t ns=GetNumberOfTRDslices();
1837 if ((slice<-1) || (slice>=ns)) {
1838 //AliError("Wrong TRD slice !");
1839 return -1.;
1840 }
1841
1842 if(slice>=0) return fTRDslices[plane*ns + slice];
1843
1844 // return average of the dEdx measurements
1845 Double_t q=0.; Double32_t *s = &fTRDslices[plane*ns];
1846 for (Int_t i=0; i<ns; i++, s++) if((*s)>0.) q+=(*s);
1847 return q/ns;
1848}
1849
1850//____________________________________________________
6984f7c1 1851void AliESDtrack::SetNumberOfTRDslices(Int_t n) {
1852 //Sets the number of slices used for PID
fae4c212 1853 if (fTRDnSlices) return;
1854
1855 fTRDnSlices=n;
6984f7c1 1856 fTRDslices=new Double32_t[fTRDnSlices];
fae4c212 1857
1858 // set-up correctly the allocated memory
1859 memset(fTRDslices, 0, n*sizeof(Double32_t));
1860 for (Int_t i=GetNumberOfTRDslices(); i--;) fTRDslices[i]=-1.;
6984f7c1 1861}
1862
fae4c212 1863//____________________________________________________
6984f7c1 1864void AliESDtrack::SetTRDslice(Double_t q, Int_t plane, Int_t slice) {
1865 //Sets the charge q in the slice of the plane
fae4c212 1866 if(!fTRDslices) {
6984f7c1 1867 AliError("No TRD slices allocated for this track !");
1868 return;
1869 }
6984f7c1 1870 if ((plane<0) || (plane>=kTRDnPlanes)) {
fae4c212 1871 AliError("Info for TRD plane not allocated !");
6984f7c1 1872 return;
1873 }
fae4c212 1874 Int_t ns=GetNumberOfTRDslices();
6984f7c1 1875 if ((slice<0) || (slice>=ns)) {
1876 AliError("Wrong TRD slice !");
1877 return;
1878 }
1879 Int_t n=plane*ns + slice;
1880 fTRDslices[n]=q;
1881}
1882
6984f7c1 1883
fae4c212 1884//____________________________________________________
1885void AliESDtrack::SetTRDmomentum(Double_t p, Int_t plane, Double_t *sp)
1886{
1887 if(!fTRDslices) {
1888 AliError("No TRD slices allocated for this track !");
1889 return;
6984f7c1 1890 }
fae4c212 1891 if ((plane<0) || (plane>=kTRDnPlanes)) {
1892 AliError("Info for TRD plane not allocated !");
1893 return;
6984f7c1 1894 }
1895
fae4c212 1896 Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
1897 // Protection for backward compatibility
1898 if(idx<GetNumberOfTRDslices()*kTRDnPlanes) return;
6984f7c1 1899
fae4c212 1900 if(sp) fTRDslices[idx+kTRDnPlanes] = (*sp);
1901 fTRDslices[idx] = p;
6984f7c1 1902}
1903
1904
c630aafd 1905//_______________________________________________________________________
1906void AliESDtrack::SetTOFpid(const Double_t *p) {
4427806c 1907 // Sets the probability of each particle type (in TOF)
d27bbc79 1908 SetPIDValues(fTOFr,p,AliPID::kSPECIES);
c630aafd 1909 SetStatus(AliESDtrack::kTOFpid);
1910}
1911
51ad6848 1912//_______________________________________________________________________
1913void AliESDtrack::SetTOFLabel(const Int_t *p) {
1914 // Sets (in TOF)
1915 for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
1916}
1917
c630aafd 1918//_______________________________________________________________________
1919void AliESDtrack::GetTOFpid(Double_t *p) const {
4427806c 1920 // Gets probabilities of each particle type (in TOF)
304864ab 1921 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
c630aafd 1922}
1923
51ad6848 1924//_______________________________________________________________________
1925void AliESDtrack::GetTOFLabel(Int_t *p) const {
1926 // Gets (in TOF)
1927 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
1928}
1929
1930//_______________________________________________________________________
1931void AliESDtrack::GetTOFInfo(Float_t *info) const {
1932 // Gets (in TOF)
1933 for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
1934}
1935
1936//_______________________________________________________________________
1937void AliESDtrack::SetTOFInfo(Float_t*info) {
1938 // Gets (in TOF)
1939 for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
1940}
1941
4a78b8c5 1942
1943
4a78b8c5 1944//_______________________________________________________________________
f4b3bbb7 1945void AliESDtrack::SetHMPIDpid(const Double_t *p) {
1946 // Sets the probability of each particle type (in HMPID)
1947 SetPIDValues(fHMPIDr,p,AliPID::kSPECIES);
1948 SetStatus(AliESDtrack::kHMPIDpid);
4a78b8c5 1949}
1950
1951//_______________________________________________________________________
f4b3bbb7 1952void AliESDtrack::GetHMPIDpid(Double_t *p) const {
1953 // Gets probabilities of each particle type (in HMPID)
1954 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fHMPIDr[i];
4a78b8c5 1955}
1956
1957
1958
8c6a71ab 1959//_______________________________________________________________________
1960void AliESDtrack::SetESDpid(const Double_t *p) {
4427806c 1961 // Sets the probability of each particle type for the ESD track
d27bbc79 1962 SetPIDValues(fR,p,AliPID::kSPECIES);
8c6a71ab 1963 SetStatus(AliESDtrack::kESDpid);
1964}
1965
1966//_______________________________________________________________________
1967void AliESDtrack::GetESDpid(Double_t *p) const {
4427806c 1968 // Gets probability of each particle type for the ESD track
304864ab 1969 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
8c6a71ab 1970}
1971
d7ddf1e9 1972//_______________________________________________________________________
436dfe39 1973Bool_t AliESDtrack::RelateToVertexTPC(const AliESDVertex *vtx,
1974Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
d7ddf1e9 1975 //
436dfe39 1976 // Try to relate the TPC-only track parameters to the vertex "vtx",
d7ddf1e9 1977 // if the (rough) transverse impact parameter is not bigger then "maxd".
1978 // Magnetic field is "b" (kG).
1979 //
1980 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
1981 // b) The impact parameters and their covariance matrix are calculated.
436dfe39 1982 // c) An attempt to constrain the TPC-only params to the vertex is done.
1983 // The constrained params are returned via "cParam".
d7ddf1e9 1984 //
436dfe39 1985 // In the case of success, the returned value is kTRUE
1986 // otherwise, it's kFALSE)
1987 //
d7ddf1e9 1988
1989 if (!fTPCInner) return kFALSE;
1990 if (!vtx) return kFALSE;
1991
1992 Double_t dz[2],cov[3];
1993 if (!fTPCInner->PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
1994
1995 fdTPC = dz[0];
1996 fzTPC = dz[1];
1997 fCddTPC = cov[0];
1998 fCdzTPC = cov[1];
1999 fCzzTPC = cov[2];
2000
436dfe39 2001 Double_t covar[6]; vtx->GetCovMatrix(covar);
2002 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2003 Double_t c[3]={covar[2],0.,covar[5]};
2004
2005 Double_t chi2=GetPredictedChi2(p,c);
2006 if (chi2>kVeryBig) return kFALSE;
2007
2008 fCchi2TPC=chi2;
2009
2010 if (!cParam) return kTRUE;
2011
2012 *cParam = *fTPCInner;
2013 if (!cParam->Update(p,c)) return kFALSE;
2014
d7ddf1e9 2015 return kTRUE;
2016}
2017
266a0f9b 2018//_______________________________________________________________________
2019Bool_t AliESDtrack::RelateToVertexTPCBxByBz(const AliESDVertex *vtx,
2020Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2021 //
2022 // Try to relate the TPC-only track parameters to the vertex "vtx",
2023 // if the (rough) transverse impact parameter is not bigger then "maxd".
2024 //
2025 // All three components of the magnetic field ,"b[3]" (kG),
2026 // are taken into account.
2027 //
2028 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
2029 // b) The impact parameters and their covariance matrix are calculated.
2030 // c) An attempt to constrain the TPC-only params to the vertex is done.
2031 // The constrained params are returned via "cParam".
2032 //
2033 // In the case of success, the returned value is kTRUE
2034 // otherwise, it's kFALSE)
2035 //
2036
2037 if (!fTPCInner) return kFALSE;
2038 if (!vtx) return kFALSE;
2039
2040 Double_t dz[2],cov[3];
2041 if (!fTPCInner->PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2042
2043 fdTPC = dz[0];
2044 fzTPC = dz[1];
2045 fCddTPC = cov[0];
2046 fCdzTPC = cov[1];
2047 fCzzTPC = cov[2];
2048
2049 Double_t covar[6]; vtx->GetCovMatrix(covar);
2050 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2051 Double_t c[3]={covar[2],0.,covar[5]};
2052
2053 Double_t chi2=GetPredictedChi2(p,c);
2054 if (chi2>kVeryBig) return kFALSE;
2055
2056 fCchi2TPC=chi2;
2057
2058 if (!cParam) return kTRUE;
2059
2060 *cParam = *fTPCInner;
2061 if (!cParam->Update(p,c)) return kFALSE;
2062
2063 return kTRUE;
2064}
2065
49d13e89 2066//_______________________________________________________________________
436dfe39 2067Bool_t AliESDtrack::RelateToVertex(const AliESDVertex *vtx,
2068Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
49d13e89 2069 //
2070 // Try to relate this track to the vertex "vtx",
2071 // if the (rough) transverse impact parameter is not bigger then "maxd".
2072 // Magnetic field is "b" (kG).
2073 //
2074 // a) The track gets extapolated to the DCA to the vertex.
2075 // b) The impact parameters and their covariance matrix are calculated.
2076 // c) An attempt to constrain this track to the vertex is done.
436dfe39 2077 // The constrained params are returned via "cParam".
49d13e89 2078 //
436dfe39 2079 // In the case of success, the returned value is kTRUE
2080 // (otherwise, it's kFALSE)
49d13e89 2081 //
b5d34a4c 2082
2083 if (!vtx) return kFALSE;
2084
e99a34df 2085 Double_t dz[2],cov[3];
2086 if (!PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
2087
2088 fD = dz[0];
2089 fZ = dz[1];
2090 fCdd = cov[0];
2091 fCdz = cov[1];
2092 fCzz = cov[2];
49d13e89 2093
e99a34df 2094 Double_t covar[6]; vtx->GetCovMatrix(covar);
2095 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2096 Double_t c[3]={covar[2],0.,covar[5]};
3231f9e5 2097
e99a34df 2098 Double_t chi2=GetPredictedChi2(p,c);
436dfe39 2099 if (chi2>kVeryBig) return kFALSE;
2100
2101 fCchi2=chi2;
49d13e89 2102
436dfe39 2103
266a0f9b 2104 //--- Could now these lines be removed ? ---
2105 delete fCp;
2106 fCp=new AliExternalTrackParam(*this);
2107
2108 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
2109 //----------------------------------------
2110
2111 fVertexID = vtx->GetID();
2112
2113 if (!cParam) return kTRUE;
2114
2115 *cParam = *this;
2116 if (!cParam->Update(p,c)) return kFALSE;
2117
2118 return kTRUE;
2119}
2120
2121//_______________________________________________________________________
2122Bool_t AliESDtrack::RelateToVertexBxByBz(const AliESDVertex *vtx,
2123Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2124 //
2125 // Try to relate this track to the vertex "vtx",
2126 // if the (rough) transverse impact parameter is not bigger then "maxd".
2127 // Magnetic field is "b" (kG).
2128 //
2129 // a) The track gets extapolated to the DCA to the vertex.
2130 // b) The impact parameters and their covariance matrix are calculated.
2131 // c) An attempt to constrain this track to the vertex is done.
2132 // The constrained params are returned via "cParam".
2133 //
2134 // In the case of success, the returned value is kTRUE
2135 // (otherwise, it's kFALSE)
2136 //
2137
2138 if (!vtx) return kFALSE;
2139
2140 Double_t dz[2],cov[3];
2141 if (!PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2142
2143 fD = dz[0];
2144 fZ = dz[1];
2145 fCdd = cov[0];
2146 fCdz = cov[1];
2147 fCzz = cov[2];
2148
2149 Double_t covar[6]; vtx->GetCovMatrix(covar);
2150 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2151 Double_t c[3]={covar[2],0.,covar[5]};
2152
2153 Double_t chi2=GetPredictedChi2(p,c);
2154 if (chi2>kVeryBig) return kFALSE;
2155
2156 fCchi2=chi2;
2157
2158
436dfe39 2159 //--- Could now these lines be removed ? ---
e99a34df 2160 delete fCp;
2161 fCp=new AliExternalTrackParam(*this);
49d13e89 2162
e99a34df 2163 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
436dfe39 2164 //----------------------------------------
2165
6dc21f57 2166 fVertexID = vtx->GetID();
436dfe39 2167
2168 if (!cParam) return kTRUE;
2169
2170 *cParam = *this;
2171 if (!cParam->Update(p,c)) return kFALSE;
2172
49d13e89 2173 return kTRUE;
2174}
2175
ac2f7574 2176//_______________________________________________________________________
2177void AliESDtrack::Print(Option_t *) const {
2178 // Prints info on the track
b9ca886f 2179 AliExternalTrackParam::Print();
5f7789fc 2180 printf("ESD track info\n") ;
304864ab 2181 Double_t p[AliPID::kSPECIESN] ;
ac2f7574 2182 Int_t index = 0 ;
2183 if( IsOn(kITSpid) ){
2184 printf("From ITS: ") ;
2185 GetITSpid(p) ;
304864ab 2186 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2187 printf("%f, ", p[index]) ;
2188 printf("\n signal = %f\n", GetITSsignal()) ;
2189 }
2190 if( IsOn(kTPCpid) ){
2191 printf("From TPC: ") ;
2192 GetTPCpid(p) ;
304864ab 2193 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2194 printf("%f, ", p[index]) ;
2195 printf("\n signal = %f\n", GetTPCsignal()) ;
2196 }
2197 if( IsOn(kTRDpid) ){
2198 printf("From TRD: ") ;
2199 GetTRDpid(p) ;
304864ab 2200 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2201 printf("%f, ", p[index]) ;
6984f7c1 2202 printf("\n signal = %f\n", GetTRDsignal()) ;
ac2f7574 2203 }
2204 if( IsOn(kTOFpid) ){
2205 printf("From TOF: ") ;
2206 GetTOFpid(p) ;
304864ab 2207 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2208 printf("%f, ", p[index]) ;
2209 printf("\n signal = %f\n", GetTOFsignal()) ;
2210 }
f4b3bbb7 2211 if( IsOn(kHMPIDpid) ){
2212 printf("From HMPID: ") ;
2213 GetHMPIDpid(p) ;
304864ab 2214 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 2215 printf("%f, ", p[index]) ;
f4b3bbb7 2216 printf("\n signal = %f\n", GetHMPIDsignal()) ;
ac2f7574 2217 }
ac2f7574 2218}
6c94f330 2219
0c19adf7 2220
2221//
2222// Draw functionality
2223// Origin: Marian Ivanov, Marian.Ivanov@cern.ch
2224//
2225void AliESDtrack::FillPolymarker(TPolyMarker3D *pol, Float_t magF, Float_t minR, Float_t maxR, Float_t stepR){
2226 //
2227 // Fill points in the polymarker
2228 //
2229 TObjArray arrayRef;
2230 arrayRef.AddLast(new AliExternalTrackParam(*this));
2231 if (fIp) arrayRef.AddLast(new AliExternalTrackParam(*fIp));
2232 if (fOp) arrayRef.AddLast(new AliExternalTrackParam(*fOp));
c38d443f 2233 if (fHMPIDp) arrayRef.AddLast(new AliExternalTrackParam(*fHMPIDp));
0c19adf7 2234 //
2235 Double_t mpos[3]={0,0,0};
2236 Int_t entries=arrayRef.GetEntries();
2237 for (Int_t i=0;i<entries;i++){
2238 Double_t pos[3];
2239 ((AliExternalTrackParam*)arrayRef.At(i))->GetXYZ(pos);
2240 mpos[0]+=pos[0]/entries;
2241 mpos[1]+=pos[1]/entries;
2242 mpos[2]+=pos[2]/entries;
2243 }
2244 // Rotate to the mean position
2245 //
2246 Float_t fi= TMath::ATan2(mpos[1],mpos[0]);
2247 for (Int_t i=0;i<entries;i++){
2248 Bool_t res = ((AliExternalTrackParam*)arrayRef.At(i))->Rotate(fi);
2249 if (!res) delete arrayRef.RemoveAt(i);
2250 }
2251 Int_t counter=0;
2252 for (Double_t r=minR; r<maxR; r+=stepR){
2253 Double_t sweight=0;
2254 Double_t mlpos[3]={0,0,0};
2255 for (Int_t i=0;i<entries;i++){
2256 Double_t point[3]={0,0,0};
2257 AliExternalTrackParam *param = ((AliExternalTrackParam*)arrayRef.At(i));
2258 if (!param) continue;
2259 if (param->GetXYZAt(r,magF,point)){
2260 Double_t weight = 1./(10.+(r-param->GetX())*(r-param->GetX()));
2261 sweight+=weight;
2262 mlpos[0]+=point[0]*weight;
2263 mlpos[1]+=point[1]*weight;
2264 mlpos[2]+=point[2]*weight;
2265 }
2266 }
2267 if (sweight>0){
2268 mlpos[0]/=sweight;
2269 mlpos[1]/=sweight;
2270 mlpos[2]/=sweight;
2271 pol->SetPoint(counter,mlpos[0],mlpos[1], mlpos[2]);
2272 printf("xyz\t%f\t%f\t%f\n",mlpos[0], mlpos[1],mlpos[2]);
2273 counter++;
2274 }
2275 }
2276}
1d4882da 2277
2278//_______________________________________________________________________
2279void AliESDtrack::SetITSdEdxSamples(const Double_t s[4]) {
2280 //
2281 // Store the dE/dx samples measured by the two SSD and two SDD layers.
2282 // These samples are corrected for the track segment length.
2283 //
2284 for (Int_t i=0; i<4; i++) fITSdEdxSamples[i]=s[i];
2285}
2286
2287//_______________________________________________________________________
2288void AliESDtrack::GetITSdEdxSamples(Double_t *s) const {
2289 //
2290 // Get the dE/dx samples measured by the two SSD and two SDD layers.
2291 // These samples are corrected for the track segment length.
2292 //
2293 for (Int_t i=0; i<4; i++) s[i]=fITSdEdxSamples[i];
2294}
949840f6 2295
2296
2297UShort_t AliESDtrack::GetTPCnclsS(Int_t i0,Int_t i1) const{
2298 //
2299 // get number of shared clusters
2300 //
2301 return fTPCSharedMap.CountBits(i0)-fTPCSharedMap.CountBits(i1);
2302}