fC42(0),
fC43(0),
fC44(0),
+ fNUsed(0),
+ fNSkipped(0),
+ fReconstructed(kFALSE),
fESDtrack(0)
{
for(Int_t i=0; i<kMaxLayer; i++) fIndex[i]=0;
for(Int_t i=0; i<4; i++) fdEdxSample[i]=0;
+ for(Int_t i=0; i<6; i++) {fDy[i]=0; fDz[i]=0; fSigmaY[i]=0; fSigmaZ[i]=0; fChi2MIP[i]=0;}
}
//____________________________________________________________________________
fC30=c[6 ]; fC31=c[7 ]; fC32=c[8 ]; fC33=c[9 ];
fC40=c[10]/x; fC41=c[11]/x; fC42=c[12]/x; fC43=c[13]/x; fC44=c[14]/x/x;
+ for(Int_t i=0; i<6; i++) {fDy[i]=0; fDz[i]=0; fSigmaY[i]=0; fSigmaZ[i]=0;}
+ //
if (!Invariant()) throw "AliITStrackV2: conversion failed !\n";
}
//____________________________________________________________________________
-AliITStrackV2::AliITStrackV2(AliESDtrack& t) throw (const Char_t *) :
+AliITStrackV2::AliITStrackV2(AliESDtrack& t,Bool_t c) throw (const Char_t *) :
AliKalmanTrack() {
//------------------------------------------------------------------
- //Conversion ESD track -> ITS track
+ // Conversion ESD track -> ITS track.
+ // If c==kTRUE, create the ITS track out of the constrained params.
//------------------------------------------------------------------
SetNumberOfClusters(t.GetITSclusters(fIndex));
SetLabel(t.GetLabel());
else if (fAlpha >= TMath::Pi()) fAlpha -= 2*TMath::Pi();
//Conversion of the track parameters
- Double_t x,p[5]; t.GetExternalParameters(x,p);
+ Double_t x,p[5];
+ if (c) t.GetConstrainedExternalParameters(x,p);
+ else t.GetExternalParameters(x,p);
fX=x; x=GetConvConst();
fP0=p[0];
fP1=p[1];
fP4=p[4]/x;
//Conversion of the covariance matrix
- Double_t c[15]; t.GetExternalCovariance(c);
-
- fC00=c[0 ];
- fC10=c[1 ]; fC11=c[2 ];
- fC20=c[3 ]; fC21=c[4 ]; fC22=c[5 ];
- fC30=c[6 ]; fC31=c[7 ]; fC32=c[8 ]; fC33=c[9 ];
- fC40=c[10]/x; fC41=c[11]/x; fC42=c[12]/x; fC43=c[13]/x; fC44=c[14]/x/x;
+ Double_t cv[15];
+ if (c) t.GetConstrainedExternalCovariance(cv);
+ else t.GetExternalCovariance(cv);
+ fC00=cv[0 ];
+ fC10=cv[1 ]; fC11=cv[2 ];
+ fC20=cv[3 ]; fC21=cv[4 ]; fC22=cv[5 ];
+ fC30=cv[6 ]; fC31=cv[7 ]; fC32=cv[8 ]; fC33=cv[9 ];
+ fC40=cv[10]/x; fC41=cv[11]/x; fC42=cv[12]/x; fC43=cv[13]/x; fC44=cv[14]/x/x;
if (t.GetStatus()&AliESDtrack::kTIME) {
StartTimeIntegral();
SetIntegratedLength(t.GetIntegratedLength());
}
fESDtrack=&t;
-
- if (!Invariant()) throw "AliITStrackV2: conversion failed !\n";
-
+ fNUsed = 0;
+ fReconstructed = kFALSE;
+ fNSkipped =0;
+ for(Int_t i=0; i<6; i++) {fDy[i]=0; fDz[i]=0; fSigmaY[i]=0; fSigmaZ[i]=0;; fChi2MIP[i]=0;}
+ //if (!Invariant()) throw "AliITStrackV2: conversion failed !\n";
+ SetFakeRatio(t.GetITSFakeRatio());
}
void AliITStrackV2::UpdateESDtrack(ULong_t flags) {
fESDtrack->UpdateTrackParams(this,flags);
+ if (flags == AliESDtrack::kITSin) fESDtrack->SetITSChi2MIP(fChi2MIP);
+}
+void AliITStrackV2::SetConstrainedESDtrack(Double_t chi2) {
+ fESDtrack->SetConstrainedTrackParams(this,chi2);
}
//____________________________________________________________________________
if (i<4) fdEdxSample[i]=t.fdEdxSample[i];
}
fESDtrack=t.fESDtrack;
+ fNUsed = t.fNUsed;
+ fReconstructed = t.fReconstructed;
+ fNSkipped = t.fNSkipped;
+ for(Int_t i=0; i<6; i++) {fDy[i]=t.fDy[i]; fDz[i]=t.fDz[i]; fSigmaY[i]=t.fSigmaY[i]; fSigmaZ[i]=t.fSigmaZ[i];; fChi2MIP[i]=t.fChi2MIP[i];}
}
//_____________________________________________________________________________
AliITStrackV2 *t=(AliITStrackV2*)o;
//Double_t co=TMath::Abs(t->Get1Pt());
//Double_t c =TMath::Abs(Get1Pt());
- Double_t co=t->GetSigmaY2()*t->GetSigmaZ2();
- Double_t c =GetSigmaY2()*GetSigmaZ2();
+ Double_t co=t->GetSigmaY2()*t->GetSigmaZ2()*TMath::Sqrt(TMath::Abs(fP4));
+ Double_t c =GetSigmaY2()*GetSigmaZ2()*TMath::Sqrt(TMath::Abs(fP4));
if (c>co) return 1;
else if (c<co) return -1;
return 0;
//-----------------------------------------------------------------
Double_t r00=c->GetSigmaY2(), r01=0., r11=c->GetSigmaZ2();
r00+=fC00; r01+=fC10; r11+=fC11;
-
+ //
Double_t det=r00*r11 - r01*r01;
if (TMath::Abs(det) < 1.e-30) {
Int_t n=GetNumberOfClusters();
Double_t det=r00*r11 - r01*r01;
Double_t tmp=r00; r00=r11/det; r11=tmp/det; r01=-r01/det;
+
Double_t k00=fC00*r00+fC10*r01, k01=fC00*r01+fC10*r11;
Double_t k10=fC10*r00+fC11*r01, k11=fC10*r01+fC11*r11;
Double_t k20=fC20*r00+fC21*r01, k21=fC20*r01+fC21*r11;
Double_t k40=fC40*r00+fC41*r01, k41=fC40*r01+fC41*r11;
Double_t dy=c->GetY() - fP0, dz=c->GetZ() - fP1;
+ Int_t layer = (index & 0xf0000000) >> 28;
+ fDy[layer] = dy;
+ fDz[layer] = dz;
+ fSigmaY[layer] = TMath::Sqrt(c->GetSigmaY2()+fC00);
+ fSigmaZ[layer] = TMath::Sqrt(c->GetSigmaZ2()+fC11);
+
Double_t sf=fP2 + k20*dy + k21*dz;
fP0 += k00*dy + k01*dz;
return 0;
}
+ if (chi2<0) return 1;
+
Int_t n=GetNumberOfClusters();
fIndex[n]=index;
SetNumberOfClusters(n+1);
return a/(1 + TMath::Sqrt(sn*sn + cs*cs));
}
+Double_t AliITStrackV2::GetZat(Double_t x) const {
+ //------------------------------------------------------------------
+ // This function calculates the z at given x point - in current coordinate system
+ //------------------------------------------------------------------
+ Double_t x1=fX, x2=x, dx=x2-x1;
+ //
+ Double_t f1=fP2, f2=f1 + fP4*dx;
+ if (TMath::Abs(f2) >= 0.9999) {
+ return 10000000;
+ }
+
+ Double_t r1=sqrt(1.- f1*f1), r2=sqrt(1.- f2*f2);
+ Double_t z = fP1 + dx*(f1+f2)/(f1*r2 + f2*r1)*fP3;
+ return z;
+}
+
+
+
+
Int_t AliITStrackV2::Improve(Double_t x0,Double_t xyz[3],Double_t ers[3]) {
//------------------------------------------------------------------
//This function improves angular track parameters