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