Updates to get jobs running on the grid
[u/mrichter/AliRoot.git] / ITS / AliITStrackV2.cxx
CommitLineData
006b5f7f 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
ae00569a 16/* $Id$ */
17
66e811e2 18///////////////////////////////////////////////////////////////////////////
006b5f7f 19// Implementation of the ITS track class
20//
21// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
a9a2d814 22// dEdx analysis by: Boris Batyunya, JINR, Boris.Batiounia@cern.ch
66e811e2 23///////////////////////////////////////////////////////////////////////////
006b5f7f 24#include <TMath.h>
006b5f7f 25
26#include "AliCluster.h"
58e536c5 27#include "AliESDVertex.h"
8a84886c 28#include "AliITSReconstructor.h"
006b5f7f 29#include "AliITStrackV2.h"
f7a1cc68 30#include "AliTracker.h"
006b5f7f 31
8602c008 32const Int_t AliITStrackV2::fgkWARN = 5;
33
1aedd96e 34ClassImp(AliITStrackV2)
8676d691 35
e43c066c 36
006b5f7f 37//____________________________________________________________________________
6c94f330 38AliITStrackV2::AliITStrackV2() : AliKalmanTrack(),
545af9ef 39 fCheckInvariant(kTRUE),
22b13da0 40 fdEdx(0),
83d73500 41 fESDtrack(0)
e43c066c 42{
ae00569a 43 for(Int_t i=0; i<2*AliITSgeomTGeo::kNLayers; i++) {fIndex[i]=-1; fModule[i]=-1;}
25015f7a 44 for(Int_t i=0; i<AliITSgeomTGeo::kNLayers; i++) {fSharedWeight[i]=0;}
ae00569a 45 for(Int_t i=0; i<4; i++) fdEdxSample[i]=0;
e43c066c 46}
47
83d73500 48
22b13da0 49//____________________________________________________________________________
763bdf3e 50AliITStrackV2::AliITStrackV2(AliESDtrack& t,Bool_t c):
6c94f330 51 AliKalmanTrack(),
545af9ef 52 fCheckInvariant(kTRUE),
6c94f330 53 fdEdx(t.GetITSsignal()),
54 fESDtrack(&t)
55{
83d73500 56 //------------------------------------------------------------------
67c3dcbe 57 // Conversion ESD track -> ITS track.
58 // If c==kTRUE, create the ITS track out of the constrained params.
83d73500 59 //------------------------------------------------------------------
6c94f330 60 const AliExternalTrackParam *par=&t;
61 if (c) {
6c4ef2ed 62 par=t.GetConstrainedParam();
763bdf3e 63 if (!par) AliError("AliITStrackV2: conversion failed !\n");
6c94f330 64 }
65 Set(par->GetX(),par->GetAlpha(),par->GetParameter(),par->GetCovariance());
66
83d73500 67 SetLabel(t.GetLabel());
68 SetMass(t.GetMass());
6c94f330 69 SetNumberOfClusters(t.GetITSclusters(fIndex));
006b5f7f 70
83d73500 71 if (t.GetStatus()&AliESDtrack::kTIME) {
72 StartTimeIntegral();
73 Double_t times[10]; t.GetIntegratedTimes(times); SetIntegratedTimes(times);
74 SetIntegratedLength(t.GetIntegratedLength());
75 }
e43c066c 76
25015f7a 77 for(Int_t i=0; i<AliITSgeomTGeo::kNLayers; i++) {fSharedWeight[i]=0;}
68b8060b 78 for(Int_t i=0; i<4; i++) fdEdxSample[i]=0;
006b5f7f 79}
80
7ac23097 81//____________________________________________________________________________
82void AliITStrackV2::ResetClusters() {
83 //------------------------------------------------------------------
84 // Reset the array of attached clusters.
85 //------------------------------------------------------------------
86 for (Int_t i=0; i<2*AliITSgeomTGeo::kNLayers; i++) fIndex[i]=-1;
25015f7a 87 for (Int_t i=0; i<AliITSgeomTGeo::kNLayers; i++) {fSharedWeight[i]=0;}
7ac23097 88 SetChi2(0.);
89 SetNumberOfClusters(0);
90}
91
09cf9d66 92//____________________________________________________________________________
15dd636f 93void AliITStrackV2::UpdateESDtrack(ULong_t flags) const {
09cf9d66 94 // Update track params
83d73500 95 fESDtrack->UpdateTrackParams(this,flags);
ae00569a 96 // copy the module indices
25015f7a 97 Int_t i;
98 for(i=0;i<2*AliITSgeomTGeo::kNLayers;i++) {
ae00569a 99 // printf(" %d\n",GetModuleIndex(i));
100 fESDtrack->SetITSModuleIndex(i,GetModuleIndex(i));
101 }
25015f7a 102 // copy the map of shared clusters
103 if(flags==AliESDtrack::kITSin) {
104 UChar_t itsSharedMap=0;
105 for(i=0;i<AliITSgeomTGeo::kNLayers;i++) {
106 if(fSharedWeight[i]>0) {SETBIT(itsSharedMap,i);printf("UpdateESD: l %d\n",i);}
107
108 }
109 fESDtrack->SetITSSharedMap(itsSharedMap);
110 }
111 for(i=0;i<6;i++) if(fESDtrack->HasSharedPointOnITSLayer(i)) printf("shared on %d\n",i);
112
09cf9d66 113 // copy the 4 dedx samples
114 Double_t sdedx[4]={0.,0.,0.,0.};
25015f7a 115 for(i=0; i<4; i++) sdedx[i]=fdEdxSample[i];
09cf9d66 116 fESDtrack->SetITSdEdxSamples(sdedx);
83d73500 117}
118
006b5f7f 119//____________________________________________________________________________
6c94f330 120AliITStrackV2::AliITStrackV2(const AliITStrackV2& t) :
121 AliKalmanTrack(t),
545af9ef 122 fCheckInvariant(t.fCheckInvariant),
6c94f330 123 fdEdx(t.fdEdx),
124 fESDtrack(t.fESDtrack)
125{
006b5f7f 126 //------------------------------------------------------------------
127 //Copy constructor
128 //------------------------------------------------------------------
ef7253ac 129 Int_t i;
ef7253ac 130 for (i=0; i<4; i++) fdEdxSample[i]=t.fdEdxSample[i];
ae00569a 131 for (i=0; i<2*AliITSgeomTGeo::GetNLayers(); i++) {
132 fIndex[i]=t.fIndex[i];
133 fModule[i]=t.fModule[i];
134 }
25015f7a 135 for (i=0; i<AliITSgeomTGeo::kNLayers; i++) {fSharedWeight[i]=t.fSharedWeight[i];}
006b5f7f 136}
a9a2d814 137
006b5f7f 138//_____________________________________________________________________________
139Int_t AliITStrackV2::Compare(const TObject *o) const {
140 //-----------------------------------------------------------------
141 // This function compares tracks according to the their curvature
142 //-----------------------------------------------------------------
7f6ddf58 143 AliITStrackV2 *t=(AliITStrackV2*)o;
6c23ffed 144 //Double_t co=OneOverPt();
145 //Double_t c =OneOverPt();
15dd636f 146 Double_t co=t->GetSigmaY2()*t->GetSigmaZ2();
147 Double_t c =GetSigmaY2()*GetSigmaZ2();
006b5f7f 148 if (c>co) return 1;
149 else if (c<co) return -1;
150 return 0;
151}
152
006b5f7f 153//____________________________________________________________________________
6c94f330 154Bool_t
155AliITStrackV2::PropagateToVertex(const AliESDVertex *v,Double_t d,Double_t x0)
156{
006b5f7f 157 //------------------------------------------------------------------
158 //This function propagates a track to the minimal distance from the origin
6c94f330 159 //------------------------------------------------------------------
160 Double_t bz=GetBz();
e50912db 161 if (PropagateToDCA(v,bz,kVeryBig)) {
162 Double_t xOverX0,xTimesRho;
163 xOverX0 = d; xTimesRho = d*x0;
164 if (CorrectForMeanMaterial(xOverX0,xTimesRho,kTRUE)) return kTRUE;
165 }
6c94f330 166 return kFALSE;
006b5f7f 167}
168
169//____________________________________________________________________________
6c94f330 170Bool_t AliITStrackV2::
e50912db 171GetGlobalXYZat(Double_t xloc, Double_t &x, Double_t &y, Double_t &z) const {
006b5f7f 172 //------------------------------------------------------------------
173 //This function returns a track position in the global system
174 //------------------------------------------------------------------
6c94f330 175 Double_t r[3];
f7a1cc68 176 Bool_t rc=GetXYZAt(xloc, GetBz(), r);
6c94f330 177 x=r[0]; y=r[1]; z=r[2];
178 return rc;
006b5f7f 179}
180
181//_____________________________________________________________________________
6c94f330 182Double_t AliITStrackV2::GetPredictedChi2(const AliCluster *c) const {
006b5f7f 183 //-----------------------------------------------------------------
184 // This function calculates a predicted chi2 increment.
185 //-----------------------------------------------------------------
6c94f330 186 Double_t p[2]={c->GetY(), c->GetZ()};
187 Double_t cov[3]={c->GetSigmaY2(), 0., c->GetSigmaZ2()};
188 return AliExternalTrackParam::GetPredictedChi2(p,cov);
a9a2d814 189}
190
191//____________________________________________________________________________
6c94f330 192Bool_t AliITStrackV2::PropagateTo(Double_t xk, Double_t d, Double_t x0) {
006b5f7f 193 //------------------------------------------------------------------
194 //This function propagates a track
195 //------------------------------------------------------------------
afd25725 196
6c94f330 197 Double_t oldX=GetX(), oldY=GetY(), oldZ=GetZ();
006b5f7f 198
1defa402 199 //Double_t bz=GetBz();
200 //if (!AliExternalTrackParam::PropagateTo(xk,bz)) return kFALSE;
201 Double_t b[3]; GetBxByBz(b);
202 if (!AliExternalTrackParam::PropagateToBxByBz(xk,b)) return kFALSE;
e50912db 203 Double_t xOverX0,xTimesRho;
204 xOverX0 = d; xTimesRho = d*x0;
205 if (!CorrectForMeanMaterial(xOverX0,xTimesRho,kTRUE)) return kFALSE;
006b5f7f 206
dd44614b 207 Double_t x=GetX(), y=GetY(), z=GetZ();
6c94f330 208 if (IsStartedTimeIntegral() && x>oldX) {
209 Double_t l2 = (x-oldX)*(x-oldX) + (y-oldY)*(y-oldY) + (z-oldZ)*(z-oldZ);
f29dbb4b 210 AddTimeStep(TMath::Sqrt(l2));
211 }
f29dbb4b 212
6c94f330 213 return kTRUE;
006b5f7f 214}
215
216//____________________________________________________________________________
db355ee7 217Bool_t AliITStrackV2::PropagateToTGeo(Double_t xToGo, Int_t nstep, Double_t &xOverX0, Double_t &xTimesRho, Bool_t addTime) {
afd25725 218 //-------------------------------------------------------------------
219 // Propagates the track to a reference plane x=xToGo in n steps.
220 // These n steps are only used to take into account the curvature.
221 // The material is calculated with TGeo. (L.Gaudichet)
222 //-------------------------------------------------------------------
223
224 Double_t startx = GetX(), starty = GetY(), startz = GetZ();
225 Double_t sign = (startx<xToGo) ? -1.:1.;
226 Double_t step = (xToGo-startx)/TMath::Abs(nstep);
227
1defa402 228 Double_t start[3], end[3], mparam[7];
229 //Double_t bz = GetBz();
230 Double_t b[3]; GetBxByBz(b);
231 Double_t bz = b[2];
232
afd25725 233 Double_t x = startx;
234
235 for (Int_t i=0; i<nstep; i++) {
236
237 GetXYZ(start); //starting global position
238 x += step;
239 if (!GetXYZAt(x, bz, end)) return kFALSE;
1defa402 240 //if (!AliExternalTrackParam::PropagateTo(x, bz)) return kFALSE;
241 if (!AliExternalTrackParam::PropagateToBxByBz(x, b)) return kFALSE;
afd25725 242 AliTracker::MeanMaterialBudget(start, end, mparam);
8fc9f3dc 243 xTimesRho = sign*mparam[4]*mparam[0];
244 xOverX0 = mparam[1];
afd25725 245 if (mparam[1]<900000) {
afd25725 246 if (!AliExternalTrackParam::CorrectForMeanMaterial(xOverX0,
8fc9f3dc 247 xTimesRho,GetMass())) return kFALSE;
248 } else { // this happens when MeanMaterialBudget cannot cross a boundary
249 return kFALSE;
afd25725 250 }
251 }
252
db355ee7 253 if (addTime && IsStartedTimeIntegral() && GetX()>startx) {
afd25725 254 Double_t l2 = ( (GetX()-startx)*(GetX()-startx) +
255 (GetY()-starty)*(GetY()-starty) +
256 (GetZ()-startz)*(GetZ()-startz) );
257 AddTimeStep(TMath::Sqrt(l2));
258 }
259
260 return kTRUE;
261}
262
263//____________________________________________________________________________
6c94f330 264Bool_t AliITStrackV2::Update(const AliCluster* c, Double_t chi2, Int_t index)
265{
006b5f7f 266 //------------------------------------------------------------------
267 //This function updates track parameters
268 //------------------------------------------------------------------
6c94f330 269 Double_t p[2]={c->GetY(), c->GetZ()};
d9ead1a0 270 Double_t cov[3]={c->GetSigmaY2(), c->GetSigmaYZ(), c->GetSigmaZ2()};
006b5f7f 271
6c94f330 272 if (!AliExternalTrackParam::Update(p,cov)) return kFALSE;
006b5f7f 273
28d5b13d 274 Int_t n=GetNumberOfClusters();
006b5f7f 275 if (!Invariant()) {
28d5b13d 276 if (n>fgkWARN) AliWarning("Wrong invariant !");
6c94f330 277 return kFALSE;
006b5f7f 278 }
279
6c94f330 280 if (chi2<0) return kTRUE;
67c3dcbe 281
b5205c90 282 // fill residuals for ITS+TPC tracks
badb951a 283 if (fESDtrack) {
284 if (fESDtrack->GetStatus()&AliESDtrack::kTPCin) {
285 AliTracker::FillResiduals(this,p,cov,c->GetVolumeId());
286 }
b5205c90 287 }
150f264c 288
006b5f7f 289 fIndex[n]=index;
290 SetNumberOfClusters(n+1);
291 SetChi2(GetChi2()+chi2);
292
6c94f330 293 return kTRUE;
006b5f7f 294}
295
6c94f330 296Bool_t AliITStrackV2::Invariant() const {
006b5f7f 297 //------------------------------------------------------------------
298 // This function is for debugging purpose only
299 //------------------------------------------------------------------
545af9ef 300 if(!fCheckInvariant) return kTRUE;
301
7f6ddf58 302 Int_t n=GetNumberOfClusters();
6c94f330 303
8a84886c 304 // take into account the misalignment error
305 Float_t maxMisalErrY2=0,maxMisalErrZ2=0;
306 for (Int_t lay=0; lay<AliITSgeomTGeo::kNLayers; lay++) {
d9ead1a0 307 maxMisalErrY2 = TMath::Max(maxMisalErrY2,AliITSReconstructor::GetRecoParam()->GetClusterMisalErrorY(lay,GetBz()));
308 maxMisalErrZ2 = TMath::Max(maxMisalErrZ2,AliITSReconstructor::GetRecoParam()->GetClusterMisalErrorZ(lay,GetBz()));
8a84886c 309 }
310 maxMisalErrY2 *= maxMisalErrY2;
311 maxMisalErrZ2 *= maxMisalErrZ2;
312 // this is because when we reset before refitting, we multiply the
313 // matrix by 10
314 maxMisalErrY2 *= 10.;
315 maxMisalErrZ2 *= 10.;
316
6c94f330 317 Double_t sP2=GetParameter()[2];
318 if (TMath::Abs(sP2) >= kAlmost1){
8602c008 319 if (n>fgkWARN) Warning("Invariant","fP2=%f\n",sP2);
6c94f330 320 return kFALSE;
a9a2d814 321 }
6c94f330 322 Double_t sC00=GetCovariance()[0];
8a84886c 323 if (sC00<=0 || sC00>(9.+maxMisalErrY2)) {
8602c008 324 if (n>fgkWARN) Warning("Invariant","fC00=%f\n",sC00);
6c94f330 325 return kFALSE;
a9a2d814 326 }
6c94f330 327 Double_t sC11=GetCovariance()[2];
8a84886c 328 if (sC11<=0 || sC11>(9.+maxMisalErrZ2)) {
8602c008 329 if (n>fgkWARN) Warning("Invariant","fC11=%f\n",sC11);
6c94f330 330 return kFALSE;
a9a2d814 331 }
6c94f330 332 Double_t sC22=GetCovariance()[5];
333 if (sC22<=0 || sC22>1.) {
8602c008 334 if (n>fgkWARN) Warning("Invariant","fC22=%f\n",sC22);
6c94f330 335 return kFALSE;
a9a2d814 336 }
6c94f330 337 Double_t sC33=GetCovariance()[9];
338 if (sC33<=0 || sC33>1.) {
8602c008 339 if (n>fgkWARN) Warning("Invariant","fC33=%f\n",sC33);
6c94f330 340 return kFALSE;
a9a2d814 341 }
6c94f330 342 Double_t sC44=GetCovariance()[14];
343 if (sC44<=0 /*|| sC44>6e-5*/) {
8602c008 344 if (n>fgkWARN) Warning("Invariant","fC44=%f\n",sC44);
6c94f330 345 return kFALSE;
14825d5a 346 }
6c94f330 347
348 return kTRUE;
006b5f7f 349}
350
351//____________________________________________________________________________
6c94f330 352Bool_t AliITStrackV2::Propagate(Double_t alp,Double_t xk) {
006b5f7f 353 //------------------------------------------------------------------
354 //This function propagates a track
355 //------------------------------------------------------------------
1defa402 356 //Double_t bz=GetBz();
357 //if (!AliExternalTrackParam::Propagate(alp,xk,bz)) return kFALSE;
358 Double_t b[3]; GetBxByBz(b);
359 if (!AliExternalTrackParam::PropagateBxByBz(alp,xk,b)) return kFALSE;
006b5f7f 360
006b5f7f 361 if (!Invariant()) {
8a84886c 362 Int_t n=GetNumberOfClusters();
363 if (n>fgkWARN) AliWarning("Wrong invariant !");
364 return kFALSE;
791f9a2a 365 }
366
6c94f330 367 return kTRUE;
a9a2d814 368}
006b5f7f 369
afd25725 370Bool_t AliITStrackV2::MeanBudgetToPrimVertex(Double_t xyz[3], Double_t step, Double_t &d) const {
371
372 //-------------------------------------------------------------------
373 // Get the mean material budget between the actual point and the
374 // primary vertex. (L.Gaudichet)
375 //-------------------------------------------------------------------
376
377 Double_t cs=TMath::Cos(GetAlpha()), sn=TMath::Sin(GetAlpha());
378 Double_t vertexX = xyz[0]*cs + xyz[1]*sn;
379
380 Int_t nstep = Int_t((GetX()-vertexX)/step);
381 if (nstep<1) nstep = 1;
382 step = (GetX()-vertexX)/nstep;
383
c7719399 384 // Double_t mparam[7], densMean=0, radLength=0, length=0;
385 Double_t mparam[7];
afd25725 386 Double_t p1[3], p2[3], x = GetX(), bz = GetBz();
387 GetXYZ(p1);
388
389 d=0.;
390
391 for (Int_t i=0; i<nstep; i++) {
392 x += step;
393 if (!GetXYZAt(x, bz, p2)) return kFALSE;
394 AliTracker::MeanMaterialBudget(p1, p2, mparam);
395 if (mparam[1]>900000) return kFALSE;
396 d += mparam[1];
397
398 p1[0] = p2[0];
399 p1[1] = p2[1];
400 p1[2] = p2[2];
401 }
402
403 return kTRUE;
404}
405
6c94f330 406Bool_t AliITStrackV2::Improve(Double_t x0,Double_t xyz[3],Double_t ers[3]) {
babd135a 407 //------------------------------------------------------------------
6c94f330 408 //This function improves angular track parameters
babd135a 409 //------------------------------------------------------------------
86be8934 410 //Store the initail track parameters
411
86be8934 412 Double_t x = GetX();
413 Double_t alpha = GetAlpha();
414 Double_t par[] = {GetY(),GetZ(),GetSnp(),GetTgl(),GetSigned1Pt()};
415 Double_t cov[] = {
416 GetSigmaY2(),
417 GetSigmaZY(),
418 GetSigmaZ2(),
419 GetSigmaSnpY(),
420 GetSigmaSnpZ(),
421 GetSigmaSnp2(),
422 GetSigmaTglY(),
423 GetSigmaTglZ(),
424 GetSigmaTglSnp(),
425 GetSigmaTgl2(),
426 GetSigma1PtY(),
427 GetSigma1PtZ(),
428 GetSigma1PtSnp(),
429 GetSigma1PtTgl(),
430 GetSigma1Pt2()
431 };
432
433
6c94f330 434 Double_t cs=TMath::Cos(GetAlpha()), sn=TMath::Sin(GetAlpha());
cb4706fe 435 Double_t xv = xyz[0]*cs + xyz[1]*sn; // vertex
6c94f330 436 Double_t yv =-xyz[0]*sn + xyz[1]*cs; // in the
437 Double_t zv = xyz[2]; // local frame
babd135a 438
cb4706fe 439 Double_t dx = x - xv, dy = par[0] - yv, dz = par[1] - zv;
440 Double_t r2=dx*dx + dy*dy;
6c23ffed 441 Double_t p2=(1.+ GetTgl()*GetTgl())/(GetSigned1Pt()*GetSigned1Pt());
a9a2d814 442 Double_t beta2=p2/(p2 + GetMass()*GetMass());
443 x0*=TMath::Sqrt((1.+ GetTgl()*GetTgl())/(1.- GetSnp()*GetSnp()));
8676d691 444 Double_t theta2=14.1*14.1/(beta2*p2*1e6)*x0;
445 //Double_t theta2=1.0259e-6*14*14/28/(beta2*p2)*x0*9.36*2.33;
6c94f330 446
447 Double_t cnv=GetBz()*kB2C;
a9a2d814 448 {
6c94f330 449 Double_t dummy = 4/r2 - GetC()*GetC();
450 if (dummy < 0) return kFALSE;
cb4706fe 451 Double_t parp = 0.5*(GetC()*dx + dy*TMath::Sqrt(dummy));
bfd20868 452 Double_t sigma2p = theta2*(1.-GetSnp())*(1.+GetSnp())*(1. + GetTgl()*GetTgl());
453 Double_t ovSqr2 = 1./TMath::Sqrt(r2);
454 Double_t tfact = ovSqr2*(1.-dy*ovSqr2)*(1.+dy*ovSqr2);
86be8934 455 sigma2p += cov[0]*tfact*tfact;
6c94f330 456 sigma2p += ers[1]*ers[1]/r2;
cb4706fe 457 sigma2p += 0.25*cov[14]*cnv*cnv*dx*dx;
86be8934 458 Double_t eps2p=sigma2p/(cov[5] + sigma2p);
459 par[0] += cov[3]/(cov[5] + sigma2p)*(parp - GetSnp());
460 par[2] = eps2p*GetSnp() + (1 - eps2p)*parp;
461 cov[5] *= eps2p;
462 cov[3] *= eps2p;
a9a2d814 463 }
464 {
6c94f330 465 Double_t parl=0.5*GetC()*dz/TMath::ASin(0.5*GetC()*TMath::Sqrt(r2));
466 Double_t sigma2l=theta2;
86be8934 467 sigma2l += cov[2]/r2 + cov[0]*dy*dy*dz*dz/(r2*r2*r2);
6c94f330 468 sigma2l += ers[2]*ers[2]/r2;
86be8934 469 Double_t eps2l = sigma2l/(cov[9] + sigma2l);
470 par[1] += cov[7 ]/(cov[9] + sigma2l)*(parl - par[3]);
471 par[4] += cov[13]/(cov[9] + sigma2l)*(parl - par[3]);
472 par[3] = eps2l*par[3] + (1-eps2l)*parl;
473 cov[9] *= eps2l;
474 cov[13]*= eps2l;
475 cov[7] *= eps2l;
a9a2d814 476 }
86be8934 477
478 Set(x,alpha,par,cov);
479
6c94f330 480 if (!Invariant()) return kFALSE;
14825d5a 481
6c94f330 482 return kTRUE;
14825d5a 483}
23efe5f1 484
485void AliITStrackV2::CookdEdx(Double_t low, Double_t up) {
486 //-----------------------------------------------------------------
a9a2d814 487 // This function calculates dE/dX within the "low" and "up" cuts.
488 // Origin: Boris Batyunya, JINR, Boris.Batiounia@cern.ch
09cf9d66 489 // Updated: F. Prino 8-June-2009
23efe5f1 490 //-----------------------------------------------------------------
09cf9d66 491 // The cluster order is: SDD-1, SDD-2, SSD-1, SSD-2
c0dd5278 492
c0dd5278 493 Int_t nc=0;
09cf9d66 494 Float_t dedx[4];
495 for (Int_t il=0; il<4; il++) { // count good (>0) dE/dx values
496 if(fdEdxSample[il]>0.){
497 dedx[nc]= fdEdxSample[il];
498 nc++;
499 }
500 }
501 if(nc<1){
502 SetdEdx(0.);
503 return;
c0dd5278 504 }
23efe5f1 505
09cf9d66 506 Int_t swap; // sort in ascending order
23efe5f1 507 do {
508 swap=0;
09cf9d66 509 for (Int_t i=0; i<nc-1; i++) {
510 if (dedx[i]<=dedx[i+1]) continue;
511 Float_t tmp=dedx[i];
512 dedx[i]=dedx[i+1];
513 dedx[i+1]=tmp;
23efe5f1 514 swap++;
515 }
516 } while (swap);
517
23efe5f1 518
09cf9d66 519 Double_t nl=low*nc, nu =up*nc;
520 Float_t sumamp = 0;
521 Float_t sumweight =0;
522 for (Int_t i=0; i<nc; i++) {
523 Float_t weight =1;
524 if (i<nl+0.1) weight = TMath::Max(1.-(nl-i),0.);
525 if (i>nu-1) weight = TMath::Max(nu-i,0.);
526 sumamp+= dedx[i]*weight;
527 sumweight+=weight;
528 }
529 SetdEdx(sumamp/sumweight);
23efe5f1 530}
c7bafca9 531
8602c008 532//____________________________________________________________________________
533Bool_t AliITStrackV2::
e50912db 534GetPhiZat(Double_t r, Double_t &phi, Double_t &z) const {
535 //------------------------------------------------------------------
536 // This function returns the global cylindrical (phi,z) of the track
537 // position estimated at the radius r.
538 // The track curvature is neglected.
539 //------------------------------------------------------------------
540 Double_t d=GetD(0.,0.);
bc02d571 541 if (TMath::Abs(d) > r) {
542 if (r>1e-1) return kFALSE;
543 r = TMath::Abs(d);
544 }
e50912db 545
546 Double_t rcurr=TMath::Sqrt(GetX()*GetX() + GetY()*GetY());
494a930c 547 if (TMath::Abs(d) > rcurr) return kFALSE;
548 Double_t globXYZcurr[3]; GetXYZ(globXYZcurr);
549 Double_t phicurr=TMath::ATan2(globXYZcurr[1],globXYZcurr[0]);
e50912db 550
2089d338 551 if (GetX()>=0.) {
552 phi=phicurr+TMath::ASin(d/r)-TMath::ASin(d/rcurr);
553 } else {
554 phi=phicurr+TMath::ASin(d/r)+TMath::ASin(d/rcurr)-TMath::Pi();
555 }
556
494a930c 557 // return a phi in [0,2pi[
558 if (phi<0.) phi+=2.*TMath::Pi();
559 else if (phi>=2.*TMath::Pi()) phi-=2.*TMath::Pi();
c7de5c65 560 z=GetZ()+GetTgl()*(TMath::Sqrt((r-d)*(r+d))-TMath::Sqrt((rcurr-d)*(rcurr+d)));
e50912db 561 return kTRUE;
562}
563//____________________________________________________________________________
564Bool_t AliITStrackV2::
565GetLocalXat(Double_t r,Double_t &xloc) const {
8602c008 566 //------------------------------------------------------------------
e50912db 567 // This function returns the local x of the track
568 // position estimated at the radius r.
8602c008 569 // The track curvature is neglected.
570 //------------------------------------------------------------------
571 Double_t d=GetD(0.,0.);
6a14afad 572 if (TMath::Abs(d) > r) {
573 if (r>1e-1) return kFALSE;
574 r = TMath::Abs(d);
575 }
8602c008 576
e50912db 577 Double_t rcurr=TMath::Sqrt(GetX()*GetX() + GetY()*GetY());
494a930c 578 Double_t globXYZcurr[3]; GetXYZ(globXYZcurr);
579 Double_t phicurr=TMath::ATan2(globXYZcurr[1],globXYZcurr[0]);
2089d338 580 Double_t phi;
581 if (GetX()>=0.) {
582 phi=phicurr+TMath::ASin(d/r)-TMath::ASin(d/rcurr);
583 } else {
584 phi=phicurr+TMath::ASin(d/r)+TMath::ASin(d/rcurr)-TMath::Pi();
585 }
8602c008 586
e50912db 587 xloc=r*(TMath::Cos(phi)*TMath::Cos(GetAlpha())
588 +TMath::Sin(phi)*TMath::Sin(GetAlpha()));
8602c008 589
590 return kTRUE;
591}