fix a memory leak coming from the TRD stand alone track finder (Markus)
[u/mrichter/AliRoot.git] / TRD / AliTRDtrackV1.cxx
CommitLineData
d9950a5a 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/* $Id$ */
17
eb38ed55 18#include "AliESDtrack.h"
41880fac 19#include "AliTracker.h"
eb38ed55 20
d9950a5a 21#include "AliTRDtrackV1.h"
22#include "AliTRDcluster.h"
23#include "AliTRDcalibDB.h"
3afdab72 24#include "AliTRDReconstructor.h"
d9950a5a 25#include "AliTRDrecoParam.h"
26
d9950a5a 27ClassImp(AliTRDtrackV1)
28
0906e73e 29///////////////////////////////////////////////////////////////////////////////
30// //
31// Represents a reconstructed TRD track //
32// Local TRD Kalman track //
33// //
34// Authors: //
35// Alex Bercuci <A.Bercuci@gsi.de> //
36// Markus Fasel <M.Fasel@gsi.de> //
37// //
38///////////////////////////////////////////////////////////////////////////////
d9950a5a 39
40//_______________________________________________________________
3b57a3f7 41AliTRDtrackV1::AliTRDtrackV1() : AliKalmanTrack()
42 ,fPIDquality(0)
43 ,fDE(0.)
44 ,fBackupTrack(0x0)
0906e73e 45{
d9950a5a 46 //
47 // Default constructor
48 //
6e49cfdb 49 //printf("AliTRDtrackV1::AliTRDtrackV1()\n");
e44586fb 50
3b57a3f7 51 for(int i =0; i<3; i++) fBudget[i] = 0.;
52
53 Float_t pid = 1./AliPID::kSPECIES;
54 for(int is =0; is<AliPID::kSPECIES; is++) fPID[is] = pid;
55
56 for(int ip=0; ip<kNplane; ip++){
57 fTrackletIndex[ip] = 0xffff;
58 fTracklet[ip] = 0x0;
59 }
d9950a5a 60}
61
62//_______________________________________________________________
3b57a3f7 63AliTRDtrackV1::AliTRDtrackV1(const AliTRDtrackV1 &ref) : AliKalmanTrack(ref)
64 ,fPIDquality(ref.fPIDquality)
65 ,fDE(ref.fDE)
66 ,fBackupTrack(0x0)
d9950a5a 67{
68 //
3b57a3f7 69 // Copy constructor
d9950a5a 70 //
71
6e49cfdb 72 //printf("AliTRDtrackV1::AliTRDtrackV1(const AliTRDtrackV1 &)\n");
29b87567 73 SetBit(kOwner, kFALSE);
3b57a3f7 74 for(int ip=0; ip<kNplane; ip++){
75 fTrackletIndex[ip] = ref.fTrackletIndex[ip];
76 fTracklet[ip] = ref.fTracklet[ip];
77 }
78
79 for (Int_t i = 0; i < 3;i++) fBudget[i] = ref.fBudget[i];
80
81 for(Int_t is = 0; is<AliPID::kSPECIES; is++) fPID[is] = ref.fPID[is];
82
83 AliKalmanTrack::SetNumberOfClusters(ref.GetNumberOfClusters());
d9950a5a 84}
85
86//_______________________________________________________________
3b57a3f7 87AliTRDtrackV1::AliTRDtrackV1(const AliESDtrack &t) : AliKalmanTrack()
88 ,fPIDquality(0)
89 ,fDE(0.)
90 ,fBackupTrack(0x0)
d9950a5a 91{
92 //
3b57a3f7 93 // Constructor from AliESDtrack
d9950a5a 94 //
95
3b57a3f7 96 SetLabel(t.GetLabel());
97 SetChi2(0.0);
98 SetMass(t.GetMass());
99 AliKalmanTrack::SetNumberOfClusters(t.GetTRDncls());
100 Int_t ti[kNplane]; t.GetTRDtracklets(&ti[0]);
101 for(int ip=0; ip<kNplane; ip++){
102 fTrackletIndex[ip] = ti[ip] < 0 ? 0xffff : ti[ip];
103 fTracklet[ip] = 0x0;
104 }
105 for(int i =0; i<3; i++) fBudget[i] = 0.;
106
107 Float_t pid = 1./AliPID::kSPECIES;
108 for(int is =0; is<AliPID::kSPECIES; is++) fPID[is] = pid;
109
110 const AliExternalTrackParam *par = &t;
111 if (t.GetStatus() & AliESDtrack::kTRDbackup) {
112 par = t.GetOuterParam();
113 if (!par) {
114 AliError("No backup info!");
115 par = &t;
116 }
117 }
118 Set(par->GetX()
119 ,par->GetAlpha()
120 ,par->GetParameter()
121 ,par->GetCovariance());
122
123 if(t.GetStatus() & AliESDtrack::kTIME) {
124 StartTimeIntegral();
125 Double_t times[10];
126 t.GetIntegratedTimes(times);
127 SetIntegratedTimes(times);
128 SetIntegratedLength(t.GetIntegratedLength());
129 }
d9950a5a 130}
131
132//_______________________________________________________________
eb38ed55 133AliTRDtrackV1::AliTRDtrackV1(AliTRDseedV1 *trklts, const Double_t p[5], const Double_t cov[15]
3b57a3f7 134 , Double_t x, Double_t alpha) : AliKalmanTrack()
135 ,fPIDquality(0)
136 ,fDE(0.)
137 ,fBackupTrack(0x0)
d9950a5a 138{
0906e73e 139 //
140 // The stand alone tracking constructor
141 // TEMPORARY !!!!!!!!!!!
142 // to check :
143 // 1. covariance matrix
144 // 2. dQdl calculation
145 //
d9950a5a 146
fb17de1f 147 Double_t cnv = GetBz() < 1.e-5 ? 1.e5 : 1.0 / (GetBz() * kB2C);
148 // Double_t cnv = 1.0 / (GetBz() * kB2C);
d9950a5a 149
150 Double_t pp[5] = { p[0]
151 , p[1]
e44586fb 152 , x*p[4] - p[2]
d9950a5a 153 , p[3]
154 , p[4]*cnv };
155
156 Double_t c22 = x*x*cov[14] - 2*x*cov[12] + cov[ 5];
157 Double_t c32 = x*cov[13] - cov[ 8];
158 Double_t c20 = x*cov[10] - cov[ 3];
159 Double_t c21 = x*cov[11] - cov[ 4];
160 Double_t c42 = x*cov[14] - cov[12];
161
162 Double_t cc[15] = { cov[ 0]
163 , cov[ 1], cov[ 2]
164 , c20, c21, c22
165 , cov[ 6], cov[ 7], c32, cov[ 9]
166 , cov[10]*cnv, cov[11]*cnv, c42*cnv, cov[13]*cnv, cov[14]*cnv*cnv };
ae3fbe1f 167
168 Double_t mostProbablePt=AliExternalTrackParam::GetMostProbablePt();
169 Double_t p0=TMath::Sign(1/mostProbablePt,pp[4]);
170 Double_t w0=cc[14]/(cc[14] + p0*p0), w1=p0*p0/(cc[14] + p0*p0);
171 pp[4] = w0*p0 + w1*pp[4];
172 cc[10]*=w1; cc[11]*=w1; cc[12]*=w1; cc[13]*=w1; cc[14]*=w1;
173
d9950a5a 174 Set(x,alpha,pp,cc);
41702fec 175 Int_t ncls = 0;
3b57a3f7 176 for(int iplane=0; iplane<kNplane; iplane++){
41702fec 177 fTrackletIndex[iplane] = 0xffff;
178 if(!trklts[iplane].IsOK()) fTracklet[iplane] = 0x0;
179 else{
180 fTracklet[iplane] = new AliTRDseedV1(trklts[iplane]);
181 ncls += fTracklet[iplane]->GetN();
182 }
d9950a5a 183 }
41702fec 184 AliKalmanTrack::SetNumberOfClusters(ncls);
185 for(int i =0; i<3; i++) fBudget[i] = 0.;
186
187 Float_t pid = 1./AliPID::kSPECIES;
188 for(int is =0; is<AliPID::kSPECIES; is++) fPID[is] = pid;
189
d9950a5a 190}
191
192//_______________________________________________________________
3b57a3f7 193AliTRDtrackV1::~AliTRDtrackV1()
bb56afff 194{
e44586fb 195 //AliInfo("");
6e49cfdb 196 //printf("I-AliTRDtrackV1::~AliTRDtrackV1() : Owner[%s]\n", TestBit(kOwner)?"YES":"NO");
3b57a3f7 197 if(fBackupTrack) {
198 delete fBackupTrack;
199 }
200 fBackupTrack = 0x0;
bb56afff 201
e44586fb 202 if(TestBit(kOwner)){
3b57a3f7 203 for(Int_t ip=0; ip<kNplane; ip++){
204 if(fTracklet[ip]) delete fTracklet[ip];
205 fTracklet[ip] = 0x0;
206 }
207 }
208}
209
210//_______________________________________________________________
211Bool_t AliTRDtrackV1::CookLabel(Float_t wrong)
212{
213 // set MC label for this track
214
bb56afff 215 Int_t s[kMAXCLUSTERSPERTRACK][2];
216 for (Int_t i = 0; i < kMAXCLUSTERSPERTRACK; i++) {
217 s[i][0] = -1;
218 s[i][1] = 0;
219 }
3b57a3f7 220
bb56afff 221 Bool_t labelAdded;
3b57a3f7 222 Int_t label;
223 AliTRDcluster *c = 0x0;
224 for (Int_t ip = 0; ip < kNplane; ip++) {
225 if(fTrackletIndex[ip] == 0xffff) continue;
226 for (Int_t ic = 0; ic < AliTRDseed::knTimebins; ic++) {
227 if(!(c = fTracklet[ip]->GetClusters(ic))) continue;
228 for (Int_t k = 0; k < 3; k++) {
229 label = c->GetLabel(k);
230 labelAdded = kFALSE;
231 Int_t j = 0;
232 if (label >= 0) {
233 while ((!labelAdded) && (j < kMAXCLUSTERSPERTRACK)) {
234 if ((s[j][0] == label) ||
235 (s[j][1] == 0)) {
236 s[j][0] = label;
237 s[j][1]++;
238 labelAdded = kTRUE;
239 }
240 j++;
241 }
242 }
243 }
244 }
245 }
246
bb56afff 247 Int_t max = 0;
248 label = -123456789;
249 for (Int_t i = 0; i < kMAXCLUSTERSPERTRACK; i++) {
250 if (s[i][1] <= max) continue;
3b57a3f7 251 max = s[i][1];
252 label = s[i][0];
bb56afff 253 }
3b57a3f7 254
bb56afff 255 if ((1. - Float_t(max)/GetNumberOfClusters()) > wrong) label = -label;
3b57a3f7 256
bb56afff 257 SetLabel(label);
3b57a3f7 258
259 return kTRUE;
bb56afff 260}
261
262//_______________________________________________________________
d9950a5a 263Bool_t AliTRDtrackV1::CookPID()
264{
0906e73e 265 //
266 // Cook the PID information
267 //
3b57a3f7 268
269 // Reset the a priori probabilities
270 Double_t pid = 1. / AliPID::kSPECIES;
0906e73e 271 for(int ispec=0; ispec<AliPID::kSPECIES; ispec++) {
3b57a3f7 272 fPID[ispec] = pid;
273 }
274 fPIDquality = 0;
275
276 // steer PID calculation @ tracklet level
277 Double_t *prob = 0x0;
278 for(int ip=0; ip<kNplane; ip++){
279 if(fTrackletIndex[ip] == 0xffff) continue;
280 if(!fTracklet[ip]->IsOK()) continue;
281 if(!(prob = fTracklet[ip]->GetProbability())) return kFALSE;
282
283 Int_t nspec = 0; // quality check of tracklet dEdx
284 for(int ispec=0; ispec<AliPID::kSPECIES; ispec++){
285 if(prob[ispec] < 0.) continue;
286 fPID[ispec] *= prob[ispec];
287 nspec++;
288 }
289 if(!nspec) continue;
290
291 fPIDquality++;
0906e73e 292 }
0906e73e 293
294 // no tracklet found for PID calculations
295 if(!fPIDquality) return kTRUE;
3b57a3f7 296
297 // slot for PID calculation @ track level
298
299
0906e73e 300 // normalize probabilities
301 Double_t probTotal = 0.0;
302 for (Int_t is = 0; is < AliPID::kSPECIES; is++) probTotal += fPID[is];
3b57a3f7 303
304
0906e73e 305 if (probTotal <= 0.0) {
306 AliWarning("The total probability over all species <= 0. This may be caused by some error in the reference data.");
d9950a5a 307 return kFALSE;
308 }
3b57a3f7 309
0906e73e 310 for (Int_t iSpecies = 0; iSpecies < AliPID::kSPECIES; iSpecies++) fPID[iSpecies] /= probTotal;
3b57a3f7 311
0906e73e 312 return kTRUE;
d9950a5a 313}
314
3b57a3f7 315//_____________________________________________________________________________
316Double_t AliTRDtrackV1::GetBz() const
0906e73e 317{
318 //
3b57a3f7 319 // Returns Bz component of the magnetic field (kG)
0906e73e 320 //
321
3b57a3f7 322 if (AliTracker::UniformField()) return AliTracker::GetBz();
323
324 Double_t r[3];
325 GetXYZ(r);
326 return AliTracker::GetBz(r);
327}
328
329//_______________________________________________________________
330Int_t AliTRDtrackV1::GetClusterIndex(Int_t id) const
331{
332 Int_t n = 0;
333 for(Int_t ip=0; ip<kNplane; ip++){
334 if(!fTracklet[ip]) continue;
335 if(n+fTracklet[ip]->GetN() < id){
336 n+=fTracklet[ip]->GetN();
337 continue;
338 }
339 for(Int_t ic=34; ic>=0; ic--){
340 if(!fTracklet[ip]->GetClusters(ic)) continue;
341 n++;
342 if(n<id) continue;
343 return fTracklet[ip]->GetIndexes(ic);
344 }
345 }
346 return -1;
0906e73e 347}
d9950a5a 348
349//_______________________________________________________________
350Double_t AliTRDtrackV1::GetPredictedChi2(const AliTRDseedV1 *trklt) const
351{
352 //
0906e73e 353 // Get the predicted chi2
d9950a5a 354 //
3b57a3f7 355
d9950a5a 356 Double_t x = trklt->GetX0();
357 Double_t p[2] = { trklt->GetYat(x)
358 , trklt->GetZat(x) };
359 Double_t cov[3];
3b57a3f7 360 trklt->GetCovAt(x, cov);
361
d9950a5a 362 return AliExternalTrackParam::GetPredictedChi2(p, cov);
3b57a3f7 363}
d9950a5a 364
3b57a3f7 365
366//_____________________________________________________________________________
367void AliTRDtrackV1::MakeBackupTrack()
368{
369 //
370 // Creates a backup track
371 //
372
373 if(fBackupTrack) {
374 fBackupTrack->~AliTRDtrackV1();
375 new(fBackupTrack) AliTRDtrackV1((AliTRDtrackV1&)(*this));
592fdd48 376 return;
3b57a3f7 377 }
378 fBackupTrack = new AliTRDtrackV1((AliTRDtrackV1&)(*this));
d9950a5a 379}
380
3b57a3f7 381//_____________________________________________________________________________
382Int_t AliTRDtrackV1::GetProlongation(Double_t xk, Double_t &y, Double_t &z)
383{
384 //
385 // Find a prolongation at given x
386 // Return 0 if it does not exist
387 //
388
389 Double_t bz = GetBz();
390 if (!AliExternalTrackParam::GetYAt(xk,bz,y)) return 0;
391 if (!AliExternalTrackParam::GetZAt(xk,bz,z)) return 0;
392
393 return 1;
394
395}
396
397//_____________________________________________________________________________
398Bool_t AliTRDtrackV1::PropagateTo(Double_t xk, Double_t xx0, Double_t xrho)
0906e73e 399{
400 //
3b57a3f7 401 // Propagates this track to a reference plane defined by "xk" [cm]
402 // correcting for the mean crossed material.
0906e73e 403 //
3b57a3f7 404 // "xx0" - thickness/rad.length [units of the radiation length]
405 // "xrho" - thickness*density [g/cm^2]
406 //
0906e73e 407
3b57a3f7 408 if (xk == GetX()) {
409 return kTRUE;
410 }
411
412 Double_t oldX = GetX();
413 Double_t oldY = GetY();
414 Double_t oldZ = GetZ();
415
416 Double_t bz = GetBz();
417
418 if (!AliExternalTrackParam::PropagateTo(xk,bz)) {
419 return kFALSE;
420 }
421
422 Double_t x = GetX();
423 Double_t y = GetY();
424 Double_t z = GetZ();
425
426 if (oldX < xk) {
427 xrho = -xrho;
428 if (IsStartedTimeIntegral()) {
429 Double_t l2 = TMath::Sqrt((x-oldX)*(x-oldX)
430 + (y-oldY)*(y-oldY)
431 + (z-oldZ)*(z-oldZ));
432 Double_t crv = AliExternalTrackParam::GetC(bz);
433 if (TMath::Abs(l2*crv) > 0.0001) {
434 // Make correction for curvature if neccesary
435 l2 = 0.5 * TMath::Sqrt((x-oldX)*(x-oldX)
436 + (y-oldY)*(y-oldY));
437 l2 = 2.0 * TMath::ASin(l2 * crv) / crv;
438 l2 = TMath::Sqrt(l2*l2 + (z-oldZ)*(z-oldZ));
439 }
440 AddTimeStep(l2);
441 }
442 }
443
444 if (!AliExternalTrackParam::CorrectForMeanMaterial(xx0,xrho,GetMass())) {
445 return kFALSE;
446 }
447
448 {
449
450 // Energy losses
451 Double_t p2 = (1.0 + GetTgl()*GetTgl()) / (GetSigned1Pt()*GetSigned1Pt());
452 Double_t beta2 = p2 / (p2 + GetMass()*GetMass());
453 if ((beta2 < 1.0e-10) ||
454 ((5940.0 * beta2/(1.0 - beta2 + 1.0e-10) - beta2) < 0.0)) {
455 return kFALSE;
456 }
457
458 Double_t dE = 0.153e-3 / beta2
459 * (TMath::Log(5940.0 * beta2/(1.0 - beta2 + 1.0e-10)) - beta2)
460 * xrho;
461 fBudget[0] += xrho;
462
463 /*
464 // Suspicious part - think about it ?
465 Double_t kinE = TMath::Sqrt(p2);
466 if (dE > 0.8*kinE) dE = 0.8 * kinE; //
467 if (dE < 0) dE = 0.0; // Not valid region for Bethe bloch
468 */
469
470 fDE += dE;
471
472 /*
473 // Suspicious ! I.B.
474 Double_t sigmade = 0.07 * TMath::Sqrt(TMath::Abs(dE)); // Energy loss fluctuation
475 Double_t sigmac2 = sigmade*sigmade*fC*fC*(p2+GetMass()*GetMass())/(p2*p2);
476 fCcc += sigmac2;
477 fCee += fX*fX * sigmac2;
478 */
479
480 }
481
482 return kTRUE;
0906e73e 483}
3b57a3f7 484
87a7fa94 485//_____________________________________________________________________________
3b57a3f7 486Int_t AliTRDtrackV1::PropagateToR(Double_t r,Double_t step)
87a7fa94 487{
488 //
3b57a3f7 489 // Propagate track to the radial position
490 // Rotation always connected to the last track position
87a7fa94 491 //
492
3b57a3f7 493 Double_t xyz0[3];
494 Double_t xyz1[3];
495 Double_t y;
496 Double_t z;
497
498 Double_t radius = TMath::Sqrt(GetX()*GetX() + GetY()*GetY());
499 // Direction +-
500 Double_t dir = (radius > r) ? -1.0 : 1.0;
501
502 for (Double_t x = radius+dir*step; dir*x < dir*r; x += dir*step) {
503
504 GetXYZ(xyz0);
505 Double_t alpha = TMath::ATan2(xyz0[1],xyz0[0]);
506 Rotate(alpha,kTRUE);
507 GetXYZ(xyz0);
508 GetProlongation(x,y,z);
509 xyz1[0] = x * TMath::Cos(alpha) + y * TMath::Sin(alpha);
510 xyz1[1] = x * TMath::Sin(alpha) - y * TMath::Cos(alpha);
511 xyz1[2] = z;
512 Double_t param[7];
513 AliTracker::MeanMaterialBudget(xyz0,xyz1,param);
514 if (param[1] <= 0) {
515 param[1] = 100000000;
516 }
517 PropagateTo(x,param[1],param[0]*param[4]);
518
519 }
520
521 GetXYZ(xyz0);
522 Double_t alpha = TMath::ATan2(xyz0[1],xyz0[0]);
523 Rotate(alpha,kTRUE);
524 GetXYZ(xyz0);
525 GetProlongation(r,y,z);
526 xyz1[0] = r * TMath::Cos(alpha) + y * TMath::Sin(alpha);
527 xyz1[1] = r * TMath::Sin(alpha) - y * TMath::Cos(alpha);
528 xyz1[2] = z;
529 Double_t param[7];
530 AliTracker::MeanMaterialBudget(xyz0,xyz1,param);
531
532 if (param[1] <= 0) {
533 param[1] = 100000000;
87a7fa94 534 }
3b57a3f7 535 PropagateTo(r,param[1],param[0]*param[4]);
536
537 return 0;
538
87a7fa94 539}
540
3b57a3f7 541//_____________________________________________________________________________
542Bool_t AliTRDtrackV1::Rotate(Double_t alpha, Bool_t absolute)
543{
544 //
545 // Rotates track parameters in R*phi plane
546 // if absolute rotation alpha is in global system
547 // otherwise alpha rotation is relative to the current rotation angle
548 //
549
550 if (absolute) alpha -= GetAlpha();
551 //else fNRotate++;
552
553 return AliExternalTrackParam::Rotate(GetAlpha()+alpha);
554}
87a7fa94 555
eb38ed55 556//___________________________________________________________
557void AliTRDtrackV1::SetNumberOfClusters()
558{
559// Calculate the number of clusters attached to this track
560
3b57a3f7 561 Int_t ncls = 0;
562 for(int ip=0; ip<kNplane; ip++){
563 if(fTracklet[ip] && fTrackletIndex[ip] != 0xffff) ncls += fTracklet[ip]->GetN();
564 }
565 AliKalmanTrack::SetNumberOfClusters(ncls);
eb38ed55 566}
567
568
0906e73e 569//_______________________________________________________________
3b57a3f7 570void AliTRDtrackV1::SetOwner()
0906e73e 571{
572 //
573 // Toggle ownership of tracklets
574 //
575
e44586fb 576 if(TestBit(kOwner)) return;
3b57a3f7 577 for (Int_t ip = 0; ip < kNplane; ip++) {
578 if(fTrackletIndex[ip] == 0xffff) continue;
579 fTracklet[ip] = new AliTRDseedV1(*fTracklet[ip]);
580 fTracklet[ip]->SetOwner();
581 }
e44586fb 582 SetBit(kOwner);
0906e73e 583}
584
585//_______________________________________________________________
3b57a3f7 586void AliTRDtrackV1::SetTracklet(AliTRDseedV1 *trklt, Int_t index)
d9950a5a 587{
588 //
0906e73e 589 // Set the tracklets
d9950a5a 590 //
3b57a3f7 591 Int_t plane = trklt->GetPlane();
41702fec 592 if(fTrackletIndex[plane]==0xffff && fTracklet[plane]){
593 delete fTracklet[plane];
594 }
3b57a3f7 595 fTracklet[plane] = trklt;
596 fTrackletIndex[plane] = index;
d9950a5a 597}
598
599//_______________________________________________________________
181d2c97 600void AliTRDtrackV1::UnsetTracklet(Int_t plane)
601{
602 if(plane<0 && plane >= kNplane) return;
603 fTrackletIndex[plane] = 0xffff;
604 fTracklet[plane] = 0x0;
605}
606
607
608//_______________________________________________________________
0906e73e 609Bool_t AliTRDtrackV1::Update(AliTRDseedV1 *trklt, Double_t chisq)
d9950a5a 610{
611 //
3b57a3f7 612 // Update track and tracklet parameters
d9950a5a 613 //
3b57a3f7 614
0906e73e 615 Double_t x = trklt->GetX0();
d9950a5a 616 Double_t p[2] = { trklt->GetYat(x)
617 , trklt->GetZat(x) };
618 Double_t cov[3];
3b57a3f7 619 trklt->GetCovAt(x, cov);
620
d9950a5a 621 if(!AliExternalTrackParam::Update(p, cov)) return kFALSE;
3b57a3f7 622
623 AliTRDcluster *c = 0x0;
624 Int_t ic = 0; while(!(c = trklt->GetClusters(ic))) ic++;
625 AliTracker::FillResiduals(this, p, cov, c->GetVolumeId());
626
627
d9950a5a 628 // Register info to track
3b57a3f7 629 SetNumberOfClusters();
d9950a5a 630 SetChi2(GetChi2() + chisq);
3b57a3f7 631
632 // update tracklet
633 trklt->SetMomentum(GetP());
634 trklt->SetSnp(GetSnp());
635 trklt->SetTgl(GetTgl());
636 return kTRUE;
d9950a5a 637}
638
639//_______________________________________________________________
0906e73e 640void AliTRDtrackV1::UpdateESDtrack(AliESDtrack *track)
d9950a5a 641{
642 //
6984f7c1 643 // Update the TRD PID information in the ESD track
d9950a5a 644 //
6984f7c1 645
646 track->SetNumberOfTRDslices(kNslice);
3b57a3f7 647
6984f7c1 648 for (Int_t ip = 0; ip < kNplane; ip++) {
3b57a3f7 649 if(fTrackletIndex[ip] == 0xffff) continue;
650 fTracklet[ip]->CookdEdx(kNslice);
651 Float_t *dedx = fTracklet[ip]->GetdEdx();
652 for (Int_t js = 0; js < kNslice; js++) track->SetTRDslice(dedx[js], ip, js);
6984f7c1 653 }
0906e73e 654
6984f7c1 655 // copy PID to ESD
c04438f1 656 if(!fPIDquality) return;
6984f7c1 657 track->SetTRDpid(fPID);
658 track->SetTRDpidQuality(fPIDquality);
d9950a5a 659}