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