]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - STEER/AliESDtrack.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Incrementing class versions
[u/mrichter/AliRoot.git] / STEER / AliESDtrack.cxx
... / ...
CommitLineData
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 **************************************************************************/
15//-----------------------------------------------------------------
16// Implementation of the ESD track class
17// ESD = Event Summary Data
18// This is the class to deal with during the phisics analysis of data
19// Origin: Iouri Belikov, CERN
20// e-mail: Jouri.Belikov@cern.ch
21//-----------------------------------------------------------------
22
23#include "TMath.h"
24
25#include "AliESDtrack.h"
26#include "AliKalmanTrack.h"
27#include "AliLog.h"
28
29ClassImp(AliESDtrack)
30
31//_______________________________________________________________________
32AliESDtrack::AliESDtrack() :
33 TObject(),
34 fFlags(0),
35 fLabel(0),
36 fID(0),
37 fTrackLength(0),
38 fD(0),
39 fZ(0),
40 fStopVertex(0),
41 fRalpha(0),
42 fRx(0),
43 fCalpha(0),
44 fCx(0),
45 fCchi2(1e10),
46 fIalpha(0),
47 fIx(0),
48 fTalpha(0),
49 fTx(0),
50 fITSchi2(0),
51 fITSncls(0),
52 fITSsignal(0),
53 fITSLabel(0),
54 fITSFakeRatio(0),
55 fITStrack(0),
56 fTPCchi2(0),
57 fTPCncls(0),
58 fTPCClusterMap(159),//number of padrows
59 fTPCsignal(0),
60 fTPCLabel(0),
61 fTRDchi2(0),
62 fTRDncls(0),
63 fTRDncls0(0),
64 fTRDsignal(0),
65 fTRDLabel(0),
66 fTRDQuality(0),
67 fTRDtrack(0),
68 fTOFchi2(0),
69 fTOFindex(0),
70 fTOFsignal(-1),
71 fPHOSsignal(-1),
72 fEMCALsignal(-1),
73 fRICHchi2(1e10),
74 fRICHncls(0),
75 fRICHindex(0),
76 fRICHsignal(-1),
77 fRICHtheta(0),
78 fRICHphi(0),
79 fRICHdx(0),
80 fRICHdy(0)
81{
82 //
83 // The default ESD constructor
84 //
85 for (Int_t i=0; i<AliPID::kSPECIES; i++) {
86 fTrackTime[i]=0.;
87 fR[i]=1.;
88 fITSr[i]=1.;
89 fTPCr[i]=1.;
90 fTRDr[i]=1.;
91 fTOFr[i]=1.;
92 fRICHr[i]=1.;
93 }
94
95 for (Int_t i=0; i<AliPID::kSPECIESN; i++) {
96 fPHOSr[i] = 1.;
97 fEMCALr[i] = 1.;
98 }
99
100
101 fPHOSpos[0]=fPHOSpos[1]=fPHOSpos[2]=0.;
102 fEMCALpos[0]=fEMCALpos[1]=fEMCALpos[2]=0.;
103 Int_t i;
104 for (i=0; i<5; i++) {
105 fRp[i]=fCp[i]=fIp[i]=fTp[i]=0.;
106 }
107 for (i=0; i<15; i++) {
108 fRc[i]=fCc[i]=fIc[i]=fTc[i]=0.;
109 }
110 for (i=0; i<6; i++) { fITSindex[i]=0; }
111 for (i=0; i<180; i++){ fTPCindex[i]=0; }
112 for (i=0; i<3;i++) { fKinkIndexes[i]=0;}
113 for (i=0; i<3;i++) { fV0Indexes[i]=-1;}
114 for (i=0; i<130; i++) { fTRDindex[i]=0; }
115 for (i=0;i<kNPlane;i++) {fTRDsignals[i]=0.; fTRDTimBin[i]=-1;}
116 for (Int_t i=0;i<4;i++) {fTPCPoints[i]=-1;}
117 for (Int_t i=0;i<3;i++) {fTOFLabel[i]=-1;}
118 for (Int_t i=0;i<10;i++) {fTOFInfo[i]=-1;}
119 fTPCLabel = 0;
120 fTRDLabel = 0;
121 fTRDQuality =0;
122 fITSLabel = 0;
123 fITStrack = 0;
124 fTRDtrack = 0;
125}
126
127//_______________________________________________________________________
128AliESDtrack::AliESDtrack(const AliESDtrack& track):
129 TObject(track),
130 fFlags(track.fFlags),
131 fLabel(track.fLabel),
132 fID(track.fID),
133 fTrackLength(track.fTrackLength),
134 fD(track.fD),
135 fZ(track.fZ),
136 fStopVertex(track.fStopVertex),
137 fRalpha(track.fRalpha),
138 fRx(track.fRx),
139 fCalpha(track.fCalpha),
140 fCx(track.fCx),
141 fCchi2(track.fCchi2),
142 fIalpha(track.fIalpha),
143 fIx(track.fIx),
144 fTalpha(track.fTalpha),
145 fTx(track.fTx),
146 fITSchi2(track.fITSchi2),
147 fITSncls(track.fITSncls),
148 fITSsignal(track.fITSsignal),
149 fITSLabel(track.fITSLabel),
150 fITSFakeRatio(track.fITSFakeRatio),
151 fITStrack(0), //coping separatelly - in user code
152 fTPCchi2(track.fTPCchi2),
153 fTPCncls(track.fTPCncls),
154 fTPCClusterMap(track.fTPCClusterMap),
155 fTPCsignal(track.fTPCsignal),
156 fTPCLabel(track.fTPCLabel),
157 fTRDchi2(track.fTRDchi2),
158 fTRDncls(track.fTRDncls),
159 fTRDncls0(track.fTRDncls0),
160 fTRDsignal(track.fTRDsignal),
161 fTRDLabel(track.fTRDLabel),
162 fTRDQuality(track.fTRDQuality),
163 fTRDtrack(0),
164 fTOFchi2(track.fTOFchi2),
165 fTOFindex(track.fTOFindex),
166 fTOFsignal(track.fTOFsignal),
167 fPHOSsignal(track.fPHOSsignal),
168 fEMCALsignal(track.fEMCALsignal),
169 fRICHchi2(track.fRICHchi2),
170 fRICHncls(track.fRICHncls),
171 fRICHindex(track.fRICHindex),
172 fRICHsignal(track.fRICHsignal),
173 fRICHtheta(track.fRICHtheta),
174 fRICHphi(track.fRICHphi),
175 fRICHdx(track.fRICHdx),
176 fRICHdy(track.fRICHdy)
177{
178 //
179 //copy constructor
180 //
181 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] =track.fTrackTime[i];
182 for (Int_t i=0;i<AliPID::kSPECIES;i++) fR[i] =track.fR[i];
183 //
184 for (Int_t i=0;i<5;i++) fRp[i] =track.fRp[i];
185 for (Int_t i=0;i<15;i++) fRc[i] =track.fRc[i];
186 //
187 for (Int_t i=0;i<5;i++) fCp[i] =track.fCp[i];
188 for (Int_t i=0;i<15;i++) fCc[i] =track.fCc[i];
189 //
190 for (Int_t i=0;i<5;i++) fIp[i] =track.fIp[i];
191 for (Int_t i=0;i<15;i++) fIc[i] =track.fIc[i];
192 //
193 for (Int_t i=0;i<5;i++) fTp[i] =track.fTp[i];
194 for (Int_t i=0;i<15;i++) fTc[i] =track.fTc[i];
195 //
196 for (Int_t i=0;i<12;i++) fITSchi2MIP[i] =track.fITSchi2MIP[i];
197 for (Int_t i=0;i<6;i++) fITSindex[i]=track.fITSindex[i];
198 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
199 //
200 for (Int_t i=0;i<180;i++) fTPCindex[i]=track.fTPCindex[i];
201 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[i];
202 for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
203 for (Int_t i=0; i<3;i++) { fKinkIndexes[i]=track.fKinkIndexes[i];}
204 for (Int_t i=0; i<3;i++) { fV0Indexes[i]=track.fV0Indexes[i];}
205 //
206 for (Int_t i=0;i<130;i++) fTRDindex[i]=track.fTRDindex[i];
207 for (Int_t i=0;i<kNPlane;i++) {
208 fTRDsignals[i]=track.fTRDsignals[i];
209 fTRDTimBin[i]=track.fTRDTimBin[i];
210 }
211 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
212 //
213 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
214 for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
215 for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
216 //
217 for (Int_t i=0;i<3;i++) fPHOSpos[i]=track.fPHOSpos[i];
218 for (Int_t i=0;i<AliPID::kSPECIESN;i++) fPHOSr[i]=track.fPHOSr[i];
219 //
220 for (Int_t i=0;i<3;i++) fEMCALpos[i]=track.fEMCALpos[i];
221 for (Int_t i=0;i<AliPID::kSPECIESN;i++) fEMCALr[i]=track.fEMCALr[i];
222 //
223 for (Int_t i=0;i<AliPID::kSPECIES;i++) fRICHr[i]=track.fRICHr[i];
224}
225//_______________________________________________________________________
226AliESDtrack::~AliESDtrack(){
227 //
228 // This is destructor according Coding Conventrions
229 //
230 //printf("Delete track\n");
231 delete fITStrack;
232 delete fTRDtrack;
233}
234
235//_______________________________________________________________________
236void AliESDtrack::MakeMiniESDtrack(){
237 // Resets everything except
238 // fFlags: Reconstruction status flags
239 // fLabel: Track label
240 // fID: Unique ID of the track
241 // fD: Impact parameter in XY-plane
242 // fZ: Impact parameter in Z
243 // fR[AliPID::kSPECIES]: combined "detector response probability"
244 // Running track parameters
245 // fRalpha: track rotation angle
246 // fRx: X-coordinate of the track reference plane
247 // fRp[5]: external track parameters
248 // fRc[15]: external cov. matrix of the track parameters
249
250 fTrackLength = 0;
251 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
252 fStopVertex = 0;
253
254 // Reset track parameters constrained to the primary vertex
255 fCalpha = 0;
256 fCx = 0;
257 for (Int_t i=0;i<5;i++) fCp[i] = 0;
258 for (Int_t i=0;i<15;i++) fCc[i] = 0;
259 fCchi2 = 0;
260
261 // Reset track parameters at the inner wall of TPC
262 fIalpha = 0;
263 fIx = 0;
264 for (Int_t i=0;i<5;i++) fIp[i] = 0;
265 for (Int_t i=0;i<15;i++) fIc[i] = 0;
266
267 // Reset track parameters at the inner wall of the TRD
268 fTalpha = 0;
269 fTx = 0;
270 for (Int_t i=0;i<5;i++) fTp[i] = 0;
271 for (Int_t i=0;i<15;i++) fTc[i] = 0;
272
273 // Reset ITS track related information
274 fITSchi2 = 0;
275 for (Int_t i=0;i<12;i++) fITSchi2MIP[i] = 0;
276 fITSncls = 0;
277 for (Int_t i=0;i<6;i++) fITSindex[i]= 0;
278 fITSsignal = 0;
279 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]= 0;
280 fITSLabel = 0;
281 fITSFakeRatio = 0;
282 fITStrack =0;
283
284 // Reset TPC related track information
285 fTPCchi2 = 0;
286 fTPCncls = 0;
287 for (Int_t i=0;i<180;i++) fTPCindex[i] = 0;
288 fTPCClusterMap = 0;
289 fTPCsignal= 0;
290 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=0;
291 fTPCLabel=0;
292 for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
293 for (Int_t i=0; i<3;i++) fKinkIndexes[i] = 0;
294 for (Int_t i=0; i<3;i++) fV0Indexes[i] = 0;
295
296 // Reset TRD related track information
297 fTRDchi2 = 0;
298 fTRDncls = 0;
299 fTRDncls0 = 0;
300 for (Int_t i=0;i<130;i++) fTRDindex[i] = 0;
301 fTRDsignal = 0;
302 for (Int_t i=0;i<kNPlane;i++) {
303 fTRDsignals[i] = 0;
304 fTRDTimBin[i] = 0;
305 }
306 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
307 fTRDLabel = 0;
308 fTRDtrack = 0;
309 fTRDQuality = 0;
310
311 // Reset TOF related track information
312 fTOFchi2 = 0;
313 fTOFindex = 0;
314 fTOFsignal = 0;
315 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
316 for (Int_t i=0;i<3;i++) fTOFLabel[i] = 0;
317 for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
318
319 // Reset PHOS related track information
320 for (Int_t i=0;i<3;i++) fPHOSpos[i] = 0;
321 fPHOSsignal = 0;
322 for (Int_t i=0;i<AliPID::kSPECIESN;i++) fPHOSr[i] = 0;
323
324 // Reset EMCAL related track information
325 for (Int_t i=0;i<3;i++) fEMCALpos[i] = 0;
326 fEMCALsignal = 0;
327 for (Int_t i=0;i<AliPID::kSPECIESN;i++) fEMCALr[i] = 0;
328
329 // Reset RICH related track information
330 fRICHchi2 = 0;
331 fRICHncls = 0;
332 fRICHindex = 0;
333 fRICHsignal = 0;
334 for (Int_t i=0;i<AliPID::kSPECIES;i++) fRICHr[i] = 0;
335 fRICHtheta = 0;
336 fRICHphi = 0;
337 fRICHdx = 0;
338 fRICHdy = 0;
339
340}
341//_______________________________________________________________________
342Double_t AliESDtrack::GetMass() const {
343 // Returns the mass of the most probable particle type
344 Float_t max=0.;
345 Int_t k=-1;
346 for (Int_t i=0; i<AliPID::kSPECIES; i++) {
347 if (fR[i]>max) {k=i; max=fR[i];}
348 }
349 if (k==0) { // dE/dx "crossing points" in the TPC
350 Double_t p=GetP();
351 if ((p>0.38)&&(p<0.48))
352 if (fR[0]<fR[3]*10.) return AliPID::ParticleMass(AliPID::kKaon);
353 if ((p>0.75)&&(p<0.85))
354 if (fR[0]<fR[4]*10.) return AliPID::ParticleMass(AliPID::kProton);
355 return 0.00051;
356 }
357 if (k==1) return AliPID::ParticleMass(AliPID::kMuon);
358 if (k==2||k==-1) return AliPID::ParticleMass(AliPID::kPion);
359 if (k==3) return AliPID::ParticleMass(AliPID::kKaon);
360 if (k==4) return AliPID::ParticleMass(AliPID::kProton);
361 AliWarning("Undefined mass !");
362 return AliPID::ParticleMass(AliPID::kPion);
363}
364
365//_______________________________________________________________________
366Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags) {
367 //
368 // This function updates track's running parameters
369 //
370 Bool_t rc=kTRUE;
371
372 SetStatus(flags);
373 fLabel=t->GetLabel();
374
375 if (t->IsStartedTimeIntegral()) {
376 SetStatus(kTIME);
377 Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
378 SetIntegratedLength(t->GetIntegratedLength());
379 }
380
381 fRalpha=t->GetAlpha();
382 t->GetExternalParameters(fRx,fRp);
383 t->GetExternalCovariance(fRc);
384
385 switch (flags) {
386
387 case kITSin: case kITSout: case kITSrefit:
388 fITSncls=t->GetNumberOfClusters();
389 fITSchi2=t->GetChi2();
390 for (Int_t i=0;i<fITSncls;i++) fITSindex[i]=t->GetClusterIndex(i);
391 fITSsignal=t->GetPIDsignal();
392 fITSLabel = t->GetLabel();
393 fITSFakeRatio = t->GetFakeRatio();
394 break;
395
396 case kTPCin: case kTPCrefit:
397 fTPCLabel = t->GetLabel();
398 fIalpha=fRalpha;
399 fIx=fRx;
400 {
401 Int_t i;
402 for (i=0; i<5; i++) fIp[i]=fRp[i];
403 for (i=0; i<15;i++) fIc[i]=fRc[i];
404 }
405 case kTPCout:
406
407 fTPCncls=t->GetNumberOfClusters();
408 fTPCchi2=t->GetChi2();
409
410 {//prevrow must be declared in separate namespace, otherwise compiler cries:
411 //"jump to case label crosses initialization of `Int_t prevrow'"
412 Int_t prevrow = -1;
413 // for (Int_t i=0;i<fTPCncls;i++)
414 for (Int_t i=0;i<160;i++)
415 {
416 fTPCindex[i]=t->GetClusterIndex(i);
417
418 // Piotr's Cluster Map for HBT
419 // ### please change accordingly if cluster array is changing
420 // to "New TPC Tracking" style (with gaps in array)
421 Int_t idx = fTPCindex[i];
422 Int_t sect = (idx&0xff000000)>>24;
423 Int_t row = (idx&0x00ff0000)>>16;
424 if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
425
426 fTPCClusterMap.SetBitNumber(row,kTRUE);
427
428 //Fill the gap between previous row and this row with 0 bits
429 //In case ### pleas change it as well - just set bit 0 in case there
430 //is no associated clusters for current "i"
431 if (prevrow < 0)
432 {
433 prevrow = row;//if previous bit was not assigned yet == this is the first one
434 }
435 else
436 { //we don't know the order (inner to outer or reverse)
437 //just to be save in case it is going to change
438 Int_t n = 0, m = 0;
439 if (prevrow < row)
440 {
441 n = prevrow;
442 m = row;
443 }
444 else
445 {
446 n = row;
447 m = prevrow;
448 }
449
450 for (Int_t j = n+1; j < m; j++)
451 {
452 fTPCClusterMap.SetBitNumber(j,kFALSE);
453 }
454 prevrow = row;
455 }
456 // End Of Piotr's Cluster Map for HBT
457 }
458 }
459 fTPCsignal=t->GetPIDsignal();
460 {Double_t mass=t->GetMass(); // preliminary mass setting
461 if (mass>0.5) fR[4]=1.; // used by
462 else if (mass<0.4) fR[2]=1.; // the ITS reconstruction
463 else fR[3]=1.;}
464 //
465 break;
466
467 case kTRDout: case kTRDin: case kTRDrefit:
468 fTRDLabel = t->GetLabel();
469 fTRDncls=t->GetNumberOfClusters();
470 fTRDchi2=t->GetChi2();
471 for (Int_t i=0;i<fTRDncls;i++) fTRDindex[i]=t->GetClusterIndex(i);
472 fTRDsignal=t->GetPIDsignal();
473 break;
474 case kTRDbackup:
475 t->GetExternalParameters(fTx,fTp);
476 t->GetExternalCovariance(fTc);
477 fTalpha = t->GetAlpha();
478 fTRDncls0 = t->GetNumberOfClusters();
479 break;
480 case kTOFin:
481 break;
482 case kTOFout:
483 break;
484 case kTRDStop:
485 break;
486 default:
487 AliError("Wrong flag !");
488 return kFALSE;
489 }
490
491 return rc;
492}
493
494//_______________________________________________________________________
495void
496AliESDtrack::SetConstrainedTrackParams(const AliKalmanTrack *t, Double_t chi2) {
497 //
498 // This function sets the constrained track parameters
499 //
500 Int_t i;
501 Double_t x,buf[15];
502 fCalpha=t->GetAlpha();
503 t->GetExternalParameters(x,buf); fCx=x;
504 for (i=0; i<5; i++) fCp[i]=buf[i];
505 t->GetExternalCovariance(buf);
506 for (i=0; i<15; i++) fCc[i]=buf[i];
507 fCchi2=chi2;
508}
509
510
511//_______________________________________________________________________
512void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
513 //---------------------------------------------------------------------
514 // This function returns external representation of the track parameters
515 //---------------------------------------------------------------------
516 x=fRx;
517 for (Int_t i=0; i<5; i++) p[i]=fRp[i];
518}
519
520//_______________________________________________________________________
521Bool_t AliESDtrack::GetExternalParametersAt(Double_t x, Double_t p[5]) const {
522 //---------------------------------------------------------------------
523 // This function returns external representation of the track parameters
524 // at the position given by the first argument
525 //---------------------------------------------------------------------
526 Double_t dx=x-fRx;
527 Double_t f1=fRp[2], f2=f1 + dx*fRp[4]/AliKalmanTrack::GetConvConst();
528
529 if (TMath::Abs(f2) >= 0.9999) return kFALSE;
530
531 Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
532 p[0] = fRp[0] + dx*(f1+f2)/(r1+r2);
533 p[1] = fRp[1] + dx*(f1+f2)/(f1*r2 + f2*r1)*fRp[3];
534 p[2] = f2;
535 p[3] = fRp[3];
536 p[4] = fRp[4];
537
538 return kTRUE;
539}
540
541//_______________________________________________________________________
542void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
543 //---------------------------------------------------------------------
544 // This function returns external representation of the cov. matrix
545 //---------------------------------------------------------------------
546 for (Int_t i=0; i<15; i++) cov[i]=fRc[i];
547}
548
549
550//_______________________________________________________________________
551void
552AliESDtrack::GetConstrainedExternalParameters(Double_t &x, Double_t p[5])const{
553 //---------------------------------------------------------------------
554 // This function returns the constrained external track parameters
555 //---------------------------------------------------------------------
556 x=fCx;
557 for (Int_t i=0; i<5; i++) p[i]=fCp[i];
558}
559//_______________________________________________________________________
560void
561AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
562 //---------------------------------------------------------------------
563 // This function returns the constrained external cov. matrix
564 //---------------------------------------------------------------------
565 for (Int_t i=0; i<15; i++) c[i]=fCc[i];
566}
567
568
569Double_t AliESDtrack::GetP() const {
570 //---------------------------------------------------------------------
571 // This function returns the track momentum
572 // Results for (nearly) straight tracks are meaningless !
573 //---------------------------------------------------------------------
574 if (TMath::Abs(fRp[4])<=0) return 0;
575 Double_t pt=1./TMath::Abs(fRp[4]);
576 return pt*TMath::Sqrt(1.+ fRp[3]*fRp[3]);
577}
578
579Bool_t Local2GlobalMomentum(Double_t p[3],Double_t alpha) {
580 //----------------------------------------------------------------
581 // This function performs local->global transformation of the
582 // track momentum.
583 // When called, the arguments are:
584 // p[0] = 1/pt of the track;
585 // p[1] = sine of local azim. angle of the track momentum;
586 // p[2] = tangent of the track momentum dip angle;
587 // alpha - rotation angle.
588 // The result is returned as:
589 // p[0] = px
590 // p[1] = py
591 // p[2] = pz
592 // Results for (nearly) straight tracks are meaningless !
593 //----------------------------------------------------------------
594 if (TMath::Abs(p[0])<=0) return kFALSE;
595 if (TMath::Abs(p[1])> 0.999999) return kFALSE;
596
597 Double_t pt=1./TMath::Abs(p[0]);
598 Double_t cs=TMath::Cos(alpha), sn=TMath::Sin(alpha);
599 Double_t r=TMath::Sqrt(1 - p[1]*p[1]);
600 p[0]=pt*(r*cs - p[1]*sn); p[1]=pt*(p[1]*cs + r*sn); p[2]=pt*p[2];
601
602 return kTRUE;
603}
604
605Bool_t Local2GlobalPosition(Double_t r[3],Double_t alpha) {
606 //----------------------------------------------------------------
607 // This function performs local->global transformation of the
608 // track position.
609 // When called, the arguments are:
610 // r[0] = local x
611 // r[1] = local y
612 // r[2] = local z
613 // alpha - rotation angle.
614 // The result is returned as:
615 // r[0] = global x
616 // r[1] = global y
617 // r[2] = global z
618 //----------------------------------------------------------------
619 Double_t cs=TMath::Cos(alpha), sn=TMath::Sin(alpha), x=r[0];
620 r[0]=x*cs - r[1]*sn; r[1]=x*sn + r[1]*cs;
621
622 return kTRUE;
623}
624
625Bool_t AliESDtrack::GetConstrainedPxPyPz(Double_t *p) const {
626 //---------------------------------------------------------------------
627 // This function returns the constrained global track momentum components
628 // Results for (nearly) straight tracks are meaningless !
629 //---------------------------------------------------------------------
630 p[0]=fCp[4]; p[1]=fCp[2]; p[2]=fCp[3];
631 return Local2GlobalMomentum(p,fCalpha);
632}
633
634Bool_t AliESDtrack::GetConstrainedXYZ(Double_t *r) const {
635 //---------------------------------------------------------------------
636 // This function returns the constrained global track position
637 //---------------------------------------------------------------------
638 r[0]=fCx; r[1]=fCp[0]; r[2]=fCp[1];
639 return Local2GlobalPosition(r,fCalpha);
640}
641
642Bool_t AliESDtrack::GetPxPyPz(Double_t *p) const {
643 //---------------------------------------------------------------------
644 // This function returns the global track momentum components
645 // Results for (nearly) straight tracks are meaningless !
646 //---------------------------------------------------------------------
647 p[0]=fRp[4]; p[1]=fRp[2]; p[2]=fRp[3];
648 return Local2GlobalMomentum(p,fRalpha);
649}
650
651Bool_t AliESDtrack::GetXYZ(Double_t *r) const {
652 //---------------------------------------------------------------------
653 // This function returns the global track position
654 //---------------------------------------------------------------------
655 r[0]=fRx; r[1]=fRp[0]; r[2]=fRp[1];
656 return Local2GlobalPosition(r,fRalpha);
657}
658
659void AliESDtrack::GetCovariance(Double_t cv[21]) const {
660 //---------------------------------------------------------------------
661 // This function returns the global covariance matrix of the track params
662 //
663 // Cov(x,x) ... : cv[0]
664 // Cov(y,x) ... : cv[1] cv[2]
665 // Cov(z,x) ... : cv[3] cv[4] cv[5]
666 // Cov(px,x)... : cv[6] cv[7] cv[8] cv[9]
667 // Cov(py,x)... : cv[10] cv[11] cv[12] cv[13] cv[14]
668 // Cov(pz,x)... : cv[15] cv[16] cv[17] cv[18] cv[19] cv[20]
669 //
670 // Results for (nearly) straight tracks are meaningless !
671 //---------------------------------------------------------------------
672 if (TMath::Abs(fRp[4])<=0) {
673 for (Int_t i=0; i<21; i++) cv[i]=0.;
674 return;
675 }
676 if (TMath::Abs(fRp[2]) > 0.999999) {
677 for (Int_t i=0; i<21; i++) cv[i]=0.;
678 return;
679 }
680 Double_t pt=1./TMath::Abs(fRp[4]);
681 Double_t cs=TMath::Cos(fRalpha), sn=TMath::Sin(fRalpha);
682 Double_t r=TMath::Sqrt(1-fRp[2]*fRp[2]);
683
684 Double_t m00=-sn, m10=cs;
685 Double_t m23=-pt*(sn + fRp[2]*cs/r), m43=-pt*pt*(r*cs - fRp[2]*sn);
686 Double_t m24= pt*(cs - fRp[2]*sn/r), m44=-pt*pt*(r*sn + fRp[2]*cs);
687 Double_t m35=pt, m45=-pt*pt*fRp[3];
688
689 cv[0]=fRc[0]*m00*m00;
690 cv[1]=fRc[0]*m00*m10;
691 cv[2]=fRc[0]*m10*m10;
692 cv[3]=fRc[1]*m00;
693 cv[4]=fRc[1]*m10;
694 cv[5]=fRc[2];
695 cv[6]=m00*(fRc[3]*m23+fRc[10]*m43);
696 cv[7]=m10*(fRc[3]*m23+fRc[10]*m43);
697 cv[8]=fRc[4]*m23+fRc[11]*m43;
698 cv[9]=m23*(fRc[5]*m23+fRc[12]*m43)+m43*(fRc[12]*m23+fRc[14]*m43);
699 cv[10]=m00*(fRc[3]*m24+fRc[10]*m44);
700 cv[11]=m10*(fRc[3]*m24+fRc[10]*m44);
701 cv[12]=fRc[4]*m24+fRc[11]*m44;
702 cv[13]=m23*(fRc[5]*m24+fRc[12]*m44)+m43*(fRc[12]*m24+fRc[14]*m44);
703 cv[14]=m24*(fRc[5]*m24+fRc[12]*m44)+m44*(fRc[12]*m24+fRc[14]*m44);
704 cv[15]=m00*(fRc[6]*m35+fRc[10]*m45);
705 cv[16]=m10*(fRc[6]*m35+fRc[10]*m45);
706 cv[17]=fRc[7]*m35+fRc[11]*m45;
707 cv[18]=m23*(fRc[8]*m35+fRc[12]*m45)+m43*(fRc[13]*m35+fRc[14]*m45);
708 cv[19]=m24*(fRc[8]*m35+fRc[12]*m45)+m44*(fRc[13]*m35+fRc[14]*m45);
709 cv[20]=m35*(fRc[9]*m35+fRc[13]*m45)+m45*(fRc[13]*m35+fRc[14]*m45);
710}
711
712Bool_t AliESDtrack::GetInnerPxPyPz(Double_t *p) const {
713 //---------------------------------------------------------------------
714 // This function returns the global track momentum components
715 // af the entrance of the TPC
716 //---------------------------------------------------------------------
717 p[0]=fIp[4]; p[1]=fIp[2]; p[2]=fIp[3];
718 return Local2GlobalMomentum(p,fIalpha);
719}
720
721Bool_t AliESDtrack::GetInnerXYZ(Double_t *r) const {
722 //---------------------------------------------------------------------
723 // This function returns the global track position
724 // af the entrance of the TPC
725 //---------------------------------------------------------------------
726 if (fIx==0) return kFALSE;
727 r[0]=fIx; r[1]=fIp[0]; r[2]=fIp[1];
728 return Local2GlobalPosition(r,fIalpha);
729}
730
731void AliESDtrack::GetInnerExternalParameters(Double_t &x, Double_t p[5]) const
732{
733 //skowron
734 //---------------------------------------------------------------------
735 // This function returns external representation of the track parameters at Inner Layer of TPC
736 //---------------------------------------------------------------------
737 x=fIx;
738 for (Int_t i=0; i<5; i++) p[i]=fIp[i];
739}
740void AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const
741{
742 //skowron
743 //---------------------------------------------------------------------
744 // This function returns external representation of the cov. matrix at Inner Layer of TPC
745 //---------------------------------------------------------------------
746 for (Int_t i=0; i<15; i++) cov[i]=fIc[i];
747
748}
749
750void AliESDtrack::GetTRDExternalParameters(Double_t &x, Double_t&alpha, Double_t p[5], Double_t cov[15]) const
751{
752 //
753 //this function returns TRD parameters
754 //
755 x=fTx;
756 alpha = fTalpha;
757 for (Int_t i=0; i<5; i++) p[i]=fTp[i];
758 for (Int_t i=0; i<15; i++) cov[i]=fTc[i];
759}
760
761Bool_t AliESDtrack::GetPxPyPzAt(Double_t x,Double_t *p) const {
762 //---------------------------------------------------------------------
763 // This function returns the global track momentum components
764 // at the position "x" using the helix track approximation
765 //---------------------------------------------------------------------
766 p[0]=fRp[4];
767 p[1]=fRp[2]+(x-fRx)*fRp[4]/AliKalmanTrack::GetConvConst();
768 p[2]=fRp[3];
769 return Local2GlobalMomentum(p,fRalpha);
770}
771
772Bool_t AliESDtrack::GetXYZAt(Double_t x, Double_t *r) const {
773 //---------------------------------------------------------------------
774 // This function returns the global track position
775 // af the radius "x" using the helix track approximation
776 //---------------------------------------------------------------------
777 Double_t dx=x-fRx;
778 Double_t f1=fRp[2], f2=f1 + dx*fRp[4]/AliKalmanTrack::GetConvConst();
779
780 if (TMath::Abs(f2) >= 0.9999) return kFALSE;
781
782 Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
783 r[0] = x;
784 r[1] = fRp[0] + dx*(f1+f2)/(r1+r2);
785 r[2] = fRp[1] + dx*(f1+f2)/(f1*r2 + f2*r1)*fRp[3];
786 return Local2GlobalPosition(r,fRalpha);
787}
788
789//_______________________________________________________________________
790void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
791 // Returns the array with integrated times for each particle hypothesis
792 for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
793}
794
795//_______________________________________________________________________
796void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
797 // Sets the array with integrated times for each particle hypotesis
798 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
799}
800
801//_______________________________________________________________________
802void AliESDtrack::SetITSpid(const Double_t *p) {
803 // Sets values for the probability of each particle type (in ITS)
804 for (Int_t i=0; i<AliPID::kSPECIES; i++) fITSr[i]=p[i];
805 SetStatus(AliESDtrack::kITSpid);
806}
807
808void AliESDtrack::SetITSChi2MIP(const Float_t *chi2mip){
809 for (Int_t i=0; i<12; i++) fITSchi2MIP[i]=chi2mip[i];
810}
811//_______________________________________________________________________
812void AliESDtrack::GetITSpid(Double_t *p) const {
813 // Gets the probability of each particle type (in ITS)
814 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
815}
816
817//_______________________________________________________________________
818Int_t AliESDtrack::GetITSclusters(UInt_t *idx) const {
819 //---------------------------------------------------------------------
820 // This function returns indices of the assgined ITS clusters
821 //---------------------------------------------------------------------
822 for (Int_t i=0; i<fITSncls; i++) idx[i]=fITSindex[i];
823 return fITSncls;
824}
825
826//_______________________________________________________________________
827Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
828 //---------------------------------------------------------------------
829 // This function returns indices of the assgined ITS clusters
830 //---------------------------------------------------------------------
831 if (idx!=0)
832 for (Int_t i=0; i<180; i++) idx[i]=fTPCindex[i]; // MI I prefer some constant
833 return fTPCncls;
834}
835
836//_______________________________________________________________________
837void AliESDtrack::SetTPCpid(const Double_t *p) {
838 // Sets values for the probability of each particle type (in TPC)
839 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTPCr[i]=p[i];
840 SetStatus(AliESDtrack::kTPCpid);
841}
842
843//_______________________________________________________________________
844void AliESDtrack::GetTPCpid(Double_t *p) const {
845 // Gets the probability of each particle type (in TPC)
846 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
847}
848
849//_______________________________________________________________________
850Int_t AliESDtrack::GetTRDclusters(UInt_t *idx) const {
851 //---------------------------------------------------------------------
852 // This function returns indices of the assgined TRD clusters
853 //---------------------------------------------------------------------
854 if (idx!=0)
855 for (Int_t i=0; i<130; i++) idx[i]=fTRDindex[i]; // MI I prefer some constant
856 return fTRDncls;
857}
858
859//_______________________________________________________________________
860void AliESDtrack::SetTRDpid(const Double_t *p) {
861 // Sets values for the probability of each particle type (in TRD)
862 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTRDr[i]=p[i];
863 SetStatus(AliESDtrack::kTRDpid);
864}
865
866//_______________________________________________________________________
867void AliESDtrack::GetTRDpid(Double_t *p) const {
868 // Gets the probability of each particle type (in TRD)
869 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
870}
871
872//_______________________________________________________________________
873void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
874{
875 // Sets the probability of particle type iSpecies to p (in TRD)
876 fTRDr[iSpecies] = p;
877}
878
879Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
880{
881 // Returns the probability of particle type iSpecies (in TRD)
882 return fTRDr[iSpecies];
883}
884
885//_______________________________________________________________________
886void AliESDtrack::SetTOFpid(const Double_t *p) {
887 // Sets the probability of each particle type (in TOF)
888 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTOFr[i]=p[i];
889 SetStatus(AliESDtrack::kTOFpid);
890}
891
892//_______________________________________________________________________
893void AliESDtrack::SetTOFLabel(const Int_t *p) {
894 // Sets (in TOF)
895 for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
896}
897
898//_______________________________________________________________________
899void AliESDtrack::GetTOFpid(Double_t *p) const {
900 // Gets probabilities of each particle type (in TOF)
901 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
902}
903
904//_______________________________________________________________________
905void AliESDtrack::GetTOFLabel(Int_t *p) const {
906 // Gets (in TOF)
907 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
908}
909
910//_______________________________________________________________________
911void AliESDtrack::GetTOFInfo(Float_t *info) const {
912 // Gets (in TOF)
913 for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
914}
915
916//_______________________________________________________________________
917void AliESDtrack::SetTOFInfo(Float_t*info) {
918 // Gets (in TOF)
919 for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
920}
921
922
923
924//_______________________________________________________________________
925void AliESDtrack::SetPHOSpid(const Double_t *p) {
926 // Sets the probability of each particle type (in PHOS)
927 for (Int_t i=0; i<AliPID::kSPECIESN; i++) fPHOSr[i]=p[i];
928 SetStatus(AliESDtrack::kPHOSpid);
929}
930
931//_______________________________________________________________________
932void AliESDtrack::GetPHOSpid(Double_t *p) const {
933 // Gets probabilities of each particle type (in PHOS)
934 for (Int_t i=0; i<AliPID::kSPECIESN; i++) p[i]=fPHOSr[i];
935}
936
937//_______________________________________________________________________
938void AliESDtrack::SetEMCALpid(const Double_t *p) {
939 // Sets the probability of each particle type (in EMCAL)
940 for (Int_t i=0; i<AliPID::kSPECIESN; i++) fEMCALr[i]=p[i];
941 SetStatus(AliESDtrack::kEMCALpid);
942}
943
944//_______________________________________________________________________
945void AliESDtrack::GetEMCALpid(Double_t *p) const {
946 // Gets probabilities of each particle type (in EMCAL)
947 for (Int_t i=0; i<AliPID::kSPECIESN; i++) p[i]=fEMCALr[i];
948}
949
950//_______________________________________________________________________
951void AliESDtrack::SetRICHpid(const Double_t *p) {
952 // Sets the probability of each particle type (in RICH)
953 for (Int_t i=0; i<AliPID::kSPECIES; i++) fRICHr[i]=p[i];
954 SetStatus(AliESDtrack::kRICHpid);
955}
956
957//_______________________________________________________________________
958void AliESDtrack::GetRICHpid(Double_t *p) const {
959 // Gets probabilities of each particle type (in RICH)
960 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fRICHr[i];
961}
962
963
964
965//_______________________________________________________________________
966void AliESDtrack::SetESDpid(const Double_t *p) {
967 // Sets the probability of each particle type for the ESD track
968 for (Int_t i=0; i<AliPID::kSPECIES; i++) fR[i]=p[i];
969 SetStatus(AliESDtrack::kESDpid);
970}
971
972//_______________________________________________________________________
973void AliESDtrack::GetESDpid(Double_t *p) const {
974 // Gets probability of each particle type for the ESD track
975 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
976}
977
978//_______________________________________________________________________
979void AliESDtrack::Print(Option_t *) const {
980 // Prints info on the track
981
982 printf("ESD track info\n") ;
983 Double_t p[AliPID::kSPECIESN] ;
984 Int_t index = 0 ;
985 if( IsOn(kITSpid) ){
986 printf("From ITS: ") ;
987 GetITSpid(p) ;
988 for(index = 0 ; index < AliPID::kSPECIES; index++)
989 printf("%f, ", p[index]) ;
990 printf("\n signal = %f\n", GetITSsignal()) ;
991 }
992 if( IsOn(kTPCpid) ){
993 printf("From TPC: ") ;
994 GetTPCpid(p) ;
995 for(index = 0 ; index < AliPID::kSPECIES; index++)
996 printf("%f, ", p[index]) ;
997 printf("\n signal = %f\n", GetTPCsignal()) ;
998 }
999 if( IsOn(kTRDpid) ){
1000 printf("From TRD: ") ;
1001 GetTRDpid(p) ;
1002 for(index = 0 ; index < AliPID::kSPECIES; index++)
1003 printf("%f, ", p[index]) ;
1004 printf("\n signal = %f\n", GetTRDsignal()) ;
1005 }
1006 if( IsOn(kTOFpid) ){
1007 printf("From TOF: ") ;
1008 GetTOFpid(p) ;
1009 for(index = 0 ; index < AliPID::kSPECIES; index++)
1010 printf("%f, ", p[index]) ;
1011 printf("\n signal = %f\n", GetTOFsignal()) ;
1012 }
1013 if( IsOn(kRICHpid) ){
1014 printf("From TOF: ") ;
1015 GetRICHpid(p) ;
1016 for(index = 0 ; index < AliPID::kSPECIES; index++)
1017 printf("%f, ", p[index]) ;
1018 printf("\n signal = %f\n", GetRICHsignal()) ;
1019 }
1020 if( IsOn(kPHOSpid) ){
1021 printf("From PHOS: ") ;
1022 GetPHOSpid(p) ;
1023 for(index = 0 ; index < AliPID::kSPECIESN; index++)
1024 printf("%f, ", p[index]) ;
1025 printf("\n signal = %f\n", GetPHOSsignal()) ;
1026 }
1027 if( IsOn(kEMCALpid) ){
1028 printf("From EMCAL: ") ;
1029 GetEMCALpid(p) ;
1030 for(index = 0 ; index < AliPID::kSPECIESN; index++)
1031 printf("%f, ", p[index]) ;
1032 printf("\n signal = %f\n", GetEMCALsignal()) ;
1033 }
1034}