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