Using AliPID (Yu.Belikov)
[u/mrichter/AliRoot.git] / STEER / AliESDtrack.cxx
CommitLineData
ae982df3 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
ae982df3 15//-----------------------------------------------------------------
16// Implementation of the ESD track class
4427806c 17// ESD = Event Summary Data
15614b8b 18// This is the class to deal with during the phisics analysis of data
4427806c 19// Origin: Iouri Belikov, CERN
20// e-mail: Jouri.Belikov@cern.ch
ae982df3 21//-----------------------------------------------------------------
22
23#include "TMath.h"
24
49d13e89 25#include "AliESDVertex.h"
ae982df3 26#include "AliESDtrack.h"
27#include "AliKalmanTrack.h"
98937d93 28#include "AliTrackPointArray.h"
5f7789fc 29#include "AliLog.h"
ae982df3 30
31ClassImp(AliESDtrack)
32
d27bbc79 33void SetPIDValues(Float_t * dest, const Double_t * src, Int_t n) {
34 // This function copies "n" PID weights from "scr" to "dest"
35 // and normalizes their sum to 1 thus producing conditional probabilities.
36 // The negative weights are set to 0.
37 // In case all the weights are non-positive they are replaced by
38 // uniform probabilities
39
40 if (n<=0) return;
41
42 Float_t uniform = 1./(Float_t)n;
43
44 Float_t sum = 0;
45 for (Int_t i=0; i<n; i++)
46 if (src[i]>=0) {
47 sum+=src[i];
48 dest[i] = src[i];
49 }
50 else {
51 dest[i] = 0;
52 }
53
54 if(sum>0)
55 for (Int_t i=0; i<n; i++) dest[i] /= sum;
56 else
57 for (Int_t i=0; i<n; i++) dest[i] = uniform;
58}
59
ae982df3 60//_______________________________________________________________________
61AliESDtrack::AliESDtrack() :
c9ec41e8 62 AliExternalTrackParam(),
90e48c0c 63 fFlags(0),
64 fLabel(0),
65 fID(0),
66 fTrackLength(0),
49d13e89 67 fD(0),fZ(0),
68 fCdd(0),fCdz(0),fCzz(0),
90e48c0c 69 fStopVertex(0),
c9ec41e8 70 fCp(0),
90e48c0c 71 fCchi2(1e10),
c9ec41e8 72 fIp(0),
73 fOp(0),
90e48c0c 74 fITSchi2(0),
75 fITSncls(0),
76 fITSsignal(0),
77 fITSLabel(0),
78 fITSFakeRatio(0),
79 fITStrack(0),
80 fTPCchi2(0),
81 fTPCncls(0),
e1d4c1b5 82 fTPCnclsF(0),
90e48c0c 83 fTPCClusterMap(159),//number of padrows
84 fTPCsignal(0),
e1d4c1b5 85 fTPCsignalN(0),
86 fTPCsignalS(0),
90e48c0c 87 fTPCLabel(0),
88 fTRDchi2(0),
89 fTRDncls(0),
90 fTRDncls0(0),
91 fTRDsignal(0),
92 fTRDLabel(0),
93 fTRDQuality(0),
23d49657 94 fTRDBudget(0),
90e48c0c 95 fTRDtrack(0),
96 fTOFchi2(0),
97 fTOFindex(0),
85324138 98 fTOFCalChannel(-1),
90e48c0c 99 fTOFsignal(-1),
85324138 100 fTOFsignalToT(0),
85c60a8e 101 // fPHOSsignal(-1),
90e48c0c 102 fRICHchi2(1e10),
103 fRICHncls(0),
104 fRICHindex(0),
105 fRICHsignal(-1),
106 fRICHtheta(0),
107 fRICHphi(0),
108 fRICHdx(0),
98937d93 109 fRICHdy(0),
110 fPoints(0)
ae982df3 111{
112 //
113 // The default ESD constructor
114 //
304864ab 115 for (Int_t i=0; i<AliPID::kSPECIES; i++) {
4a78b8c5 116 fTrackTime[i]=0.;
117 fR[i]=1.;
118 fITSr[i]=1.;
119 fTPCr[i]=1.;
120 fTRDr[i]=1.;
121 fTOFr[i]=1.;
4a78b8c5 122 fRICHr[i]=1.;
2bad268c 123 }
ac2f7574 124
85c60a8e 125 // for (Int_t i=0; i<AliPID::kSPECIESN; i++) {
126 // fPHOSr[i] = 1.;
127 // }
128 // fPHOSpos[0]=fPHOSpos[1]=fPHOSpos[2]=0.;
704be597 129
bb2ceb1f 130 Int_t i;
c9ec41e8 131 for (i=0;i<12;i++) fITSchi2MIP[i] =1e10;
a866ac60 132 for (i=0; i<6; i++) { fITSindex[i]=0; }
133 for (i=0; i<180; i++){ fTPCindex[i]=0; }
51ad6848 134 for (i=0; i<3;i++) { fKinkIndexes[i]=0;}
135 for (i=0; i<3;i++) { fV0Indexes[i]=-1;}
e1d4c1b5 136 for (i=0; i<180; i++) { fTRDindex[i]=0; }
eab5961e 137 for (i=0;i<kNPlane;i++) {fTRDsignals[i]=0.; fTRDTimBin[i]=-1;}
c9ec41e8 138 for (i=0;i<4;i++) {fTPCPoints[i]=-1;}
139 for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
140 for (i=0;i<10;i++) {fTOFInfo[i]=-1;}
6e5b1b04 141 fTPCLabel = 0;
142 fTRDLabel = 0;
7c97ee80 143 fTRDQuality =0;
23d49657 144 fTRDBudget =0;
6e5b1b04 145 fITSLabel = 0;
c4d11b15 146 fITStrack = 0;
147 fTRDtrack = 0;
148}
149
150//_______________________________________________________________________
90e48c0c 151AliESDtrack::AliESDtrack(const AliESDtrack& track):
c9ec41e8 152 AliExternalTrackParam(track),
90e48c0c 153 fFlags(track.fFlags),
154 fLabel(track.fLabel),
155 fID(track.fID),
156 fTrackLength(track.fTrackLength),
49d13e89 157 fD(track.fD),fZ(track.fZ),
158 fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
90e48c0c 159 fStopVertex(track.fStopVertex),
c9ec41e8 160 fCp(0),
90e48c0c 161 fCchi2(track.fCchi2),
c9ec41e8 162 fIp(0),
163 fOp(0),
90e48c0c 164 fITSchi2(track.fITSchi2),
165 fITSncls(track.fITSncls),
166 fITSsignal(track.fITSsignal),
167 fITSLabel(track.fITSLabel),
168 fITSFakeRatio(track.fITSFakeRatio),
169 fITStrack(0), //coping separatelly - in user code
170 fTPCchi2(track.fTPCchi2),
171 fTPCncls(track.fTPCncls),
e1d4c1b5 172 fTPCnclsF(track.fTPCnclsF),
90e48c0c 173 fTPCClusterMap(track.fTPCClusterMap),
174 fTPCsignal(track.fTPCsignal),
e1d4c1b5 175 fTPCsignalN(track.fTPCsignalN),
176 fTPCsignalS(track.fTPCsignalS),
90e48c0c 177 fTPCLabel(track.fTPCLabel),
178 fTRDchi2(track.fTRDchi2),
179 fTRDncls(track.fTRDncls),
180 fTRDncls0(track.fTRDncls0),
181 fTRDsignal(track.fTRDsignal),
182 fTRDLabel(track.fTRDLabel),
183 fTRDQuality(track.fTRDQuality),
23d49657 184 fTRDBudget(track.fTRDBudget),
90e48c0c 185 fTRDtrack(0),
186 fTOFchi2(track.fTOFchi2),
187 fTOFindex(track.fTOFindex),
85324138 188 fTOFCalChannel(track.fTOFCalChannel),
90e48c0c 189 fTOFsignal(track.fTOFsignal),
85324138 190 fTOFsignalToT(track.fTOFsignalToT),
85c60a8e 191 //fPHOSsignal(track.fPHOSsignal),
90e48c0c 192 fRICHchi2(track.fRICHchi2),
193 fRICHncls(track.fRICHncls),
194 fRICHindex(track.fRICHindex),
195 fRICHsignal(track.fRICHsignal),
196 fRICHtheta(track.fRICHtheta),
197 fRICHphi(track.fRICHphi),
198 fRICHdx(track.fRICHdx),
e1d4c1b5 199 fRICHdy(track.fRICHdy)
90e48c0c 200{
c4d11b15 201 //
202 //copy constructor
203 //
304864ab 204 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] =track.fTrackTime[i];
205 for (Int_t i=0;i<AliPID::kSPECIES;i++) fR[i] =track.fR[i];
c4d11b15 206 //
c4d11b15 207 for (Int_t i=0;i<12;i++) fITSchi2MIP[i] =track.fITSchi2MIP[i];
c4d11b15 208 for (Int_t i=0;i<6;i++) fITSindex[i]=track.fITSindex[i];
304864ab 209 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
c4d11b15 210 //
c4d11b15 211 for (Int_t i=0;i<180;i++) fTPCindex[i]=track.fTPCindex[i];
304864ab 212 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[i];
51ad6848 213 for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
214 for (Int_t i=0; i<3;i++) { fKinkIndexes[i]=track.fKinkIndexes[i];}
215 for (Int_t i=0; i<3;i++) { fV0Indexes[i]=track.fV0Indexes[i];}
c4d11b15 216 //
e1d4c1b5 217 for (Int_t i=0;i<180;i++) fTRDindex[i]=track.fTRDindex[i];
eab5961e 218 for (Int_t i=0;i<kNPlane;i++) {
219 fTRDsignals[i]=track.fTRDsignals[i];
220 fTRDTimBin[i]=track.fTRDTimBin[i];
221 }
304864ab 222 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
c4d11b15 223 //
304864ab 224 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
51ad6848 225 for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
226 for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
c4d11b15 227 //
85c60a8e 228 // for (Int_t i=0;i<3;i++) fPHOSpos[i]=track.fPHOSpos[i];
229 //for (Int_t i=0;i<AliPID::kSPECIESN;i++) fPHOSr[i]=track.fPHOSr[i];
c4d11b15 230 //
304864ab 231 for (Int_t i=0;i<AliPID::kSPECIES;i++) fRICHr[i]=track.fRICHr[i];
c9ec41e8 232
233 if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
234 if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
235 if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
e1d4c1b5 236 fPoints =0;
237 if (track.fPoints){
238 fPoints = new AliTrackPointArray(*(track.fPoints));
239 }
ae982df3 240}
c4d11b15 241//_______________________________________________________________________
242AliESDtrack::~AliESDtrack(){
243 //
244 // This is destructor according Coding Conventrions
245 //
246 //printf("Delete track\n");
c9ec41e8 247 delete fIp;
248 delete fOp;
249 delete fCp;
3fd96ae3 250 delete fITStrack;
98937d93 251 delete fTRDtrack;
252 delete fPoints;
c4d11b15 253}
ae982df3 254
255//_______________________________________________________________________
9559cbc4 256void AliESDtrack::MakeMiniESDtrack(){
257 // Resets everything except
258 // fFlags: Reconstruction status flags
259 // fLabel: Track label
260 // fID: Unique ID of the track
261 // fD: Impact parameter in XY-plane
262 // fZ: Impact parameter in Z
263 // fR[AliPID::kSPECIES]: combined "detector response probability"
264 // Running track parameters
265 // fRalpha: track rotation angle
266 // fRx: X-coordinate of the track reference plane
267 // fRp[5]: external track parameters
268 // fRc[15]: external cov. matrix of the track parameters
269
270 fTrackLength = 0;
271 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
272 fStopVertex = 0;
273
274 // Reset track parameters constrained to the primary vertex
c9ec41e8 275 fCp = 0;
9559cbc4 276 fCchi2 = 0;
277
278 // Reset track parameters at the inner wall of TPC
c9ec41e8 279 fIp = 0;
9559cbc4 280
281 // Reset track parameters at the inner wall of the TRD
c9ec41e8 282 fOp = 0;
9559cbc4 283
284 // Reset ITS track related information
285 fITSchi2 = 0;
286 for (Int_t i=0;i<12;i++) fITSchi2MIP[i] = 0;
287 fITSncls = 0;
288 for (Int_t i=0;i<6;i++) fITSindex[i]= 0;
289 fITSsignal = 0;
290 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]= 0;
291 fITSLabel = 0;
292 fITSFakeRatio = 0;
293 fITStrack =0;
294
295 // Reset TPC related track information
296 fTPCchi2 = 0;
297 fTPCncls = 0;
e1d4c1b5 298 fTPCnclsF = 0;
9559cbc4 299 for (Int_t i=0;i<180;i++) fTPCindex[i] = 0;
300 fTPCClusterMap = 0;
301 fTPCsignal= 0;
e1d4c1b5 302 fTPCsignalS= 0;
303 fTPCsignalN= 0;
9559cbc4 304 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=0;
305 fTPCLabel=0;
306 for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
307 for (Int_t i=0; i<3;i++) fKinkIndexes[i] = 0;
308 for (Int_t i=0; i<3;i++) fV0Indexes[i] = 0;
309
310 // Reset TRD related track information
311 fTRDchi2 = 0;
312 fTRDncls = 0;
313 fTRDncls0 = 0;
e1d4c1b5 314 for (Int_t i=0;i<180;i++) fTRDindex[i] = 0;
9559cbc4 315 fTRDsignal = 0;
316 for (Int_t i=0;i<kNPlane;i++) {
317 fTRDsignals[i] = 0;
318 fTRDTimBin[i] = 0;
319 }
320 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
321 fTRDLabel = 0;
322 fTRDtrack = 0;
323 fTRDQuality = 0;
23d49657 324 fTRDBudget = 0;
9559cbc4 325
326 // Reset TOF related track information
327 fTOFchi2 = 0;
328 fTOFindex = 0;
329 fTOFsignal = 0;
85324138 330 fTOFCalChannel = -1;
331 fTOFsignalToT = 0;
9559cbc4 332 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
333 for (Int_t i=0;i<3;i++) fTOFLabel[i] = 0;
334 for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
335
336 // Reset PHOS related track information
85c60a8e 337 //for (Int_t i=0;i<3;i++) fPHOSpos[i] = 0;
338 //fPHOSsignal = 0;
339 //for (Int_t i=0;i<AliPID::kSPECIESN;i++) fPHOSr[i] = 0;
340
9559cbc4 341 // Reset RICH related track information
342 fRICHchi2 = 0;
343 fRICHncls = 0;
344 fRICHindex = 0;
345 fRICHsignal = 0;
346 for (Int_t i=0;i<AliPID::kSPECIES;i++) fRICHr[i] = 0;
347 fRICHtheta = 0;
348 fRICHphi = 0;
349 fRICHdx = 0;
350 fRICHdy = 0;
351
98937d93 352 fPoints = 0;
9559cbc4 353}
354//_______________________________________________________________________
4a78b8c5 355Double_t AliESDtrack::GetMass() const {
4427806c 356 // Returns the mass of the most probable particle type
ae982df3 357 Float_t max=0.;
358 Int_t k=-1;
304864ab 359 for (Int_t i=0; i<AliPID::kSPECIES; i++) {
ae982df3 360 if (fR[i]>max) {k=i; max=fR[i];}
361 }
db3989b3 362 if (k==0) { // dE/dx "crossing points" in the TPC
363 Double_t p=GetP();
364 if ((p>0.38)&&(p<0.48))
304864ab 365 if (fR[0]<fR[3]*10.) return AliPID::ParticleMass(AliPID::kKaon);
db3989b3 366 if ((p>0.75)&&(p<0.85))
304864ab 367 if (fR[0]<fR[4]*10.) return AliPID::ParticleMass(AliPID::kProton);
db3989b3 368 return 0.00051;
369 }
304864ab 370 if (k==1) return AliPID::ParticleMass(AliPID::kMuon);
371 if (k==2||k==-1) return AliPID::ParticleMass(AliPID::kPion);
372 if (k==3) return AliPID::ParticleMass(AliPID::kKaon);
373 if (k==4) return AliPID::ParticleMass(AliPID::kProton);
5f7789fc 374 AliWarning("Undefined mass !");
304864ab 375 return AliPID::ParticleMass(AliPID::kPion);
ae982df3 376}
377
378//_______________________________________________________________________
c9ec41e8 379Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
ae982df3 380 //
381 // This function updates track's running parameters
382 //
15614b8b 383 Bool_t rc=kTRUE;
384
9b859005 385 SetStatus(flags);
386 fLabel=t->GetLabel();
387
388 if (t->IsStartedTimeIntegral()) {
389 SetStatus(kTIME);
390 Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
391 SetIntegratedLength(t->GetIntegratedLength());
392 }
393
c9ec41e8 394 Set(*t);
e1d4c1b5 395
ae982df3 396 switch (flags) {
ad2f1f2b 397
9b859005 398 case kITSin: case kITSout: case kITSrefit:
ae982df3 399 fITSncls=t->GetNumberOfClusters();
400 fITSchi2=t->GetChi2();
401 for (Int_t i=0;i<fITSncls;i++) fITSindex[i]=t->GetClusterIndex(i);
402 fITSsignal=t->GetPIDsignal();
6e5b1b04 403 fITSLabel = t->GetLabel();
babd135a 404 fITSFakeRatio = t->GetFakeRatio();
ae982df3 405 break;
ad2f1f2b 406
9b859005 407 case kTPCin: case kTPCrefit:
6e5b1b04 408 fTPCLabel = t->GetLabel();
c9ec41e8 409 if (!fIp) fIp=new AliExternalTrackParam(*t);
410 else fIp->Set(*t);
9b859005 411 case kTPCout:
1d303a24 412 if (flags & kTPCout){
413 if (!fOp) fOp=new AliExternalTrackParam(*t);
414 else fOp->Set(*t);
415 }
e1d4c1b5 416 fTPCncls=t->GetNumberOfClusters();
ae982df3 417 fTPCchi2=t->GetChi2();
a866ac60 418
419 {//prevrow must be declared in separate namespace, otherwise compiler cries:
420 //"jump to case label crosses initialization of `Int_t prevrow'"
421 Int_t prevrow = -1;
6e5b1b04 422 // for (Int_t i=0;i<fTPCncls;i++)
423 for (Int_t i=0;i<160;i++)
a866ac60 424 {
425 fTPCindex[i]=t->GetClusterIndex(i);
426
427 // Piotr's Cluster Map for HBT
428 // ### please change accordingly if cluster array is changing
429 // to "New TPC Tracking" style (with gaps in array)
430 Int_t idx = fTPCindex[i];
431 Int_t sect = (idx&0xff000000)>>24;
432 Int_t row = (idx&0x00ff0000)>>16;
433 if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
434
435 fTPCClusterMap.SetBitNumber(row,kTRUE);
436
437 //Fill the gap between previous row and this row with 0 bits
438 //In case ### pleas change it as well - just set bit 0 in case there
439 //is no associated clusters for current "i"
440 if (prevrow < 0)
441 {
442 prevrow = row;//if previous bit was not assigned yet == this is the first one
443 }
444 else
445 { //we don't know the order (inner to outer or reverse)
446 //just to be save in case it is going to change
447 Int_t n = 0, m = 0;
448 if (prevrow < row)
449 {
450 n = prevrow;
451 m = row;
452 }
453 else
454 {
455 n = row;
456 m = prevrow;
457 }
458
459 for (Int_t j = n+1; j < m; j++)
460 {
461 fTPCClusterMap.SetBitNumber(j,kFALSE);
462 }
463 prevrow = row;
464 }
465 // End Of Piotr's Cluster Map for HBT
466 }
467 }
ae982df3 468 fTPCsignal=t->GetPIDsignal();
ae982df3 469 break;
9b859005 470
23904d16 471 case kTRDout: case kTRDin: case kTRDrefit:
51ad6848 472 fTRDLabel = t->GetLabel();
79e94bf8 473 fTRDncls=t->GetNumberOfClusters();
474 fTRDchi2=t->GetChi2();
bb2ceb1f 475 for (Int_t i=0;i<fTRDncls;i++) fTRDindex[i]=t->GetClusterIndex(i);
79e94bf8 476 fTRDsignal=t->GetPIDsignal();
477 break;
c4d11b15 478 case kTRDbackup:
c9ec41e8 479 if (!fOp) fOp=new AliExternalTrackParam(*t);
480 else fOp->Set(*t);
c4d11b15 481 fTRDncls0 = t->GetNumberOfClusters();
482 break;
483 case kTOFin:
484 break;
485 case kTOFout:
486 break;
d0862fea 487 case kTRDStop:
488 break;
ae982df3 489 default:
5f7789fc 490 AliError("Wrong flag !");
ae982df3 491 return kFALSE;
492 }
493
15614b8b 494 return rc;
ae982df3 495}
496
497//_______________________________________________________________________
498void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
499 //---------------------------------------------------------------------
500 // This function returns external representation of the track parameters
501 //---------------------------------------------------------------------
c9ec41e8 502 x=GetX();
503 for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
15614b8b 504}
505
67c3dcbe 506//_______________________________________________________________________
a866ac60 507void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
67c3dcbe 508 //---------------------------------------------------------------------
509 // This function returns external representation of the cov. matrix
510 //---------------------------------------------------------------------
c9ec41e8 511 for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
67c3dcbe 512}
513
67c3dcbe 514//_______________________________________________________________________
c0b978f0 515Bool_t AliESDtrack::GetConstrainedExternalParameters
516 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
67c3dcbe 517 //---------------------------------------------------------------------
518 // This function returns the constrained external track parameters
519 //---------------------------------------------------------------------
c0b978f0 520 if (!fCp) return kFALSE;
521 alpha=fCp->GetAlpha();
c9ec41e8 522 x=fCp->GetX();
523 for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
c0b978f0 524 return kTRUE;
67c3dcbe 525}
c9ec41e8 526
67c3dcbe 527//_______________________________________________________________________
c0b978f0 528Bool_t
67c3dcbe 529AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
530 //---------------------------------------------------------------------
531 // This function returns the constrained external cov. matrix
532 //---------------------------------------------------------------------
c0b978f0 533 if (!fCp) return kFALSE;
c9ec41e8 534 for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
c0b978f0 535 return kTRUE;
67c3dcbe 536}
537
c0b978f0 538Bool_t
539AliESDtrack::GetInnerExternalParameters
540 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
541 //---------------------------------------------------------------------
c9ec41e8 542 // This function returns external representation of the track parameters
543 // at the inner layer of TPC
9b859005 544 //---------------------------------------------------------------------
c0b978f0 545 if (!fIp) return kFALSE;
546 alpha=fIp->GetAlpha();
c9ec41e8 547 x=fIp->GetX();
548 for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
c0b978f0 549 return kTRUE;
9b859005 550}
551
c0b978f0 552Bool_t
553AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const {
c9ec41e8 554 //---------------------------------------------------------------------
555 // This function returns external representation of the cov. matrix
556 // at the inner layer of TPC
557 //---------------------------------------------------------------------
c0b978f0 558 if (!fIp) return kFALSE;
c9ec41e8 559 for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
c0b978f0 560 return kTRUE;
9b859005 561}
562
c0b978f0 563Bool_t
564AliESDtrack::GetOuterExternalParameters
565 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
566 //---------------------------------------------------------------------
c9ec41e8 567 // This function returns external representation of the track parameters
568 // at the inner layer of TRD
a866ac60 569 //---------------------------------------------------------------------
c0b978f0 570 if (!fOp) return kFALSE;
571 alpha=fOp->GetAlpha();
c9ec41e8 572 x=fOp->GetX();
573 for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
c0b978f0 574 return kTRUE;
a866ac60 575}
c9ec41e8 576
c0b978f0 577Bool_t
578AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
a866ac60 579 //---------------------------------------------------------------------
c9ec41e8 580 // This function returns external representation of the cov. matrix
581 // at the inner layer of TRD
a866ac60 582 //---------------------------------------------------------------------
c0b978f0 583 if (!fOp) return kFALSE;
c9ec41e8 584 for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
c0b978f0 585 return kTRUE;
a866ac60 586}
587
98937d93 588Int_t AliESDtrack::GetNcls(Int_t idet) const
589{
590 // Get number of clusters by subdetector index
591 //
592 Int_t ncls = 0;
593 switch(idet){
594 case 0:
595 ncls = fITSncls;
596 break;
597 case 1:
598 ncls = fTPCncls;
599 break;
600 case 2:
601 ncls = fTRDncls;
602 break;
603 case 3:
604 if (fTOFindex != 0)
605 ncls = 1;
606 break;
607 default:
608 break;
609 }
610 return ncls;
611}
612
613Int_t AliESDtrack::GetClusters(Int_t idet, UInt_t *idx) const
614{
615 // Get cluster index array by subdetector index
616 //
617 Int_t ncls = 0;
618 switch(idet){
619 case 0:
620 ncls = GetITSclusters(idx);
621 break;
622 case 1:
623 ncls = GetTPCclusters((Int_t *)idx);
624 break;
625 case 2:
626 ncls = GetTRDclusters(idx);
627 break;
628 case 3:
629 if (fTOFindex != 0) {
630 idx[0] = GetTOFcluster();
631 ncls = 1;
632 }
633 break;
634 default:
635 break;
636 }
637 return ncls;
638}
639
ae982df3 640//_______________________________________________________________________
ae982df3 641void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
4427806c 642 // Returns the array with integrated times for each particle hypothesis
304864ab 643 for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
ae982df3 644}
645
646//_______________________________________________________________________
647void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
4427806c 648 // Sets the array with integrated times for each particle hypotesis
304864ab 649 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
ae982df3 650}
651
652//_______________________________________________________________________
4427806c 653void AliESDtrack::SetITSpid(const Double_t *p) {
654 // Sets values for the probability of each particle type (in ITS)
d27bbc79 655 SetPIDValues(fITSr,p,AliPID::kSPECIES);
c630aafd 656 SetStatus(AliESDtrack::kITSpid);
657}
658
babd135a 659void AliESDtrack::SetITSChi2MIP(const Float_t *chi2mip){
c4d11b15 660 for (Int_t i=0; i<12; i++) fITSchi2MIP[i]=chi2mip[i];
babd135a 661}
c630aafd 662//_______________________________________________________________________
663void AliESDtrack::GetITSpid(Double_t *p) const {
4427806c 664 // Gets the probability of each particle type (in ITS)
304864ab 665 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
c630aafd 666}
667
668//_______________________________________________________________________
ae982df3 669Int_t AliESDtrack::GetITSclusters(UInt_t *idx) const {
670 //---------------------------------------------------------------------
671 // This function returns indices of the assgined ITS clusters
672 //---------------------------------------------------------------------
673 for (Int_t i=0; i<fITSncls; i++) idx[i]=fITSindex[i];
674 return fITSncls;
675}
676
677//_______________________________________________________________________
05e445cd 678Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
ae982df3 679 //---------------------------------------------------------------------
680 // This function returns indices of the assgined ITS clusters
681 //---------------------------------------------------------------------
d1420ddf 682 if (idx!=0)
683 for (Int_t i=0; i<180; i++) idx[i]=fTPCindex[i]; // MI I prefer some constant
ae982df3 684 return fTPCncls;
685}
8c6a71ab 686
81e97e0d 687Float_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
688 //
689 // GetDensity of the clusters on given region between row0 and row1
690 // Dead zone effect takin into acoount
691 //
692 Int_t good = 0;
693 Int_t found = 0;
694 //
695 for (Int_t i=row0;i<=row1;i++){
696 Int_t index = fTPCindex[i];
697 if (index!=-1) good++; // track outside of dead zone
698 if (index>0) found++;
699 }
700 Float_t density=0.5;
701 if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
702 return density;
703}
c84a5e9e 704
8c6a71ab 705//_______________________________________________________________________
706void AliESDtrack::SetTPCpid(const Double_t *p) {
4427806c 707 // Sets values for the probability of each particle type (in TPC)
d27bbc79 708 SetPIDValues(fTPCr,p,AliPID::kSPECIES);
8c6a71ab 709 SetStatus(AliESDtrack::kTPCpid);
710}
711
712//_______________________________________________________________________
713void AliESDtrack::GetTPCpid(Double_t *p) const {
4427806c 714 // Gets the probability of each particle type (in TPC)
304864ab 715 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
8c6a71ab 716}
717
718//_______________________________________________________________________
bb2ceb1f 719Int_t AliESDtrack::GetTRDclusters(UInt_t *idx) const {
720 //---------------------------------------------------------------------
721 // This function returns indices of the assgined TRD clusters
722 //---------------------------------------------------------------------
d1420ddf 723 if (idx!=0)
e1d4c1b5 724 for (Int_t i=0; i<180; i++) idx[i]=fTRDindex[i]; // MI I prefer some constant
bb2ceb1f 725 return fTRDncls;
726}
727
728//_______________________________________________________________________
c630aafd 729void AliESDtrack::SetTRDpid(const Double_t *p) {
4427806c 730 // Sets values for the probability of each particle type (in TRD)
d27bbc79 731 SetPIDValues(fTRDr,p,AliPID::kSPECIES);
c630aafd 732 SetStatus(AliESDtrack::kTRDpid);
733}
734
735//_______________________________________________________________________
736void AliESDtrack::GetTRDpid(Double_t *p) const {
4427806c 737 // Gets the probability of each particle type (in TRD)
304864ab 738 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
c630aafd 739}
740
741//_______________________________________________________________________
79e94bf8 742void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
743{
4427806c 744 // Sets the probability of particle type iSpecies to p (in TRD)
79e94bf8 745 fTRDr[iSpecies] = p;
746}
747
748Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
749{
4427806c 750 // Returns the probability of particle type iSpecies (in TRD)
79e94bf8 751 return fTRDr[iSpecies];
752}
753
754//_______________________________________________________________________
c630aafd 755void AliESDtrack::SetTOFpid(const Double_t *p) {
4427806c 756 // Sets the probability of each particle type (in TOF)
d27bbc79 757 SetPIDValues(fTOFr,p,AliPID::kSPECIES);
c630aafd 758 SetStatus(AliESDtrack::kTOFpid);
759}
760
761//_______________________________________________________________________
51ad6848 762void AliESDtrack::SetTOFLabel(const Int_t *p) {
763 // Sets (in TOF)
764 for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
765}
766
767//_______________________________________________________________________
c630aafd 768void AliESDtrack::GetTOFpid(Double_t *p) const {
4427806c 769 // Gets probabilities of each particle type (in TOF)
304864ab 770 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
c630aafd 771}
772
51ad6848 773//_______________________________________________________________________
774void AliESDtrack::GetTOFLabel(Int_t *p) const {
775 // Gets (in TOF)
776 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
777}
778
779//_______________________________________________________________________
780void AliESDtrack::GetTOFInfo(Float_t *info) const {
781 // Gets (in TOF)
782 for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
783}
784
785//_______________________________________________________________________
786void AliESDtrack::SetTOFInfo(Float_t*info) {
787 // Gets (in TOF)
788 for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
789}
790
4a78b8c5 791
792
793//_______________________________________________________________________
4a78b8c5 794void AliESDtrack::SetRICHpid(const Double_t *p) {
795 // Sets the probability of each particle type (in RICH)
d27bbc79 796 SetPIDValues(fRICHr,p,AliPID::kSPECIES);
4a78b8c5 797 SetStatus(AliESDtrack::kRICHpid);
798}
799
800//_______________________________________________________________________
801void AliESDtrack::GetRICHpid(Double_t *p) const {
802 // Gets probabilities of each particle type (in RICH)
304864ab 803 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fRICHr[i];
4a78b8c5 804}
805
806
807
c630aafd 808//_______________________________________________________________________
8c6a71ab 809void AliESDtrack::SetESDpid(const Double_t *p) {
4427806c 810 // Sets the probability of each particle type for the ESD track
d27bbc79 811 SetPIDValues(fR,p,AliPID::kSPECIES);
8c6a71ab 812 SetStatus(AliESDtrack::kESDpid);
813}
814
815//_______________________________________________________________________
816void AliESDtrack::GetESDpid(Double_t *p) const {
4427806c 817 // Gets probability of each particle type for the ESD track
304864ab 818 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
8c6a71ab 819}
820
ac2f7574 821//_______________________________________________________________________
49d13e89 822Bool_t AliESDtrack::RelateToVertex
823(const AliESDVertex *vtx, Double_t b, Double_t maxd) {
824 //
825 // Try to relate this track to the vertex "vtx",
826 // if the (rough) transverse impact parameter is not bigger then "maxd".
827 // Magnetic field is "b" (kG).
828 //
829 // a) The track gets extapolated to the DCA to the vertex.
830 // b) The impact parameters and their covariance matrix are calculated.
831 // c) An attempt to constrain this track to the vertex is done.
832 //
833 // In the case of success, the returned value is kTRUE
834 // (otherwise, it's kFALSE)
835 //
836 Double_t alpha=GetAlpha();
837 Double_t sn=TMath::Sin(alpha), cs=TMath::Cos(alpha);
838 Double_t x=GetX(), y=GetParameter()[0], snp=GetParameter()[2];
839 Double_t xv= vtx->GetXv()*cs + vtx->GetYv()*sn;
840 Double_t yv=-vtx->GetXv()*sn + vtx->GetYv()*cs, zv=vtx->GetZv();
841 x-=xv; y-=yv;
842
843 //Estimate the impact parameter neglecting the track curvature
844 Double_t d=TMath::Abs(x*snp - y*TMath::Sqrt(1.- snp*snp));
845 if (d > maxd) return kFALSE;
846
847 //Propagate to the DCA
848 Double_t crv=0.299792458e-3*b*GetParameter()[4];
849 Double_t tgfv=-(crv*x - snp)/(crv*y + TMath::Sqrt(1.-snp*snp));
1d303a24 850 sn=tgfv/TMath::Sqrt(1.+ tgfv*tgfv); cs=TMath::Sqrt(1.- sn*sn);
49d13e89 851
852 x = xv*cs + yv*sn;
853 yv=-xv*sn + yv*cs; xv=x;
854
855 if (!Propagate(alpha+TMath::ASin(sn),xv,b)) return kFALSE;
856
857 fD = GetParameter()[0] - yv;
858 fZ = GetParameter()[1] - zv;
859
860 Double_t cov[6]; vtx->GetCovMatrix(cov);
861 fCdd = GetCovariance()[0] + cov[2]; // neglecting non-diagonals
862 fCdz = GetCovariance()[1]; // in the vertex's
863 fCzz = GetCovariance()[2] + cov[5]; // covariance matrix
864
865 {//Try to constrain
866 Double_t p[2]={yv,zv}, c[3]={cov[2],0.,cov[5]};
867 Double_t chi2=GetPredictedChi2(p,c);
868
869 if (chi2>77.) return kFALSE;
870
871 AliExternalTrackParam tmp(*this);
872 if (!tmp.Update(p,c)) return kFALSE;
873
874 fCchi2=chi2;
875 if (!fCp) fCp=new AliExternalTrackParam();
876 new (fCp) AliExternalTrackParam(tmp);
877 }
878
879 return kTRUE;
880}
881
882//_______________________________________________________________________
ac2f7574 883void AliESDtrack::Print(Option_t *) const {
884 // Prints info on the track
885
5f7789fc 886 printf("ESD track info\n") ;
304864ab 887 Double_t p[AliPID::kSPECIESN] ;
ac2f7574 888 Int_t index = 0 ;
889 if( IsOn(kITSpid) ){
890 printf("From ITS: ") ;
891 GetITSpid(p) ;
304864ab 892 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 893 printf("%f, ", p[index]) ;
894 printf("\n signal = %f\n", GetITSsignal()) ;
895 }
896 if( IsOn(kTPCpid) ){
897 printf("From TPC: ") ;
898 GetTPCpid(p) ;
304864ab 899 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 900 printf("%f, ", p[index]) ;
901 printf("\n signal = %f\n", GetTPCsignal()) ;
902 }
903 if( IsOn(kTRDpid) ){
904 printf("From TRD: ") ;
905 GetTRDpid(p) ;
304864ab 906 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 907 printf("%f, ", p[index]) ;
908 printf("\n signal = %f\n", GetTRDsignal()) ;
909 }
910 if( IsOn(kTOFpid) ){
911 printf("From TOF: ") ;
912 GetTOFpid(p) ;
304864ab 913 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 914 printf("%f, ", p[index]) ;
915 printf("\n signal = %f\n", GetTOFsignal()) ;
916 }
917 if( IsOn(kRICHpid) ){
038834e7 918 printf("From RICH: ") ;
ac2f7574 919 GetRICHpid(p) ;
304864ab 920 for(index = 0 ; index < AliPID::kSPECIES; index++)
ac2f7574 921 printf("%f, ", p[index]) ;
922 printf("\n signal = %f\n", GetRICHsignal()) ;
923 }
85c60a8e 924 // Since 9 March 2006 PHOS left ESDtrack for ESDCaloCluster
925 // and cannot participate in the global PID for the moment
926// if( IsOn(kPHOSpid) ){
927// printf("From PHOS: ") ;
928// GetPHOSpid(p) ;
929// for(index = 0 ; index < AliPID::kSPECIESN; index++)
930// printf("%f, ", p[index]) ;
931// printf("\n signal = %f\n", GetPHOSsignal()) ;
932// }
ac2f7574 933}