X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITStrackV2.cxx;h=a4d86770e9bf142c443f69aa886ca6869fda3ff4;hb=20f79d37d89dc1fa42a87fab4697de017cd08cf0;hp=4c3609088ec7cd734e3d1e07db0b06214b3ad57e;hpb=23efe5f17d6456f1990a8854c04e89879830fe5c;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITStrackV2.cxx b/ITS/AliITStrackV2.cxx index 4c3609088ec..a4d86770e9b 100644 --- a/ITS/AliITStrackV2.cxx +++ b/ITS/AliITStrackV2.cxx @@ -13,880 +13,758 @@ * provided "as is" without express or implied warranty. * **************************************************************************/ -//------------------------------------------------------------------------- +/* $Id$ */ + +/////////////////////////////////////////////////////////////////////////// // Implementation of the ITS track class // // Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch -//------------------------------------------------------------------------- - -#include - +// dEdx analysis by: Boris Batyunya, JINR, Boris.Batiounia@cern.ch +/////////////////////////////////////////////////////////////////////////// #include -#include #include "AliCluster.h" -#include "AliTPCtrack.h" +#include "AliESDVertex.h" +#include "AliITSReconstructor.h" #include "AliITStrackV2.h" +#include "AliTracker.h" +#include "AliLog.h" + +const Int_t AliITStrackV2::fgkWARN = 5; ClassImp(AliITStrackV2) -const Int_t kWARN=5; //____________________________________________________________________________ -AliITStrackV2::AliITStrackV2(const AliTPCtrack& t) throw (const Char_t *) { +AliITStrackV2::AliITStrackV2() : AliKalmanTrack(), + fCheckInvariant(kTRUE), + fdEdx(0), + fESDtrack(0) +{ + for(Int_t i=0; i<2*AliITSgeomTGeo::kNLayers; i++) {fIndex[i]=-1; fModule[i]=-1;} + for(Int_t i=0; i ITS track + // Conversion ESD track -> ITS track. + // If c==kTRUE, create the ITS track out of the constrained params. //------------------------------------------------------------------ - SetLabel(t.GetLabel()); - SetChi2(0.); - SetNumberOfClusters(0); - //SetConvConst(t.GetConvConst()); + const AliExternalTrackParam *par=&t; + if (c) { + par=t.GetConstrainedParam(); + if (!par) AliError("AliITStrackV2: conversion failed !\n"); + } + Set(par->GetX(),par->GetAlpha(),par->GetParameter(),par->GetCovariance()); - fdEdx = t.GetdEdx(); + SetLabel(t.GetLabel()); SetMass(t.GetMass()); + SetNumberOfClusters(t.GetITSclusters(fIndex)); + + if (t.GetStatus()&AliESDtrack::kTIME) { + StartTimeIntegral(); + Double_t times[10]; t.GetIntegratedTimes(times); SetIntegratedTimes(times); + SetIntegratedLength(t.GetIntegratedLength()); + } - fAlpha = t.GetAlpha(); - if (fAlpha < -TMath::Pi()) fAlpha += 2*TMath::Pi(); - else if (fAlpha >= TMath::Pi()) fAlpha -= 2*TMath::Pi(); - - //Conversion of the track parameters - Double_t x,p[5]; t.GetExternalParameters(x,p); - fX=x; x=GetConvConst(); - fP0=p[0]; - fP1=p[1]; - fP2=p[2]; - fP3=p[3]; - 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; - - if (!Invariant()) throw "AliITStrackV2: conversion failed !\n"; + for(Int_t i=0; iUpdateTrackParams(this,flags); + // copy the module indices + Int_t i; + for(i=0;i<2*AliITSgeomTGeo::kNLayers;i++) { + // printf(" %d\n",GetModuleIndex(i)); + fESDtrack->SetITSModuleIndex(i,GetModuleIndex(i)); + } + // copy the map of shared clusters + if(flags==AliESDtrack::kITSin) { + UChar_t itsSharedMap=0; + for(i=0;i0) SETBIT(itsSharedMap,i); + + } + fESDtrack->SetITSSharedMap(itsSharedMap); + } - fC00=t.fC00; - fC10=t.fC10; fC11=t.fC11; - fC20=t.fC20; fC21=t.fC21; fC22=t.fC22; - fC30=t.fC30; fC31=t.fC31; fC32=t.fC32; fC33=t.fC33; - fC40=t.fC40; fC41=t.fC41; fC42=t.fC42; fC43=t.fC43; fC44=t.fC44; + // copy the 4 dedx samples + Double_t sdedx[4]={0.,0.,0.,0.}; + for(i=0; i<4; i++) sdedx[i]=fdEdxSample[i]; + fESDtrack->SetITSdEdxSamples(sdedx); +} - Int_t n=GetNumberOfClusters(); - //for (Int_t i=0; iGet1Pt()); - Double_t c =TMath::Abs(Get1Pt()); + //Double_t co=OneOverPt(); + //Double_t c =OneOverPt(); + Double_t co=t->GetSigmaY2()*t->GetSigmaZ2(); + Double_t c =GetSigmaY2()*GetSigmaZ2(); if (c>co) return 1; else if (cGet1Pt()*t->Get1Pt()); - Double_t bo2=po2/(po2 + t->GetMass()*t->GetMass()); - if (p2*b2>po2*bo2) return -1; - else if (p2*b2= 0.99999) { - Int_t n=GetNumberOfClusters(); - if (n>kWARN) - cerr<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(); - if (n>kWARN) - cerr<GetY() - fP0, dz=c->GetZ() - fP1; - - return (dy*r00*dy + 2*r01*dy*dz + dz*r11*dz)/det; -} - -//_____________________________________________________________________________ -Double_t AliITStrackV2::GetPredictedChi2(const AliCluster *c,Double_t *m, -Double_t x0) const { - //----------------------------------------------------------------- - // This function calculates a chi2 increment with a vertex contraint - //----------------------------------------------------------------- - TVectorD x(5); x(0)=fP0; x(1)=fP1; x(2)=fP2; x(3)=fP3; x(4)=fP4; - TMatrixD C(5,5); - C(0,0)=fC00; - C(1,0)=fC10; C(1,1)=fC11; - C(2,0)=fC20; C(2,1)=fC21; C(2,2)=fC22; - C(3,0)=fC30; C(3,1)=fC31; C(3,2)=fC32; C(3,3)=fC33; - C(4,0)=fC40; C(4,1)=fC41; C(4,2)=fC42; C(4,3)=fC43; C(4,4)=fC44; - - C(0,1)=C(1,0); - C(0,2)=C(2,0); C(1,2)=C(2,1); - C(0,3)=C(3,0); C(1,3)=C(3,1); C(2,3)=C(3,2); - C(0,4)=C(4,0); C(1,4)=C(4,1); C(2,4)=C(4,2); C(3,4)=C(4,3); - - TMatrixD H(4,5); H.UnitMatrix(); - Double_t dy=(c->GetY() - m[0]), dz=(c->GetZ() - m[1]); - - Double_t dr=TMath::Sqrt(fX*fX + dy*dy); - Double_t r =TMath::Sqrt(4/dr/dr - fP4*fP4); - Double_t sn=0.5*(fP4*fX + dy*r); - Double_t tg=0.5*fP4*dz/TMath::ASin(0.5*fP4*dr); - TVectorD mm(4); - mm(0)=m[0]=c->GetY(); mm(1)=m[1]=c->GetZ(); mm(2)=m[2]=sn; mm(3)=m[3]=tg; - - Double_t v22=0.,v33=0.; - //x0=0.; - if (x0!=0.) { - Double_t pp2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt()); - Double_t beta2=pp2/(pp2 + GetMass()*GetMass()); - x0*=TMath::Sqrt((1.+ GetTgl()*GetTgl())/(1.- GetSnp()*GetSnp())); - Double_t theta2=14.1*14.1/(beta2*pp2*1e6)*x0; - v22 = theta2*(1.- GetSnp()*GetSnp())*(1. + GetTgl()*GetTgl()); - v33 = theta2*(1.+ GetTgl()*GetTgl())*(1. + GetTgl()*GetTgl()); - } - Double_t sy2=c->GetSigmaY2(), sz2=c->GetSigmaZ2(); - v22+=kSigmaYV*kSigmaYV/dr/dr; - v22+=sy2/dr/dr; - Double_t v20=sy2/dr; - - v33+=kSigmaZV*kSigmaZV/dr/dr; - v33+=sz2/dr/dr; - Double_t v31=sz2/dr; - - TMatrixD V(4,4); - V(0,0)=m[4 ]=sy2; V(0,1)=m[5 ]=0.; V(0,2)=m[6 ]=v20; V(0,3)=m[7 ]=0.; - V(1,0)=m[8 ]=0.; V(1,1)=m[9 ]=sz2; V(1,2)=m[10]=0.; V(1,3)=m[11]=v31; - V(2,0)=m[12]=v20; V(2,1)=m[13]=0.; V(2,2)=m[14]=v22; V(2,3)=m[15]=0.; - V(3,0)=m[16]=0.; V(3,1)=m[17]=v31; V(3,2)=m[18]=0.; V(3,3)=m[19]=v33; - - TVectorD res=x; res*=H; res-=mm; //res*=-1; - TMatrixD tmp(H,TMatrixD::kMult,C); - TMatrixD R(tmp,TMatrixD::kMult,TMatrixD(TMatrixD::kTransposed,H)); R+=V; - - Double_t det=R.Determinant(); - if (TMath::Abs(det) < 1.e-30) { - Int_t n=GetNumberOfClusters(); - if (n>kWARN) - cerr<GetY(), c->GetZ()}; + Double_t cov[3]={c->GetSigmaY2(), 0., c->GetSigmaZ2()}; + return AliExternalTrackParam::GetPredictedChi2(p,cov); } //____________________________________________________________________________ -Int_t -AliITStrackV2::PropagateTo(Double_t xk,Double_t x0,Double_t rho) { +Bool_t AliITStrackV2::PropagateTo(Double_t xk, Double_t d, Double_t x0) { //------------------------------------------------------------------ //This function propagates a track //------------------------------------------------------------------ - Double_t x1=fX, x2=xk, dx=x2-x1; - Double_t f1=fP2, f2=f1 + fP4*dx; - if (TMath::Abs(f2) >= 0.99999) { - Int_t n=GetNumberOfClusters(); - if (n>kWARN) - cerr<oldX) { + Double_t l2 = (x-oldX)*(x-oldX) + (y-oldY)*(y-oldY) + (z-oldZ)*(z-oldZ); + AddTimeStep(TMath::Sqrt(l2)); } - //Energy losses************************ - if (rho!=0.) { - rho*=TMath::Sqrt((1.+ fP3*fP3)/(1.- fP2*fP2)); - Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*rho; - if (x1 < x2) dE=-dE; - fP4*=(1.- sqrt(p2+GetMass()*GetMass())/p2*dE); - } - - if (!Invariant()) {cout<<"Propagate !\n"; return 0;} - - return 1; + return kTRUE; } //____________________________________________________________________________ -Int_t AliITStrackV2::Update(const AliCluster* c, Double_t chi2, UInt_t index) { - //------------------------------------------------------------------ - //This function updates track parameters - //------------------------------------------------------------------ - Double_t p0=fP0,p1=fP1,p2=fP2,p3=fP3,p4=fP4; - Double_t c00=fC00; - Double_t c10=fC10, c11=fC11; - Double_t c20=fC20, c21=fC21, c22=fC22; - Double_t c30=fC30, c31=fC31, c32=fC32, c33=fC33; - Double_t c40=fC40, c41=fC41, c42=fC42, c43=fC43, c44=fC44; - - - Double_t r00=c->GetSigmaY2(), r01=0., r11=c->GetSigmaZ2(); - r00+=fC00; r01+=fC10; r11+=fC11; - 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 k30=fC30*r00+fC31*r01, k31=fC30*r01+fC31*r11; - Double_t k40=fC40*r00+fC41*r01, k41=fC40*r01+fC41*r11; - - Double_t dy=c->GetY() - fP0, dz=c->GetZ() - fP1; - Double_t sf=fP2 + k20*dy + k21*dz; +Bool_t AliITStrackV2::PropagateToTGeo(Double_t xToGo, Int_t nstep, Double_t &xOverX0, Double_t &xTimesRho, Bool_t addTime) { + //------------------------------------------------------------------- + // Propagates the track to a reference plane x=xToGo in n steps. + // These n steps are only used to take into account the curvature. + // The material is calculated with TGeo. (L.Gaudichet) + //------------------------------------------------------------------- - fP0 += k00*dy + k01*dz; - fP1 += k10*dy + k11*dz; - fP2 = sf; - fP3 += k30*dy + k31*dz; - fP4 += k40*dy + k41*dz; - - Double_t c01=fC10, c02=fC20, c03=fC30, c04=fC40; - Double_t c12=fC21, c13=fC31, c14=fC41; - - fC00-=k00*fC00+k01*fC10; fC10-=k00*c01+k01*fC11; - fC20-=k00*c02+k01*c12; fC30-=k00*c03+k01*c13; - fC40-=k00*c04+k01*c14; - - fC11-=k10*c01+k11*fC11; - fC21-=k10*c02+k11*c12; fC31-=k10*c03+k11*c13; - fC41-=k10*c04+k11*c14; + Double_t startx = GetX(), starty = GetY(), startz = GetZ(); + Double_t sign = (startxstartx) { + Double_t l2 = ( (GetX()-startx)*(GetX()-startx) + + (GetY()-starty)*(GetY()-starty) + + (GetZ()-startz)*(GetZ()-startz) ); + AddTimeStep(TMath::Sqrt(l2)); + } - return 1; + return kTRUE; } - //____________________________________________________________________________ -Int_t AliITStrackV2::Update(const Double_t* m, Double_t chi2, UInt_t index) { +Bool_t AliITStrackV2::Update(const AliCluster* c, Double_t chi2, Int_t index) +{ //------------------------------------------------------------------ - //This function updates track parameters with a vertex constraint + //This function updates track parameters //------------------------------------------------------------------ - Double_t p0=fP0,p1=fP1,p2=fP2,p3=fP3,p4=fP4; - Double_t c00=fC00; - Double_t c10=fC10, c11=fC11; - Double_t c20=fC20, c21=fC21, c22=fC22; - Double_t c30=fC30, c31=fC31, c32=fC32, c33=fC33; - Double_t c40=fC40, c41=fC41, c42=fC42, c43=fC43, c44=fC44; - - - TVectorD x(5); x(0)=fP0; x(1)=fP1; x(2)=fP2; x(3)=fP3; x(4)=fP4; - TMatrixD C(5,5); - C(0,0)=fC00; - C(1,0)=fC10; C(1,1)=fC11; - C(2,0)=fC20; C(2,1)=fC21; C(2,2)=fC22; - C(3,0)=fC30; C(3,1)=fC31; C(3,2)=fC32; C(3,3)=fC33; - C(4,0)=fC40; C(4,1)=fC41; C(4,2)=fC42; C(4,3)=fC43; C(4,4)=fC44; - - C(0,1)=C(1,0); - C(0,2)=C(2,0); C(1,2)=C(2,1); - C(0,3)=C(3,0); C(1,3)=C(3,1); C(2,3)=C(3,2); - C(0,4)=C(4,0); C(1,4)=C(4,1); C(2,4)=C(4,2); C(3,4)=C(4,3); - - TMatrixD H(4,5); H.UnitMatrix(); - TMatrixD Ht(TMatrixD::kTransposed,H); - TVectorD mm(4); mm(0)=m[0]; mm(1)=m[1]; mm(2)=m[2]; mm(3)=m[3]; - TMatrixD V(4,4); - V(0,0)=m[4 ]; V(0,1)=m[5 ]; V(0,2)=m[6 ]; V(0,3)=m[7 ]; - V(1,0)=m[8 ]; V(1,1)=m[9 ]; V(1,2)=m[10]; V(1,3)=m[11]; - V(2,0)=m[12]; V(2,1)=m[13]; V(2,2)=m[14]; V(2,3)=m[15]; - V(3,0)=m[16]; V(3,1)=m[17]; V(3,2)=m[18]; V(3,3)=m[19]; - - TMatrixD tmp(H,TMatrixD::kMult,C); - TMatrixD R(tmp,TMatrixD::kMult,Ht); R+=V; - - R.Invert(); - - TMatrixD K(C,TMatrixD::kMult,Ht); K*=R; - - TVectorD savex=x; - x*=H; x-=mm; x*=-1; x*=K; x+=savex; + Double_t p[2]={c->GetY(), c->GetZ()}; + Double_t cov[3]={c->GetSigmaY2(), c->GetSigmaYZ(), c->GetSigmaZ2()}; - TMatrixD saveC=C; - C.Mult(K,tmp); C-=saveC; C*=-1; + if (!AliExternalTrackParam::Update(p,cov)) return kFALSE; - fP0=x(0); fP1=x(1); fP2=x(2); fP3=x(3); fP4=x(4); - fC00=C(0,0); - fC10=C(1,0); fC11=C(1,1); - fC20=C(2,0); fC21=C(2,1); fC22=C(2,2); - fC30=C(3,0); fC31=C(3,1); fC32=C(3,2); fC33=C(3,3); - fC40=C(4,0); fC41=C(4,1); fC42=C(4,2); fC43=C(4,3); fC44=C(4,4); + Int_t n=GetNumberOfClusters(); + if (!Invariant()) { + if (n>fgkWARN) AliDebug(1,"Wrong invariant !"); + return kFALSE; + } + if (chi2<0) return kTRUE; - if (!Invariant()) { - fP0=p0; fP1=p1; fP2=p2; fP3=p3; fP4=p4; - fC00=c00; - fC10=c10; fC11=c11; - fC20=c20; fC21=c21; fC22=c22; - fC30=c30; fC31=c31; fC32=c32; fC33=c33; - fC40=c40; fC41=c41; fC42=c42; fC43=c43; fC44=c44; - return 0; + // fill residuals for ITS+TPC tracks + if (fESDtrack) { + if (fESDtrack->GetStatus()&AliESDtrack::kTPCin) { + AliTracker::FillResiduals(this,p,cov,c->GetVolumeId()); + } } - Int_t n=GetNumberOfClusters(); fIndex[n]=index; SetNumberOfClusters(n+1); SetChi2(GetChi2()+chi2); - return 1; + return kTRUE; } -Int_t AliITStrackV2::Invariant() const { +Bool_t AliITStrackV2::Invariant() const { //------------------------------------------------------------------ // This function is for debugging purpose only //------------------------------------------------------------------ + if(!fCheckInvariant) return kTRUE; + Int_t n=GetNumberOfClusters(); - - //if (TMath::Abs(fP1)>11.5) - //if (fP1*fP4<0) { - // if (n>kWARN) cerr<<"fP1*fP4="<=1) {if (n>kWARN) cerr<<"fP2="<kWARN) cerr<<"fC00="<kWARN) cerr<<"fC11="<kWARN) cerr<<"fC22="<kWARN) cerr<<"fC33="<kWARN) cerr<<"fC44="<kWARN) { cerr<<" bad determinant "<GetClusterMisalErrorY(lay,bz)); + maxMisalErrZ2 = TMath::Max(maxMisalErrZ2,recopar->GetClusterMisalErrorZ(lay,bz)); + } + maxMisalErrY2 *= maxMisalErrY2; + maxMisalErrZ2 *= maxMisalErrZ2; + // this is because when we reset before refitting, we multiply the + // matrix by 10 + maxMisalErrY2 *= 10.; + maxMisalErrZ2 *= 10.; + + Double_t sP2=GetParameter()[2]; + if (TMath::Abs(sP2) >= kAlmost1){ + if (n>fgkWARN) AliDebug(1,Form("fP2=%f\n",sP2)); + return kFALSE; + } + Double_t sC00=GetCovariance()[0]; + if (sC00<=0 || sC00>(9.+maxMisalErrY2)) { + if (n>fgkWARN) AliDebug(1,Form("fC00=%f\n",sC00)); + return kFALSE; + } + Double_t sC11=GetCovariance()[2]; + if (sC11<=0 || sC11>(9.+maxMisalErrZ2)) { + if (n>fgkWARN) AliDebug(1,Form("fC11=%f\n",sC11)); + return kFALSE; + } + Double_t sC22=GetCovariance()[5]; + if (sC22<=0 || sC22>1.) { + if (n>fgkWARN) AliDebug(1,Form("fC22=%f\n",sC22)); + return kFALSE; + } + Double_t sC33=GetCovariance()[9]; + if (sC33<=0 || sC33>1.) { + if (n>fgkWARN) AliDebug(1,Form("fC33=%f\n",sC33)); + return kFALSE; + } + Double_t sC44=GetCovariance()[14]; + if (sC44<=0 /*|| sC44>6e-5*/) { + if (n>fgkWARN) AliDebug(1,Form("fC44=%f\n",sC44)); + return kFALSE; + } + + return kTRUE; } //____________________________________________________________________________ -Int_t -AliITStrackV2::Propagate(Double_t alp,Double_t xk,Double_t x0,Double_t rho) { +Bool_t AliITStrackV2::Propagate(Double_t alp,Double_t xk) { //------------------------------------------------------------------ //This function propagates a track //------------------------------------------------------------------ - Double_t p0=fP0,p1=fP1,p2=fP2,p3=fP3,p4=fP4; - Double_t c00=fC00; - Double_t c10=fC10, c11=fC11; - Double_t c20=fC20, c21=fC21, c22=fC22; - Double_t c30=fC30, c31=fC31, c32=fC32, c33=fC33; - Double_t c40=fC40, c41=fC41, c42=fC42, c43=fC43, c44=fC44; + //Double_t bz=GetBz(); + //if (!AliExternalTrackParam::Propagate(alp,xk,bz)) return kFALSE; + Double_t b[3]; GetBxByBz(b); + if (!AliExternalTrackParam::PropagateBxByBz(alp,xk,b)) return kFALSE; + if (!Invariant()) { + Int_t n=GetNumberOfClusters(); + if (n>fgkWARN) AliDebug(1,"Wrong invariant !"); + return kFALSE; + } - Double_t dalp=alp-fAlpha; + return kTRUE; +} - Double_t ca=TMath::Cos(dalp), sa=TMath::Sin(dalp); - Double_t sf=fP2, cf=TMath::Sqrt(1.- fP2*fP2); +Bool_t AliITStrackV2::MeanBudgetToPrimVertex(Double_t xyz[3], Double_t step, Double_t &d) const { - Double_t pp2=fP2*ca - cf*sa; - if (TMath::Abs(pp2) >= 0.99999) { - Int_t n=GetNumberOfClusters(); - if (n>kWARN) - cerr<= TMath::Pi()) fAlpha -= 2*TMath::Pi(); - - Double_t x1=fX, y1=fP0; + Double_t cs=TMath::Cos(GetAlpha()), sn=TMath::Sin(GetAlpha()); + Double_t vertexX = xyz[0]*cs + xyz[1]*sn; - fX = x1*ca + y1*sa; - fP0=-x1*sa + y1*ca; - fP2 = pp2; + Int_t nstep = Int_t((GetX()-vertexX)/step); + if (nstep<1) nstep = 1; + step = (GetX()-vertexX)/nstep; - cf=ca + sf*sa/cf; + // Double_t mparam[7], densMean=0, radLength=0, length=0; + Double_t mparam[7]; + Double_t p1[3], p2[3], x = GetX(), bz = GetBz(); + GetXYZ(p1); - if (!Invariant()) {cout<= 0.99999) { - Int_t n=GetNumberOfClusters(); - if (n>kWARN) - cerr<900000) return kFALSE; + d += mparam[1]; - Double_t r1=sqrt(1.- f1*f1), r2=sqrt(1.- f2*f2); - - fP0 += dx*(f1+f2)/(r1+r2); - fP1 += dx*(f1+f2)/(f1*r2 + f2*r1)*fP3; - fP2 += dx*fP4; - - //f = F - 1 - Double_t f02= dx/(r1*r1*r1); - Double_t f04=0.5*dx*dx/(r1*r1*r1); - Double_t f12= dx*fP3*f1/(r1*r1*r1); - Double_t f14=0.5*dx*dx*fP3*f1/(r1*r1*r1); - Double_t f13= dx/r1; - Double_t f24= dx; - /* - //b = C*ft - Double_t b00=f02*fC20 + f03*fC30, b01=f12*fC20 + f13*fC30 + f14*fC40; - Double_t b02=f23*fC30; - Double_t b10=f02*fC21 + f03*fC31, b11=f12*fC21 + f13*fC31 + f14*fC41; - Double_t b12=f23*fC31; - Double_t b20=f02*fC22 + f03*fC32, b21=f12*fC22 + f13*fC32 + f14*fC42; - Double_t b22=f23*fC32; - Double_t b30=f02*fC32 + f03*fC33, b31=f12*fC32 + f13*fC33 + f14*fC43; - Double_t b32=f23*fC33; - Double_t b40=f02*fC42 + f03*fC43, b41=f12*fC42 + f13*fC43 + f14*fC44; - Double_t b42=f23*fC43; - - //a = f*b = f*C*ft - Double_t a00=f02*b20+f03*b30,a01=f02*b21+f03*b31,a02=f02*b22+f03*b32; - Double_t a11=f12*b21+f13*b31+f14*b41,a12=f12*b22+f13*b32+f14*b42; - Double_t a22=f23*b32; - - //F*C*Ft = C + (b + bt + a) - fC00 += b00 + b00 + a00; - fC10 += b10 + b01 + a01; - fC20 += b20 + b02 + a02; - fC30 += b30; - fC40 += b40; - fC11 += b11 + b11 + a11; - fC21 += b21 + b12 + a12; - fC31 += b31; - fC41 += b41; - fC22 += b22 + b22 + a22; - fC32 += b32; - fC42 += b42; -*/ - - TMatrixD F(5,5); F.UnitMatrix(); - F(0,0)=-(f1+f2)/(r1+r2)*sa + ca; F(0,2)=f02*cf; F(0,4)=f04; - F(1,0)=-(f1+f2)/(f1*r2 + f2*r1)*fP3*sa; F(1,2)=f12*cf; F(1,4)=f14; F(1,3)=f13; - F(2,0)=-fP4*sa; F(2,2)=cf; F(2,4)=f24; - - TMatrixD C(5,5); - C(0,0)=fC00; - C(1,0)=fC10; C(1,1)=fC11; - C(2,0)=fC20; C(2,1)=fC21; C(2,2)=fC22; - C(3,0)=fC30; C(3,1)=fC31; C(3,2)=fC32; C(3,3)=fC33; - C(4,0)=fC40; C(4,1)=fC41; C(4,2)=fC42; C(4,3)=fC43; C(4,4)=fC44; - - C(0,1)=C(1,0); - C(0,2)=C(2,0); C(1,2)=C(2,1); - C(0,3)=C(3,0); C(1,3)=C(3,1); C(2,3)=C(3,2); - C(0,4)=C(4,0); C(1,4)=C(4,1); C(2,4)=C(4,2); C(3,4)=C(4,3); - - TMatrixD tmp(C,TMatrixD::kMult,TMatrixD(TMatrixD::kTransposed, F)); - C.Mult(F,tmp); - - fC00=C(0,0); - fC10=C(1,0); fC11=C(1,1); - fC20=C(2,0); fC21=C(2,1); fC22=C(2,2); - fC30=C(3,0); fC31=C(3,1); fC32=C(3,2); fC33=C(3,3); - fC40=C(4,0); fC41=C(4,1); fC42=C(4,2); fC43=C(4,3); fC44=C(4,4); - - pp2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt()); - Double_t beta2=pp2/(pp2 + GetMass()*GetMass()); - - //Multiple scattering****************** - //x0=0.; - if (x0!=0.) { - x0*=TMath::Sqrt((1.+ fP3*fP3)/(1.- fP2*fP2)); - Double_t theta2=14.1*14.1/(beta2*pp2*1e6)*x0; - fC22 += theta2*(1.- fP2*fP2)*(1. + fP3*fP3); - fC33 += theta2*(1. + fP3*fP3)*(1. + fP3*fP3); - fC43 += theta2*fP3*fP4*(1. + fP3*fP3); - fC44 += theta2*fP3*fP4*fP3*fP4; - } - - //Energy losses************************ - if (rho!=0.) { - rho*=TMath::Sqrt((1.+ fP3*fP3)/(1.- fP2*fP2)); - Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*rho; - if (x1 < x2) dE=-dE; - fP4*=(1.- sqrt(pp2+GetMass()*GetMass())/pp2*dE); - } - - if (!Invariant()) { - fP0=p0; fP1=p1; fP2=p2; fP3=p3; fP4=p4; - fC00=c00; - fC10=c10; fC11=c11; - fC20=c20; fC21=c21; fC22=c22; - fC30=c30; fC31=c31; fC32=c32; fC33=c33; - fC40=c40; fC41=c41; fC42=c42; fC43=c43; fC44=c44; - return 0; + p1[0] = p2[0]; + p1[1] = p2[1]; + p1[2] = p2[2]; } - fX=x2; - - return 1; + return kTRUE; } -Double_t AliITStrackV2::GetD() const { - //------------------------------------------------------------------ - //This function calculates the transverse impact parameter - //------------------------------------------------------------------ - Double_t sn=fP4*fX - fP2, cs=fP4*fP0 + TMath::Sqrt(1.- fP2*fP2); - Double_t a=2*(fX*fP2 - fP0*TMath::Sqrt(1.- fP2*fP2))-fP4*(fX*fX + fP0*fP0); - if (fP4<0) a=-a; - return a/(1 + TMath::Sqrt(sn*sn + cs*cs)); -} - - -Int_t AliITStrackV2::Improve(Double_t x0,Double_t yv,Double_t zv) { - //------------------------------------------------------------------ - //This function improves angular track parameters - //------------------------------------------------------------------ - Double_t dy=fP0-yv, dz=fP1-zv; - Double_t r2=fX*fX+dy*dy; - Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt()); - Double_t beta2=p2/(p2 + GetMass()*GetMass()); - x0*=TMath::Sqrt((1.+ GetTgl()*GetTgl())/(1.- GetSnp()*GetSnp())); - Double_t theta2=14.1*14.1/(beta2*p2*1e6)*x0; - - Double_t par=0.5*(fP4*fX + dy*TMath::Sqrt(4/r2-fP4*fP4)); - Double_t sigma2 = theta2*(1.- GetSnp()*GetSnp())*(1. + GetTgl()*GetTgl()); - sigma2 += fC00/r2*(1.- dy*dy/r2)*(1.- dy*dy/r2); - sigma2 += kSigmaYV*kSigmaYV/r2; - sigma2 += 0.25*fC44*fX*fX; - Double_t eps2=sigma2/(fC22+sigma2), eps=TMath::Sqrt(eps2); - if (10*r2*fC440) dE/dx values + if(fdEdxSample[il]>0.){ + dedx[nc]= fdEdxSample[il]; + nc++; } - */ + } + if(nc<1){ + SetdEdx(0.); + return; + } + Int_t swap; // sort in ascending order do { swap=0; - for (i=0; i r) { + if (r>1e-1) return kFALSE; + r = TMath::Abs(d); + } + + Double_t rcurr=TMath::Sqrt(GetX()*GetX() + GetY()*GetY()); + if (TMath::Abs(d) > rcurr) return kFALSE; + Double_t globXYZcurr[3]; GetXYZ(globXYZcurr); + Double_t phicurr=TMath::ATan2(globXYZcurr[1],globXYZcurr[0]); - cout<<"! CookdEdx end: dedx ="<=0.) { + phi=phicurr+TMath::ASin(d/r)-TMath::ASin(d/rcurr); + } else { + phi=phicurr+TMath::ASin(d/r)+TMath::ASin(d/rcurr)-TMath::Pi(); + } + + // return a phi in [0,2pi[ + if (phi<0.) phi+=2.*TMath::Pi(); + else if (phi>=2.*TMath::Pi()) phi-=2.*TMath::Pi(); + z=GetZ()+GetTgl()*(TMath::Sqrt((r-d)*(r+d))-TMath::Sqrt((rcurr-d)*(rcurr+d))); + return kTRUE; } - +//____________________________________________________________________________ +Bool_t AliITStrackV2:: +GetLocalXat(Double_t r,Double_t &xloc) const { + //------------------------------------------------------------------ + // This function returns the local x of the track + // position estimated at the radius r. + // The track curvature is neglected. + //------------------------------------------------------------------ + Double_t d=GetD(0.,0.); + if (TMath::Abs(d) > r) { + if (r>1e-1) return kFALSE; + r = TMath::Abs(d); + } + + Double_t rcurr=TMath::Sqrt(GetX()*GetX() + GetY()*GetY()); + Double_t globXYZcurr[3]; GetXYZ(globXYZcurr); + Double_t phicurr=TMath::ATan2(globXYZcurr[1],globXYZcurr[0]); + Double_t phi; + if (GetX()>=0.) { + phi=phicurr+TMath::ASin(d/r)-TMath::ASin(d/rcurr); + } else { + phi=phicurr+TMath::ASin(d/r)+TMath::ASin(d/rcurr)-TMath::Pi(); + } + + xloc=r*(TMath::Cos(phi)*TMath::Cos(GetAlpha()) + +TMath::Sin(phi)*TMath::Sin(GetAlpha())); + return kTRUE; +} + +//____________________________________________________________________________ +Bool_t AliITStrackV2::ImproveKalman(Double_t xyz[3],Double_t ers[3], const Double_t* xlMS, const Double_t* x2X0MS, Int_t nMS) +{ + // Substitute the state of the track (p_{k|k},C_{k|k}) at the k-th measumerent by its + // smoothed value from the k-th measurement + measurement at the vertex. + // Account for the MS on nMS layers at x-postions xlMS with x/x0 = x2X0MS + // p_{k|kv} = p_{k|k} + C_{k|k}*D^Tr_{k+1} B^{-1}_{k+1} ( vtx - D_{k+1}*p_{k|k}) + // C_{k|kv} = C_{k|k}*( I - D^Tr_{k+1} B^{-1}_{k+1} D_{k+1} C^Tr_{k|k}) + // + // where D_{k} = H_{k} F_{k} with H being the matrix converting the tracks parameters + // to measurements m_{k} = H_{k} p_{k} and F_{k} the matrix propagating the track between the + // the point k-1 and k: p_{k|k-1} = F_{k} p_{k-1|k-1} + // + // B_{k+1} = V_{k+1} + H_{k+1} C_{k+1|k} H^Tr_{k+1} with V_{k+1} being the error of the measurment + // at point k+1 (i.e. vertex), and C_{k+1|k} - error matrix extrapolated from k-th measurement to + // k+1 (vtx) and accounting for the MS inbetween + // + // H = {{1,0,0,0,0},{0,1,0,0,0}} + // + double covc[15], *cori = (double*) GetCovariance(),par[5] = {GetY(),GetZ(),GetSnp(),GetTgl(),GetSigned1Pt()}, + &c00=cori[0], + &c01=cori[1],&c11=cori[2], + &c02=cori[3],&c12=cori[4],&c22=cori[5], + &c03=cori[6],&c13=cori[7],&c23=cori[8],&c33=cori[9], + &c04=cori[10],&c14=cori[11],&c24=cori[12],&c34=cori[13],&c44=cori[14], + // for smoothed cov matrix + &cov00=covc[0], + &cov01=covc[1],&cov11=covc[2], + &cov02=covc[3],&cov12=covc[4],&cov22=covc[5], + &cov03=covc[6],&cov13=covc[7],&cov23=covc[8],&cov33=covc[9], + &cov04=covc[10],&cov14=covc[11],&cov24=covc[12],&cov34=covc[13],&cov44=covc[14]; + // + double x = GetX(), alpha = GetAlpha(); + // vertex in the track frame + double cs=TMath::Cos(alpha), sn=TMath::Sin(alpha); + double xv = xyz[0]*cs + xyz[1]*sn, yv =-xyz[0]*sn + xyz[1]*cs, zv = xyz[2]; + double dx = xv - GetX(); + if (TMath::Abs(dx)<=kAlmost0) return kTRUE; + // + double cnv=GetBz()*kB2C, x2r=cnv*par[4]*dx, f1=par[2], f2=f1+x2r; + if (TMath::Abs(f1) >= kAlmost1 || TMath::Abs(f2) >= kAlmost1) { + AliInfo(Form("Fail: %+e %+e",f1,f2)); + return kFALSE; + } + double r1=TMath::Sqrt((1.-f1)*(1.+f1)), r2=TMath::Sqrt((1.-f2)*(1.+f2)), dx2r=dx/(r1+r2); + // elements of matrix F_{k+1} (1s on diagonal) + double f02 = 2*dx2r, f04 = cnv*dx*dx2r, f13/*, f24 = cnv*dx*/; + if (TMath::Abs(x2r)<0.05) f13 = dx*r2+f2*(f1+f2)*dx2r; // see AliExternalTrackParam::PropagateTo + else { + double dy2dx = (f1+f2)/(r1+r2); + f13 = 2*TMath::ASin(0.5*TMath::Sqrt(1+dy2dx*dy2dx)*x2r)/(cnv*par[4]); + } + // elements of matrix D_{k+1} = H_{k+1} * F_{k+1} + // double d00 = 1., d11 = 1.; + double &d02 = f02, &d04 = f04, &d13 = f13; + // + // elements of matrix DC = D_{k+1}*C_{kk}^T + double dc00 = c00+c02*d02+c04*d04, dc10 = c01+c03*d13; + double dc01 = c01+c12*d02+c14*d04, dc11 = c11+c13*d13; + double dc02 = c02+c22*d02+c24*d04, dc12 = c12+c23*d13; + double dc03 = c03+c23*d02+c34*d04, dc13 = c13+c33*d13; + double dc04 = c04+c24*d02+c44*d04, dc14 = c14+c34*d13; + // + // difference between the vertex and the the track extrapolated to vertex + yv -= par[0] + par[2]*d02 + par[4]*d04; + zv -= par[1] + par[3]*d13; + // + // y,z part of the cov.matrix extrapolated to vtx (w/o MS contribution) + // C_{k+1,k} = H F_{k+1} C_{k,k} F^Tr_{k+1} H^Tr = D C D^Tr + double cv00 = dc00+dc02*d02+dc04*d04, cv01 = dc01+dc03*d13, cv11 = dc11+dc13*d13; + // + // add MS contribution layer by layer + double xCurr = x; + double p2Curr = par[2]; + // + // precalculated factors of MS contribution matrix: + double ms22t = (1. + par[3]*par[3]); + double ms33t = ms22t*ms22t; + double p34 = par[3]*par[4]; + double ms34t = p34*ms22t; + double ms44t = p34*p34; + // + double p2=(1.+ par[3]*par[3])/(par[4]*par[4]); + double beta2 = p2/(p2+GetMass()*GetMass()); + double theta2t = 14.1*14.1/(beta2*p2*1e6) * (1. + par[3]*par[3]); + // + // account for the MS in the layers between the last measurement and the vertex + for (int il=0;il= kAlmost1 || TMath::Abs(f2L) >= kAlmost1) { + AliInfo(Form("FailMS at step %d of %d: dfx:%e dxL:%e %e %e",il,nMS,dfx,dxL,f1L,f2L)); + return kFALSE; + } + double r1L=TMath::Sqrt((1.-f1L)*(1.+f1L)), r2L=TMath::Sqrt((1.-f2L)*(1.+f2L)), dx2rL=dxL/(r1L+r2L); + // elements of matrix for propagation from scatering layer to vertex + double f02L = 2*dx2rL, f04L = cnv*dxL*dx2rL, f13L/*, f24L = cnv*dxL*/; + if (TMath::Abs(x2rL)<0.05) f13L = dxL*r2L+f2L*(f1L+f2L)*dx2rL; // see AliExternalTrackParam::PropagateTo + else { + double dy2dxL = (f1L+f2L)/(r1L+r2L); + f13L = 2*TMath::ASin(0.5*TMath::Sqrt(1+dy2dxL*dy2dxL)*x2rL)/(cnv*par[4]); + } + // MS contribution matrix: + double theta2 = theta2t*TMath::Abs(x2X0MS[il]); + double ms22 = theta2*(1.-p2Curr)*(1.+p2Curr)*ms22t; + double ms33 = theta2*ms33t; + double ms34 = theta2*ms34t; + double ms44 = theta2*ms44t; + // + // add H F MS F^Tr H^Tr to cv + cv00 += f02L*f02L*ms22 + f04L*f04L*ms44; + cv01 += f04L*f13L*ms34; + cv11 += f13L*f13L*ms33; + } + // + // inverse of matrix B + double b11 = ers[1]*ers[1] + cv00; + double b00 = ers[2]*ers[2] + cv11; + double det = b11*b00 - cv01*cv01; + if (TMath::Abs(det)