Common track parametrization in the barrel detectors (Yu.Belikov)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 5 Sep 2006 08:45:28 +0000 (08:45 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 5 Sep 2006 08:45:28 +0000 (08:45 +0000)
51 files changed:
HLT/ITS/AliL3ITStrack.cxx
HLT/ITS/AliL3ITStrack.h
HLT/ITS/AliL3ITStracker.cxx
HLT/hough/AliL3HoughKalmanTrack.cxx
ITS/AliITSComparisonV2.C
ITS/AliITSPid.cxx
ITS/AliITSVertexerTracks.cxx
ITS/AliITStrackMI.cxx
ITS/AliITStrackMI.h
ITS/AliITStrackSA.cxx
ITS/AliITStrackV2.cxx
ITS/AliITStrackV2.h
ITS/AliITStrackerANN.cxx
ITS/AliITStrackerMI.cxx
ITS/AliITStrackerSA.cxx
ITS/AliITStrackerV2.cxx
ITS/AliITStrackerV2.h
STEER/AliESDV0MI.h
STEER/AliESDtrack.cxx
STEER/AliESDtrack.h
STEER/AliExternalTrackParam.cxx
STEER/AliExternalTrackParam.h
STEER/AliHelix.cxx
STEER/AliKalmanTrack.cxx
STEER/AliKalmanTrack.h
STEER/AliKink.cxx [new file with mode: 0644]
STEER/AliKink.h [new file with mode: 0644]
STEER/AliTracker.h
STEER/AliV0.cxx [new file with mode: 0644]
STEER/AliV0.h [new file with mode: 0644]
STEER/AliVertexerTracks.cxx
STEER/ESDLinkDef.h
STEER/STEERLinkDef.h
STEER/libESD.pkg
STEER/libSTEER.pkg
TOF/AliTOFtrack.cxx
TOF/AliTOFtrack.h
TOF/AliTOFtracker.cxx
TOF/AliTOFtrackerMI.cxx
TPC/AliTPCseed.cxx
TPC/AliTPCseed.h
TPC/AliTPCtrack.cxx
TPC/AliTPCtrack.h
TPC/AliTPCtracker.cxx
TPC/AliTPCtracker.h
TPC/AliTPCtrackerMI.cxx
TPC/AliTPCtrackerMI.h
TPC/AliTPCtrackerParam.cxx
TRD/AliTRDtrack.cxx
TRD/AliTRDtrack.h
TRD/AliTRDtracker.cxx

index d75392f..5fe2339 100644 (file)
@@ -66,23 +66,3 @@ Int_t AliL3ITStrack::Compare(const TObject *o) const {
   else if (c<co) return -1;
   return 0;
 }
-
-Bool_t AliL3ITStrack::GetPxPyPzAt(Double_t x,Double_t *p) const {
-  //---------------------------------------------------------------------
-  // This function returns the global track momentum components
-  // at the position "x" using the helix track approximation
-  //---------------------------------------------------------------------
-  p[0]=fP4;
-  p[1]=fP2+(x-fX)*fP4/AliKalmanTrack::GetConvConst(); 
-  p[2]=fP3;
-
-  if (TMath::Abs(p[0])<=0)        return kFALSE;
-  if (TMath::Abs(p[1])> 0.999999) return kFALSE;
-
-  Double_t pt=1./TMath::Abs(p[0]);
-  Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
-  Double_t r=TMath::Sqrt(1 - p[1]*p[1]);
-  p[0]=pt*(r*cs - p[1]*sn); p[1]=pt*(p[1]*cs + r*sn); p[2]=pt*p[2];
-
-  return kTRUE;
-}
index 1e1dcd3..6e7621c 100644 (file)
@@ -26,8 +26,6 @@ public:
 
   Int_t Compare(const TObject *o) const;
 
-  Bool_t GetPxPyPzAt(Double_t x,Double_t *p) const;
-
   ClassDef(AliL3ITStrack,2)   //HLT ITS reconstructed track
 };
 
index 3d752f1..8a9ba37 100644 (file)
@@ -82,7 +82,7 @@ Int_t AliL3ITStracker::Clusters2Tracks(AliESD *event) {
         delete t;
         continue;
       }
-      if (TMath::Abs(t->GetD())>5) {
+      if (TMath::Abs(t->GetD(GetX(),GetY()))>5) {
        delete t;
        continue;
       }
@@ -124,7 +124,7 @@ Int_t AliL3ITStracker::Clusters2Tracks(AliESD *event) {
        }
        
        if (!fBestTrack.PropagateTo(3.,0.0028,65.19)) continue;
-       if (!fBestTrack.PropagateToVertex()) continue;
+       if (!fBestTrack.PropagateToVertex(event->GetVertex())) continue;
        fBestTrack.SetLabel(tpcLabel);
        fBestTrack.CookdEdx();
        CookLabel(&fBestTrack,0.); //For comparison only
index eaffbb9..3825c5f 100644 (file)
@@ -45,27 +45,20 @@ AliL3HoughKalmanTrack::AliL3HoughKalmanTrack(const AliL3HoughTrack& t) throw (co
   SetMass(0.13957);
 
   fdEdx=0;
-  fAlpha = fmod((t.GetSector()+0.5)*(2*TMath::Pi()/18),2*TMath::Pi());
-  if      (fAlpha < -TMath::Pi()) fAlpha += 2*TMath::Pi();
-  else if (fAlpha >= TMath::Pi()) fAlpha -= 2*TMath::Pi();
+  Double_t alpha = fmod((t.GetSector()+0.5)*(2*TMath::Pi()/18),2*TMath::Pi());
+  if      (alpha < -TMath::Pi()) alpha += 2*TMath::Pi();
+  else if (alpha >= TMath::Pi()) alpha -= 2*TMath::Pi();
 
   const Double_t xhit = 82.97;
   const Double_t zvertex = t.GetFirstPointZ();
-  Double_t xx[5];
+  Double_t par[5];
   Double_t deltax = t.GetPterr();
   Double_t deltay = t.GetPsierr();
   Double_t deltaeta = t.GetTglerr();
-  if(CalcExternalParams(t,0,0,0,zvertex,xhit,xx)==0) throw "AliL3HoughKalmanTrack: conversion failed !\n";
+  if(CalcExternalParams(t,0,0,0,zvertex,xhit,par)==0) throw "AliL3HoughKalmanTrack: conversion failed !\n";
 
-  //Filling of the track paramaters
-  fX=xhit;
-  fP0=xx[0];
-  fP1=xx[1];
-  fP2=xx[2];
-  fP3=xx[3];
-  fP4=xx[4];
-
-  SaveLocalConvConst();
+  Double_t cnv=1./(GetBz()*kB2C);
+  par[4]*=cnv;;
 
   //and covariance matrix
   //For the moment estimate the covariance matrix numerically
@@ -78,14 +71,19 @@ AliL3HoughKalmanTrack::AliL3HoughKalmanTrack(const AliL3HoughTrack& t) throw (co
 
   Double_t dx1[5],dx2[5],dx3[5];
   for(Int_t i=0;i<5;i++) {
-    dx1[i]=xx1[i]-xx[i];
-    dx2[i]=xx2[i]-xx[i];
-    dx3[i]=xx3[i]-xx[i];
+    dx1[i]=xx1[i]-par[i];
+    dx2[i]=xx2[i]-par[i];
+    dx3[i]=xx3[i]-par[i];
   }
 
-  fC00=dx1[0]*dx1[0]+dx2[0]*dx2[0];
-  fC22=dx1[2]*dx1[2]+dx2[2]*dx2[2];
-  fC44=dx1[4]*dx1[4]+dx2[4]*dx2[4];
+  Double_t cov[15]={
+    dx1[0]*dx1[0]+dx2[0]*dx2[0],
+    0.,  dx3[1]*dx3[1],
+    0.,  0.,  dx1[2]*dx1[2]+dx2[2]*dx2[2],
+    0.,  dx3[3]*dx3[1],  0.,  dx3[3]*dx3[3],
+    0.,  0.,  0.,  0.,  dx1[4]*dx1[4]+dx2[4]*dx2[4]
+  };
+  /*
   fC20=dx1[2]*dx1[0]+dx2[2]*dx2[0];
   fC40=dx1[4]*dx1[0]+dx2[4]*dx2[0];
   fC42=dx1[4]*dx1[2]+dx2[4]*dx2[2];
@@ -94,6 +92,10 @@ AliL3HoughKalmanTrack::AliL3HoughKalmanTrack(const AliL3HoughTrack& t) throw (co
   fC31=dx3[3]*dx3[1];
   fC10=fC30=fC21=fC41=fC32=fC43=0;
   fC20=fC42=fC40=0;
+  */
+  cov[10]*=cnv; cov[11]*=cnv; cov[12]*=cnv; cov[13]*=cnv; cov[14]*=(cnv*cnv); 
+
+  Set(xhit,alpha,par,cov);
 
 }
 
@@ -132,12 +134,9 @@ Int_t CalcExternalParams(const AliL3HoughTrack& t, Double_t deltax, Double_t del
   Double_t tanl = 1./tan(theta);
   zhit = zvertex + stot*tanl;
 
-  //Local sine of track azimuthal angle
-  Double_t sinbeta = centerx/radius;
-
   xx[0] = yhit;
   xx[1] = zhit;
-  xx[2] = sinbeta;
+  xx[2] = (xhit-centerx)/radius;
   xx[3] = tanl;
   xx[4] = kappa;
   return 1;
index e142816..7b3e01b 100644 (file)
@@ -208,8 +208,6 @@ Int_t AliITSComparisonV2
            numb[nmult]=cnt; nmult++;        
         }
 
-       if (esd->GetITSFakeRatio()<ratio) tlab = TMath::Abs(tlab);
-
         if (lab==tlab) hfound->Fill(ptg);
         else {
           fake[nfake++]=lab;
index 6300d29..e6a5045 100644 (file)
@@ -213,7 +213,7 @@ Int_t   AliITSPid::GetPcode(AliITStrackV2 *track)
   if(track==0)return 0;
   //      track->Propagate(track->GetAlpha(),3.,0.1/65.19*1.848,0.1*1.848);
       track->PropagateTo(3.,0.0028,65.19);
-      track->PropagateToVertex();
+      //track->PropagateToVertex();          Not needed. (I.B.)
     Double_t xk,par[5]; track->GetExternalParameters(xk,par);
     Float_t lam=TMath::ATan(par[3]);
     Float_t pt1=TMath::Abs(par[4]);
index ad1949a..9e44cf5 100644 (file)
@@ -271,7 +271,7 @@ Int_t AliITSVertexerTracks::PrepareTracks(TTree &trkTree) {
     // propagate track to vtxSeed
     alpha  = track->GetAlpha();
     xlStart = fNominalPos[0]*TMath::Cos(alpha)+fNominalPos[1]*TMath::Sin(alpha);
-    track->PropagateTo(xlStart,field);   // to vtxSeed
+    track->AliExternalTrackParam::PropagateTo(xlStart,field);   // to vtxSeed
 
     // select tracks with d0rphi < maxd0rphi
    
@@ -494,7 +494,7 @@ void AliITSVertexerTracks::VertexFitter() {
       t = (AliESDtrack*)fTrkArray.At(k);
       alpha = t->GetAlpha();
       xlStart = initPos[0]*TMath::Cos(alpha)+initPos[1]*TMath::Sin(alpha);
-      t->PropagateTo(xlStart,AliTracker::GetBz());   // to vtxSeed
+      t->AliExternalTrackParam::PropagateTo(xlStart,AliTracker::GetBz());   // to vtxSeed
       rotAngle = alpha;
       if(alpha<0.) rotAngle += 2.*TMath::Pi();
       cosRot = TMath::Cos(rotAngle);
index c3ab695..634b6a7 100644 (file)
@@ -133,21 +133,9 @@ Double_t AliITStrackMI::GetPredictedChi2MI(Double_t cy, Double_t cz, Double_t ce
   //-----------------------------------------------------------------
   // This function calculates a predicted chi2 increment.
   //-----------------------------------------------------------------
-  Double_t r00=cerry*cerry, r01=0., r11=cerrz*cerrz;
-  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) 
-      Warning("GetPredictedChi2","Singular matrix (%d) !\n",n);
-    return 1e10;
-  }
-  Double_t tmp=r00; r00=r11; r11=tmp; r01=-r01;
-
-  Double_t dy=cy - fP0, dz=cz - fP1;
-
-  return (dy*r00*dy + 2*r01*dy*dz + dz*r11*dz)/det;
+  Double_t p[2]={cy, cz};
+  Double_t cov[3]={cerry*cerry, 0., cerrz*cerrz};
+  return AliExternalTrackParam::GetPredictedChi2(p,cov);
 }
 
 //____________________________________________________________________________
@@ -155,22 +143,22 @@ Int_t AliITStrackMI::CorrectForMaterial(Double_t d, Double_t x0) {
   //------------------------------------------------------------------
   //This function corrects the track parameters for crossed material
   //------------------------------------------------------------------
-  //  Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
-  Double_t p2=(1.+ fP3*fP3)/(Get1Pt()*Get1Pt());
+  //d=x0=0.;
+
+  Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
   Double_t et   = p2 + GetMass()*GetMass();
   Double_t beta2=p2/et;
   et = sqrt(et);  
-  d*=TMath::Sqrt((1.+ fP3*fP3)/(1.- fP2*fP2));
-  //d*=TMath::Sqrt(1.+ fP3*fP3 +fP2*fP2/(1.- fP2*fP2));
+  d*=TMath::Sqrt((1.+ GetTgl()*GetTgl())/(1.- GetSnp()*GetSnp()));
 
   //Multiple scattering******************
   if (d!=0) {
      Double_t theta2=14.1*14.1/(beta2*p2*1e6)*TMath::Abs(d);
      //Double_t theta2=1.0259e-6*14*14/28/(beta2*p2)*TMath::Abs(d)*9.36*2.33;
-     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;
+     Cov(5) += theta2*(1.- GetSnp()*GetSnp())*(1. + GetTgl()*GetTgl());
+     Cov(9) += theta2*(1. + GetTgl()*GetTgl())*(1. + GetTgl()*GetTgl());
+     Cov(13)+= theta2*GetTgl()*Get1Pt()*(1. + GetTgl()*GetTgl());
+     Cov(14)+= theta2*GetTgl()*Get1Pt()*GetTgl()*Get1Pt();
   }
 
   //Energy losses************************
@@ -179,19 +167,18 @@ Int_t AliITStrackMI::CorrectForMaterial(Double_t d, Double_t x0) {
      //     Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*d;
      //Double_t dE=0; 
      Double_t dE = 0.265*0.153e-3*(39.2-55.6*beta2+28.7*beta2*beta2+27.41/beta2)*d;
-     /*
-     if (beta2/(1-beta2)>3.5*3.5){
-       dE=0.153e-3/beta2*(log(3.5*5940)+0.5*log(beta2/(1-beta2)) - beta2)*d;
-     }
-     else{
-       dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*d;
-       dE+=0.06e-3/(beta2*beta2)*d;
-     }
-     */
-     fP4*=(1.- et/p2*dE);
-     Double_t delta44 = (dE*fP4*et/p2);
+     //if (beta2/(1-beta2)>3.5*3.5){
+     //  dE=0.153e-3/beta2*(log(3.5*5940)+0.5*log(beta2/(1-beta2)) - beta2)*d;
+     //}
+     //else{
+     //  dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*d;
+     //  dE+=0.06e-3/(beta2*beta2)*d;
+     //}
+
+     Par(4)*=(1.- et/p2*dE);
+     Double_t delta44 = (dE*Get1Pt()*et/p2);
      delta44*=delta44;
-     fC44+= delta44/400.;
+     Cov(14)+= delta44/400.;
   }
 
   if (!Invariant()) return 0;
@@ -200,72 +187,24 @@ Int_t AliITStrackMI::CorrectForMaterial(Double_t d, Double_t x0) {
 }
 
 //____________________________________________________________________________
-Int_t AliITStrackMI::UpdateMI(Double_t cy, Double_t cz, Double_t cerry, Double_t cerrz, Double_t chi2,UInt_t index) {
+Bool_t AliITStrackMI::UpdateMI(Double_t cy, Double_t cz, Double_t cerry, Double_t cerrz, Double_t chi2, Int_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=cerry*cerry, r01=0., r11=cerrz*cerrz;
-  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=cy - fP0, dz=cz - fP1;
+  Double_t dy=cy - GetY(), dz=cz - GetZ();
   Int_t layer = (index & 0xf0000000) >> 28;
   fDy[layer] = dy;
   fDz[layer] = dz;
-  fSigmaY[layer] = TMath::Sqrt(cerry*cerry+fC00);
-  fSigmaZ[layer] = TMath::Sqrt(cerrz*cerrz+fC11);
-
-  Double_t sf=fP2 + k20*dy + k21*dz;
-  
-  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; 
+  fSigmaY[layer] = TMath::Sqrt(cerry*cerry+GetSigmaY2());
+  fSigmaZ[layer] = TMath::Sqrt(cerrz*cerrz+GetSigmaZ2());
 
-  fC22-=k20*c02+k21*c12;   fC32-=k20*c03+k21*c13;
-  fC42-=k20*c04+k21*c14; 
-
-  fC33-=k30*c03+k31*c13;
-  fC43-=k30*c04+k31*c14; 
-
-  fC44-=k40*c04+k41*c14; 
+  Double_t p[2]={cy, cz};
+  Double_t cov[3]={cerry*cerry, 0., cerrz*cerrz};
+  if (!AliExternalTrackParam::Update(p,cov)) return kFALSE;
 
   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;
+     AliWarning("Wrong invariant !");
+     return kFALSE;
   }
 
   if (chi2<0) return 1;
@@ -274,7 +213,7 @@ Int_t AliITStrackMI::UpdateMI(Double_t cy, Double_t cz, Double_t cerry, Double_t
   SetNumberOfClusters(n+1);
   SetChi2(GetChi2()+chi2);
 
-  return 1;
+  return kTRUE;
 }
 
 Int_t AliITStrackMI::GetProlongationFast(Double_t alp, Double_t xk,Double_t &y, Double_t &z)
@@ -282,19 +221,19 @@ Int_t AliITStrackMI::GetProlongationFast(Double_t alp, Double_t xk,Double_t &y,
   //-----------------------------------------------------------------------------
   //get fast prolongation 
   //-----------------------------------------------------------------------------
-  Double_t ca=TMath::Cos(alp-fAlpha), sa=TMath::Sin(alp-fAlpha);
-  Double_t cf=TMath::Sqrt(1.- fP2*fP2);  
+  Double_t ca=TMath::Cos(alp-GetAlpha()), sa=TMath::Sin(alp-GetAlpha());
+  Double_t cf=TMath::Sqrt(1.- GetSnp()*GetSnp());  
   // **** rotation **********************  
-  y= -fX*sa + fP0*ca;
+  y= -GetX()*sa + GetY()*ca;
   // **** translation ******************  
-  Double_t dx = xk- fX*ca - fP0*sa;
-  Double_t f1=fP2*ca - cf*sa, f2=f1 + fP4*dx;
+  Double_t dx = xk- GetX()*ca - GetY()*sa;
+  Double_t f1=GetSnp()*ca - cf*sa, f2=f1 + GetC()*dx;
   if (TMath::Abs(f2) >= 0.9999) {
     return 0;
   }
   Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);  
   y += dx*(f1+f2)/(r1+r2);
-  z  = fP1+dx*(f1+f2)/(f1*r2 + f2*r1)*fP3;  
+  z  = GetZ()+dx*(f1+f2)/(f1*r2 + f2*r1)*GetTgl();  
   return 1;
 }
 
index 14e0227..72f1613 100644 (file)
@@ -41,7 +41,7 @@ public:
   AliITStrackMI(AliESDtrack& t,Bool_t c=kFALSE) throw (const Char_t *);
   AliITStrackMI(const AliITStrackMI& t);
   Int_t GetProlongationFast(Double_t alpha, Double_t xr,Double_t &y, Double_t &z);
-  Int_t UpdateMI(Double_t cy, Double_t cz, Double_t cerry, Double_t cerrz, Double_t chi2,UInt_t i);  
+  Bool_t UpdateMI(Double_t cy, Double_t cz, Double_t cerry, Double_t cerrz, Double_t chi2, Int_t i);  
   Int_t CorrectForMaterial(Double_t d, Double_t x0=21.82);
 
   void UpdateESDtrack(ULong_t flags);
@@ -56,8 +56,8 @@ public:
   Float_t GetNUsed() const {return fNUsed;}
 
   Int_t Compare(const TObject *o) const;
-  Double_t GetCov33() const {return fC33;} // cov. matrix el. 3,3
-  Double_t GetCov44() const {return fC44;} // cov. matrix el. 4,4
+  Double_t GetCov33() const {return GetCovariance()[9];} // cov. matrix el. 3,3
+  //Double_t GetCov44() const {return GetCovariance()[15];}// cov. matrix el. 4,4
   Float_t GetDy(Int_t i) const {return fDy[i];}
   Float_t GetDz(Int_t i) const {return fDz[i];}
   Float_t GetSigmaY(Int_t i) const {return fSigmaY[i];}
index 27444e7..81d3445 100755 (executable)
@@ -88,9 +88,9 @@ AliITStrackSA::AliITStrackSA(AliITSgeom* geom,Int_t layer, Int_t ladder, Int_t d
   // cluster of this track (data member fAlpha)
   Float_t rotmatr[9];
   geom->GetRotMatrix(layer,ladder,detector,rotmatr);
-  fAlpha=TMath::ATan2(rotmatr[1],rotmatr[0])+TMath::Pi();
-  fAlpha+=TMath::Pi()/2.;
-  if(layer==1) fAlpha+=TMath::Pi();
+  Double_t sAlpha=TMath::ATan2(rotmatr[1],rotmatr[0])+TMath::Pi();
+  sAlpha+=TMath::Pi()/2.;
+  if(layer==1) sAlpha+=TMath::Pi();
 
 
   // get the radius of this detector. Procedure taken from the 
@@ -102,33 +102,36 @@ AliITStrackSA::AliITStrackSA(AliITSgeom* geom,Int_t layer, Int_t ladder, Int_t d
   fi+=TMath::Pi()/2;
   if (layer==1) fi+=TMath::Pi();
   Double_t cp=TMath::Cos(fi), sp=TMath::Sin(fi);
-  fX=x*cp+y*sp;
+  Double_t sX=x*cp+y*sp;
 
 
   fdEdx = 0;
 
-  fC00 = 0.000009; // 0.000009
-  fC10 = 0.;
-  fC11 = 0.000003; //0.000030
-  fC20 = 0.;
-  fC21 = 0.;
-  fC22 = 0.000001; //0.000001
-  fC30 = 0.;
-  fC31 = 0.;
-  fC32 = 0.;
-  fC33 = 0.000002; //0.000002
-  fC40 = 0.;
-  fC41 = 0.;
-  fC42 = 0.;
-  fC43 = 0.;
-  fC44 = 0.000001; //0.0000001
-
-  fP0 = Ycoor;
-  fP1 = Zcoor;
-  
-  fP2 = TMath::Sin(phi-fAlpha);
-  fP3 = tanlambda;
-  fP4 = curv;
+  Double_t conv=GetBz()*kB2C;
+  Double_t sC[] = {0.000009, // 0.000009
+                   0.,
+                   0.000003, //0.000030
+                   0.,
+                  0.,
+                  0.000001, //0.000001
+                  0.,
+                  0.,
+                  0.,
+                  0.000002, //0.000002
+                  0.,
+                  0.,
+                  0.,
+                  0.,
+                  0.000001/(conv*conv)}; //0.0000001
+
+  Double_t sP[] = {Ycoor,
+                  Zcoor,
+                   TMath::Sin(phi-sAlpha),
+                  tanlambda,
+                  curv/conv};
+
+  Set(sX,sAlpha,sP,sC);
+
   for(Int_t i=0; i<kMaxLayer; i++) fIndex[i] = 0;  // to be set explicitely
 
   for(Int_t i=0; i<4; i++) fdEdxSample[i] = 0; 
@@ -142,7 +145,6 @@ AliITStrackSA::AliITStrackSA(AliITSgeom* geom,Int_t layer, Int_t ladder, Int_t d
   SetMass(0.139);    // pion mass
   SetLabel(lab); 
   
-
 }
 
 //____________________________________________________________
index 975688a..5950e9d 100644 (file)
@@ -22,6 +22,7 @@
 #include <TMath.h>
 
 #include "AliCluster.h"
+#include "AliTracker.h"
 #include "AliESDtrack.h"
 #include "AliITStrackV2.h"
 
@@ -30,30 +31,8 @@ ClassImp(AliITStrackV2)
 const Int_t kWARN=5;
 
 //____________________________________________________________________________
-AliITStrackV2::AliITStrackV2():AliKalmanTrack(),
-  fX(0),
-  fAlpha(0),
+AliITStrackV2::AliITStrackV2() : AliKalmanTrack(),
   fdEdx(0),
-  fP0(0),
-  fP1(0),
-  fP2(0),
-  fP3(0),
-  fP4(0),
-  fC00(0),
-  fC10(0),
-  fC11(0),
-  fC20(0),
-  fC21(0),
-  fC22(0),
-  fC30(0),
-  fC31(0),
-  fC32(0),
-  fC33(0),
-  fC40(0),
-  fC41(0),
-  fC42(0),
-  fC43(0),
-  fC44(0),
   fESDtrack(0)
 {
     for(Int_t i=0; i<2*kMaxLayer; i++) fIndex[i]=-1;
@@ -63,51 +42,33 @@ AliITStrackV2::AliITStrackV2():AliKalmanTrack(),
 
 //____________________________________________________________________________
 AliITStrackV2::AliITStrackV2(AliESDtrack& t,Bool_t c) throw (const Char_t *) :
-AliKalmanTrack() {
+  AliKalmanTrack(),
+  fdEdx(t.GetITSsignal()),
+  fESDtrack(&t)
+{
   //------------------------------------------------------------------
   // Conversion ESD track -> ITS track.
   // If c==kTRUE, create the ITS track out of the constrained params.
   //------------------------------------------------------------------
-  SetNumberOfClusters(t.GetITSclusters(fIndex));
+  const AliExternalTrackParam *par=&t;
+  if (c) {
+    par=t.GetConstrainedExternalParameters();
+    if (!par) throw "AliITStrackV2: conversion failed !\n";
+  }
+  Set(par->GetX(),par->GetAlpha(),par->GetParameter(),par->GetCovariance());
+
+  //if (!Invariant()) throw "AliITStrackV2: conversion failed !\n";
+
   SetLabel(t.GetLabel());
   SetMass(t.GetMass());
-  //
-  //
-
-  fdEdx=t.GetITSsignal();
-  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]; 
-  if (c) t.GetConstrainedExternalParameters(fAlpha,x,p);
-  else t.GetExternalParameters(x,p);
-  fX=x;   
-  fP0=p[0]; 
-  fP1=p[1];   SaveLocalConvConst(); 
-  fP2=p[2];
-  fP3=p[3];   x=GetLocalConvConst();
-  fP4=p[4]/x; 
-
-  //Conversion of the covariance matrix
-  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;
+  SetNumberOfClusters(t.GetITSclusters(fIndex));
 
   if (t.GetStatus()&AliESDtrack::kTIME) {
     StartTimeIntegral();
     Double_t times[10]; t.GetIntegratedTimes(times); SetIntegratedTimes(times);
     SetIntegratedLength(t.GetIntegratedLength());
   }
-  fESDtrack=&t;
 
-  //  if (!Invariant()) throw "AliITStrackV2: conversion failed !\n";
   for(Int_t i=0; i<4; i++) fdEdxSample[i]=0;
 }
 
@@ -116,27 +77,17 @@ void AliITStrackV2::UpdateESDtrack(ULong_t flags) const {
 }
 
 //____________________________________________________________________________
-AliITStrackV2::AliITStrackV2(const AliITStrackV2& t) : AliKalmanTrack(t) {
+AliITStrackV2::AliITStrackV2(const AliITStrackV2& t) : 
+  AliKalmanTrack(t),
+  fdEdx(t.fdEdx),
+  fESDtrack(t.fESDtrack) 
+{
   //------------------------------------------------------------------
   //Copy constructor
   //------------------------------------------------------------------
-  fX=t.fX;
-  fAlpha=t.fAlpha;
-  fdEdx=t.fdEdx;
-
-  fP0=t.fP0; fP1=t.fP1; fP2=t.fP2; fP3=t.fP3; fP4=t.fP4;
-
-  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;
-
   Int_t i;
-  for (i=0; i<2*kMaxLayer; i++) fIndex[i]=t.fIndex[i];
   for (i=0; i<4; i++) fdEdxSample[i]=t.fdEdxSample[i];
-
-  fESDtrack=t.fESDtrack;
+  for (i=0; i<2*kMaxLayer; i++) fIndex[i]=t.fIndex[i];
 }
 
 //_____________________________________________________________________________
@@ -154,556 +105,191 @@ Int_t AliITStrackV2::Compare(const TObject *o) const {
   return 0;
 }
 
-//_____________________________________________________________________________
-void AliITStrackV2::GetExternalCovariance(Double_t cc[15]) const {
-  //-------------------------------------------------------------------------
-  // This function returns an external representation of the covriance matrix.
-  //   (See comments in AliTPCtrack.h about external track representation)
-  //-------------------------------------------------------------------------
-  Double_t a=GetLocalConvConst();
-
-  cc[0 ]=fC00;
-  cc[1 ]=fC10;   cc[2 ]=fC11;
-  cc[3 ]=fC20;   cc[4 ]=fC21;   cc[5 ]=fC22;
-  cc[6 ]=fC30;   cc[7 ]=fC31;   cc[8 ]=fC32;   cc[9 ]=fC33;
-  cc[10]=fC40*a; cc[11]=fC41*a; cc[12]=fC42*a; cc[13]=fC43*a; cc[14]=fC44*a*a;
-}
-
 //____________________________________________________________________________
-Int_t AliITStrackV2::PropagateToVertex(Double_t d,Double_t x0) {
+Bool_t 
+AliITStrackV2::PropagateToVertex(const AliESDVertex *v,Double_t d,Double_t x0) 
+{
   //------------------------------------------------------------------
   //This function propagates a track to the minimal distance from the origin
-  //------------------------------------------------------------------
-  //Double_t xv=fP2*(fX*fP2 - fP0*TMath::Sqrt(1.- fP2*fP2)); //linear approxim.
-  Double_t tgf=-(fP4*fX - fP2)/(fP4*fP0 + TMath::Sqrt(1 - fP2*fP2));
-  Double_t snf=tgf/TMath::Sqrt(1.+ tgf*tgf);
-  Double_t xv=(snf - fP2)/fP4 + fX;
-  return PropagateTo(xv,d,x0);
+  //------------------------------------------------------------------  
+  Double_t bz=GetBz();
+  if (PropagateToDCA(v,bz,kVeryBig))
+   if (AliExternalTrackParam::CorrectForMaterial(d,x0,GetMass())) return kTRUE;
+  return kFALSE;
 }
 
 //____________________________________________________________________________
-Int_t AliITStrackV2::
+Bool_t AliITStrackV2::
 GetGlobalXYZat(Double_t xk, Double_t &x, Double_t &y, Double_t &z) const {
   //------------------------------------------------------------------
   //This function returns a track position in the global system
   //------------------------------------------------------------------
-  Double_t dx=xk-fX;
-  Double_t f1=fP2, f2=f1 + fP4*dx;
-  if (TMath::Abs(f2) >= 0.9999) {
-    Int_t n=GetNumberOfClusters();
-    if (n>kWARN) 
-      Warning("GetGlobalXYZat","Propagation failed (%d) !\n",n);
-    return 0;
-  }
-
-  Double_t r1=sqrt(1.- f1*f1), r2=sqrt(1.- f2*f2);
-  
-  Double_t yk = fP0 + dx*(f1+f2)/(r1+r2);
-  Double_t zk = fP1 + dx*(f1+f2)/(f1*r2 + f2*r1)*fP3;
-
-  Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
-  x = xk*cs - yk*sn;
-  y = xk*sn + yk*cs;
-  z = zk;
-
-  return 1;
+  Double_t r[3];
+  Bool_t rc=GetXYZAt(xk, AliTracker::GetBz(), r);
+  x=r[0]; y=r[1]; z=r[2]; 
+  return rc;
 }
 
 //_____________________________________________________________________________
-Double_t AliITStrackV2::GetPredictedChi2(const AliCluster *c) const 
-{
+Double_t AliITStrackV2::GetPredictedChi2(const AliCluster *c) const {
   //-----------------------------------------------------------------
   // This function calculates a predicted chi2 increment.
   //-----------------------------------------------------------------
-  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();
-    if (n>kWARN) 
-      Warning("GetPredictedChi2","Singular matrix (%d) !\n",n);
-    return 1e10;
-  }
-  Double_t tmp=r00; r00=r11; r11=tmp; r01=-r01;
-
-  Double_t dy=c->GetY() - fP0, dz=c->GetZ() - fP1;
-
-  return (dy*r00*dy + 2*r01*dy*dz + dz*r11*dz)/det;
-}
-
-//____________________________________________________________________________
-Int_t AliITStrackV2::CorrectForMaterial(Double_t d, Double_t x0) {
-  //------------------------------------------------------------------
-  //This function corrects the track parameters for crossed material
-  //------------------------------------------------------------------
-  Double_t p2=(1.+ fP3*fP3)/(Get1Pt()*Get1Pt());
-  Double_t beta2=p2/(p2 + GetMass()*GetMass());
-  d*=TMath::Sqrt((1.+ fP3*fP3)/(1.- fP2*fP2));
-
-  //Multiple scattering******************
-  if (d!=0) {
-     Double_t theta2=14.1*14.1/(beta2*p2*1e6)*TMath::Abs(d);
-     //Double_t theta2=1.0259e-6*14*14/28/(beta2*p2)*TMath::Abs(d)*9.36*2.33;
-     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 (x0!=0.) {
-     d*=x0;
-     Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*d;
-     if (beta2/(1-beta2)>3.5*3.5)
-       dE=0.153e-3/beta2*(log(3.5*5940)+0.5*log(beta2/(1-beta2)) - beta2)*d;
-
-     fP4*=(1.- TMath::Sqrt(p2+GetMass()*GetMass())/p2*dE);
-  }
-
-  if (!Invariant()) return 0;
-
-  return 1;
+  Double_t p[2]={c->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 d, Double_t x0) {
+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.98) {
-    // MI change  - don't propagate highly inclined tracks
-    //              covariance matrix distorted
-    //Int_t n=GetNumberOfClusters();
-    //if (n>kWARN) 
-    //   Warning("PropagateTo","Propagation failed !\n",n);
-    return 0;
-  }
-  Double_t lcc=GetLocalConvConst();  
-
-  // old position [SR, GSI, 17.02.2003]
-  Double_t oldX = fX, oldY = fP0, oldZ = fP1;
-
-  Double_t r1=sqrt(1.- f1*f1), r2=sqrt(1.- f2*f2);
+  Double_t oldX=GetX(), oldY=GetY(), oldZ=GetZ();
   
-  fP0 += dx*(f1+f2)/(r1+r2);
-  fP1 += dx*(f1+f2)/(f1*r2 + f2*r1)*fP3;
-  fP2 += dx*fP4;
+  Double_t bz=GetBz();
+  if (!AliExternalTrackParam::PropagateTo(xk,bz)) return kFALSE;
+ if (!AliExternalTrackParam::CorrectForMaterial(d,x0,GetMass())) return kFALSE;
 
-  //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 + f04*fC40, b01=f12*fC20 + f14*fC40 + f13*fC30;
-  Double_t b02=f24*fC40;
-  Double_t b10=f02*fC21 + f04*fC41, b11=f12*fC21 + f14*fC41 + f13*fC31;
-  Double_t b12=f24*fC41;
-  Double_t b20=f02*fC22 + f04*fC42, b21=f12*fC22 + f14*fC42 + f13*fC32;
-  Double_t b22=f24*fC42;
-  Double_t b40=f02*fC42 + f04*fC44, b41=f12*fC42 + f14*fC44 + f13*fC43;
-  Double_t b42=f24*fC44;
-  Double_t b30=f02*fC32 + f04*fC43, b31=f12*fC32 + f14*fC43 + f13*fC33;
-  Double_t b32=f24*fC43;
-  
-  //a = f*b = f*C*ft
-  Double_t a00=f02*b20+f04*b40,a01=f02*b21+f04*b41,a02=f02*b22+f04*b42;
-  Double_t a11=f12*b21+f14*b41+f13*b31,a12=f12*b22+f14*b42+f13*b32;
-  Double_t a22=f24*b42;
-
-  //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;
-
-  fX=x2;
-
-  //Change of the magnetic field *************
-  SaveLocalConvConst();
-  fP4*=lcc/GetLocalConvConst();
-
-  if (!CorrectForMaterial(d,x0)) return 0;
-
-  // Integrated Time [SR, GSI, 17.02.2003]
-  if (IsStartedTimeIntegral() && fX>oldX) {
-    Double_t l2 = (fX-oldX)*(fX-oldX)+(fP0-oldY)*(fP0-oldY)+
-                  (fP1-oldZ)*(fP1-oldZ);
+  Double_t x=GetX(), y=GetZ(), z=GetZ();
+  if (IsStartedTimeIntegral() && x>oldX) {
+    Double_t l2 = (x-oldX)*(x-oldX) + (y-oldY)*(y-oldY) + (z-oldZ)*(z-oldZ);
     AddTimeStep(TMath::Sqrt(l2));
   }
-  //
 
-  return 1;
+  return kTRUE;
 }
 
 //____________________________________________________________________________
-Int_t AliITStrackV2::Update(const AliCluster* c, Double_t chi2, UInt_t index) {
+Bool_t AliITStrackV2::Update(const AliCluster* c, Double_t chi2, Int_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;
-  
-  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; 
-
-  fC22-=k20*c02+k21*c12;   fC32-=k20*c03+k21*c13;
-  fC42-=k20*c04+k21*c14; 
+  Double_t p[2]={c->GetY(), c->GetZ()};
+  Double_t cov[3]={c->GetSigmaY2(), 0., c->GetSigmaZ2()};
 
-  fC33-=k30*c03+k31*c13;
-  fC43-=k30*c04+k31*c14; 
-
-  fC44-=k40*c04+k41*c14; 
+  if (!AliExternalTrackParam::Update(p,cov)) return kFALSE;
 
   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;
+     AliWarning("Wrong invariant !");
+     return kFALSE;
   }
 
-  if (chi2<0) return 1;
+  if (chi2<0) return kTRUE;
 
   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
   //------------------------------------------------------------------
   Int_t n=GetNumberOfClusters();
-  
-  if (TMath::Abs(fP2)>=0.9999){
-     if (n>kWARN) Warning("Invariant","fP2=%f\n",fP2);
-     return 0;
+
+  Double_t sP2=GetParameter()[2];
+  if (TMath::Abs(sP2) >= kAlmost1){
+     if (n>kWARN) Warning("Invariant","fP2=%f\n",sP2);
+     return kFALSE;
   }
-  if (fC00<=0 || fC00>9.) {
-     if (n>kWARN) Warning("Invariant","fC00=%f\n",fC00); 
-     return 0;
+  Double_t sC00=GetCovariance()[0];
+  if (sC00<=0 || sC00>9.) {
+     if (n>kWARN) Warning("Invariant","fC00=%f\n",sC00); 
+     return kFALSE;
   }
-  if (fC11<=0 || fC11>9.) {
-     if (n>kWARN) Warning("Invariant","fC11=%f\n",fC11); 
-     return 0;
+  Double_t sC11=GetCovariance()[2];
+  if (sC11<=0 || sC11>9.) {
+     if (n>kWARN) Warning("Invariant","fC11=%f\n",sC11); 
+     return kFALSE;
   }
-  if (fC22<=0 || fC22>1.) {
-     if (n>kWARN) Warning("Invariant","fC22=%f\n",fC22); 
-     return 0;
+  Double_t sC22=GetCovariance()[5];
+  if (sC22<=0 || sC22>1.) {
+     if (n>kWARN) Warning("Invariant","fC22=%f\n",sC22); 
+     return kFALSE;
   }
-  if (fC33<=0 || fC33>1.) {
-     if (n>kWARN) Warning("Invariant","fC33=%f\n",fC33); 
-     return 0;
+  Double_t sC33=GetCovariance()[9];
+  if (sC33<=0 || sC33>1.) {
+     if (n>kWARN) Warning("Invariant","fC33=%f\n",sC33); 
+     return kFALSE;
   }
-  if (fC44<=0 || fC44>6e-5) {
-     if (n>kWARN) Warning("Invariant","fC44=%f\n",fC44);
-     return 0;
+  Double_t sC44=GetCovariance()[14];
+  if (sC44<=0 /*|| sC44>6e-5*/) {
+     if (n>kWARN) Warning("Invariant","fC44=%f\n",sC44);
+     return kFALSE;
   }
-  return 1;
+
+  return kTRUE;
 }
 
 //____________________________________________________________________________
-Int_t AliITStrackV2::Propagate(Double_t alp,Double_t xk) {
+Bool_t AliITStrackV2::Propagate(Double_t alp,Double_t xk) {
   //------------------------------------------------------------------
   //This function propagates a track
   //------------------------------------------------------------------
-  Double_t alpha=fAlpha, x=fX;
-  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;
-
-  if      (alp < -TMath::Pi()) alp += 2*TMath::Pi();
-  else if (alp >= TMath::Pi()) alp -= 2*TMath::Pi();
-  Double_t ca=TMath::Cos(alp-fAlpha), sa=TMath::Sin(alp-fAlpha);
-  Double_t sf=fP2, cf=TMath::Sqrt(1.- fP2*fP2);
-
-  // **** rotation **********************
-  {
-  fAlpha = alp;
-  fX =  x*ca + p0*sa;
-  fP0= -x*sa + p0*ca;
-  fP2=  sf*ca - cf*sa;
-
-  Double_t rr=(ca+sf/cf*sa);  
-
-  fC00 *= (ca*ca);
-  fC10 *= ca; 
-  fC20 *= ca*rr;
-  fC30 *= ca;
-  fC40 *= ca;
-  //fC11 = fC11;
-  fC21 *= rr;
-  //fC31 = fC31; 
-  //fC41 = fC41;
-  fC22 *= rr*rr;
-  fC32 *= rr;
-  fC42 *= rr;
-  //fC33=fC33;
-  //fC43=fC43;
-  //fC44=fC44;
-  }
-
-  // **** translation ******************
-  {
-  Double_t dx=xk-fX;
-  Double_t f1=fP2, f2=f1 + fP4*dx;
-  if (TMath::Abs(f2) >= 0.98) {
-    // don't propagate highly inclined tracks MI
-    return 0;
-  }
-  //    Int_t n=GetNumberOfClusters();
-  //  if (n>kWARN) 
-  //     Warning("Propagate","Propagation failed (%d) !\n",n);
-  //  return 0;
-  //}
-  Double_t lcc=GetLocalConvConst();  
-
-  Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
-
-  fX=xk;
-  fP0 += dx*(f1+f2)/(r1+r2);
-  fP1 += dx*(f1+f2)/(f1*r2 + f2*r1)*fP3;
-  fP2 += dx*fP4;
-
-  //Change of the magnetic field *************
-  SaveLocalConvConst();
-  fP4*=lcc/GetLocalConvConst();
-
-  //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 + f04*fC40, b01=f12*fC20 + f14*fC40 + f13*fC30;
-  Double_t b02=f24*fC40;
-  Double_t b10=f02*fC21 + f04*fC41, b11=f12*fC21 + f14*fC41 + f13*fC31;
-  Double_t b12=f24*fC41;
-  Double_t b20=f02*fC22 + f04*fC42, b21=f12*fC22 + f14*fC42 + f13*fC32;
-  Double_t b22=f24*fC42;
-  Double_t b40=f02*fC42 + f04*fC44, b41=f12*fC42 + f14*fC44 + f13*fC43;
-  Double_t b42=f24*fC44;
-  Double_t b30=f02*fC32 + f04*fC43, b31=f12*fC32 + f14*fC43 + f13*fC33;
-  Double_t b32=f24*fC43;
-  
-  //a = f*b = f*C*ft
-  Double_t a00=f02*b20+f04*b40,a01=f02*b21+f04*b41,a02=f02*b22+f04*b42;
-  Double_t a11=f12*b21+f14*b41+f13*b31,a12=f12*b22+f14*b42+f13*b32;
-  Double_t a22=f24*b42;
-
-  //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;
+  Double_t bz=GetBz();
+  if (!AliExternalTrackParam::Propagate(alp,xk,bz)) return kFALSE;
 
   if (!Invariant()) {
-     fAlpha=alpha; 
-     fX=x; 
-     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;
-  }
-  }
-
-  return 1;
-}
-
-
-Double_t AliITStrackV2::GetD(Double_t x, Double_t y) const {
-  //------------------------------------------------------------------
-  // This function calculates the transverse impact parameter
-  // with respect to a point with global coordinates (x,y)
-  //------------------------------------------------------------------
-  Double_t xt=fX, yt=fP0;
-
-  Double_t sn=TMath::Sin(fAlpha), cs=TMath::Cos(fAlpha);
-  Double_t a = x*cs + y*sn;
-  y = -x*sn + y*cs; x=a;
-  xt-=x; yt-=y;
-
-  sn=fP4*xt - fP2; cs=fP4*yt + TMath::Sqrt(1.- fP2*fP2);
-  a=2*(xt*fP2 - yt*TMath::Sqrt(1.- fP2*fP2))-fP4*(xt*xt + yt*yt);
-  return -a/(1 + TMath::Sqrt(sn*sn + cs*cs));
-}
-
-void 
-AliITStrackV2::GetDZ(Double_t x, Double_t y, Double_t z, Float_t dz[2]) const {
-  //------------------------------------------------------------------
-  // This function calculates the transverse and longitudinal impact parameters
-  // with respect to a point with global coordinates (x,y,z)
-  //------------------------------------------------------------------
-  Double_t f1 = fP2, r1 = TMath::Sqrt(1. - f1*f1);
-  Double_t xt=fX, yt=fP0;
-  Double_t sn=TMath::Sin(fAlpha), cs=TMath::Cos(fAlpha);
-  Double_t a = x*cs + y*sn;
-  y = -x*sn + y*cs; x=a;
-  xt-=x; yt-=y;
-
-  Double_t rp4=fP4;
-  if (TMath::Abs(rp4) < kAlmost0) {
-     dz[0] = -(xt*f1 - yt*r1);
-     dz[1] = fP1 + (dz[0]*f1 - xt)/r1*fP3 - z;
-     return;
+     AliWarning("Wrong invariant !");
+     return kFALSE;
   }
 
-  sn=rp4*xt - f1; cs=rp4*yt + r1;
-  a=2*(xt*f1 - yt*r1)-rp4*(xt*xt + yt*yt);
-  Double_t rr=TMath::Sqrt(sn*sn + cs*cs);
-  dz[0] = -a/(1 + rr);
-  Double_t f2 = -sn/rr, r2 = TMath::Sqrt(1. - f2*f2);
-  dz[1] = fP1 + fP3/rp4*TMath::ASin(f2*r1 - f1*r2) - z;
+  return kTRUE;
 }
 
-Double_t AliITStrackV2::GetZat(Double_t x) const {
+Bool_t AliITStrackV2::Improve(Double_t x0,Double_t xyz[3],Double_t ers[3]) {
   //------------------------------------------------------------------
-  // This function calculates the z at given x point - in current coordinate system
+  //This function improves angular track parameters
   //------------------------------------------------------------------
-  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;
-}
-
-
+  Double_t cs=TMath::Cos(GetAlpha()), sn=TMath::Sin(GetAlpha());
+//Double_t xv = xyz[0]*cs + xyz[1]*sn; // vertex
+  Double_t yv =-xyz[0]*sn + xyz[1]*cs; // in the
+  Double_t zv = xyz[2];                // local frame
 
-
-Int_t AliITStrackV2::Improve(Double_t x0,Double_t xyz[3],Double_t ers[3]) {
-  //------------------------------------------------------------------
-  //This function improves angular track parameters  
-  //------------------------------------------------------------------
-  Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
-  //Double_t xv = xyz[0]*cs + xyz[1]*sn; // vertex
-    Double_t yv =-xyz[0]*sn + xyz[1]*cs; // in the
-    Double_t zv = xyz[2];                // local frame
-  Double_t dy=fP0-yv, dz=fP1-zv;
-  Double_t r2=fX*fX+dy*dy;
+  Double_t dy = Par(0) - yv, dz = Par(1) - zv;
+  Double_t r2=GetX()*GetX() + 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 theta2=1.0259e-6*14*14/28/(beta2*p2)*x0*9.36*2.33;
+
+  Double_t cnv=GetBz()*kB2C;
   {
-  Double_t dummy=4/r2-fP4*fP4;
-  if (dummy < 0) return 0;
-  Double_t parp=0.5*(fP4*fX + dy*TMath::Sqrt(dummy));
-  Double_t sigma2p = theta2*(1.- GetSnp()*GetSnp())*(1. + GetTgl()*GetTgl());
-  sigma2p += fC00/r2*(1.- dy*dy/r2)*(1.- dy*dy/r2);
-  sigma2p += ers[1]*ers[1]/r2;
-  sigma2p += 0.25*fC44*fX*fX;
-  Double_t eps2p=sigma2p/(fC22+sigma2p);
-  fP0 += fC20/(fC22+sigma2p)*(parp-fP2);
-  fP2 = eps2p*fP2 + (1-eps2p)*parp;
-  fC22 *= eps2p;
-  fC20 *= eps2p;
+    Double_t dummy = 4/r2 - GetC()*GetC();
+    if (dummy < 0) return kFALSE;
+    Double_t parp = 0.5*(GetC()*GetX() + dy*TMath::Sqrt(dummy));
+    Double_t sigma2p = theta2*(1.- GetSnp()*GetSnp())*(1. + GetTgl()*GetTgl());
+    sigma2p += Cov(0)/r2*(1.- dy*dy/r2)*(1.- dy*dy/r2);
+    sigma2p += ers[1]*ers[1]/r2;
+    sigma2p += 0.25*Cov(14)*cnv*cnv*GetX()*GetX();
+    Double_t eps2p=sigma2p/(Cov(2) + sigma2p);
+    Par(0) += Cov(3)/(Cov(5) + sigma2p)*(parp - GetSnp());
+    Par(2)  = eps2p*GetSnp() + (1 - eps2p)*parp;
+    Cov(5) *= eps2p;
+    Cov(3) *= eps2p;
   }
   {
-  Double_t parl=0.5*fP4*dz/TMath::ASin(0.5*fP4*TMath::Sqrt(r2));
-  Double_t sigma2l=theta2;
-  sigma2l += fC11/r2+fC00*dy*dy*dz*dz/(r2*r2*r2);
-  sigma2l += ers[2]*ers[2]/r2;
-  Double_t eps2l=sigma2l/(fC33+sigma2l);
-  fP1 += fC31/(fC33+sigma2l)*(parl-fP3);
-  fP4 += fC43/(fC33+sigma2l)*(parl-fP3);
-  fP3 = eps2l*fP3 + (1-eps2l)*parl;
-  fC33 *= eps2l; fC43 *= eps2l; 
-  fC31 *= eps2l; 
+    Double_t parl=0.5*GetC()*dz/TMath::ASin(0.5*GetC()*TMath::Sqrt(r2));
+    Double_t sigma2l=theta2;
+    sigma2l += Cov(2)/r2 + Cov(0)*dy*dy*dz*dz/(r2*r2*r2);
+    sigma2l += ers[2]*ers[2]/r2;
+    Double_t eps2l = sigma2l/(Cov(9) + sigma2l);
+    Par(1) += Cov(7 )/(Cov(9) + sigma2l)*(parl - Par(3));
+    Par(4) += Cov(13)/(Cov(9) + sigma2l)*(parl - Par(3));
+    Par(3)  = eps2l*Par(3) + (1-eps2l)*parl;
+    Cov(9) *= eps2l; 
+    Cov(13)*= (eps2l/cnv/cnv); 
+    Cov(7) *= eps2l; 
   }
-  if (!Invariant()) return 0;
-  return 1;
-} 
-
-void AliITStrackV2::ResetCovariance() {
-  //------------------------------------------------------------------
-  //This function makes a track forget its history :)  
-  //------------------------------------------------------------------
-
-  fC00*=10.;
-  fC10=0.;  fC11*=10.;
-  fC20=0.;  fC21=0.;  fC22*=10.;
-  fC30=0.;  fC31=0.;  fC32=0.;  fC33*=10.;
-  fC40=0.;  fC41=0.;  fC42=0.;  fC43=0.;  fC44*=10.;
+  if (!Invariant()) return kFALSE;
 
+  return kTRUE;
 }
 
 void AliITStrackV2::CookdEdx(Double_t low, Double_t up) {
@@ -742,39 +328,12 @@ void AliITStrackV2::CookdEdx(Double_t low, Double_t up) {
   SetdEdx(dedx);
 }
 
-Double_t AliITStrackV2::
-PropagateToDCA(AliKalmanTrack *p, Double_t d, Double_t x0) {
-  //--------------------------------------------------------------
-  // Propagates this track and the argument track to the position of the
-  // distance of closest approach. 
-  // Returns the (weighed !) distance of closest approach.
-  //--------------------------------------------------------------
-  Double_t xthis, xp, dca;
-  {
-  //Temporary solution
-  Double_t b=1./GetLocalConvConst()/kB2C;
-  AliExternalTrackParam dummy1(*this), dummy2(*p); 
-  dca=dummy1.GetDCA(&dummy2,b,xthis,xp);
-  }
-  if (!PropagateTo(xthis,d,x0)) {
-    //AliWarning(" propagation failed !");
-    return 1e+33;
-  }  
-
-  if (!p->PropagateTo(xp,d,x0)) {
-    //AliWarning(" propagation failed !";
-    return 1e+33;
-  }  
-
-  return dca;
-} 
-
-Double_t AliITStrackV2::Get1Pt() const {
-  //--------------------------------------------------------------
-  // Returns the inverse Pt (1/GeV/c)
-  // (or 1/"most probable pt", if the field is too weak)
-  //--------------------------------------------------------------
-  if (TMath::Abs(GetLocalConvConst()) > kVeryBigConvConst)
-      return 1./kMostProbableMomentum/TMath::Sqrt(1.+ GetTgl()*GetTgl());
-  return (TMath::Sign(1e-9,fP4) + fP4)*GetLocalConvConst();
+Double_t AliITStrackV2::GetBz() const {
+  //
+  // returns Bz component of the magnetic field (kG)
+  //
+  if (AliTracker::UniformField()) return AliTracker::GetBz();
+  Double_t r[3]; GetXYZ(r); 
+  return AliTracker::GetBz(r);
 }
+
index 9464ea6..77b95da 100644 (file)
 //     dEdx analysis by: Boris Batyunya, JINR, Boris.Batiounia@cern.ch
 //-------------------------------------------------------------------------
 
-
-/*****************************************************************************
- *                          December 18, 2000                                *
- *  Internal view of the ITS track parametrisation as well as the order of   *
- *           track parameters are subject for possible changes !             *
- *  Use GetExternalParameters() and GetExternalCovariance() to access ITS    *
- *      track information regardless of its internal representation.         *
- * This formation is now fixed in the following way:                         *
- *      external param0:   local Y-coordinate of a track (cm)                *
- *      external param1:   local Z-coordinate of a track (cm)                *
- *      external param2:   local sine of the track momentum azimuthal angle  *
- *      external param3:   tangent of the track momentum dip angle           *
- *      external param4:   1/pt (1/(GeV/c))                                  *
- *****************************************************************************/
-
 #include <AliKalmanTrack.h>
-
 #include "AliITSrecoV2.h"
 
 class AliESDtrack;
@@ -37,87 +21,61 @@ public:
   AliITStrackV2();
   AliITStrackV2(AliESDtrack& t,Bool_t c=kFALSE) throw (const Char_t *);
   AliITStrackV2(const AliITStrackV2& t);
-  Int_t PropagateToVertex(Double_t d=0., Double_t x0=0.);
-  Int_t Propagate(Double_t alpha, Double_t xr);
-  virtual Int_t CorrectForMaterial(Double_t d, Double_t x0=21.82);
-  Int_t PropagateTo(Double_t xr, Double_t d, Double_t x0=21.82);
-  Double_t PropagateToDCA(AliKalmanTrack *p, Double_t d=0., Double_t x0=0.); 
-  Int_t Update(const AliCluster* cl,Double_t chi2,UInt_t i);
-  Int_t Improve(Double_t x0,Double_t xyz[3],Double_t ers[3]);
+
+  Bool_t CorrectForMaterial(Double_t d, Double_t x0=21.82) {
+    return AliExternalTrackParam::CorrectForMaterial(d,x0,GetMass());
+  }
+  Bool_t PropagateTo(Double_t xr, Double_t d, Double_t x0=21.82);
+  Double_t GetPredictedChi2(const AliCluster *cluster) const;
+  Bool_t Update(const AliCluster *cl, Double_t chi2, Int_t i);
+
+  Bool_t 
+     PropagateToVertex(const AliESDVertex *v,Double_t d=0.,Double_t x0=0.);
+  Bool_t Propagate(Double_t alpha, Double_t xr);
+  Bool_t Improve(Double_t x0,Double_t xyz[3],Double_t ers[3]);
+
   void SetdEdx(Double_t dedx) {fdEdx=dedx;}
   void SetSampledEdx(Float_t q, Int_t i);
   void CookdEdx(Double_t low=0., Double_t up=0.51);
   void SetDetectorIndex(Int_t i) {SetLabel(i);}
-  void ResetCovariance();
   void ResetClusters() { SetChi2(0.); SetNumberOfClusters(0); }
   void UpdateESDtrack(ULong_t flags) const;
   
   AliESDtrack *GetESDtrack() const {return fESDtrack;}
 
   Int_t GetDetectorIndex() const {return GetLabel();}
-  Double_t GetX()    const {return fX;}
-  Double_t GetAlpha()const {return fAlpha;}
   Double_t GetdEdx() const {return fdEdx;}
   Double_t GetPIDsignal() const {return GetdEdx();}
-  Double_t GetY()    const {return fP0;}
-  Double_t GetZ()    const {return fP1;}
-  Double_t GetSnp()  const {return fP2;}
-  Double_t GetTgl()  const {return fP3;}
-  Double_t GetC()    const {return fP4;}
-  Double_t Get1Pt() const;
-  Double_t GetD(Double_t x=0, Double_t y=0) const;
-  void GetDZ(Double_t xv, Double_t yv, Double_t zv, Float_t dz[2]) const;
-  Double_t GetZat(Double_t x=0) const;
-
-  Double_t GetSigmaY2() const {return fC00;}
-  Double_t GetSigmaZ2() const {return fC11;}
+  Double_t GetC() const {return AliExternalTrackParam::GetC(GetBz());}
+  Double_t GetD(Double_t x, Double_t y) const {
+    return AliExternalTrackParam::GetD(x,y,GetBz());
+  }
+  void GetDZ(Double_t xv, Double_t yv, Double_t zv, Float_t dz[2]) const {
+    return AliExternalTrackParam::GetDZ(xv,yv,zv,GetBz(),dz);
+  }
+
+  Bool_t GetGlobalXYZat(Double_t r,Double_t &x,Double_t &y,Double_t &z) const;
+
   Int_t Compare(const TObject *o) const;
-  void GetExternalParameters(Double_t& xr, Double_t x[5]) const ;
-  void GetExternalCovariance(Double_t cov[15]) const ;
   Int_t GetClusterIndex(Int_t i) const {return fIndex[i];}
-  Int_t GetGlobalXYZat(Double_t r,Double_t &x,Double_t &y,Double_t &z) const;
-  Double_t GetPredictedChi2(const AliCluster *cluster) const;
-  Int_t Invariant() const;
+  Bool_t Invariant() const;
 
   void  SetExtraCluster(Int_t i, Int_t idx) {fIndex[kMaxLayer+i]=idx;}
   Int_t GetExtraCluster(Int_t i) const {return fIndex[kMaxLayer+i];}
-protected:
-  void GetXYZ(Float_t r[3]) const;
 
-  Double_t fX;              // X-coordinate of this track (reference plane)
-  Double_t fAlpha;          // rotation angle
-
-  Double_t fdEdx;           // dE/dx
-
-  Double_t fP0;             // Y-coordinate of a track 
-  Double_t fP1;             // Z-coordinate of a track
-  Double_t fP2;             // sine of the track momentum azimuthal angle
-  Double_t fP3;             // tangent of the track momentum dip angle
-  Double_t fP4;             // track curvature
-
-  Double_t fC00;                         // covariance
-  Double_t fC10, fC11;                   // matrix
-  Double_t fC20, fC21, fC22;             // of the
-  Double_t fC30, fC31, fC32, fC33;       // track
-  Double_t fC40, fC41, fC42, fC43, fC44; // parameters 
+protected:
+  Double_t GetBz() const ;
+  Double_t fdEdx;            // dE/dx
+  Float_t fdEdxSample[4];    // array of dE/dx samples b.b.
 
   Int_t fIndex[2*kMaxLayer]; // indices of associated clusters 
-  Float_t fdEdxSample[4];    // array of dE/dx samples b.b.
 
   AliESDtrack *fESDtrack;    //! pointer to the connected ESD track
-  ClassDef(AliITStrackV2,5)  //ITS reconstructed track
-};
 
-inline 
-void AliITStrackV2::GetExternalParameters(Double_t& xr, Double_t x[5]) const {
-  //---------------------------------------------------------------------
-  // This function return external ITS track representation
-  //---------------------------------------------------------------------
-     xr=fX;          
-     x[0]=GetY(); x[1]=GetZ(); x[2]=GetSnp(); x[3]=GetTgl();
-     x[4]=(TMath::Sign(1e-9,fP4) + fP4)*GetLocalConvConst();
-}
+private:
+  AliITStrackV2 &operator=(const AliITStrackV2 &tr);
+  ClassDef(AliITStrackV2,6)  //ITS reconstructed track
+};
 
 inline
 void AliITStrackV2::SetSampledEdx(Float_t q, Int_t i) {
@@ -132,14 +90,6 @@ void AliITStrackV2::SetSampledEdx(Float_t q, Int_t i) {
   fdEdxSample[i]=q;
 }
 
-inline void AliITStrackV2::GetXYZ(Float_t r[3]) const {
-  //---------------------------------------------------------------------
-  // Returns the position of the track in the global coord. system 
-  //---------------------------------------------------------------------
-  Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
-  r[0]=fX*cs - fP0*sn; r[1]=fX*sn + fP0*cs; r[2]=fP1;
-}
-
 #endif
 
 
index 58e2273..f1a60ae 100644 (file)
@@ -1448,11 +1448,11 @@ Int_t AliITStrackerANN::SaveTracks(Int_t sector)
                                        if (cluster) trac->AddClusterV2(l, (node[l]->ClusterRef() & 0x0fffffff)>>0);
                                }
             AliITStrackV2* ot = new AliITStrackV2(*trac);
-                               ot->ResetCovariance();
+                               ot->ResetCovariance(10.);
                                ot->ResetClusters();
                                if (RefitAt(49.,ot,trac)) { //fit from layer 1 to layer 6
                                        AliITStrackV2 *otrack2 = new AliITStrackV2(*ot);
-                                       otrack2->ResetCovariance();
+                                       otrack2->ResetCovariance(10.);
                                        otrack2->ResetClusters();
                                        //fit from layer 6 to layer 1
                                        if (RefitAt(3.7,otrack2,ot)) fFoundTracks->AddLast(otrack2);
@@ -1613,11 +1613,11 @@ Int_t AliITStrackerANN::StoreTracks()
                                if (cluster) trac->AddClusterV2(l, (annTrack[l]->ClusterRef() & 0x0fffffff)>>0);
                        }
                        AliITStrackV2* ot = new AliITStrackV2(*trac);
-                       ot->ResetCovariance();
+                       ot->ResetCovariance(10.);
                        ot->ResetClusters();
                        if (RefitAt(49.,ot,trac)) { //fit from layer 1 to layer 6
                                AliITStrackV2 *otrack2 = new AliITStrackV2(*ot);
-                               otrack2->ResetCovariance();
+                               otrack2->ResetCovariance(10.);
                                otrack2->ResetClusters();
                                //fit from layer 6 to layer 1
                                if (RefitAt(3.7,otrack2,ot)) fFoundTracks->AddLast(otrack2);
index 563120c..19e8fa7 100644 (file)
@@ -30,7 +30,7 @@
 #include <TTree.h>
 
 #include "AliESD.h"
-#include "AliESDV0MI.h"
+#include "AliV0.h"
 #include "AliHelix.h"
 #include "AliITSRecPoint.h"
 #include "AliITSgeom.h"
@@ -410,13 +410,13 @@ Int_t AliITStrackerMI::PropagateBack(AliESD *event) {
      // propagete to vertex [SR, GSI 17.02.2003]
      // Start Time measurement [SR, GSI 17.02.2003], corrected by I.Belikov
      if (fTrackToFollow.PropagateTo(3.,0.0028,65.19)) {
-       if (fTrackToFollow.PropagateToVertex()) {
+       if (fTrackToFollow.PropagateToVertex(event->GetVertex())) {
           fTrackToFollow.StartTimeIntegral();
        }
        fTrackToFollow.PropagateTo(3.,-0.0028,65.19);
      }
 
-     fTrackToFollow.ResetCovariance(); fTrackToFollow.ResetClusters();
+     fTrackToFollow.ResetCovariance(10.); fTrackToFollow.ResetClusters();
      if (RefitAt(49.,&fTrackToFollow,t)) {
         if (CorrectForDeadZoneMaterial(&fTrackToFollow)!=0) {
           //Warning("PropagateBack",
@@ -478,7 +478,7 @@ Int_t AliITStrackerMI::RefitInward(AliESD *event) {
     fTrackToFollow.ResetClusters();
 
     if ((esd->GetStatus()&AliESDtrack::kTPCin)==0)
-      fTrackToFollow.ResetCovariance();
+      fTrackToFollow.ResetCovariance(10.);
 
     //Refitting...
     if (RefitAt(3.7, &fTrackToFollow, t,kTRUE)) {
@@ -794,7 +794,7 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin
        ntracks[ilayer]++;
       }
 
-      if (constrain&&itrack<1&&TMath::Abs(currenttrack1.fP3)>1.1){  //big theta -- for low mult. runs
+      if (constrain&&itrack<1&&TMath::Abs(currenttrack1.GetTgl())>1.1){  //big theta -- for low mult. runs
        AliITStrackMI* vtrack = new (&tracks[ilayer][ntracks[ilayer]]) AliITStrackMI(currenttrack1);
        vtrack->fClIndex[ilayer]=0;
        fI = ilayer;
@@ -889,10 +889,10 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin
     for (Int_t i=0;i<3;i++){
       Int_t  index = otrack->fESDtrack->GetV0Index(i); 
       if (index==0) break;
-      AliESDV0MI * vertex = fEsd->GetV0MI(index);
+      AliV0 * vertex = (AliV0*)fEsd->GetV0MI(index);
       if (vertex->GetStatus()<0) continue;     // rejected V0
       //
-      if (otrack->fP4>0) {
+      if (otrack->GetSign()>0) {
        vertex->SetIndex(0,esdindex);
       }
       else{
@@ -911,7 +911,7 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin
       if (nearestold<5&&nearest<5){
        Bool_t accept = track.fNormChi2[nearest]<10; 
        if (accept){
-         if (track.fP4>0) {
+         if (track.GetSign()>0) {
            vertex->SetP(track);
            vertex->Update(fprimvertex);
            //      vertex->SetIndex(0,track.fESDtrack->GetID()); 
@@ -1871,32 +1871,32 @@ Double_t AliITStrackerMI::GetMatchingChi2(AliITStrackMI * track1, AliITStrackMI
   AliITStrackMI track3(*track2);
   track3.Propagate(track1->GetAlpha(),track1->GetX());
   TMatrixD vec(5,1);
-  vec(0,0)=track1->fP0-track3.fP0;
-  vec(1,0)=track1->fP1-track3.fP1;
-  vec(2,0)=track1->fP2-track3.fP2;
-  vec(3,0)=track1->fP3-track3.fP3;
-  vec(4,0)=track1->fP4-track3.fP4;
+  vec(0,0)=track1->GetY()   - track3.GetY();
+  vec(1,0)=track1->GetZ()   - track3.GetZ();
+  vec(2,0)=track1->GetSnp() - track3.GetSnp();
+  vec(3,0)=track1->GetTgl() - track3.GetTgl();
+  vec(4,0)=track1->Get1Pt() - track3.Get1Pt();
   //
   TMatrixD cov(5,5);
-  cov(0,0) = track1->fC00+track3.fC00;
-  cov(1,1) = track1->fC11+track3.fC11;
-  cov(2,2) = track1->fC22+track3.fC22;
-  cov(3,3) = track1->fC33+track3.fC33;
-  cov(4,4) = track1->fC44+track3.fC44;
+  cov(0,0) = track1->GetSigmaY2()+track3.GetSigmaY2();
+  cov(1,1) = track1->GetSigmaZ2()+track3.GetSigmaZ2();
+  cov(2,2) = track1->GetSigmaSnp2()+track3.GetSigmaSnp2();
+  cov(3,3) = track1->GetSigmaTgl2()+track3.GetSigmaTgl2();
+  cov(4,4) = track1->GetSigma1Pt2()+track3.GetSigma1Pt2();
   
-  cov(0,1)=cov(1,0) = track1->fC10+track3.fC10;
-  cov(0,2)=cov(2,0) = track1->fC20+track3.fC20;
-  cov(0,3)=cov(3,0) = track1->fC30+track3.fC30;
-  cov(0,4)=cov(4,0) = track1->fC40+track3.fC40;
+  cov(0,1)=cov(1,0) = track1->GetSigmaZY()+track3.GetSigmaZY();
+  cov(0,2)=cov(2,0) = track1->GetSigmaSnpY()+track3.GetSigmaSnpY();
+  cov(0,3)=cov(3,0) = track1->GetSigmaTglY()+track3.GetSigmaTglY();
+  cov(0,4)=cov(4,0) = track1->GetSigma1PtY()+track3.GetSigma1PtY();
   //
-  cov(1,2)=cov(2,1) = track1->fC21+track3.fC21;
-  cov(1,3)=cov(3,1) = track1->fC31+track3.fC31;
-  cov(1,4)=cov(4,1) = track1->fC41+track3.fC41;
+  cov(1,2)=cov(2,1) = track1->GetSigmaSnpZ()+track3.GetSigmaSnpZ();
+  cov(1,3)=cov(3,1) = track1->GetSigmaTglZ()+track3.GetSigmaTglZ();
+  cov(1,4)=cov(4,1) = track1->GetSigma1PtZ()+track3.GetSigma1PtZ();
   //
-  cov(2,3)=cov(3,2) = track1->fC32+track3.fC32;
-  cov(2,4)=cov(4,2) = track1->fC42+track3.fC42;
+  cov(2,3)=cov(3,2) = track1->GetSigmaTglSnp()+track3.GetSigmaTglSnp();
+  cov(2,4)=cov(4,2) = track1->GetSigma1PtSnp()+track3.GetSigma1PtSnp();
   //
-  cov(3,4)=cov(4,3) = track1->fC43+track3.fC43;
+  cov(3,4)=cov(4,3) = track1->GetSigma1PtTgl()+track3.GetSigma1PtTgl();
   
   cov.Invert();
   TMatrixD vec2(cov,TMatrixD::kMult,vec);
@@ -2681,15 +2681,15 @@ AliITStrackMI * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackMI
     if (track->fConstrain){
       if (!backtrack->PropagateTo(3.,0.0028,65.19)) continue;
       if (!backtrack->Improve(0,xyzv,ersv))         continue;      
-      if (!backtrack->PropagateTo(2.,0.0028,0))     continue;
-      if (!backtrack->Improve(0,xyzv,ersv))         continue;
-      if (!backtrack->PropagateTo(1.,0.0028,0))     continue;
-      if (!backtrack->Improve(0,xyzv,ersv))         continue;                    
-      if (!backtrack->PropagateToVertex())          continue;
-      backtrack->ResetCovariance();      
-      if (!backtrack->Improve(0,xyzv,ersv))         continue;                          
+      //if (!backtrack->PropagateTo(2.,0.0028,0))     continue; // This 
+      //if (!backtrack->Improve(0,xyzv,ersv))         continue; // is
+      //if (!backtrack->PropagateTo(1.,0.0028,0))     continue; // an over-kill
+      //if (!backtrack->Improve(0,xyzv,ersv))         continue; //   (I.B.)
+      //if (!backtrack->PropagateToVertex())          continue; //
+      backtrack->ResetCovariance(10.);      
+      //if (!backtrack->Improve(0,xyzv,ersv))         continue;                        
     }else{
-      backtrack->ResetCovariance();
+      backtrack->ResetCovariance(10.);
     }
     backtrack->ResetClusters();
 
@@ -3065,7 +3065,7 @@ Double_t AliITStrackerMI::GetPredictedChi2MI(AliITStrackMI* track, const AliITSR
   track->fSigmaY[layer] = erry;
   track->fSigmaZ[layer] = errz;
   //track->fNormQ[layer] = cluster->GetQ()/TMath::Sqrt(1+theta*theta+phi*phi);
-  track->fNormQ[layer] = cluster->GetQ()/TMath::Sqrt((1.+ track->fP3*track->fP3)/(1.- track->fP2*track->fP2));
+  track->fNormQ[layer] = cluster->GetQ()/TMath::Sqrt((1.+ track->GetTgl()*track->GetTgl())/(1.- track->GetSnp()*track->GetSnp()));
   return chi2;
 
 }
@@ -3274,8 +3274,8 @@ void   AliITStrackerMI::GetDCASigma(AliITStrackMI* track, Float_t & sigmarfi, Fl
   //to be paramterized using external parameters in future 
   //
   // 
-  sigmarfi = 0.004+1.4 *TMath::Abs(track->fP4)+332.*track->fP4*track->fP4;
-  sigmaz   = 0.011+4.37*TMath::Abs(track->fP4);
+  sigmarfi = 0.004+1.4 *TMath::Abs(track->GetC())+332.*track->GetC()*track->GetC();
+  sigmaz   = 0.011+4.37*TMath::Abs(track->GetC());
 }
 
 
@@ -3458,7 +3458,7 @@ void AliITStrackerMI::UpdateTPCV0(AliESD *event){
     if (clayer < 5 ){ // calculate chi2 after vertex
       Float_t chi2p = 0, chi2m=0;  
       //
-      if (trackp&&TMath::Abs(trackp->fP3)<1.){
+      if (trackp&&TMath::Abs(trackp->GetTgl())<1.){
        for (Int_t ilayer=clayer;ilayer<6;ilayer++){
          if (trackp->fClIndex[ilayer]>0){
            chi2p+=trackp->fDy[ilayer]*trackp->fDy[ilayer]/(trackp->fSigmaY[ilayer]*trackp->fSigmaY[ilayer])+
@@ -3472,7 +3472,7 @@ void AliITStrackerMI::UpdateTPCV0(AliESD *event){
        chi2p = 0;
       }
       //
-      if (trackm&&TMath::Abs(trackm->fP3)<1.){
+      if (trackm&&TMath::Abs(trackm->GetTgl())<1.){
        for (Int_t ilayer=clayer;ilayer<6;ilayer++){
          if (trackm->fClIndex[ilayer]>0){
            chi2m+=trackm->fDy[ilayer]*trackm->fDy[ilayer]/(trackm->fSigmaY[ilayer]*trackm->fSigmaY[ilayer])+
@@ -3542,7 +3542,7 @@ void  AliITStrackerMI::FindV02(AliESD *event)
   Float_t *minr        = new Float_t[ntracks+2];
   Float_t *minPointAngle= new Float_t[ntracks+2];
   //
-  AliESDV0MI *pvertex      = new AliESDV0MI;
+  AliV0 *pvertex      = new AliV0;
   AliITStrackMI * dummy= new AliITStrackMI;
   dummy->SetLabel(0);
   AliITStrackMI  trackat0;    //temporary track for DCA calculation
@@ -3626,19 +3626,20 @@ void  AliITStrackerMI::FindV02(AliESD *event)
       best     = original;
       bestLong = original;
     }
-    trackat0 = *bestLong;
+    //I.B. trackat0 = *bestLong;
+    new (&trackat0) AliITStrackV2(*bestLong);
     Double_t xx,yy,zz,alpha; 
     bestLong->GetGlobalXYZat(bestLong->GetX(),xx,yy,zz);
     alpha = TMath::ATan2(yy,xx);    
     trackat0.Propagate(alpha,0);      
     // calculate normalized distances to the vertex 
     //
-    Float_t ptfac  = (1.+100.*TMath::Abs(trackat0.fP4));
+    Float_t ptfac  = (1.+100.*TMath::Abs(trackat0.GetC()));
     if ( bestLong->fN>3 ){      
-      dist[itsindex]      = trackat0.fP0;
-      norm[itsindex]      = ptfac*TMath::Sqrt(trackat0.fC00);
-      normdist0[itsindex] = TMath::Abs(trackat0.fP0/norm[itsindex]);
-      normdist1[itsindex] = TMath::Abs((trackat0.fP1-primvertex[2])/(ptfac*TMath::Sqrt(trackat0.fC11)));
+      dist[itsindex]      = trackat0.GetY();
+      norm[itsindex]      = ptfac*TMath::Sqrt(trackat0.GetSigmaY2());
+      normdist0[itsindex] = TMath::Abs(trackat0.GetY()/norm[itsindex]);
+      normdist1[itsindex] = TMath::Abs((trackat0.GetZ()-primvertex[2])/(ptfac*TMath::Sqrt(trackat0.GetSigmaZ2())));
       normdist[itsindex]  = TMath::Sqrt(normdist0[itsindex]*normdist0[itsindex]+normdist1[itsindex]*normdist1[itsindex]);
       if (!bestConst){
        if (bestLong->fN+bestLong->fNDeadZone<6) normdist[itsindex]*=2.;
@@ -3657,12 +3658,12 @@ void  AliITStrackerMI::FindV02(AliESD *event)
        normdist1[itsindex] = TMath::Abs(bestConst->fD[0]/norm[itsindex]);
        normdist[itsindex]  = TMath::Sqrt(normdist0[itsindex]*normdist0[itsindex]+normdist1[itsindex]*normdist1[itsindex]);
       }else{
-       dist[itsindex]      = trackat0.fP0;
-       norm[itsindex]      = ptfac*TMath::Sqrt(trackat0.fC00);
-       normdist0[itsindex] = TMath::Abs(trackat0.fP0/norm[itsindex]);
-       normdist1[itsindex] = TMath::Abs((trackat0.fP1-primvertex[2])/(ptfac*TMath::Sqrt(trackat0.fC11)));
+       dist[itsindex]      = trackat0.GetY();
+       norm[itsindex]      = ptfac*TMath::Sqrt(trackat0.GetSigmaY2());
+       normdist0[itsindex] = TMath::Abs(trackat0.GetY()/norm[itsindex]);
+       normdist1[itsindex] = TMath::Abs((trackat0.GetZ()-primvertex[2])/(ptfac*TMath::Sqrt(trackat0.GetSigmaZ2())));
        normdist[itsindex]  = TMath::Sqrt(normdist0[itsindex]*normdist0[itsindex]+normdist1[itsindex]*normdist1[itsindex]);
-       if (TMath::Abs(trackat0.fP3)>1.05){
+       if (TMath::Abs(trackat0.GetTgl())>1.05){
          if (normdist[itsindex]<3) forbidden[itsindex]=kTRUE;
          if (normdist[itsindex]>3) {
            minr[itsindex] = TMath::Max(Float_t(40.),minr[itsindex]);
@@ -3756,7 +3757,7 @@ void  AliITStrackerMI::FindV02(AliESD *event)
     if (forbidden[itrack0]) continue;
     AliITStrackMI * btrack0 = (AliITStrackMI*)trackarray.At(itrack0);
     if (!btrack0) continue;    
-    if (btrack0->fP4>0) continue;
+    if (btrack0->GetC()>0) continue;
     AliITStrackMI *trackc0 = (AliITStrackMI*)trackarrayc.At(itrack0);
     //
     for (Int_t iesd1=0;iesd1<ntracks;iesd1++){
@@ -3765,7 +3766,7 @@ void  AliITStrackerMI::FindV02(AliESD *event)
 
       AliITStrackMI * btrack1 = (AliITStrackMI*)trackarray.At(itrack1); 
       if (!btrack1) continue;
-      if (btrack1->fP4<0) continue;
+      if (btrack1->GetC()<0) continue;
       Bool_t isGold = kFALSE;
       if (TMath::Abs(TMath::Abs(btrack0->GetLabel())-TMath::Abs(btrack1->GetLabel()))==1){
        isGold = kTRUE;
@@ -3845,10 +3846,10 @@ void  AliITStrackerMI::FindV02(AliESD *event)
       //
       //
       TObjArray * array0b     = (TObjArray*)fBestHypothesys.At(itrack0);
-      if (!array0b&&pvertex->GetRr()<40 && TMath::Abs(track0->fP3)<1.1) 
+      if (!array0b&&pvertex->GetRr()<40 && TMath::Abs(track0->GetTgl())<1.1) 
        FollowProlongationTree((AliITStrackMI*)fOriginal.At(itrack0),itrack0, kFALSE);
       TObjArray * array1b    = (TObjArray*)fBestHypothesys.At(itrack1);
-      if (!array1b&&pvertex->GetRr()<40 && TMath::Abs(track1->fP3)<1.1) 
+      if (!array1b&&pvertex->GetRr()<40 && TMath::Abs(track1->GetTgl())<1.1) 
        FollowProlongationTree((AliITStrackMI*)fOriginal.At(itrack1),itrack1, kFALSE);
       //
       AliITStrackMI * track0b = (AliITStrackMI*)fOriginal.At(itrack0);       
@@ -3868,7 +3869,7 @@ void  AliITStrackerMI::FindV02(AliESD *event)
        if (!btrack) continue;
        if (btrack->fN>track0l->fN) track0l = btrack;     
        //      if (btrack->fX<pvertex->GetRr()-2.-0.5/(0.1+pvertex->GetAnglep()[2])) {
-       if (btrack->fX<pvertex->GetRr()-2.) {
+       if (btrack->GetX()<pvertex->GetRr()-2.) {
          if ( (maxLayer>i+2|| (i==0)) && btrack->fN==(6-i)&&i<3){
            Float_t sumchi2= 0;
            Float_t sumn   = 0;
@@ -3912,7 +3913,7 @@ void  AliITStrackerMI::FindV02(AliESD *event)
        if (!btrack) continue;
        if (btrack->fN>track1l->fN) track1l = btrack;     
        //      if (btrack->fX<pvertex->GetRr()-2-0.5/(0.1+pvertex->GetAnglep()[2])){
-       if (btrack->fX<pvertex->GetRr()-2){
+       if (btrack->GetX()<pvertex->GetRr()-2){
          if ((maxLayer>i+2 || (i==0))&&btrack->fN==(6-i)&&(i<3)){
            Float_t sumchi2= 0;
            Float_t sumn   = 0;
@@ -3952,9 +3953,9 @@ void  AliITStrackerMI::FindV02(AliESD *event)
       }
       //
       // position resolution - used for DCA cut
-      Float_t sigmad = track0b->fC00+track0b->fC11+track1b->fC00+track1b->fC11+
-       (track0b->fX-pvertex->GetRr())*(track0b->fX-pvertex->GetRr())*(track0b->fC22+track0b->fC33)+
-       (track1b->fX-pvertex->GetRr())*(track1b->fX-pvertex->GetRr())*(track1b->fC22+track1b->fC33);
+      Float_t sigmad = track0b->GetSigmaY2()+track0b->GetSigmaZ2()+track1b->GetSigmaY2()+track1b->GetSigmaZ2()+
+       (track0b->GetX()-pvertex->GetRr())*(track0b->GetX()-pvertex->GetRr())*(track0b->GetSigmaSnp2()+track0b->GetSigmaTgl2())+
+       (track1b->GetX()-pvertex->GetRr())*(track1b->GetX()-pvertex->GetRr())*(track1b->GetSigmaSnp2()+track1b->GetSigmaTgl2());
       sigmad =TMath::Sqrt(sigmad)+0.04;
       if (pvertex->GetRr()>50){
        Double_t cov0[15],cov1[15];
@@ -3966,7 +3967,7 @@ void  AliITStrackerMI::FindV02(AliESD *event)
        sigmad =TMath::Sqrt(sigmad)+0.05;
       }
       //       
-      AliESDV0MI vertex2;
+      AliV0 vertex2;
       vertex2.SetM(*track0b);
       vertex2.SetP(*track1b);
       vertex2.Update(primvertex);
@@ -4115,9 +4116,9 @@ void AliITStrackerMI::RefitV02(AliESD *event)
   //
   Int_t  nv0s = event->GetNumberOfV0MIs();
   Float_t primvertex[3]={GetX(),GetY(),GetZ()};
-  AliESDV0MI v0temp;
+  AliV0 v0temp;
   for (Int_t iv0 = 0; iv0<nv0s;iv0++){
-    AliESDV0MI * v0mi = event->GetV0MI(iv0);
+    AliV0 * v0mi = (AliV0*)event->GetV0MI(iv0);
     if (!v0mi) continue;
     Int_t     itrack0   = v0mi->GetIndex(0);
     Int_t     itrack1   = v0mi->GetIndex(1);
index cb5694e..d3d1371 100644 (file)
@@ -620,12 +620,12 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert
 
               AliITStrackMI* ot = new AliITStrackSA(*trac);
               
-              ot->ResetCovariance();
+              ot->ResetCovariance(10.);
               ot->ResetClusters();
               
               if(RefitAt(49.,ot,trac)){ //fit from layer 1 to layer 6
                 AliITStrackMI *otrack2 = new AliITStrackMI(*ot);
-                otrack2->ResetCovariance(); 
+                otrack2->ResetCovariance(10.); 
                 otrack2->ResetClusters();
                 //fit from layer 6 to layer 1
                 if(RefitAt(3.7,otrack2,ot)) {
index 9f40d65..9236c8b 100644 (file)
@@ -37,7 +37,62 @@ ClassImp(AliITStrackerV2)
 
 AliITStrackerV2::AliITSlayer AliITStrackerV2::fgLayers[kMaxLayer]; // ITS layers
 
-AliITStrackerV2::AliITStrackerV2(const AliITSgeom *geom) : AliTracker() {
+AliITStrackerV2::AliITStrackerV2(): 
+  AliTracker(), 
+  fI(kMaxLayer),
+  fBestTrack(),
+  fTrackToFollow(),
+  fPass(0),
+  fLastLayerToTrackTo(kLastLayerToTrackTo)
+{
+  //--------------------------------------------------------------------
+  //This is the AliITStrackerV2 default constructor
+  //--------------------------------------------------------------------
+
+  for (Int_t i=1; i<kMaxLayer+1; i++) new(fgLayers+i-1) AliITSlayer();
+
+  fConstraint[0]=1; fConstraint[1]=0;
+
+  Double_t xyz[]={kXV,kYV,kZV}, ers[]={kSigmaXV,kSigmaYV,kSigmaZV}; 
+  SetVertex(xyz,ers);
+
+  for (Int_t i=0; i<kMaxLayer; i++) fLayersNotToSkip[i]=kLayersNotToSkip[i];
+
+}
+
+AliITStrackerV2::AliITStrackerV2(const AliITStrackerV2 &t): 
+  AliTracker(t), 
+  fI(t.fI),
+  fBestTrack(t.fBestTrack),
+  fTrackToFollow(t.fTrackToFollow),
+  fPass(t.fPass),
+  fLastLayerToTrackTo(t.fLastLayerToTrackTo)
+{
+  //--------------------------------------------------------------------
+  //This is the AliITStrackerV2 copy constructor
+  //--------------------------------------------------------------------
+
+  //for (Int_t i=1; i<kMaxLayer+1; i++) new(fgLayers+i-1) AliITSlayer();
+
+  fConstraint[0]=t.fConstraint[0]; fConstraint[1]=t.fConstraint[1];
+
+  Double_t xyz[]={kXV,kYV,kZV}, ers[]={kSigmaXV,kSigmaYV,kSigmaZV};
+  xyz[0]=t.GetX(); xyz[1]=t.GetY(); xyz[2]=t.GetZ(); 
+  ers[0]=t.GetSigmaX(); ers[1]=t.GetSigmaY(); ers[2]=t.GetSigmaZ(); 
+  SetVertex(xyz,ers);
+
+  for (Int_t i=0; i<kMaxLayer; i++) fLayersNotToSkip[i]=t.fLayersNotToSkip[i];
+
+}
+
+AliITStrackerV2::AliITStrackerV2(const AliITSgeom *geom) : 
+  AliTracker(), 
+  fI(kMaxLayer),
+  fBestTrack(),
+  fTrackToFollow(),
+  fPass(0),
+  fLastLayerToTrackTo(kLastLayerToTrackTo)
+{
   //--------------------------------------------------------------------
   //This is the AliITStrackerV2 constructor
   //--------------------------------------------------------------------
@@ -85,16 +140,12 @@ AliITStrackerV2::AliITStrackerV2(const AliITSgeom *geom) : AliTracker() {
 
   }
 
-  fI=kMaxLayer;
-
-  fPass=0;
   fConstraint[0]=1; fConstraint[1]=0;
 
   Double_t xyz[]={kXV,kYV,kZV}, ers[]={kSigmaXV,kSigmaYV,kSigmaZV}; 
   SetVertex(xyz,ers);
 
   for (Int_t i=0; i<kMaxLayer; i++) fLayersNotToSkip[i]=kLayersNotToSkip[i];
-  fLastLayerToTrackTo=kLastLayerToTrackTo;
 
 }
 
@@ -213,7 +264,7 @@ Int_t AliITStrackerV2::Clusters2Tracks(AliESD *event) {
         delete t;
         continue;
       }
-      if (TMath::Abs(t->GetD())>4) {
+      if (TMath::Abs(t->GetD(GetX(),GetY()))>4) {
        delete t;
        continue;
       }
@@ -300,13 +351,13 @@ Int_t AliITStrackerV2::PropagateBack(AliESD *event) {
      // propagete to vertex [SR, GSI 17.02.2003]
      // Start Time measurement [SR, GSI 17.02.2003], corrected by I.Belikov
      if (fTrackToFollow.PropagateTo(3.,0.0028,65.19)) {
-       if (fTrackToFollow.PropagateToVertex()) {
+       if (fTrackToFollow.PropagateToVertex(event->GetVertex())) {
           fTrackToFollow.StartTimeIntegral();
        }
        fTrackToFollow.PropagateTo(3.,-0.0028,65.19);
      }
 
-     fTrackToFollow.ResetCovariance(); fTrackToFollow.ResetClusters();
+     fTrackToFollow.ResetCovariance(10.); fTrackToFollow.ResetClusters();
      if (RefitAt(49.,&fTrackToFollow,t)) {
         if (CorrectForDeadZoneMaterial(&fTrackToFollow)!=0) {
           Warning("PropagateBack",
@@ -551,7 +602,7 @@ Int_t AliITStrackerV2::TakeNextProlongation() {
   }
 
   if (fTrackToFollow.GetNumberOfClusters()>1)
-  if (TMath::Abs(fTrackToFollow.GetD())>4) return 0;
+    if (TMath::Abs(fTrackToFollow.GetD(GetX(),GetY()))>4) return 0;
 
   fTrackToFollow.
     SetSampledEdx(cc->GetQ(),fTrackToFollow.GetNumberOfClusters()-1); //b.b.
@@ -573,35 +624,43 @@ Int_t AliITStrackerV2::TakeNextProlongation() {
 }
 
 
-AliITStrackerV2::AliITSlayer::AliITSlayer() {
+AliITStrackerV2::AliITSlayer::AliITSlayer():
+  fR(0.),
+  fPhiOffset(0.),
+  fNladders(0),
+  fZOffset(0.),
+  fNdetectors(0),
+  fDetectors(0),
+  fNsel(0),
+  fRoad(2*fR*TMath::Sqrt(3.14/1.)) //assuming that there's only one cluster
+{
   //--------------------------------------------------------------------
   //default AliITSlayer constructor
   //--------------------------------------------------------------------
-  fR=0.; fPhiOffset=0.; fZOffset=0.;
-  fNladders=0; fNdetectors=0;
-  fDetectors=0;
   
   for (Int_t i=0; i<kNsector; i++) fN[i]=0;
-  fNsel=0;
 
-  fRoad=2*fR*TMath::Sqrt(3.14/1.);//assuming that there's only one cluster
 }
 
 AliITStrackerV2::AliITSlayer::
-AliITSlayer(Double_t r,Double_t p,Double_t z,Int_t nl,Int_t nd) {
+AliITSlayer(Double_t r,Double_t p,Double_t z,Int_t nl,Int_t nd): 
+  fR(r), 
+  fPhiOffset(p), 
+  fNladders(nl),
+  fZOffset(z),
+  fNdetectors(nd),
+  fDetectors(new AliITSdetector[nl*nd]),
+  fNsel(0),
+  fRoad(2*r*TMath::Sqrt(3.14/1.)) //assuming that there's only one cluster
+{
   //--------------------------------------------------------------------
   //main AliITSlayer constructor
   //--------------------------------------------------------------------
-  fR=r; fPhiOffset=p; fZOffset=z;
-  fNladders=nl; fNdetectors=nd;
-  fDetectors=new AliITSdetector[fNladders*fNdetectors];
 
   for (Int_t i=0; i<kNsector; i++) fN[i]=0;
-  fNsel=0;
 
   for (Int_t i=0; i<kMaxClusterPerLayer; i++) fClusters[i]=0;
 
-  fRoad=2*fR*TMath::Sqrt(3.14/1.);//assuming that there's only one cluster
 }
 
 AliITStrackerV2::AliITSlayer::~AliITSlayer() {
index 5029a32..23689f7 100644 (file)
@@ -21,7 +21,7 @@ class TTree;
 //-------------------------------------------------------------------------
 class AliITStrackerV2 : public AliTracker {
 public:
-  AliITStrackerV2():AliTracker(){}
+  AliITStrackerV2();
   AliITStrackerV2(const AliITSgeom *geom);
   ~AliITStrackerV2(){}
   AliCluster *GetCluster(Int_t index) const;
@@ -48,8 +48,8 @@ public:
 
   class AliITSdetector {
   public:
-    AliITSdetector(){}
-    AliITSdetector(Double_t r,Double_t phi) {fR=r; fPhi=phi;}
+    AliITSdetector():fR(0.),fPhi(0.){}
+    AliITSdetector(Double_t r,Double_t phi):fR(r),fPhi(phi){}
     Double_t GetR()   const {return fR;}
     Double_t GetPhi() const {return fPhi;}
   private:
@@ -78,6 +78,8 @@ public:
     Int_t GetNdetectors() const {return fNdetectors;}
     Int_t GetNumberOfClusters() const;
   protected:
+    AliITSlayer(const AliITSlayer&);
+    AliITSlayer &operator=(const AliITSlayer &tr);  
     Double_t fR;                // mean radius of this layer
     Double_t fPhiOffset;        // offset of the first detector in Phi
     Int_t fNladders;            // number of ladders
@@ -96,6 +98,7 @@ public:
   };
 
 protected:
+  AliITStrackerV2(const AliITStrackerV2&);
   void CookLabel(AliKalmanTrack *t,Float_t wrong) const;
   Double_t GetEffectiveThickness(Double_t y, Double_t z) const;
   void  FollowProlongation();
@@ -119,6 +122,8 @@ protected:
   Int_t fLayersNotToSkip[kMaxLayer];     // layer masks
   Int_t fLastLayerToTrackTo;             // the innermost layer to track to
 
+private:
+  AliITStrackerV2 &operator=(const AliITStrackerV2 &tr);  
   ClassDef(AliITStrackerV2,1)   //ITS tracker V2
 };
 
index 5aa1d8b..55a307e 100644 (file)
@@ -86,7 +86,7 @@ public:
   const Int_t * GetClusters(Int_t i) const {return fClusters[i];}
   void SetNormDCAPrim(Float_t nd0, Float_t nd1){fNormDCAPrim[0] = nd0; fNormDCAPrim[1]=nd1;}
   const Float_t  *GetNormDCAPrimP() const {return fNormDCAPrim;}
-private:
+protected:
   AliExternalTrackParam fParamP;  // external parameters of positive particle
   AliExternalTrackParam fParamM;  // external parameters of negative particle
   Float_t        fRP[5];         // combined pid positive
index 86b1365..ccc7cfb 100644 (file)
@@ -75,7 +75,6 @@ AliESDtrack::AliESDtrack() :
   fITSncls(0),
   fITSsignal(0),
   fITSLabel(0),
-  fITSFakeRatio(0),
   fTPCchi2(0),
   fTPCncls(0),
   fTPCnclsF(0),
@@ -154,7 +153,6 @@ AliESDtrack::AliESDtrack(const AliESDtrack& track):
   fITSncls(track.fITSncls),
   fITSsignal(track.fITSsignal),
   fITSLabel(track.fITSLabel),
-  fITSFakeRatio(track.fITSFakeRatio),
   fTPCchi2(track.fTPCchi2),
   fTPCncls(track.fTPCncls),
   fTPCnclsF(track.fTPCnclsF),
@@ -282,7 +280,6 @@ void AliESDtrack::MakeMiniESDtrack(){
   fITSsignal = 0;     
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0; 
   fITSLabel = 0;       
-  fITSFakeRatio = 0;   
 
   // Reset TPC related track information
   fTPCchi2 = 0;       
@@ -381,7 +378,7 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
     SetIntegratedLength(t->GetIntegratedLength());
   }
 
-  Set(*t);
+  Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
   
   switch (flags) {
     
@@ -393,18 +390,19 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
     fITSchi2=t->GetChi2();
     fITSsignal=t->GetPIDsignal();
     fITSLabel = t->GetLabel();
-    fITSFakeRatio = t->GetFakeRatio();
     break;
     
   case kTPCin: case kTPCrefit:
     fTPCLabel = t->GetLabel();
     if (!fIp) fIp=new AliExternalTrackParam(*t);
-    else fIp->Set(*t);
+    else 
+      fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
   case kTPCout:
     index=fFriendTrack->GetTPCindices(); 
     if (flags & kTPCout){
       if (!fOp) fOp=new AliExternalTrackParam(*t);
-      else fOp->Set(*t);
+      else 
+        fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
     }
     fTPCncls=t->GetNumberOfClusters();    
     fTPCchi2=t->GetChi2();
@@ -473,7 +471,8 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
     break;
   case kTRDbackup:
     if (!fOp) fOp=new AliExternalTrackParam(*t);
-    else fOp->Set(*t);
+    else 
+      fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
     fTRDncls0 = t->GetNumberOfClusters(); 
     break;
   case kTOFin: 
@@ -939,3 +938,52 @@ void AliESDtrack::Print(Option_t *) const {
     printf("\n           signal = %f\n", GetRICHsignal()) ;
   }
 } 
+
+Bool_t AliESDtrack::PropagateTo(Double_t xToGo, Double_t b, Double_t mass, 
+Double_t maxStep, Bool_t rotateTo, Double_t maxSnp){
+  //----------------------------------------------------------------
+  //
+  // MI's function
+  //
+  // Propagates this track to the plane X=xk (cm) 
+  // in the magnetic field "b" (kG),
+  // the correction for the material is included
+  //
+  // mass     - mass used in propagation - used for energy loss correction
+  // maxStep  - maximal step for propagation
+  //----------------------------------------------------------------
+  const Double_t kEpsilon = 0.00001;
+  Double_t xpos     = GetX();
+  Double_t dir      = (xpos<xToGo) ? 1.:-1.;
+  //
+  while ( (xToGo-xpos)*dir > kEpsilon){
+    Double_t step = dir*TMath::Min(TMath::Abs(xToGo-xpos), maxStep);
+    Double_t x    = xpos+step;
+    Double_t xyz0[3],xyz1[3],param[7];
+    GetXYZ(xyz0);   //starting global position
+    if (!GetXYZAt(x,b,xyz1)) return kFALSE;   // no prolongation
+    xyz1[2]+=kEpsilon; // waiting for bug correction in geo
+    AliKalmanTrack::MeanMaterialBudget(xyz0,xyz1,param);       
+    if (TMath::Abs(GetSnpAt(x,b)) >= maxSnp) return kFALSE;
+    if (!AliExternalTrackParam::PropagateTo(x,b))  return kFALSE;
+
+    Double_t rho=param[0],x0=param[1],distance=param[4];
+    Double_t d=distance*rho/x0;
+
+    if (!CorrectForMaterial(d,x0,mass)) return kFALSE;
+    if (rotateTo){
+      if (TMath::Abs(GetSnp()) >= maxSnp) return kFALSE;
+      GetXYZ(xyz0);   // global position
+      Double_t alphan = TMath::ATan2(xyz0[1], xyz0[0]); 
+      //
+      Double_t ca=TMath::Cos(alphan-GetAlpha()), 
+               sa=TMath::Sin(alphan-GetAlpha());
+      Double_t sf=GetSnp(), cf=TMath::Sqrt(1.- sf*sf);
+      Double_t sinNew =  sf*ca - cf*sa;
+      if (TMath::Abs(sinNew) >= maxSnp) return kFALSE;
+      if (!Rotate(alphan)) return kFALSE;
+    }
+    xpos = GetX();
+  }
+  return kTRUE;
+}
index c117236..b6812c6 100644 (file)
@@ -73,6 +73,9 @@ public:
     if (!fCp) return kFALSE;
     return fCp->GetXYZ(r);
   }
+  const AliExternalTrackParam *GetConstrainedExternalParameters() const {
+    return fCp;
+  }
   Bool_t GetConstrainedExternalParameters
               (Double_t &alpha, Double_t &x, Double_t p[5]) const;
   Bool_t GetConstrainedExternalCovariance(Double_t cov[15]) const;
@@ -115,8 +118,6 @@ public:
   Float_t GetITSchi2() const {return fITSchi2;}
   Int_t   GetITSclusters(Int_t *idx) const;
   Int_t   GetITSLabel() const {return fITSLabel;}
-  Float_t GetITSFakeRatio() const {return fITSFakeRatio;}
-
   void    SetITStrack(AliKalmanTrack * track){
      fFriendTrack->SetITStrack(track);
   }
@@ -170,7 +171,6 @@ public:
   Float_t GetTRDchi2() const {return fTRDchi2;}
   Int_t   GetTRDclusters(Int_t *idx) const;
   Int_t   GetTRDncls() const {return fTRDncls;}
-  Int_t   GetTRDncls0() const {return fTRDncls0;}
   void    SetTRDpid(Int_t iSpecies, Float_t p);
   Float_t GetTRDpid(Int_t iSpecies) const;
   Int_t   GetTRDLabel() const {return fTRDLabel;}
@@ -238,6 +238,10 @@ public:
   }
   virtual void Print(Option_t * opt) const ; 
 
+  //MI
+  Bool_t PropagateTo(Double_t x, Double_t b, Double_t mass, Double_t maxStep,
+                     Bool_t rotateTo=kTRUE, Double_t maxSnp=0.8);
+
   enum {
     kITSin=0x0001,kITSout=0x0002,kITSrefit=0x0004,kITSpid=0x0008,
     kTPCin=0x0010,kTPCout=0x0020,kTPCrefit=0x0040,kTPCpid=0x0080,
@@ -283,8 +287,6 @@ protected:
   Float_t fITSsignal;      // detector's PID signal
   Float_t fITSr[AliPID::kSPECIES]; // "detector response probabilities" (for the PID)
   Int_t   fITSLabel;       // label according TPC
-  Float_t fITSFakeRatio;   // ration of fake tracks
-
 
   // TPC related track information
   Float_t  fTPCchi2;       // chi2 in the TPC
@@ -344,7 +346,7 @@ protected:
 
   AliESDtrack & operator=(const AliESDtrack & ) {return *this;}
 
-  ClassDef(AliESDtrack,29)  //ESDtrack 
+  ClassDef(AliESDtrack,30)  //ESDtrack 
 };
 
 #endif 
index c4ecff6..3d6859f 100644 (file)
 // Origin: I.Belikov, CERN, Jouri.Belikov@cern.ch                            //
 ///////////////////////////////////////////////////////////////////////////////
 #include "AliExternalTrackParam.h"
-#include "AliKalmanTrack.h"
 #include "AliESDVertex.h"
-
+#include "AliLog.h"
 
 ClassImp(AliExternalTrackParam)
 
 //_____________________________________________________________________________
 AliExternalTrackParam::AliExternalTrackParam() :
+  TObject(),
   fX(0),
   fAlpha(0)
 {
@@ -45,9 +45,23 @@ AliExternalTrackParam::AliExternalTrackParam() :
 }
 
 //_____________________________________________________________________________
+AliExternalTrackParam::AliExternalTrackParam(const AliExternalTrackParam &track):
+  TObject(track),
+  fX(track.fX),
+  fAlpha(track.fAlpha)
+{
+  //
+  // copy constructor
+  //
+  for (Int_t i = 0; i < 5; i++) fP[i] = track.fP[i];
+  for (Int_t i = 0; i < 15; i++) fC[i] = track.fC[i];
+}
+
+//_____________________________________________________________________________
 AliExternalTrackParam::AliExternalTrackParam(Double_t x, Double_t alpha, 
                                             const Double_t param[5], 
                                             const Double_t covar[15]) :
+  TObject(),
   fX(x),
   fAlpha(alpha)
 {
@@ -59,23 +73,15 @@ AliExternalTrackParam::AliExternalTrackParam(Double_t x, Double_t alpha,
 }
 
 //_____________________________________________________________________________
-AliExternalTrackParam::AliExternalTrackParam(const AliKalmanTrack& track) :
-  fX(0),
-  fAlpha(track.GetAlpha())
-{
-  //
-  //
-  track.GetExternalParameters(fX,fP);
-  track.GetExternalCovariance(fC);
-}
-
-//_____________________________________________________________________________
-void AliExternalTrackParam::Set(const AliKalmanTrack& track) {
+void AliExternalTrackParam::Set(Double_t x, Double_t alpha,
+                               const Double_t p[5], const Double_t cov[15]) {
   //
+  //  Sets the parameters
   //
-  fAlpha=track.GetAlpha();
-  track.GetExternalParameters(fX,fP);
-  track.GetExternalCovariance(fC);
+  fX=x;
+  fAlpha=alpha;
+  for (Int_t i = 0; i < 5; i++)  fP[i] = p[i];
+  for (Int_t i = 0; i < 15; i++) fC[i] = cov[i];
 }
 
 //_____________________________________________________________________________
@@ -776,6 +782,26 @@ AliExternalTrackParam::GetYAt(Double_t x, Double_t b, Double_t &y) const {
 }
 
 Bool_t 
+AliExternalTrackParam::GetZAt(Double_t x, Double_t b, Double_t &z) const {
+  //---------------------------------------------------------------------
+  // This function returns the local Z-coordinate of the intersection 
+  // point between this track and the reference plane "x" (cm). 
+  // Magnetic field "b" (kG)
+  //---------------------------------------------------------------------
+  Double_t dx=x-fX;
+  if(TMath::Abs(dx)<=kAlmost0) {z=fP[1]; return kTRUE;}
+
+  Double_t f1=fP[2], f2=f1 + dx*fP[4]*b*kB2C;
+
+  if (TMath::Abs(f1) >= kAlmost1) return kFALSE;
+  if (TMath::Abs(f2) >= kAlmost1) return kFALSE;
+  
+  Double_t r1=sqrt(1.- f1*f1), r2=sqrt(1.- f2*f2);
+  z = fP[1] + dx*(r2 + f2*(f1+f2)/(r1+r2))*fP[3]; // Many thanks to P.Hristov !
+  return kTRUE;
+}
+
+Bool_t 
 AliExternalTrackParam::GetXYZAt(Double_t x, Double_t b, Double_t *r) const {
   //---------------------------------------------------------------------
   // This function returns the global track position extrapolated to
@@ -792,7 +818,7 @@ AliExternalTrackParam::GetXYZAt(Double_t x, Double_t b, Double_t *r) const {
   Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
   r[0] = x;
   r[1] = fP[0] + dx*(f1+f2)/(r1+r2);
-  r[2] = fP[1] + dx*(r2 + f2*(f1+f2)/(r1+r2))*fP[3];//Many thanks to P.Hristov !
+  r[2] = fP[1] + dx*(f1+f2)/(f1*r2 + f2*r1)*fP[3];
   return Local2GlobalPosition(r,fAlpha);
 }
 
@@ -823,56 +849,3 @@ Double_t AliExternalTrackParam::GetSnpAt(Double_t x,Double_t b) const {
   Double_t res = fP[2]+dx*crv;
   return res;
 }
-
-Bool_t AliExternalTrackParam::PropagateTo(Double_t xToGo, Double_t b, Double_t mass, Double_t maxStep, Bool_t rotateTo, Double_t maxSnp){
-  //----------------------------------------------------------------
-  //
-  // Very expensive function !  Don't abuse it !
-  //
-  // Propagates this track to the plane X=xk (cm) 
-  // in the magnetic field "b" (kG),
-  // the correction for the material is included
-  //
-  //  Requires acces to geomanager
-  //
-  // mass     - mass used in propagation - used for energy loss correction
-  // maxStep  - maximal step for propagation
-  //----------------------------------------------------------------
-  const Double_t kEpsilon = 0.00001;
-  Double_t xpos     = GetX();
-  Double_t dir      = (xpos<xToGo) ? 1.:-1.;
-  //
-  while ( (xToGo-xpos)*dir > kEpsilon){
-    Double_t step = dir*TMath::Min(TMath::Abs(xToGo-xpos), maxStep);
-    Double_t x    = xpos+step;
-    Double_t xyz0[3],xyz1[3],param[7];
-    GetXYZ(xyz0);   //starting global position
-    if (!GetXYZAt(x,b,xyz1)) return kFALSE;   // no prolongation
-    xyz1[2]+=kEpsilon; // waiting for bug correction in geo
-    AliKalmanTrack::MeanMaterialBudget(xyz0,xyz1,param);       
-    if (TMath::Abs(GetSnpAt(x,b)) >= maxSnp) return kFALSE;
-    if (!PropagateTo(x,b))  return kFALSE;
-
-    Double_t rho=param[0],x0=param[1],distance=param[4];
-    Double_t d=distance*rho/x0;
-
-    if (!CorrectForMaterial(d,x0,mass)) return kFALSE;
-    if (rotateTo){
-      if (TMath::Abs(fP[2]) >= maxSnp) return kFALSE;
-      GetXYZ(xyz0);   // global position
-      Double_t alphan = TMath::ATan2(xyz0[1], xyz0[0]); 
-      //
-      Double_t ca=TMath::Cos(alphan-fAlpha), sa=TMath::Sin(alphan-fAlpha);
-      Double_t sf=fP[2], cf=TMath::Sqrt(1.- fP[2]*fP[2]);
-      Double_t sinNew =  sf*ca - cf*sa;
-      if (TMath::Abs(sinNew) >= maxSnp) return kFALSE;
-      if (!Rotate(alphan)) return kFALSE;
-    }
-    xpos = GetX();
-  }
-  return kTRUE;
-}
-
-
-
-
index f9f100a..7a6f6b1 100644 (file)
@@ -19,6 +19,7 @@
  *        Origin: I.Belikov, CERN, Jouri.Belikov@cern.ch                     *
  *****************************************************************************/
 #include "TObject.h"
+#include "TMath.h"
 
 const Double_t kAlmost1=0.999;
 const Double_t kAlmost0=1e-33;
@@ -29,30 +30,59 @@ const Double_t kAlmost0Field=1.e-13;
 const Double_t kVeryBigConvConst=1/kB2C/kAlmost0Field;
 const Double_t kMostProbableMomentum=0.35;
 
-class AliKalmanTrack;
 class AliESDVertex;
 
 class AliExternalTrackParam: public TObject {
  public:
   AliExternalTrackParam();
+  AliExternalTrackParam(const AliExternalTrackParam &);
   AliExternalTrackParam(Double_t x, Double_t alpha, 
                        const Double_t param[5], const Double_t covar[15]);
-  AliExternalTrackParam(const AliKalmanTrack& track);
   virtual ~AliExternalTrackParam(){}
 
+  void Set(Double_t x,Double_t alpha,
+                       const Double_t param[5], const Double_t covar[15]);
   void Reset();
-  void Set(const AliKalmanTrack& track);
+  void ResetCovariance(Double_t s2) {
+    fC[0]*= s2;
+    fC[1] = 0.;  fC[2]*= s2;
+    fC[3] = 0.;  fC[4] = 0.;  fC[5]*= s2;
+    fC[6] = 0.;  fC[7] = 0.;  fC[8] = 0.;  fC[9]*= s2;
+    fC[10]= 0.;  fC[11]= 0.;  fC[12]= 0.;  fC[13]= 0.;  fC[14]*=10.;
+  }
 
   const Double_t *GetParameter() const {return fP;}
   const Double_t *GetCovariance() const {return fC;}
-  Double_t GetSigmaY2() const {return fC[0];}
-  Double_t GetSigmaZ2() const {return fC[2];}
+
+  Double_t GetAlpha() const {return fAlpha;}
   Double_t GetX() const {return fX;}
   Double_t GetY()    const {return fP[0];}
   Double_t GetZ()    const {return fP[1];}
-  Double_t GetAlpha() const {return fAlpha;}
+  Double_t GetSnp()  const {return fP[2];}
+  Double_t GetTgl()  const {return fP[3];}
+  Double_t Get1Pt()  const {return fP[4];}
+
+  Double_t GetSigmaY2() const {return fC[0];}
+  Double_t GetSigmaZY() const {return fC[1];}
+  Double_t GetSigmaZ2() const {return fC[2];}
+  Double_t GetSigmaSnpY() const {return fC[3];}
+  Double_t GetSigmaSnpZ() const {return fC[4];}
+  Double_t GetSigmaSnp2() const {return fC[5];}
+  Double_t GetSigmaTglY() const {return fC[6];}
+  Double_t GetSigmaTglZ() const {return fC[7];}
+  Double_t GetSigmaTglSnp() const {return fC[8];}
+  Double_t GetSigmaTgl2() const {return fC[9];}
+  Double_t GetSigma1PtY() const {return fC[10];}
+  Double_t GetSigma1PtZ() const {return fC[11];}
+  Double_t GetSigma1PtSnp() const {return fC[12];}
+  Double_t GetSigma1PtTgl() const {return fC[13];}
+  Double_t GetSigma1Pt2() const {return fC[14];}
+
   Double_t GetSign() const {return (fP[4]>0) ? 1 : -1;}
   Double_t GetP() const;
+  Double_t GetPt() const {
+    return (TMath::Abs(fP[4])>kAlmost0) ? 1./fP[4]:TMath::Sign(kVeryBig,fP[4]);
+  }
   Double_t Get1P() const;
   Double_t GetC(Double_t b) const {return fP[4]*b*kB2C;}
   void GetDZ(Double_t x,Double_t y,Double_t z,Double_t b,Float_t dz[2]) const; 
@@ -81,10 +111,14 @@ class AliExternalTrackParam: public TObject {
   Bool_t GetPxPyPzAt(Double_t x, Double_t b, Double_t p[3]) const;
   Bool_t GetXYZAt(Double_t x, Double_t b, Double_t r[3]) const;
   Bool_t GetYAt(Double_t x,  Double_t b,  Double_t &y) const;
+  Bool_t GetZAt(Double_t x,  Double_t b,  Double_t &z) const;
   void Print(Option_t* option = "") const;
-  // MI
-  virtual Bool_t   PropagateTo(Double_t x, Double_t b, Double_t mass, Double_t maxStep, Bool_t rotateTo=kTRUE, Double_t maxSnp=0.8);
   Double_t GetSnpAt(Double_t x,Double_t b) const;
+
+protected:
+  Double_t &Par(Int_t i) {return fP[i];}
+  Double_t &Cov(Int_t i) {return fC[i];}
+
 private:
   Double_t             fX;     // X coordinate for the point of parametrisation
   Double_t             fAlpha; // Local <-->global coor.system rotation angle
index 7050e3b..268e1d8 100644 (file)
@@ -23,7 +23,7 @@
 
 #include "AliHelix.h"
 #include "AliKalmanTrack.h"
-#include "AliExternalTrackParam.h"
+#include "AliTracker.h"
 #include "TMath.h"
 ClassImp(AliHelix)
 
@@ -56,7 +56,7 @@ AliHelix::AliHelix(const AliKalmanTrack &t)
   //circle parameters
   //PH Sometimes fP4 and fHelix[4] are very big and the calculation
   //PH of the Sqrt cannot be done. To be investigated...
-  fHelix[4]=fHelix[4]/t.GetConvConst();    // C
+  fHelix[4]=fHelix[4]/(1000/0.299792458/AliTracker::GetBz());    // C
   cs=TMath::Cos(alpha); sn=TMath::Sin(alpha);
 
   Double_t xc, yc, rc;
@@ -101,7 +101,7 @@ AliHelix::AliHelix(const AliExternalTrackParam &t)
   //circle parameters
   //PH Sometimes fP4 and fHelix[4] are very big and the calculation
   //PH of the Sqrt cannot be done. To be investigated...
-  fHelix[4]=fHelix[4]/AliKalmanTrack::GetConvConst();    // C
+  fHelix[4]=fHelix[4]/(1000/0.299792458/AliTracker::GetBz());    // C
   cs=TMath::Cos(alpha); sn=TMath::Sin(alpha);
 
   Double_t xc, yc, rc;
@@ -137,7 +137,7 @@ AliHelix::AliHelix(Double_t x[3], Double_t p[3], Double_t charge, Double_t conve
   //
   Double_t pt = TMath::Sqrt(p[0]*p[0]+p[1]*p[1]);
   if (TMath::Abs(conversion)<0.00000001) 
-    conversion = AliKalmanTrack::GetConvConst();
+    conversion = 1000/0.299792458/AliTracker::GetBz();
   //
   //  
   fHelix[4] = charge/(conversion*pt); // C
@@ -175,7 +175,7 @@ void  AliHelix::GetMomentum(Double_t phase, Double_t p[4],Double_t conversion, D
   // return  momentum at given phase
   Double_t x[3],g[3],gg[3];
   Evaluate(phase,x,g,gg);
-  if (TMath::Abs(conversion)<0.0001) conversion = AliKalmanTrack::GetConvConst();
+  if (TMath::Abs(conversion)<0.0001) conversion = 1000/0.299792458/AliTracker::GetBz();
   Double_t mt = TMath::Sqrt(g[0]*g[0]+g[1]*g[1]);
   p[0] = fHelix[8]*g[0]/(mt*conversion);
   p[1] = fHelix[8]*g[1]/(mt*conversion);
index 439a3a4..a3d09ff 100644 (file)
 //   that is the base for AliTPCtrack, AliITStrackV2 and AliTRDtrack
 //        Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
 //-------------------------------------------------------------------------
-#include "AliTracker.h"
+#include <TGeoManager.h>
 #include "AliKalmanTrack.h"
-#include "TGeoManager.h"
 
 ClassImp(AliKalmanTrack)
 
 //_______________________________________________________________________
-AliKalmanTrack::AliKalmanTrack():
+  AliKalmanTrack::AliKalmanTrack():AliExternalTrackParam(),
   fLab(-3141593),
   fFakeRatio(0),
   fChi2(0),
   fMass(AliPID::ParticleMass(AliPID::kPion)),
   fN(0),
-  fLocalConvConst(0),
   fStartTimeIntegral(kFALSE),
   fIntegratedLength(0)
 {
   //
   // Default constructor
   //
-  if (AliTracker::GetFieldMap()==0) {
-      AliError("The magnetic field has not been set!");
-  }
 
   for(Int_t i=0; i<AliPID::kSPECIES; i++) fIntegratedTime[i] = 0;
 }
 
 //_______________________________________________________________________
 AliKalmanTrack::AliKalmanTrack(const AliKalmanTrack &t):
-  TObject(t),
+  AliExternalTrackParam(t),
   fLab(t.fLab),
   fFakeRatio(t.fFakeRatio),
   fChi2(t.fChi2),
   fMass(t.fMass),
   fN(t.fN),
-  fLocalConvConst(t.fLocalConvConst),
   fStartTimeIntegral(t.fStartTimeIntegral),
   fIntegratedLength(t.fIntegratedLength)
 {
   //
   // Copy constructor
   //
-  if (AliTracker::GetFieldMap()==0) {
-    AliFatal("The magnetic field has not been set!");
-  }
   
   for (Int_t i=0; i<AliPID::kSPECIES; i++)
       fIntegratedTime[i] = t.fIntegratedTime[i];
@@ -172,29 +163,13 @@ void AliKalmanTrack::SetIntegratedTimes(const Double_t *times) {
   for (Int_t i=0; i<AliPID::kSPECIES; i++) fIntegratedTime[i]=times[i];
 }
 
-void AliKalmanTrack::External2Helix(Double_t helix[6]) const { 
-  //--------------------------------------------------------------------
-  // External track parameters -> helix parameters 
-  //--------------------------------------------------------------------
-  Double_t alpha,x,cs,sn;
-  GetExternalParameters(x,helix); alpha=GetAlpha();
-
-  cs=TMath::Cos(alpha); sn=TMath::Sin(alpha);
-  helix[5]=x*cs - helix[0]*sn;            // x0
-  helix[0]=x*sn + helix[0]*cs;            // y0
-//helix[1]=                               // z0
-  helix[2]=TMath::ASin(helix[2]) + alpha; // phi0
-//helix[3]=                               // tgl
-  helix[4]=helix[4]/GetLocalConvConst();  // C
-}
-
 Double_t AliKalmanTrack::MeanMaterialBudget(Double_t *start, Double_t *end, Double_t *mparam)
 {
-  //
+  // 
   // calculate mean material budget and material properties beween point start and end
   // mparam - returns parameters used for dEdx and multiple scatering
   //
-  // mparam[0] - density mean 
+  // mparam[0] - density mean
   // mparam[1] - rad length
   // mparam[2] - A mean
   // mparam[3] - Z mean
@@ -202,10 +177,10 @@ Double_t AliKalmanTrack::MeanMaterialBudget(Double_t *start, Double_t *end, Doub
   // mparam[5] - Z/A mean
   // mparam[6] - number of boundary crosses
   //
-    mparam[0]=0; mparam[1]=1; mparam[2] =0; mparam[3] =0, mparam[4]=0, mparam[5]=0; mparam[6]=0; 
+    mparam[0]=0; mparam[1]=1; mparam[2] =0; mparam[3] =0, mparam[4]=0, mparam[5]=0; mparam[6]=0;
   //
   Double_t bparam[6], lparam[6];          // bparam - total param - lparam - local parameters
-  for (Int_t i=0;i<6;i++) bparam[i]=0;    // 
+  for (Int_t i=0;i<6;i++) bparam[i]=0;    //
 
   if (!gGeoManager) {
     printf("ERROR: no TGeo\n");
@@ -215,8 +190,8 @@ Double_t AliKalmanTrack::MeanMaterialBudget(Double_t *start, Double_t *end, Doub
   Double_t length;
   Double_t dir[3];
   length = TMath::Sqrt((end[0]-start[0])*(end[0]-start[0])+
-                      (end[1]-start[1])*(end[1]-start[1])+
-                      (end[2]-start[2])*(end[2]-start[2]));
+                       (end[1]-start[1])*(end[1]-start[1])+
+                       (end[2]-start[2])*(end[2]-start[2]));
   mparam[4]=length;
   if (length<TGeoShape::Tolerance()) return 0.0;
   Double_t invlen = 1./length;
@@ -236,7 +211,7 @@ Double_t AliKalmanTrack::MeanMaterialBudget(Double_t *start, Double_t *end, Doub
   lparam[1]   = material->GetRadLen();
   lparam[2]   = material->GetA();
   lparam[3]   = material->GetZ();
-  lparam[4]   = length; 
+  lparam[4]   = length;
   lparam[5]   = lparam[3]/lparam[2];
   if (material->IsMixture()) {
     lparam[1]*=lparam[0];  // different normalization in the modeler for mixture
@@ -254,7 +229,7 @@ Double_t AliKalmanTrack::MeanMaterialBudget(Double_t *start, Double_t *end, Doub
   Double_t step = 0.0;
   // If no boundary within proposed length, return current density
   if (snext>=length) {
-    for (Int_t ip=0;ip<5;ip++) mparam[ip] = lparam[ip];  
+    for (Int_t ip=0;ip<5;ip++) mparam[ip] = lparam[ip];
     return lparam[0];
   }
   // Try to cross the boundary and see what is next
@@ -265,7 +240,7 @@ Double_t AliKalmanTrack::MeanMaterialBudget(Double_t *start, Double_t *end, Doub
     bparam[1]    += snext*lparam[1];
     bparam[2]    += snext*lparam[2];
     bparam[3]    += snext*lparam[3];
-    bparam[5]    += snext*lparam[5];    
+    bparam[5]    += snext*lparam[5];
     bparam[0]    += snext*lparam[0];
 
     if (snext>=length) break;
@@ -275,15 +250,15 @@ Double_t AliKalmanTrack::MeanMaterialBudget(Double_t *start, Double_t *end, Doub
       gGeoManager->SetStep(1.E-3);
       currentnode = gGeoManager->Step();
       if (!gGeoManager->IsEntering() || !currentnode) {
-       //      printf("ERROR: cannot cross boundary\n"); 
-       mparam[0] = bparam[0]/step;
-       mparam[1] = bparam[1]/step;
-       mparam[2] = bparam[2]/step;
-       mparam[3] = bparam[3]/step;     
-       mparam[5] = bparam[5]/step;     
-       mparam[4] = step;
-       mparam[0] = 0.;             // if crash of navigation take mean density 0 
-       mparam[1] = 1000000;        // and infinite rad length
+        //      printf("ERROR: cannot cross boundary\n");
+        mparam[0] = bparam[0]/step;
+        mparam[1] = bparam[1]/step;
+        mparam[2] = bparam[2]/step;
+        mparam[3] = bparam[3]/step;
+        mparam[5] = bparam[5]/step;
+        mparam[4] = step;
+        mparam[0] = 0.;             // if crash of navigation take mean density 0
+        mparam[1] = 1000000;        // and infinite rad length
         return bparam[0]/step;
       }
       step += 1.E-3;
@@ -304,39 +279,23 @@ Double_t AliKalmanTrack::MeanMaterialBudget(Double_t *start, Double_t *end, Doub
     if (material->IsMixture()) {
       lparam[1]*=lparam[0];
       TGeoMixture * mixture = (TGeoMixture*)material;
-      lparam[5]=0; 
+      lparam[5]=0;
       Double_t sum =0;
       for (Int_t iel=0;iel<mixture->GetNelements();iel++){
-       sum+= mixture->GetWmixt()[iel];
-       lparam[5]+= mixture->GetZmixt()[iel]*mixture->GetWmixt()[iel]/mixture->GetAmixt()[iel];
+        sum+= mixture->GetWmixt()[iel];
+        lparam[5]+= mixture->GetZmixt()[iel]*mixture->GetWmixt()[iel]/mixture->GetAmixt()[iel];
       }
       lparam[5]/=sum;
     }
     gGeoManager->FindNextBoundary(length);
     snext = gGeoManager->GetStep();
-  }   
+  }
   mparam[0] = bparam[0]/step;
   mparam[1] = bparam[1]/step;
   mparam[2] = bparam[2]/step;
-  mparam[3] = bparam[3]/step;  
-  mparam[5] = bparam[5]/step;  
-  return bparam[0]/step;   
-  
-}
+  mparam[3] = bparam[3]/step;
+  mparam[5] = bparam[5]/step;
+  return bparam[0]/step;
 
-Double_t AliKalmanTrack::GetConvConst() {
-  return 1000/0.299792458/AliTracker::GetBz();
 }
 
-void AliKalmanTrack::SaveLocalConvConst() {
-  //---------------------------------------------------------------------
-  // Saves local conversion constant "curvature (1/cm) -> pt (GeV/c)" 
-  //---------------------------------------------------------------------
-  if (AliTracker::UniformField()) {
-     fLocalConvConst=1000/0.299792458/AliTracker::GetBz();
-  } else {
-     Float_t r[3]; GetXYZ(r);
-     fLocalConvConst=1000/0.299792458/AliTracker::GetBz(r);
-  }
-} 
-
index 4596e30..92cd170 100644 (file)
 //            Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch 
 //-------------------------------------------------------------------------
 
-#include <TObject.h>
+#include "AliExternalTrackParam.h"
 #include "AliLog.h"
 #include "AliPID.h"
 
 class AliCluster;
 
-class AliKalmanTrack : public TObject {
+class AliKalmanTrack : public AliExternalTrackParam {
 public:
   AliKalmanTrack();
   AliKalmanTrack(const AliKalmanTrack &t);
-
   virtual ~AliKalmanTrack(){};
+
   void SetLabel(Int_t lab) {fLab=lab;}
-  void SetFakeRatio(Float_t ratio) {fFakeRatio=ratio;}
+
+  virtual Double_t GetPredictedChi2(const AliCluster *c) const = 0;
+  virtual Bool_t PropagateTo(Double_t xr, Double_t x0, Double_t rho) = 0;
+  virtual Bool_t Update(const AliCluster* c, Double_t chi2, Int_t index) = 0;
 
   Bool_t   IsSortable() const {return kTRUE;}
   Int_t    GetLabel()   const {return fLab;}
-  Float_t    GetFakeRatio()   const {return fFakeRatio;}
   Double_t GetChi2()    const {return fChi2;}
   Double_t GetMass()    const {return fMass;}
   Int_t    GetNumberOfClusters() const {return fN;}
@@ -42,51 +44,36 @@ public:
     return 0.;
   }
 
-  virtual Double_t GetAlpha() const {
-    AliWarning("Method must be overloaded !\n");
-    return 0.;
-  }
-  virtual Double_t GetSigmaY2() const {
-    AliWarning("Method must be overloaded !\n");
-    return 0.;
-  }
-  virtual Double_t GetSigmaZ2() const {
-    AliWarning("Method must be overloaded !\n");
-    return 0.;
-  }
-
   virtual Int_t Compare(const TObject *) const {return 0;} 
 
-  virtual void GetExternalParameters(Double_t&/*xr*/,Double_t/*x*/[5]) const=0;
-  virtual void GetExternalCovariance(Double_t /*cov*/[15]) const = 0;
-
-  virtual Double_t GetPredictedChi2(const AliCluster *) const = 0;
-  virtual Int_t PropagateTo(Double_t/*xr*/,Double_t/*x0*/,Double_t/*rho*/) = 0;
+  void GetExternalParameters(Double_t &xr,Double_t p[5]) const {
+    xr=GetX();
+    for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
+  }
+  void GetExternalCovariance(Double_t cov[15]) const {
+    for (Int_t i=0; i<15; i++) cov[i]=GetCovariance()[i];
+  }
 
-  virtual Int_t Update(const AliCluster*, Double_t /*chi2*/, UInt_t) = 0;
+  static 
+  Double_t MeanMaterialBudget(Double_t *start,Double_t *end,Double_t *mparam);
 
-  static Double_t MeanMaterialBudget(Double_t *start, Double_t *end, Double_t *mparam);
   // Time integration (S.Radomski@gsi.de)
-  void   StartTimeIntegral();
+  void StartTimeIntegral();
   void SetIntegratedLength(Double_t l) {fIntegratedLength=l;}
   void SetIntegratedTimes(const Double_t *times);
 
   Bool_t IsStartedTimeIntegral() const {return fStartTimeIntegral;}
-  void     AddTimeStep(Double_t length);
+  void AddTimeStep(Double_t length);
   void GetIntegratedTimes(Double_t *times) const;
   Double_t GetIntegratedTime(Int_t pdg) const;
   Double_t GetIntegratedLength() const {return fIntegratedLength;}
-  virtual void GetXYZ(Float_t r[3]) const = 0;
 
-  static Double_t GetConvConst();
   void SetNumberOfClusters(Int_t n) {fN=n;} 
-protected:
-  void     SaveLocalConvConst();
-  Double_t GetLocalConvConst() const {return fLocalConvConst;}
 
-  void External2Helix(Double_t helix[6]) const;
+  void SetFakeRatio(Float_t ratio) {fFakeRatio=ratio;}
+  Float_t  GetFakeRatio()   const {return fFakeRatio;}
 
+protected:
   void SetChi2(Double_t chi2) {fChi2=chi2;} 
   void SetMass(Double_t mass) {fMass=mass;}
 
@@ -97,14 +84,12 @@ protected:
   Int_t fN;               // number of associated clusters
 
 private:
-  Double_t fLocalConvConst;   //local conversion "curvature(1/cm) -> pt(GeV/c)"
-
   // variables for time integration (S.Radomski@gsi.de)
   Bool_t  fStartTimeIntegral;       // indicator wether integrate time
   Double_t fIntegratedTime[AliPID::kSPECIES];       // integrated time
   Double_t fIntegratedLength;        // integrated length
   
-  ClassDef(AliKalmanTrack,5)    // Reconstructed track
+  ClassDef(AliKalmanTrack,6)    // Reconstructed track
 };
 
 #endif
diff --git a/STEER/AliKink.cxx b/STEER/AliKink.cxx
new file mode 100644 (file)
index 0000000..f04eba0
--- /dev/null
@@ -0,0 +1,116 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+//-------------------------------------------------------------------------
+//    Origin: Marian Ivanov marian.ivanov@cern.ch
+//-------------------------------------------------------------------------
+
+#include <TMath.h>
+#include "AliKink.h"
+#include "AliHelix.h"
+
+
+ClassImp(AliKink)
+
+void  AliKink::Update()
+{
+  //
+  // updates Kink Info
+  //
+  Float_t distance2=1000;
+  //
+  AliHelix dhelix1(fParamDaughter);
+  AliHelix mhelix(fParamMother);    
+  //
+  //find intersection linear
+  //
+  Double_t phase[2][2],radius[2];
+  Double_t delta1=10000,delta2=10000;  
+  Int_t points=0;
+  /*
+    Float_t distance1=0;
+  Int_t  points = dhelix1.GetRPHIintersections(mhelix, phase, radius,200);
+  
+  if (points>0){
+    dhelix1.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1);
+  }
+  if (points==2){    
+    dhelix1.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2);
+  }
+  distance1 = TMath::Min(delta1,delta2);
+  */
+  //
+  //find intersection parabolic
+  //
+  points = dhelix1.GetRPHIintersections(mhelix, phase, radius,7);
+
+  delta1=10000,delta2=10000;  
+  Double_t d1=1000.,d2=10000.;
+  if (points>0){
+    dhelix1.ParabolicDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1,6);
+    //    dhelix1.ParabolicDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1);
+    Double_t xd[3],xm[3];
+    dhelix1.Evaluate(phase[0][0],xd);
+    mhelix.Evaluate(phase[0][1],xm);
+    d1 = (xd[0]-xm[0])*(xd[0]-xm[0])+(xd[1]-xm[1])*(xd[1]-xm[1])+(xd[2]-xm[2])*(xd[2]-xm[2]);
+  }
+  if (points==2){    
+    dhelix1.ParabolicDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2,6);
+    //dhelix1.ParabolicDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2);
+    Double_t xd[3],xm[3];
+    dhelix1.Evaluate(phase[1][0],xd);
+    mhelix.Evaluate(phase[1][1],xm);
+    d2 = (xd[0]-xm[0])*(xd[0]-xm[0])+(xd[1]-xm[1])*(xd[1]-xm[1])+(xd[2]-xm[2])*(xd[2]-xm[2]);
+  }
+  //
+  distance2 = TMath::Min(delta1,delta2);
+  if (delta1<delta2){
+    //get V0 info
+    //    dhelix1.Evaluate(phase[0][0],fXr);
+    Double_t xd[3],xm[3];
+    dhelix1.Evaluate(phase[0][0],xd);
+    mhelix.Evaluate(phase[0][1], xm);
+    fXr[0] = 0.5*(xd[0]+xm[0]);
+    fXr[1] = 0.5*(xd[1]+xm[1]);
+    fXr[2] = 0.5*(xd[2]+xm[2]);
+    //
+    dhelix1.GetMomentum(phase[0][0],fPdr);
+    mhelix.GetMomentum(phase[0][1],fPm);
+    dhelix1.GetAngle(phase[0][0],mhelix,phase[0][1],fAngle);
+    //fRr = TMath::Sqrt(radius[0]);
+    fRr = TMath::Sqrt(fXr[0]*fXr[0]+fXr[1]*fXr[1]);
+  }
+  else{
+    //dhelix1.Evaluate(phase[1][0],fXr);
+    Double_t xd[3],xm[3];
+    dhelix1.Evaluate(phase[1][0],xd);
+    mhelix.Evaluate(phase[1][1], xm);
+    fXr[0] = 0.5*(xd[0]+xm[0]);
+    fXr[1] = 0.5*(xd[1]+xm[1]);
+    fXr[2] = 0.5*(xd[2]+xm[2]);
+    //
+    dhelix1.GetMomentum(phase[1][0], fPdr);
+    mhelix.GetMomentum(phase[1][1], fPm);
+    dhelix1.GetAngle(phase[1][0],mhelix,phase[1][1],fAngle);
+    //    fRr = TMath::Sqrt(radius[1]); 
+    fRr = TMath::Sqrt(fXr[0]*fXr[0]+fXr[1]*fXr[1]);
+  }
+  fDist1 = TMath::Sqrt(TMath::Min(d1,d2));
+  fDist2 = TMath::Sqrt(distance2);      
+  //            
+  //
+
+}
+
diff --git a/STEER/AliKink.h b/STEER/AliKink.h
new file mode 100644 (file)
index 0000000..ae71579
--- /dev/null
@@ -0,0 +1,24 @@
+#ifndef ALIKINK_H
+#define ALIKINK_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+//-------------------------------------------------------------------------
+//                          Kink Vertex Class
+//          This class is part of the reconstruction
+//    Origin: Marian Ivanov marian.ivanov@cern.ch
+//-------------------------------------------------------------------------
+
+#include "AliESDkink.h"
+
+class AliKink : public AliESDkink {
+public:
+  AliKink(){;}             //constructor
+  void Update();            //update
+  ClassDef(AliKink,1)      //kink vertex
+};
+
+#endif
+
+
index 12a468c..d8c8827 100644 (file)
@@ -21,11 +21,8 @@ class AliTrackPoint;
 
 class AliTracker : public TObject {
 public:
-
   enum Propagation_t {kTrackInward, kTrackBack, kTrackRefit}; //type of propagation
-  
   AliTracker();
-  AliTracker(const AliTracker &atr);
   virtual ~AliTracker(){}
   virtual Int_t Clusters2Tracks(AliESD *event)=0;
   virtual Int_t PropagateBack(AliESD *event)=0;
@@ -56,11 +53,16 @@ public:
     Double_t bz=-Double_t(b[2]);
     return  (TMath::Sign(1e-13,bz) + bz);
   }
+  static Double_t GetBz(Double_t *r) {
+    Float_t rr[]={r[0],r[1],r[2]};
+    return GetBz(rr);
+  }
   static Double_t GetBz() {return fgBz;}
   static Bool_t UniformField() {return fgUniformField;}
 
+protected:
+  AliTracker(const AliTracker &atr);
 private:
-
   AliTracker & operator=(const AliTracker & atr);
 
   static Bool_t fgUniformField;       // uniform field flag
@@ -70,7 +72,7 @@ private:
   Double_t fX;  //X-coordinate of the primary vertex
   Double_t fY;  //Y-coordinate of the primary vertex
   Double_t fZ;  //Z-coordinate of the primary vertex
-
   Double_t fSigmaX; // error of the primary vertex position in X
   Double_t fSigmaY; // error of the primary vertex position in Y
   Double_t fSigmaZ; // error of the primary vertex position in Z
diff --git a/STEER/AliV0.cxx b/STEER/AliV0.cxx
new file mode 100644 (file)
index 0000000..2a06aaf
--- /dev/null
@@ -0,0 +1,173 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+//-------------------------------------------------------------------------
+//
+//    Implementation of the V0 vertex class
+//    Numerical part - AliHelix functionality used             
+//
+//    Origin: Marian Ivanov marian.ivanov@cern.ch
+//-------------------------------------------------------------------------
+#include <TMath.h>
+
+#include "AliV0.h"
+#include "AliHelix.h"
+
+
+ClassImp(AliV0)
+
+void  AliV0::Update(Float_t vertex[3])
+{
+  //
+  // updates Kink Info
+  //
+  //  Float_t distance1,distance2;
+  Float_t distance2;
+  //
+  AliHelix phelix(fParamP);
+  AliHelix mhelix(fParamM);    
+  //
+  //find intersection linear
+  //
+  Double_t phase[2][2],radius[2];
+  Int_t  points = phelix.GetRPHIintersections(mhelix, phase, radius,200);
+  Double_t delta1=10000,delta2=10000;  
+  /*
+  if (points<=0) return;
+  if (points>0){
+    phelix.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1);
+    phelix.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1);
+    phelix.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1);
+  }
+  if (points==2){    
+    phelix.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2);
+    phelix.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2);
+    phelix.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2);
+  }
+  distance1 = TMath::Min(delta1,delta2);
+  */
+  //
+  //find intersection parabolic
+  //
+  points = phelix.GetRPHIintersections(mhelix, phase, radius);
+  delta1=10000,delta2=10000;  
+  Double_t d1=1000.,d2=10000.;
+  Double_t err[3],angles[3];
+  if (points<=0) return;
+  if (points>0){
+    phelix.ParabolicDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1);
+    phelix.ParabolicDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1);
+    if (TMath::Abs(fParamP.GetX()-TMath::Sqrt(radius[0])<3) && TMath::Abs(fParamM.GetX()-TMath::Sqrt(radius[0])<3)){
+      // if we are close to vertex use error parama
+      //
+      err[1] = fParamP.GetCovariance()[0]+fParamM.GetCovariance()[0]+0.05*0.05
+       +0.3*(fParamP.GetCovariance()[2]+fParamM.GetCovariance()[2]);
+      err[2] = fParamP.GetCovariance()[2]+fParamM.GetCovariance()[2]+0.05*0.05
+       +0.3*(fParamP.GetCovariance()[0]+fParamM.GetCovariance()[0]);
+      
+      phelix.GetAngle(phase[0][0],mhelix,phase[0][1],angles);
+      Double_t tfi  = TMath::Abs(TMath::Tan(angles[0]));
+      Double_t tlam = TMath::Abs(TMath::Tan(angles[1]));
+      err[0] = err[1]/((0.2+tfi)*(0.2+tfi))+err[2]/((0.2+tlam)*(0.2+tlam));
+      err[0] = ((err[1]*err[2]/((0.2+tfi)*(0.2+tfi)*(0.2+tlam)*(0.2+tlam))))/err[0];
+      phelix.ParabolicDCA2(mhelix,phase[0][0],phase[0][1],radius[0],delta1,err);
+    }
+    Double_t xd[3],xm[3];
+    phelix.Evaluate(phase[0][0],xd);
+    mhelix.Evaluate(phase[0][1],xm);
+    d1 = (xd[0]-xm[0])*(xd[0]-xm[0])+(xd[1]-xm[1])*(xd[1]-xm[1])+(xd[2]-xm[2])*(xd[2]-xm[2]);
+  }
+  if (points==2){    
+    phelix.ParabolicDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2);
+    phelix.ParabolicDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2);
+    if (TMath::Abs(fParamP.GetX()-TMath::Sqrt(radius[1])<3) && TMath::Abs(fParamM.GetX()-TMath::Sqrt(radius[1])<3)){
+      // if we are close to vertex use error paramatrization
+      //
+      err[1] = fParamP.GetCovariance()[0]+fParamM.GetCovariance()[0]+0.05*0.05
+       +0.3*(fParamP.GetCovariance()[2]+fParamM.GetCovariance()[2]);
+      err[2] = fParamP.GetCovariance()[2]+fParamM.GetCovariance()[2]+0.05*0.05
+       +0.3*(fParamP.GetCovariance()[0]+fParamM.GetCovariance()[0]);
+      
+      phelix.GetAngle(phase[1][0],mhelix,phase[1][1],angles);
+      Double_t tfi  = TMath::Abs(TMath::Tan(angles[0]));
+      Double_t tlam = TMath::Abs(TMath::Tan(angles[1]));
+      err[0] = err[1]/((0.2+tfi)*(0.2+tfi))+err[2]/((0.2+tlam)*(0.2+tlam));     
+      err[0] = ((err[1]*err[2]/((0.2+tfi)*(0.2+tfi)*(0.2+tlam)*(0.2+tlam))))/err[0];
+      phelix.ParabolicDCA2(mhelix,phase[1][0],phase[1][1],radius[1],delta2,err);
+    }
+    Double_t xd[3],xm[3];
+    phelix.Evaluate(phase[1][0],xd);
+    mhelix.Evaluate(phase[1][1],xm);
+    d2 = (xd[0]-xm[0])*(xd[0]-xm[0])+(xd[1]-xm[1])*(xd[1]-xm[1])+(xd[2]-xm[2])*(xd[2]-xm[2]);
+  }
+  //
+  distance2 = TMath::Min(delta1,delta2);
+  if (delta1<delta2){
+    //get V0 info
+    Double_t xd[3],xm[3];
+    phelix.Evaluate(phase[0][0],xd);
+    mhelix.Evaluate(phase[0][1], xm);
+    fXr[0] = 0.5*(xd[0]+xm[0]);
+    fXr[1] = 0.5*(xd[1]+xm[1]);
+    fXr[2] = 0.5*(xd[2]+xm[2]);
+
+    Float_t wy = fParamP.GetCovariance()[0]/(fParamP.GetCovariance()[0]+fParamM.GetCovariance()[0]);
+    Float_t wz = fParamP.GetCovariance()[2]/(fParamP.GetCovariance()[2]+fParamM.GetCovariance()[2]);
+    fXr[0] = 0.5*( (1.-wy)*xd[0]+ wy*xm[0] + (1.-wz)*xd[0]+ wz*xm[0] );
+    fXr[1] = (1.-wy)*xd[1]+ wy*xm[1];
+    fXr[2] = (1.-wz)*xd[2]+ wz*xm[2];
+    //
+    phelix.GetMomentum(phase[0][0],fPP);
+    mhelix.GetMomentum(phase[0][1],fPM);
+    phelix.GetAngle(phase[0][0],mhelix,phase[0][1],fAngle);
+    fRr = TMath::Sqrt(fXr[0]*fXr[0]+fXr[1]*fXr[1]);
+  }
+  else{
+    Double_t xd[3],xm[3];
+    phelix.Evaluate(phase[1][0],xd);
+    mhelix.Evaluate(phase[1][1], xm);
+    fXr[0] = 0.5*(xd[0]+xm[0]);
+    fXr[1] = 0.5*(xd[1]+xm[1]);
+    fXr[2] = 0.5*(xd[2]+xm[2]);
+    Float_t wy = fParamP.GetCovariance()[0]/(fParamP.GetCovariance()[0]+fParamM.GetCovariance()[0]);
+    Float_t wz = fParamP.GetCovariance()[2]/(fParamP.GetCovariance()[2]+fParamM.GetCovariance()[2]);
+    fXr[0] = 0.5*( (1.-wy)*xd[0]+ wy*xm[0] + (1.-wz)*xd[0]+ wz*xm[0] );
+    fXr[1] = (1.-wy)*xd[1]+ wy*xm[1];
+    fXr[2] = (1.-wz)*xd[2]+ wz*xm[2];
+    //
+    phelix.GetMomentum(phase[1][0], fPP);
+    mhelix.GetMomentum(phase[1][1], fPM);
+    phelix.GetAngle(phase[1][0],mhelix,phase[1][1],fAngle);
+    fRr = TMath::Sqrt(fXr[0]*fXr[0]+fXr[1]*fXr[1]);
+  }
+  fDist1 = TMath::Sqrt(TMath::Min(d1,d2));
+  fDist2 = TMath::Sqrt(distance2);      
+  //            
+  //
+  Double_t v[3] = {fXr[0]-vertex[0],fXr[1]-vertex[1],fXr[2]-vertex[2]};
+  Double_t p[3] = {fPP[0]+fPM[0], fPP[1]+fPM[1],fPP[2]+fPM[2]};
+  Double_t vnorm2 = v[0]*v[0]+v[1]*v[1];
+  if (TMath::Abs(v[2])>100000) return;
+  Double_t vnorm3 = TMath::Sqrt(TMath::Abs(v[2]*v[2]+vnorm2));
+  vnorm2 = TMath::Sqrt(vnorm2);
+  Double_t pnorm2 = p[0]*p[0]+p[1]*p[1];
+  Double_t pnorm3 = TMath::Sqrt(p[2]*p[2]+pnorm2);
+  pnorm2 = TMath::Sqrt(pnorm2);  
+  fPointAngleFi = (v[0]*p[0]+v[1]*p[1])/(vnorm2*pnorm2);
+  fPointAngleTh = (v[2]*p[2]+vnorm2*pnorm2)/(vnorm3*pnorm3);  
+  fPointAngle   = (v[0]*p[0]+v[1]*p[1]+v[2]*p[2])/(vnorm3*pnorm3);
+  //
+}
+
diff --git a/STEER/AliV0.h b/STEER/AliV0.h
new file mode 100644 (file)
index 0000000..aca70a0
--- /dev/null
@@ -0,0 +1,24 @@
+#ifndef ALIV0_H
+#define ALIV0_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+
+//-------------------------------------------------------------------------
+//                          V0 Vertex Class
+//          This class is part of the reconstruction
+//    Origin: Marian Ivanov marian.ivanov@cern.ch
+//-------------------------------------------------------------------------
+
+#include "AliESDV0MI.h"
+
+class AliV0 :  public AliESDV0MI {
+public:
+  AliV0(){;} 
+  void Update(Float_t vertex[3]);            //update
+  ClassDef(AliV0,1)      // V0 MI vertex
+};
+
+
+#endif
index 8802526..661dff7 100644 (file)
@@ -840,7 +840,7 @@ void AliVertexerTracks::VertexFitter(Bool_t useNominalVtx) {
       t = (AliESDtrack*)fTrkArray.At(k);
       alpha = t->GetAlpha();
       xlStart = initPos[0]*TMath::Cos(alpha)+initPos[1]*TMath::Sin(alpha);
-      t->PropagateTo(xlStart,AliTracker::GetBz());   // to vtxSeed
+      t->AliExternalTrackParam::PropagateTo(xlStart,AliTracker::GetBz());   // to vtxSeed
       rotAngle = alpha;
       if(alpha<0.) rotAngle += 2.*TMath::Pi();
       cosRot = TMath::Cos(rotAngle);
index 2e2783c..6606664 100644 (file)
@@ -29,7 +29,6 @@
 #pragma link C++ class  AliESDCaloCluster+;
 
 #pragma link C++ class  AliKalmanTrack+;
-#pragma link C++ class  AliHelix+;
 #pragma link C++ class  AliExternalTrackParam+;
 #pragma link C++ class  AliLog+;
 #pragma link C++ class  AliPID+;
@@ -49,7 +48,6 @@
 
 #pragma link C++ class AliTrackPointArray+;
 #pragma link C++ class AliTrackPoint+;
-#pragma link C++ class  AliCluster+;
 
 #pragma link C++ class  AliESDFMD+;
 #pragma link C++ class  AliFMDMap+;
@@ -57,7 +55,6 @@
 
 #pragma link C++ class  AliESDMultITS+;
 #pragma link C++ class  AliMultiplicity+;
-#pragma link C++ class  AliTracker+;
 #endif
 
 
index 47d61dd..a2dc81a 100644 (file)
 #pragma link C++ class AliCTPRawStream+;
 #pragma link C++ class AliMathBase+;
 #pragma link C++ class AliSignalProcesor+;
+#pragma link C++ class  AliHelix+;
+#pragma link C++ class  AliCluster+;
+#pragma link C++ class  AliTracker+;
+#pragma link C++ class  AliV0+;
+#pragma link C++ class  AliKink+;
 
 #endif
index 4f52b26..3005d00 100644 (file)
@@ -4,14 +4,14 @@ SRCS = AliESD.cxx AliESDfriend.cxx\
        AliESDv0.cxx AliESDcascade.cxx AliVertex.cxx AliESDVertex.cxx \
        AliESDpid.cxx AliESDkink.cxx AliESDV0MI.cxx \
        AliESDCaloCluster.cxx \
-       AliKalmanTrack.cxx AliHelix.cxx AliExternalTrackParam.cxx \
+       AliKalmanTrack.cxx AliExternalTrackParam.cxx \
        AliLog.cxx AliPID.cxx AliESDV0MIParams.cxx \
        AliRunTag.cxx AliLHCTag.cxx AliDetectorTag.cxx AliEventTag.cxx \
        AliTagCreator.cxx AliTagAnalysis.cxx AliEventTagCuts.cxx AliRunTagCuts.cxx\
-       AliTrackPointArray.cxx AliCluster.cxx \
+       AliTrackPointArray.cxx \
        AliESDFMD.cxx AliFMDMap.cxx AliFMDFloatMap.cxx \
        AliESDMultITS.cxx \
-       AliTracker.cxx AliMultiplicity.cxx AliXMLCollection.cxx
+       AliMultiplicity.cxx AliXMLCollection.cxx
 
 
 HDRS:= $(SRCS:.cxx=.h) 
index 67d12ef..5be9f56 100644 (file)
@@ -31,7 +31,8 @@ AliTrackResiduals.cxx AliTrackResidualsChi2.cxx AliTrackResidualsFast.cxx AliTra
 AliAlignmentTracks.cxx \
 AliExpression.cxx \
 AliCTPRawData.cxx AliCTPRawStream.cxx \
-AliMathBase.cxx AliSignalProcesor.cxx
+AliMathBase.cxx AliSignalProcesor.cxx \
+AliTracker.cxx AliCluster.cxx AliHelix.cxx AliV0.cxx AliKink.cxx
 
 HDRS:= $(SRCS:.cxx=.h) 
 
index 24f7431..47309c9 100644 (file)
@@ -26,9 +26,9 @@
 /////////////////////////////////////////////////////////////////////////////
 
 #include "AliESDtrack.h" 
-#include "AliLog.h" 
+#include "AliTracker.h" 
 
-#include "AliTOFGeometryV5.h"
+#include "AliTOFGeometryV4.h"
 #include "AliTOFGeometry.h"
 #include "AliTOFtrack.h" 
 
@@ -39,156 +39,46 @@ AliTOFtrack::AliTOFtrack() :
   AliKalmanTrack(),
   fSeedInd(-1),
   fSeedLab(-1),
-  fAlpha(0),
-  fX(0),
-  fY(0),
-  fZ(0),
-  fE(0),
-  fT(0),
-  fC(0),
-  fCyy(0),
-  fCzy(0),
-  fCzz(0),
-  fCey(0),
-  fCez(0),
-  fCee(0),
-  fCty(0),
-  fCtz(0),
-  fCte(0),
-  fCtt(0),
-  fCcy(0),
-  fCcz(0),
-  fCce(0),
-  fCct(0),
-  fCcc(0),
-  fTOFgeometry(0x0)
- {
-}//_____________________________________________________________________________
-AliTOFtrack::AliTOFtrack(const AliTOFtrack& t) : AliKalmanTrack(t),
-  fSeedInd(-1),
-  fSeedLab(-1),
-  fAlpha(0),
-  fX(0),
-  fY(0),
-  fZ(0),
-  fE(0),
-  fT(0),
-  fC(0),
-  fCyy(0),
-  fCzy(0),
-  fCzz(0),
-  fCey(0),
-  fCez(0),
-  fCee(0),
-  fCty(0),
-  fCtz(0),
-  fCte(0),
-  fCtt(0),
-  fCcy(0),
-  fCcz(0),
-  fCce(0),
-  fCct(0),
-  fCcc(0),
-  fTOFgeometry(0x0)
- {
+  fTOFgeometry(0)
+{
   //
-  // Copy constructor.
+  // Default constructor.
   //
-  
-  SetSeedIndex(t.GetSeedIndex());
-  SetLabel(t.GetLabel());
-  fSeedLab=t.GetSeedLabel();
-  SetChi2(t.GetChi2());
-
-  fAlpha=t.fAlpha;
-  fX=t.fX;
-
-  fY=t.fY; fZ=t.fZ; fE=t.fE; fT=t.fT; fC=t.fC;
-
-  fCyy=t.fCyy;
-  fCzy=t.fCzy;  fCzz=t.fCzz;
-  fCey=t.fCey;  fCez=t.fCez;  fCee=t.fCee;
-  fCty=t.fCty;  fCtz=t.fCtz;  fCte=t.fCte;  fCtt=t.fCtt;
-  fCcy=t.fCcy;  fCcz=t.fCcz;  fCce=t.fCce;  fCct=t.fCct;  fCcc=t.fCcc;  
-
-  fTOFgeometry = new AliTOFGeometryV5();
+}                                
 
+//_____________________________________________________________________________
+AliTOFtrack::AliTOFtrack(const AliTOFtrack& t) : 
+  AliKalmanTrack(t),
+  fSeedInd(t.fSeedInd),
+  fSeedLab(t.fSeedLab),
+  fTOFgeometry(new AliTOFGeometryV4()) 
+{
+  //
+  // Copy constructor.
+  //
 }                                
 
 //_____________________________________________________________________________
-AliTOFtrack::AliTOFtrack(const AliESDtrack& t):
-  AliKalmanTrack(),
+AliTOFtrack::AliTOFtrack(const AliESDtrack& t) :
+  AliKalmanTrack(), 
   fSeedInd(-1),
   fSeedLab(-1),
-  fAlpha(0),
-  fX(0),
-  fY(0),
-  fZ(0),
-  fE(0),
-  fT(0),
-  fC(0),
-  fCyy(0),
-  fCzy(0),
-  fCzz(0),
-  fCey(0),
-  fCez(0),
-  fCee(0),
-  fCty(0),
-  fCtz(0),
-  fCte(0),
-  fCtt(0),
-  fCcy(0),
-  fCcz(0),
-  fCce(0),
-  fCct(0),
-  fCcc(0),
-  fTOFgeometry(0x0)
- {
+  fTOFgeometry(new AliTOFGeometryV4()) 
+{
   //
   // Constructor from AliESDtrack
   //
-
-  fTOFgeometry = new AliTOFGeometryV5();
-
-  SetSeedIndex(-1);
   SetLabel(t.GetLabel());
   SetChi2(0.);
   SetMass(t.GetMass());
 
-  fAlpha = t.GetAlpha();
-  if      (fAlpha < -TMath::Pi()) fAlpha += 2*TMath::Pi();
-  else if (fAlpha >= TMath::Pi()) fAlpha -= 2*TMath::Pi();
-  Double_t x, p[5]; t.GetExternalParameters(x,p);
-
-  fX=x;
-
-  fY=p[0];
-  fZ=p[1]; SaveLocalConvConst();
-  fT=p[3]; x=GetLocalConvConst();
-  fC=p[4]/x;
-  fE=fC*fX - p[2];   
-
-  //Conversion of the covariance matrix
-  Double_t c[15]; t.GetExternalCovariance(c);
-
-  c[10]/=x; c[11]/=x; c[12]/=x; c[13]/=x; c[14]/=x*x;
-
-  Double_t c22=fX*fX*c[14] - 2*fX*c[12] + c[5];
-  Double_t c32=fX*c[13] - c[8];
-  Double_t c20=fX*c[10] - c[3], c21=fX*c[11] - c[4], c42=fX*c[14] - c[12];
-
-  fCyy=c[0 ];
-  fCzy=c[1 ];   fCzz=c[2 ];
-  fCey=c20;     fCez=c21;     fCee=c22;
-  fCty=c[6 ];   fCtz=c[7 ];   fCte=c32;   fCtt=c[9 ];
-  fCcy=c[10];   fCcz=c[11];   fCce=c42;   fCct=c[13]; fCcc=c[14];  
+  Set(t.GetX(),t.GetAlpha(),t.GetParameter(),t.GetCovariance());
 
   if ((t.GetStatus()&AliESDtrack::kTIME) == 0) return;
   StartTimeIntegral();
   Double_t times[10]; t.GetIntegratedTimes(times); SetIntegratedTimes(times);
   SetIntegratedLength(t.GetIntegratedLength());
 
-
 }              
 
 //____________________________________________________________________________
@@ -201,151 +91,28 @@ AliTOFtrack& AliTOFtrack::operator=(const AliTOFtrack &source)
 
 }
 
-//____________________________________________________________________________
-void AliTOFtrack::GetExternalParameters(Double_t& xr, Double_t x[5]) const {
-  //
-  // This function returns external TOF track representation
-  //
-     xr=fX;
-     x[0]=GetY();
-     x[1]=GetZ();
-     x[2]=GetSnp();
-     x[3]=GetTgl();
-     x[4]=Get1Pt();
-}           
-
-//_____________________________________________________________________________
-void AliTOFtrack::GetExternalCovariance(Double_t cc[15]) const {
-  //
-  // This function returns external representation of the covriance matrix.
-  //
-  Double_t a=GetLocalConvConst();
-  Double_t c22=fX*fX*fCcc-2*fX*fCce+fCee;
-  Double_t c32=fX*fCct-fCte;
-  Double_t c20=fX*fCcy-fCey, c21=fX*fCcz-fCez, c42=fX*fCcc-fCce;
-
-  cc[0 ]=fCyy;
-  cc[1 ]=fCzy;   cc[2 ]=fCzz;
-  cc[3 ]=c20;    cc[4 ]=c21;    cc[5 ]=c22;
-  cc[6 ]=fCty;   cc[7 ]=fCtz;   cc[8 ]=c32;   cc[9 ]=fCtt;
-  cc[10]=fCcy*a; cc[11]=fCcz*a; cc[12]=c42*a; cc[13]=fCct*a; cc[14]=fCcc*a*a; 
-  
-}               
-                       
-
 //_____________________________________________________________________________
-void AliTOFtrack::GetCovariance(Double_t cc[15]) const {
-  //
-  // Returns the covariance matrix.
-  //
-
-  cc[0]=fCyy;
-  cc[1]=fCzy;  cc[2]=fCzz;
-  cc[3]=fCey;  cc[4]=fCez;  cc[5]=fCee;
-  cc[6]=fCcy;  cc[7]=fCcz;  cc[8]=fCce;  cc[9]=fCcc;
-  cc[10]=fCty; cc[11]=fCtz; cc[12]=fCte; cc[13]=fCct; cc[14]=fCtt;
-  
-}    
-
-
-//_____________________________________________________________________________
-Int_t AliTOFtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
+Bool_t AliTOFtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
 {
   // Propagates a track of particle with mass=pm to a reference plane 
   // defined by x=xk through media of density=rho and radiationLength=x0
 
-  if (xk == fX) return 1;
+  if (xk == GetX()) return kTRUE;
   
-  if (TMath::Abs(fC*xk - fE) >= 0.90000) {
-    return 0;
-  }
-  Double_t lcc=GetLocalConvConst();
+  Double_t oldX=GetX(), oldY=GetY(), oldZ=GetZ();
 
-  // track Length measurement [SR, GSI, 17.02.2003]
+  Double_t bz=GetBz();
+  if (!AliExternalTrackParam::PropagateTo(xk,bz)) return kFALSE;
 
-  Double_t oldX = fX, oldY = fY, oldZ = fZ;  
+  Double_t d = TMath::Sqrt((GetX()-oldX)*(GetX()-oldX) + 
+                           (GetY()-oldY)*(GetY()-oldY) + 
+                           (GetZ()-oldZ)*(GetZ()-oldZ));
+  if (IsStartedTimeIntegral() && GetX()>oldX) AddTimeStep(d);
+
+  if (!AliExternalTrackParam::CorrectForMaterial(d*rho/x0,x0,GetMass())) 
+     return kFALSE;
 
-  Double_t x1=fX, x2=x1+(xk-x1), dx=x2-x1, y1=fY, z1=fZ;
-  Double_t c1=fC*x1 - fE;
-  if((c1*c1) > 1){
-    return 0;}
-  Double_t r1=sqrt(1.- c1*c1);
-  Double_t c2=fC*x2 - fE; 
-  if((c2*c2) > 1) {
-    return 0;
-  }
-  Double_t r2=sqrt(1.- c2*c2);
-
-  fY += dx*(c1+c2)/(r1+r2);
-  fZ += dx*(c1+c2)/(c1*r2 + c2*r1)*fT;
-
-  //f = F - 1
-  Double_t rr=r1+r2, cc=c1+c2, xx=x1+x2;
-  Double_t f02=-dx*(2*rr + cc*(c1/r1 + c2/r2))/(rr*rr);
-  Double_t f04= dx*(rr*xx + cc*(c1*x1/r1+c2*x2/r2))/(rr*rr);
-  Double_t cr=c1*r2+c2*r1;
-  Double_t f12=-dx*fT*(2*cr + cc*(c2*c1/r1-r1 + c1*c2/r2-r2))/(cr*cr);
-  Double_t f13= dx*cc/cr;
-  Double_t f14=dx*fT*(cr*xx-cc*(r1*x2-c2*c1*x1/r1+r2*x1-c1*c2*x2/r2))/(cr*cr);
-
-  //b = C*ft
-  Double_t b00=f02*fCey + f04*fCcy, b01=f12*fCey + f14*fCcy + f13*fCty;
-  Double_t b10=f02*fCez + f04*fCcz, b11=f12*fCez + f14*fCcz + f13*fCtz;
-  Double_t b20=f02*fCee + f04*fCce, b21=f12*fCee + f14*fCce + f13*fCte;
-  Double_t b30=f02*fCte + f04*fCct, b31=f12*fCte + f14*fCct + f13*fCtt;
-  Double_t b40=f02*fCce + f04*fCcc, b41=f12*fCce + f14*fCcc + f13*fCct;
-
-  //a = f*b = f*C*ft
-  Double_t a00=f02*b20+f04*b40,a01=f02*b21+f04*b41,a11=f12*b21+f14*b41+f13*b31;
-
-  //F*C*Ft = C + (a + b + bt)
-  fCyy += a00 + 2*b00;
-  fCzy += a01 + b01 + b10;
-  fCey += b20;
-  fCty += b30;
-  fCcy += b40;
-  fCzz += a11 + 2*b11;
-  fCez += b21;
-  fCtz += b31;
-  fCcz += b41;
-
-  fX=x2;                                                     
-
-  //Change of the magnetic field *************
-  SaveLocalConvConst();
-  cc=fC;
-  fC*=lcc/GetLocalConvConst();
-  fE+=fX*(fC-cc);
-
-  //Multiple scattering  ******************
-  Double_t d=sqrt((x1-fX)*(x1-fX)+(y1-fY)*(y1-fY)+(z1-fZ)*(z1-fZ));
-  Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
-  Double_t beta2=p2/(p2 + GetMass()*GetMass());
-  Double_t theta2=14.1*14.1/(beta2*p2*1e6)*d/x0*rho;
-
-  Double_t ey=fC*fX - fE, ez=fT;
-  Double_t xz=fC*ez, zz1=ez*ez+1, xy=fE+ey;
-  
-  fCee += (2*ey*ez*ez*fE+1-ey*ey+ez*ez+fE*fE*ez*ez)*theta2;
-  fCte += ez*zz1*xy*theta2;
-  fCtt += zz1*zz1*theta2;
-  fCce += xz*ez*xy*theta2;
-  fCct += xz*zz1*theta2;
-  fCcc += xz*xz*theta2;
   /*
-  Double_t dc22 = (1-ey*ey+xz*xz*fX*fX)*theta2;
-  Double_t dc32 = (xz*fX*zz1)*theta2;
-  Double_t dc33 = (zz1*zz1)*theta2;
-  Double_t dc42 = (xz*fX*xz)*theta2;
-  Double_t dc43 = (zz1*xz)*theta2;
-  Double_t dc44 = (xz*xz)*theta2; 
-  fCee += dc22;
-  fCte += dc32;
-  fCtt += dc33;
-  fCce += dc42;
-  fCct += dc43;
-  fCcc += dc44;
-  */
   //Energy losses************************
   if((5940*beta2/(1-beta2+1e-10) - beta2) < 0){return 0;}
 
@@ -355,25 +122,13 @@ Int_t AliTOFtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
   Double_t kinE =  TMath::Sqrt(p2);
   if (dE>0.8*kinE) dE = 0.8*kinE;  //      
   if (dE<0)        dE = 0.0;       // not valid region for Bethe bloch 
-  //
-  //
-  if (x1 < x2) dE=-dE;
-  cc=fC;
-  fC*=(1.- sqrt(p2+GetMass()*GetMass())/p2*dE);
-  fE+=fX*(fC-cc);    
-
-  // track time measurement [SR, GSI 17.02.2002]
-  if (x1 < x2)
-  if (IsStartedTimeIntegral()) {
-    Double_t l2 = (fX-oldX)*(fX-oldX) + (fY-oldY)*(fY-oldY) + (fZ-oldZ)*(fZ-oldZ);
-    AddTimeStep(TMath::Sqrt(l2));
-  }
+  */
 
-  return 1;            
+  return kTRUE;            
 }     
 
 //_____________________________________________________________________________
-Int_t AliTOFtrack::PropagateToInnerTOF( Bool_t holes)
+Bool_t AliTOFtrack::PropagateToInnerTOF(Bool_t holes)
 {
   // Propagates a track of particle with mass=pm to a reference plane 
   // defined by x=xk through media of density=rho and radiationLength=x0
@@ -382,16 +137,16 @@ Int_t AliTOFtrack::PropagateToInnerTOF( Bool_t holes)
   Double_t ymax=fTOFgeometry->RinTOF()*TMath::Tan(0.5*AliTOFGeometry::GetAlpha());
   Bool_t skip = kFALSE;
   Double_t y=GetYat(fTOFgeometry->RinTOF(),skip);
-  if(skip){
-    return 0;
+  if (skip) {
+    return kFALSE;
   }
   if (y > ymax) {
     if (!Rotate(AliTOFGeometry::GetAlpha())) {
-      return 0;
+      return kFALSE;
     }
   } else if (y <-ymax) {
     if (!Rotate(-AliTOFGeometry::GetAlpha())) {
-      return 0;
+      return kFALSE;
     }
   }
   
@@ -408,143 +163,20 @@ Int_t AliTOFtrack::PropagateToInnerTOF( Bool_t holes)
   
   if(!PropagateTo(fTOFgeometry->RinTOF()))return 0;
   
-  return 1;
+  return kTRUE;
   
 }     
 
-//_____________________________________________________________________________
-Int_t AliTOFtrack::Rotate(Double_t alpha)
-{
-  // Rotates track parameters in R*phi plane
-  
-
-  fAlpha += alpha;
-  if (fAlpha<-TMath::Pi()) fAlpha += 2*TMath::Pi();
-  if (fAlpha>=TMath::Pi()) fAlpha -= 2*TMath::Pi();
-
-  Double_t x1=fX, y1=fY;
-  Double_t ca=cos(alpha), sa=sin(alpha);
-  Double_t r1=fC*fX - fE;
-
-  fX = x1*ca + y1*sa;
-  fY =-x1*sa + y1*ca;
-  if((r1*r1) > 1) return 0;
-  fE=fE*ca + (fC*y1 + sqrt(1.- r1*r1))*sa;
-
-  Double_t r2=fC*fX - fE;
-  if (TMath::Abs(r2) >= 0.90000) {
-    AliWarning("Rotation failed !");
-    return 0;
-  }
-
-  if((r2*r2) > 1) return 0;
-  Double_t y0=fY + sqrt(1.- r2*r2)/fC;
-  if ((fY-y0)*fC >= 0.) {
-    AliWarning("Rotation failed !!!");
-    return 0;
-  }
-
-  //f = F - 1
-  Double_t f00=ca-1,    f24=(y1 - r1*x1/sqrt(1.- r1*r1))*sa,
-           f20=fC*sa,  f22=(ca + sa*r1/sqrt(1.- r1*r1))-1;
-
-  //b = C*ft
-  Double_t b00=fCyy*f00, b02=fCyy*f20+fCcy*f24+fCey*f22;
-  Double_t b10=fCzy*f00, b12=fCzy*f20+fCcz*f24+fCez*f22;
-  Double_t b20=fCey*f00, b22=fCey*f20+fCce*f24+fCee*f22;
-  Double_t b30=fCty*f00, b32=fCty*f20+fCct*f24+fCte*f22;
-  Double_t b40=fCcy*f00, b42=fCcy*f20+fCcc*f24+fCce*f22;
-
-  //a = f*b = f*C*ft
-  Double_t a00=f00*b00, a02=f00*b02, a22=f20*b02+f24*b42+f22*b22;
-
-  //F*C*Ft = C + (a + b + bt)
-  fCyy += a00 + 2*b00;
-  fCzy += b10;
-  fCey += a02+b20+b02;
-  fCty += b30;
-  fCcy += b40;
-  fCez += b12;
-  fCte += b32;
-  fCee += a22 + 2*b22;
-  fCce += b42;
-
-  return 1;                            
-}                         
-
 //_________________________________________________________________________
 Double_t AliTOFtrack::GetYat(Double_t xk, Bool_t & skip) const {     
 //-----------------------------------------------------------------
 // This function calculates the Y-coordinate of a track at the plane x=xk.
 // Needed for matching with the TOF (I.Belikov)
 //-----------------------------------------------------------------
-     skip=kFALSE;
-     Double_t c1=fC*fX - fE, r1=TMath::Sqrt(TMath::Abs(1.- c1*c1));
-     Double_t c2=fC*xk - fE, r2=TMath::Sqrt(TMath::Abs(1.- c2*c2));
-      if( ((1.- c2*c2)<0) || ((1.- c1*c1)<0) ) skip=kTRUE;
-      return fY + (xk-fX)*(c1+c2)/(r1+r2);
+     Double_t y=0.;
+     skip=(!GetYAt(xk,GetBz(),y));
+     return y;
 }
-//_________________________________________________________________________
-void AliTOFtrack::GetPxPyPz(Double_t& px, Double_t& py, Double_t& pz) const
-{
-  // Returns reconstructed track momentum in the global system.
-
-  Double_t pt=TMath::Abs(GetPt()); // GeV/c
-  Double_t r=fC*fX-fE;
-
-  Double_t y0; 
-  if(r > 1) { py = pt; px = 0; }
-  else if(r < -1) { py = -pt; px = 0; }
-  else {
-    y0=fY + sqrt(1.- r*r)/fC;  
-    px=-pt*(fY-y0)*fC;    //cos(phi);
-    py=-pt*(fE-fX*fC);    //sin(phi);
-  }
-  pz=pt*fT;
-  Double_t tmp=px*TMath::Cos(fAlpha) - py*TMath::Sin(fAlpha);
-  py=px*TMath::Sin(fAlpha) + py*TMath::Cos(fAlpha);
-  px=tmp;            
-
-}                                
-
-//_________________________________________________________________________
-void AliTOFtrack::GetGlobalXYZ(Double_t& x, Double_t& y, Double_t& z) const
-{
-  // Returns reconstructed track coordinates in the global system.
-
-  x = fX; y = fY; z = fZ; 
-  Double_t tmp=x*TMath::Cos(fAlpha) - y*TMath::Sin(fAlpha);
-  y=x*TMath::Sin(fAlpha) + y*TMath::Cos(fAlpha);
-  x=tmp;            
-
-}                                
-
-//_________________________________________________________________________
-void AliTOFtrack::ResetCovariance() {
-  //
-  // Resets covariance matrix
-  //
-
-  fCyy*=10.;
-  fCzy=0.;  fCzz*=10.;
-  fCey=0.;  fCez=0.;  fCee*=10.;
-  fCty=0.;  fCtz=0.;  fCte=0.;  fCtt*=10.;
-  fCcy=0.;  fCcz=0.;  fCce=0.;  fCct=0.;  fCcc*=10.;  
-}                                                         
-
-
-//_________________________________________________________________________
-void AliTOFtrack::ResetCovariance(Float_t mult) {
-  //
-  // Resets covariance matrix
-  //
-
-  fCyy*=mult;
-  fCzy*=0.;  fCzz*=mult;
-  fCey*=0.;  fCez*=0.;  fCee*=mult;
-  fCty*=0.;  fCtz*=0.;  fCte*=0.;  fCtt*=mult;
-  fCcy*=0.;  fCcz*=0.;  fCce*=0.;  fCct*=0.;  fCcc*=mult;  
-}                                                         
 
 //_____________________________________________________________________________
 Int_t AliTOFtrack::Compare(const TObject *o) const {
@@ -559,6 +191,15 @@ Int_t AliTOFtrack::Compare(const TObject *o) const {
   return 0;
 }
 
+Double_t AliTOFtrack::GetBz() const {
+  //
+  // returns Bz component of the magnetic field (kG)
+  //
+  if (AliTracker::UniformField()) return AliTracker::GetBz();
+  Double_t r[3]; GetXYZ(r);
+  return AliTracker::GetBz(r);
+}
+
 //_____________________________________________________________________________
 void AliTOFtrack::GetPropagationParameters(Bool_t holes, Double_t *param) {
 
@@ -588,9 +229,8 @@ void AliTOFtrack::GetPropagationParameters(Bool_t holes, Double_t *param) {
   Double_t rhoTRD =0.33;
 
   Int_t isec = GetSector();
-  Double_t xtr,ytr,ztr;
-  GetGlobalXYZ(xtr,ytr,ztr);
-  Float_t thetatr = TMath::ATan2(TMath::Sqrt(xtr*xtr+ytr*ytr),ztr);
+  Double_t r[3]; GetXYZ(r);
+  Float_t thetatr = TMath::ATan2(TMath::Sqrt(r[0]*r[0]+r[1]*r[1]),r[2]);
 
   if(holes){
     if (isec == 0 || isec == 1 || isec == 2 ) {
@@ -600,7 +240,7 @@ void AliTOFtrack::GetPropagationParameters(Bool_t holes, Double_t *param) {
       }
     }
     if (isec == 11 || isec == 12 || isec == 13 || isec == 14 || isec == 15 ) {
-      if( ztr>=zmin && ztr<=zmax){ 
+      if( r[2]>=zmin && r[2]<=zmax){ 
        x0TRD= x0Air;
        rhoTRD = rhoAir;
       }
index 9d149ea..079269d 100644 (file)
@@ -25,94 +25,45 @@ class AliTOFtrack : public AliKalmanTrack {
 
 public:
 
-  AliTOFtrack();
+   AliTOFtrack();
    AliTOFtrack(const AliTOFtrack& t);
    AliTOFtrack(const AliESDtrack& t);
    AliTOFtrack& operator=(const AliTOFtrack &source); // ass. op.
 
-   Double_t GetAlpha() const {return fAlpha;}
    Int_t    GetSector() const {
-     return Int_t(TVector2::Phi_0_2pi(fAlpha)/AliTOFGeometry::GetAlpha())%AliTOFGeometry::NSectors();}
+     return Int_t(TVector2::Phi_0_2pi(GetAlpha())/AliTOFGeometry::GetAlpha())%AliTOFGeometry::NSectors();}
 
-   Double_t GetC()     const {return fC;}
-   void     GetCovariance(Double_t cov[15]) const; // track covariance
-   Double_t GetEta()   const {return fE;}
-
-   void     GetExternalCovariance(Double_t cov[15]) const ;// track covariance
-   void     GetExternalParameters(Double_t& xr, Double_t x[5]) const ;//track parameters
-   Double_t GetSigmaY2() const {return fCyy;}
-   Double_t GetSigmaZ2() const {return fCzz;}
-
-   Double_t Get1Pt() const {
-      return (TMath::Sign(1e-9,fC) + fC)*GetLocalConvConst();
-   }
-   Double_t GetP()     const {  
-     return TMath::Abs(GetPt())*sqrt(1.+GetTgl()*GetTgl());
-   }
-   Double_t GetPt()    const {return 1./Get1Pt();}   
-   void     GetPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const ;
-   void     GetGlobalXYZ(Double_t &x, Double_t &y, Double_t &z) const ;
    Int_t    GetSeedLabel() const { return fSeedLab; }
    Int_t    GetSeedIndex() const { return fSeedInd; }
    void     SetSeedLabel(Int_t lab) { fSeedLab=lab; }
    void     SetSeedIndex(Int_t ind) { fSeedInd=ind; }
-   Double_t GetSnp()  const {return fX*fC - fE;}
-   Double_t GetTgl()  const {return fT;}
-   Double_t GetX()    const {return fX;}
-   Double_t GetY()    const {return fY;}
-   Double_t GetZ()    const {return fZ;}
   
    Int_t Compare(const TObject *o) const;
 
-
    Double_t GetYat(Double_t xk, Bool_t & skip) const;
-   Int_t    PropagateTo(Double_t xr, Double_t x0=8.72, Double_t rho=5.86e-3);
-   Int_t    PropagateToInnerTOF(Bool_t holes);
-   void     ResetCovariance();   
-   void     ResetCovariance(Float_t mult);   
-   Int_t    Rotate(Double_t angle);
+   Bool_t   PropagateTo(Double_t xr, Double_t x0=8.72, Double_t rho=5.86e-3);
+   Bool_t   PropagateToInnerTOF(Bool_t holes);
+   Bool_t   Rotate(Double_t angle) {
+     return AliExternalTrackParam::Rotate(GetAlpha()+angle);
+   }
 
 protected:
-   void GetXYZ(Float_t r[3]) const;
-   
-   Int_t Update(const AliCluster */*c*/, Double_t /*chi2*/, UInt_t /*idx*/) { 
+   Double_t GetBz() const;
+   Bool_t Update(const AliCluster */*c*/, Double_t /*chi2*/, Int_t /*idx*/) {
      return 0;
    }
    Double_t GetPredictedChi2(const AliCluster */*c*/) const {return 0.;}
-
+   
    Int_t    fSeedInd;     // ESD seed track index  
    Int_t    fSeedLab;     // track label taken from seeding  
-   Double_t fAlpha;       // rotation angle
-   Double_t fX;           // running local X-coordinate of the track (time bin)
-  
-   Double_t fY;             // Y-coordinate of the track
-   Double_t fZ;             // Z-coordinate of the track
-   Double_t fE;             // C*x0
-   Double_t fT;             // tangent of the track momentum dip angle
-   Double_t fC;             // track curvature
-
-   Double_t fCyy;                         // covariance
-   Double_t fCzy, fCzz;                   // matrix
-   Double_t fCey, fCez, fCee;             // of the
-   Double_t fCty, fCtz, fCte, fCtt;       // track
-   Double_t fCcy, fCcz, fCce, fCct, fCcc; // parameters   
-
    AliTOFGeometry *fTOFgeometry; // pointer to the TOF geometry
 
  private:
 
    void GetPropagationParameters(Bool_t holes, Double_t *param);
    
-   ClassDef(AliTOFtrack,0) // TOF reconstructed tracks
+   ClassDef(AliTOFtrack,1) // TOF reconstructed tracks
 
 };                     
 
-inline void AliTOFtrack::GetXYZ(Float_t r[3]) const {
-  //---------------------------------------------------------------------
-  // Returns the position of the track in the global coord. system 
-  //---------------------------------------------------------------------
-  Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
-  r[0]=fX*cs - fY*sn; r[1]=fX*sn + fY*cs; r[2]=fZ;
-}
-
 #endif
index 54877d2..b44c706 100644 (file)
@@ -212,8 +212,6 @@ Int_t AliTOFtracker::PropagateBack(AliESD* event) {
       t->SetTOFcluster(seed->GetTOFcluster());
       t->SetTOFsignalToT(seed->GetTOFsignalToT());
       t->SetTOFCalChannel(seed->GetTOFCalChannel());
-      Int_t tlab[3]; seed->GetTOFLabel(tlab);    
-      t->SetTOFLabel(tlab);
       AliTOFtrack *track = new AliTOFtrack(*seed); 
       t->UpdateTrackParams(track,AliESDtrack::kTOFout);   
       delete track;
@@ -318,6 +316,7 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){
     trackTOFin->GetExternalParameters(x,par);
     Double_t cov[15]; 
     trackTOFin->GetExternalCovariance(cov);
+
     Float_t scalefact=3.;    
     Double_t dphi=
       scalefact*
@@ -325,7 +324,7 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){
     Double_t dz=
       scalefact*
       (5*TMath::Sqrt(cov[2]) + 0.5*fDz + 2.5*TMath::Abs(par[3]));
-    
+
     Double_t phi=TMath::ATan2(par[0],x) + trackTOFin->GetAlpha();
     if (phi<-TMath::Pi())phi+=2*TMath::Pi();
     if (phi>=TMath::Pi())phi-=2*TMath::Pi();
@@ -346,14 +345,21 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){
       AliTOFcluster *c=fClusters[k];
       if (c->GetZ() > z+dz) break;
       if (c->IsUsed()) continue;
-      if (!c->GetStatus()) continue; // skip bad channels as declared in OCDB
-      
       //AliInfo(Form(" fClusters[k]->GetZ() (%f) z-dz (%f)   %4i ", fClusters[k]->GetZ(), z-dz, k));
 
       Double_t dph=TMath::Abs(c->GetPhi()-phi);
       if (dph>TMath::Pi()) dph-=2.*TMath::Pi();
       if (TMath::Abs(dph)>dphi) continue;
-    
+
+      {
+      Double_t maxChi2=150.; // "calibratin constant". Needs to be tuned.
+      Double_t yc=(c->GetPhi() - trackTOFin->GetAlpha())*c->GetR();
+      Double_t p[2]={yc, c->GetZ()};
+      Double_t cov[3]={fDy*fDy/12., 0., fDz*fDz/12.};
+      if (trackTOFin->AliExternalTrackParam::GetPredictedChi2(p,cov) > 150.) 
+         continue;
+      }
+
       clind[0][nc] = c->GetDetInd(0);
       clind[1][nc] = c->GetDetInd(1);
       clind[2][nc] = c->GetDetInd(2);
@@ -385,7 +391,7 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){
 
       Bool_t skip=kFALSE;
       Double_t ysect=trackTOFin->GetYat(xs,skip);
-      if(skip)break;
+      if (skip) break;
       if (ysect > ymax) {
        if (!trackTOFin->Rotate(AliTOFGeometry::GetAlpha())) {
          break;
@@ -404,11 +410,11 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){
 
       // store the running point (Globalrf) - fine propagation     
 
-      Double_t x,y,z;
-      trackTOFin->GetGlobalXYZ(x,y,z);
-      trackPos[0][istep]= (Float_t) x;
-      trackPos[1][istep]= (Float_t) y;
-      trackPos[2][istep]= (Float_t) z;   
+      Double_t r[3];
+      trackTOFin->GetXYZ(r);
+      trackPos[0][istep]= (Float_t) r[0];
+      trackPos[1][istep]= (Float_t) r[1];
+      trackPos[2][istep]= (Float_t) r[2];   
       trackPos[3][istep]= trackTOFin->GetIntegratedLength();
     }
 
@@ -521,12 +527,6 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){
     ind[4]=c->GetDetInd(4);
     Int_t calindex = calib->GetIndex(ind);
     t->SetTOFCalChannel(calindex);
-
-    // keep track of the track labels in the matched cluster
-    Int_t tlab[3];
-    tlab[0]=c->GetLabel(0);
-    tlab[1]=c->GetLabel(1);
-    tlab[2]=c->GetLabel(2);
     
     Double_t tof=AliTOFGeometry::TdcBinWidth()*c->GetTDC()+32; // in ps
     t->SetTOFsignal(tof);
@@ -544,7 +544,6 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){
     t->UpdateTrackParams(trackTOFout,AliESDtrack::kTOFout);    
     t->SetIntegratedLength(recL);
     t->SetIntegratedTimes(time);
-    t->SetTOFLabel(tlab);
 
     delete trackTOFout;
   }
index f965f9d..698429d 100644 (file)
@@ -798,8 +798,8 @@ Float_t AliTOFtrackerMI::GetLinearDistances(AliTOFtrack * track, AliTOFcluster *
   //
   Double_t v0[3];
   Double_t dir[3];
-  track->GetGlobalXYZ(v0[0],v0[1],v0[2]);
-  track->GetPxPyPz(dir[0],dir[1],dir[2]);
+  track->GetXYZ(v0);
+  track->GetPxPyPz(dir);
   dir[0]/=track->GetP();
   dir[1]/=track->GetP();
   dir[2]/=track->GetP();
index a36626d..56ffe62 100644 (file)
@@ -167,10 +167,9 @@ AliTPCseed::AliTPCseed(const AliTPCtrack &t):
   for (Int_t i=0;i<12;i++) fOverlapLabels[i] = -1;
 }
 
-AliTPCseed::AliTPCseed(UInt_t index,  const Double_t xx[5],
-                      const Double_t cc[15], 
-                      Double_t xr, Double_t alpha):      
-  AliTPCtrack(index, xx, cc, xr, alpha),
+AliTPCseed::AliTPCseed(Double_t xr, Double_t alpha, const Double_t xx[5],
+                      const Double_t cc[15], Int_t index):      
+  AliTPCtrack(xr, alpha, xx, cc, index),
   fEsd(0x0),
   fClusterOwner(kFALSE),
   fPoints(0x0),
@@ -328,7 +327,7 @@ void AliTPCseed::Reset(Bool_t all)
   SetNumberOfClusters(0);
   fNFoundable = 0;
   SetChi2(0);
-  ResetCovariance();
+  ResetCovariance(10.);
   /*
   if (fTrackPoints){
     for (Int_t i=0;i<8;i++){
@@ -354,14 +353,11 @@ void AliTPCseed::Modify(Double_t factor)
   //This function makes a track forget its history :)  
   //------------------------------------------------------------------
   if (factor<=0) {
-    ResetCovariance();
+    ResetCovariance(10.);
     return;
   }
-  fC00*=factor;
-  fC10*=0;  fC11*=factor;
-  fC20*=0;  fC21*=0;  fC22*=factor;
-  fC30*=0;  fC31*=0;  fC32*=0;  fC33*=factor;
-  fC40*=0;  fC41*=0;  fC42*=0;  fC43*=0;  fC44*=factor;
+  ResetCovariance(factor);
+
   SetNumberOfClusters(0);
   fNFoundable =0;
   SetChi2(0);
@@ -383,25 +379,25 @@ Int_t  AliTPCseed::GetProlongation(Double_t xk, Double_t &y, Double_t & z) const
   // doesn't change internal state of the track
   //-----------------------------------------------------------------
   
-  Double_t x1=fX, x2=x1+(xk-x1), dx=x2-x1;
+  Double_t x1=GetX(), x2=x1+(xk-x1), dx=x2-x1;
 
-  if (TMath::Abs(fP4*xk - fP2) >= AliTPCReconstructor::GetMaxSnpTrack()) {   
+  if (TMath::Abs(GetSnp()+GetC()*dx) >= AliTPCReconstructor::GetMaxSnpTrack()) {   
     return 0;
   }
 
   //  Double_t y1=fP0, z1=fP1;
-  Double_t c1=fP4*x1 - fP2, r1=sqrt(1.- c1*c1);
-  Double_t c2=fP4*x2 - fP2, r2=sqrt(1.- c2*c2);
+  Double_t c1=GetSnp(), r1=sqrt(1.- c1*c1);
+  Double_t c2=c1 + GetC()*dx, r2=sqrt(1.- c2*c2);
   
-  y = fP0;
-  z = fP1;
+  y = GetY();
+  z = GetZ();
   //y += dx*(c1+c2)/(r1+r2);
   //z += dx*(c1+c2)/(c1*r2 + c2*r1)*fP3;
   
   Double_t dy = dx*(c1+c2)/(r1+r2);
   Double_t dz = 0;
   //
-  Double_t delta = fP4*dx*(c1+c2)/(c1*r2 + c2*r1);
+  Double_t delta = GetC()*dx*(c1+c2)/(c1*r2 + c2*r1);
   /*
   if (TMath::Abs(delta)>0.0001){
     dz = fP3*TMath::ASin(delta)/fP4;
@@ -410,7 +406,7 @@ Int_t  AliTPCseed::GetProlongation(Double_t xk, Double_t &y, Double_t & z) const
   }
   */
   //  dz =  fP3*AliTPCFastMath::FastAsin(delta)/fP4;
-  dz =  fP3*TMath::ASin(delta)/fP4;
+  dz =  GetTgl()*TMath::ASin(delta)/GetC();
   //
   y+=dy;
   z+=dz;
@@ -426,24 +422,11 @@ Double_t AliTPCseed::GetPredictedChi2(const AliCluster *c) const
   //-----------------------------------------------------------------
   // This function calculates a predicted chi2 increment.
   //-----------------------------------------------------------------
-  //Double_t r00=c->GetSigmaY2(), r01=0., r11=c->GetSigmaZ2();
-  Double_t r00=fErrorY2, r01=0., r11=fErrorZ2;
-  r00+=fC00; r01+=fC10; r11+=fC11;
-
-  Double_t det=r00*r11 - r01*r01;
-  if (TMath::Abs(det) < 1.e-10) {
-    //Int_t n=GetNumberOfClusters();
-    //if (n>4) cerr<<n<<" AliKalmanTrack warning: Singular matrix !\n";
-    return 1e10;
-  }
-  Double_t tmp=r00; r00=r11; r11=tmp; r01=-r01;
-  
-  Double_t dy=c->GetY() - fP0, dz=c->GetZ() - fP1;
-  
-  return (dy*r00*dy + 2*r01*dy*dz + dz*r11*dz)/det;
+  Double_t p[2]={c->GetY(), c->GetZ()};
+  Double_t cov[3]={fErrorY2, 0., fErrorZ2};
+  return AliExternalTrackParam::GetPredictedChi2(p,cov);
 }
 
-
 //_________________________________________________________________________________________
 
 
@@ -452,7 +435,7 @@ Int_t AliTPCseed::Compare(const TObject *o) const {
   // This function compares tracks according to the sector - for given sector according z
   //-----------------------------------------------------------------
   AliTPCseed *t=(AliTPCseed*)o;
-  const Double_t kfC44mean = 0.0001; 
+
   if (fSort == 0){
     if (t->fRelativeSector>fRelativeSector) return -1;
     if (t->fRelativeSector<fRelativeSector) return 1;
@@ -463,23 +446,12 @@ Int_t AliTPCseed::Compare(const TObject *o) const {
     return 0;
   }
   else {
-    if (t->fC44<0){
-      AliError("Non positive covariance");
-      t->Dump();
-      return -1;
-    }
-    if (fC44<0){
-      AliError("Non positive covariance");
-      Dump();
-      return 1;
-    }
-    //
     Float_t f2 =1;
-    f2 = 1./(kfC44mean+TMath::Sqrt(TMath::Abs(t->fC44)));
+    f2 = 1-20*TMath::Sqrt(t->GetSigma1Pt2())/(TMath::Abs(t->Get1Pt())+0.0066);
     if (t->fBConstrain) f2=1.2;
 
     Float_t f1 =1;
-    f1 = 1./(kfC44mean+TMath::Sqrt(TMath::Abs(fC44)));
+    f1 = 1-20*TMath::Sqrt(GetSigma1Pt2())/(TMath::Abs(Get1Pt())+0.0066);
 
     if (fBConstrain)   f1=1.2;
  
@@ -492,59 +464,22 @@ Int_t AliTPCseed::Compare(const TObject *o) const {
 
 
 //_____________________________________________________________________________
-Int_t AliTPCseed::Update(const AliCluster *c, Double_t chisq, UInt_t /*index*/) {
+Bool_t AliTPCseed::Update(const AliCluster *c, Double_t chisq, Int_t /*index*/)
+{
   //-----------------------------------------------------------------
   // This function associates a cluster with this track.
   //-----------------------------------------------------------------
-  Double_t r00=fErrorY2, r01=0., r11=fErrorZ2;
+  Double_t p[2]={c->GetY(), c->GetZ()};
+  Double_t cov[3]={fErrorY2, 0., fErrorZ2};
 
-  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 cur=fP4 + k40*dy + k41*dz, eta=fP2 + k20*dy + k21*dz;
-  if (TMath::Abs(cur*fX-eta) >= AliTPCReconstructor::GetMaxSnpTrack()) {
-    return 0;
-  }
-
-  fP0 += k00*dy + k01*dz;
-  fP1 += k10*dy + k11*dz;
-  fP2  = eta;
-  fP3 += k30*dy + k31*dz;
-  fP4  = cur;
-
-  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; 
-
-  fC22-=k20*c02+k21*c12;   fC32-=k20*c03+k21*c13;
-  fC42-=k20*c04+k21*c14; 
-
-  fC33-=k30*c03+k31*c13;
-  fC43-=k40*c03+k41*c13; 
-
-  fC44-=k40*c04+k41*c14; 
+  if (!AliExternalTrackParam::Update(p,cov)) return kFALSE;
 
   Int_t n=GetNumberOfClusters();
   //  fIndex[n]=index;
   SetNumberOfClusters(n+1);
   SetChi2(GetChi2()+chisq);
 
-  return 1;
+  return kTRUE;
 }
 
 
@@ -805,7 +740,7 @@ void AliTPCseed::CookPID()
   Double_t sumr =0;
   for (Int_t j=0; j<ns; j++) {
     Double_t mass=AliPID::ParticleMass(j);
-    Double_t mom=P();
+    Double_t mom=GetP();
     Double_t dedx=fdEdx/fMIP;
     Double_t bethe=Bethe(mom/mass); 
     Double_t sigma=fRes*bethe;
@@ -1000,3 +935,15 @@ void AliTPCseed::CookdEdx2(Double_t low, Double_t up) {
 
 }
 */
+Double_t AliTPCseed::GetYat(Double_t xk) const {
+//-----------------------------------------------------------------
+// This function calculates the Y-coordinate of a track at the plane x=xk.
+//-----------------------------------------------------------------
+  if (TMath::Abs(GetSnp())>AliTPCReconstructor::GetMaxSnpTrack()) return 0.; //patch 01 jan 06
+    Double_t c1=GetSnp(), r1=TMath::Sqrt(1.- c1*c1);
+    Double_t c2=c1+GetC()*(xk-GetX());
+    if (TMath::Abs(c2)>AliTPCReconstructor::GetMaxSnpTrack()) return 0;
+    Double_t r2=TMath::Sqrt(1.- c2*c2);
+    return GetY() + (xk-GetX())*(c1+c2)/(r1+r2);
+}
+
index 4e6fd72..a16c035 100644 (file)
@@ -35,18 +35,22 @@ class AliTPCseed : public AliTPCtrack {
      AliTPCseed(const AliTPCtrack &t);
      AliTPCseed(const AliTPCseed &s, Bool_t clusterOwner = kFALSE);
      //AliTPCseed(const AliTPCseed &t, Double_t a);
-     AliTPCseed(UInt_t index, const Double_t xx[5], 
-                const Double_t cc[15], Double_t xr, Double_t alpha);     
+     AliTPCseed(Double_t xr, Double_t alpha, const Double_t xx[5], 
+                const Double_t cc[15], Int_t i);     
      Int_t Compare(const TObject *o) const;
      void Reset(Bool_t all = kTRUE);
      Int_t GetProlongation(Double_t xr, Double_t &y, Double_t & z) const;
      virtual Double_t GetPredictedChi2(const AliCluster *cluster2) const;
-     virtual Int_t Update(const AliCluster* c2, Double_t chi2, UInt_t i);
+     virtual Bool_t Update(const AliCluster* c2, Double_t chi2, Int_t i);
      AliTPCTrackerPoint * GetTrackPoint(Int_t i);
      AliTPCclusterMI * GetClusterFast(Int_t irow){ return fClusterPointer[irow];}
      void RebuildSeed(); // rebuild seed to be ready for storing
      Double_t GetDensityFirst(Int_t n);
-     Double_t GetSigma2C() const {return fC44;};
+     Double_t GetSigma2C() const {
+       Double_t cnv=GetBz()*kB2C;
+       return GetSigma1Pt2()*cnv*cnv;
+     }
+     Double_t GetEta() const { return GetC()*GetX() - GetSnp();}
      void GetClusterStatistic(Int_t first, Int_t last, Int_t &found, Int_t &foundable, Int_t &shared, Bool_t plus2);
      
      void Modify(Double_t factor);
@@ -62,6 +66,8 @@ class AliTPCseed : public AliTPCtrack {
        return pica;
      }
     
+     Double_t GetYat(Double_t x) const;
+
      void SetErrorY2(Float_t sy2){fErrorY2=sy2;}
      void SetErrorZ2(Float_t sz2){fErrorZ2=sz2;}
      Float_t  CookdEdx(Double_t low=0.05, Double_t up=0.70, Int_t i1=0, Int_t i2=159, Bool_t onlyused = kFALSE);
index d6733b3..fce664f 100644 (file)
 
 #include "AliTPCtrack.h"
 #include "AliCluster.h"
+#include "AliTracker.h"
 #include "AliESDtrack.h"
-#include "AliTPCReconstructor.h"
 
 ClassImp(AliTPCtrack)
 
 //_________________________________________________________________________
 AliTPCtrack::AliTPCtrack(): 
   AliKalmanTrack(),
-  fX(0),
-  fAlpha(0),
   fdEdx(0),
-  fP0(0),
-  fP1(0),
-  fP2(0),
-  fP3(0),
-  fP4(0),
-  fC00(1e10),
-  fC10(0),
-  fC11(1e10),
-  fC20(0),
-  fC21(0),
-  fC22(1e10),
-  fC30(0),
-  fC31(0),
-  fC32(0),
-  fC33(1e10),
-  fC40(0),
-  fC41(0),
-  fC42(0),
-  fC43(0),
-  fC44(0),
-  fNumber(0),
   fSdEdx(1e10),
   fNFoundable(0),
   fBConstrain(kFALSE),
@@ -82,32 +59,10 @@ AliTPCtrack::AliTPCtrack():
 
 
 
-AliTPCtrack::AliTPCtrack(UInt_t index, const Double_t xx[5],
-const Double_t cc[15], Double_t xref, Double_t alpha) :
+AliTPCtrack::AliTPCtrack(Double_t x, Double_t alpha, const Double_t p[5],
+                        const Double_t cov[15], Int_t index) :
   AliKalmanTrack(),
-  fX(xref),
   fdEdx(0),
-  fP0(xx[0]),
-  fP1(xx[1]),
-  fP2(xx[2]),
-  fP3(xx[3]),
-  fP4(xx[4]),
-  fC00(cc[0]),
-  fC10(cc[1]),
-  fC11(cc[2]),
-  fC20(cc[3]),
-  fC21(cc[4]),
-  fC22(cc[5]),
-  fC30(cc[6]),
-  fC31(cc[7]),
-  fC32(cc[8]),
-  fC33(cc[9]),
-  fC40(cc[10]),
-  fC41(cc[11]),
-  fC42(cc[12]),
-  fC43(cc[13]),
-  fC44(cc[14]),
-  fNumber(1),
   fSdEdx(1e10),
   fNFoundable(0),
   fBConstrain(kFALSE),
@@ -122,11 +77,31 @@ const Double_t cc[15], Double_t xref, Double_t alpha) :
   //-----------------------------------------------------------------
   // This is the main track constructor.
   //-----------------------------------------------------------------
-  fAlpha=alpha;
-  if (fAlpha<-TMath::Pi()) fAlpha += 2*TMath::Pi();
-  if (fAlpha>=TMath::Pi()) fAlpha -= 2*TMath::Pi();
 
-  SaveLocalConvConst();
+  Double_t cnv=1./(GetBz()*kB2C);
+
+  Double_t pp[5]={
+    p[0],
+    p[1],
+    x*p[4] - p[2],
+    p[3],
+    p[4]*cnv
+  };
+
+  Double_t c22 = x*x*cov[14] - 2*x*cov[12] + cov[5];
+  Double_t c32 = x*cov[13] - cov[8];
+  Double_t c20 = x*cov[10] - cov[3], 
+           c21 = x*cov[11] - cov[4], c42 = x*cov[14] - cov[12];
+
+  Double_t cc[15]={
+    cov[0 ],
+    cov[1 ],     cov[2 ],
+    c20,         c21,         c22,
+    cov[6 ],     cov[7 ],     c32,     cov[9 ],
+    cov[10]*cnv, cov[11]*cnv, c42*cnv, cov[13]*cnv, cov[14]*cnv*cnv
+  };
+
+  Set(x,alpha,pp,cc);
 
   SetNumberOfClusters(1);
   
@@ -141,6 +116,7 @@ const Double_t cc[15], Double_t xref, Double_t alpha) :
 //_____________________________________________________________________________
 AliTPCtrack::AliTPCtrack(const AliESDtrack& t) :
   AliKalmanTrack(),
+  fdEdx(t.GetTPCsignal()),
   fSdEdx(1e10),
   fNFoundable(0),
   fBConstrain(kFALSE),
@@ -163,34 +139,7 @@ AliTPCtrack::AliTPCtrack(const AliESDtrack& t) :
   for (Int_t i=0; i<3;i++) fKinkIndexes[i]=0;
   for (Int_t i=0; i<3;i++) fV0Indexes[i]=0;
 
-  fdEdx  = t.GetTPCsignal();
-  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);
-  Double_t c[15]; t.GetExternalCovariance(c);
-
-  fX=x;    
-  fP0=p[0];
-  fP1=p[1];    SaveLocalConvConst();
-  fP3=p[3];    x=GetLocalConvConst();
-  fP4=p[4]/x;
-  fP2=fP4*fX - p[2];
-
-  //Conversion of the covariance matrix
-  c[10]/=x; c[11]/=x; c[12]/=x; c[13]/=x; c[14]/=x*x;
-
-  Double_t c22=fX*fX*c[14] - 2*fX*c[12] + c[5];
-  Double_t c32=fX*c[13] - c[8];
-  Double_t c20=fX*c[10] - c[3], c21=fX*c[11] - c[4], c42=fX*c[14] - c[12];
-
-  fC00=c[0 ];
-  fC10=c[1 ];   fC11=c[2 ];
-  fC20=c20;     fC21=c21;     fC22=c22;
-  fC30=c[6 ];   fC31=c[7 ];   fC32=c32;   fC33=c[9 ];
-  fC40=c[10];   fC41=c[11];   fC42=c42;   fC43=c[13]; fC44=c[14];
+  Set(t.GetX(),t.GetAlpha(),t.GetParameter(),t.GetCovariance());
 
   if ((t.GetStatus()&AliESDtrack::kTIME) == 0) return;
   StartTimeIntegral();
@@ -201,30 +150,7 @@ AliTPCtrack::AliTPCtrack(const AliESDtrack& t) :
 //_____________________________________________________________________________
 AliTPCtrack::AliTPCtrack(const AliTPCtrack& t) :
   AliKalmanTrack(t),
-  fX(t.fX),
-  fAlpha(t.fAlpha),
   fdEdx(t.fdEdx),
-  fP0(t.fP0),
-  fP1(t.fP1),
-  fP2(t.fP2),
-  fP3(t.fP3),
-  fP4(t.fP4),
-  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),
-  fNumber(t.fNumber),
   fSdEdx(t.fSdEdx),
   fNFoundable(t.fNFoundable),
   fBConstrain(t.fBConstrain),
@@ -240,6 +166,8 @@ AliTPCtrack::AliTPCtrack(const AliTPCtrack& t) :
   //-----------------------------------------------------------------
   // This is a track copy constructor.
   //-----------------------------------------------------------------
+  Set(t.GetX(),t.GetAlpha(),t.GetParameter(),t.GetCovariance());
+
   for (Int_t i=0; i<kMaxRow; i++) fIndex[i]=t.fIndex[i];
   for (Int_t i=0; i<4;i++) fPoints[i]=t.fPoints[i];
   for (Int_t i=0; i<12;i++) fKinkPoint[i]=t.fKinkPoint[i];
@@ -262,347 +190,70 @@ Int_t AliTPCtrack::Compare(const TObject *o) const {
   return 0;
 }
 
-//_____________________________________________________________________________
-void AliTPCtrack::GetExternalCovariance(Double_t cc[15]) const {
- //-------------------------------------------------------------------------
-  // This function returns an external representation of the covriance matrix.
-  //   (See comments in AliTPCtrack.h about external track representation)
-  //-------------------------------------------------------------------------
-  Double_t a=GetLocalConvConst();
-
-  Double_t c22=fX*fX*fC44-2*fX*fC42+fC22;
-  Double_t c32=fX*fC43-fC32;
-  Double_t c20=fX*fC40-fC20, c21=fX*fC41-fC21, c42=fX*fC44-fC42;
-  
-  cc[0 ]=fC00;
-  cc[1 ]=fC10;   cc[2 ]=fC11;
-  cc[3 ]=c20;    cc[4 ]=c21;    cc[5 ]=c22;
-  cc[6 ]=fC30;   cc[7 ]=fC31;   cc[8 ]=c32;   cc[9 ]=fC33; 
-  cc[10]=fC40*a; cc[11]=fC41*a; cc[12]=c42*a; cc[13]=fC43*a; cc[14]=fC44*a*a;
-
-}
-
-//_____________________________________________________________________________
-Double_t AliTPCtrack::GetPredictedChi2(const AliCluster *c) const 
-{
+Double_t AliTPCtrack::GetPredictedChi2(const AliCluster *c) const {
   //-----------------------------------------------------------------
   // This function calculates a predicted chi2 increment.
   //-----------------------------------------------------------------
-  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-10) {
-    Int_t n=GetNumberOfClusters();
-    if (n>4) cerr<<n<<" AliKalmanTrack warning: Singular matrix !\n";
-    return 1e10;
-  }
-  Double_t tmp=r00; r00=r11; r11=tmp; r01=-r01;
-  
-  Double_t dy=c->GetY() - fP0, dz=c->GetZ() - fP1;
-  
-  return (dy*r00*dy + 2*r01*dy*dz + dz*r11*dz)/det;
-}
-
-Double_t AliTPCtrack::GetYat(Double_t xk) const {
-//-----------------------------------------------------------------
-// This function calculates the Y-coordinate of a track at the plane x=xk.
-//-----------------------------------------------------------------
-  if (TMath::Abs(fP4*fX - fP2)>AliTPCReconstructor::GetMaxSnpTrack()) return 0.; //patch 01 jan 06
-    Double_t c1=fP4*fX - fP2, r1=TMath::Sqrt(1.- c1*c1);
-    Double_t c2=fP4*xk - fP2;
-    if (c2*c2>AliTPCReconstructor::GetMaxSnpTrack()) {
-      //       Int_t n=GetNumberOfClusters();
-      // if (n>4) cerr<<n<<"AliTPCtrack::GetYat: can't evaluate the y-coord !\n";
-       return 0;
-    } 
-    Double_t r2=TMath::Sqrt(1.- c2*c2);
-    return fP0 + (xk-fX)*(c1+c2)/(r1+r2);
+  Double_t p[2]={c->GetY(), c->GetZ()};
+  Double_t cov[3]={c->GetSigmaY2(), 0., c->GetSigmaZ2()};
+  return AliExternalTrackParam::GetPredictedChi2(p,cov);
 }
 
 //_____________________________________________________________________________
-Int_t AliTPCtrack::PropagateTo(Double_t xk,Double_t /*x0*/,Double_t rho) {
+Bool_t AliTPCtrack::PropagateTo(Double_t xk,Double_t rho,Double_t x0) {
   //-----------------------------------------------------------------
-  // This function propagates a track to a reference plane x=xk.
+  //  This function propagates a track to a reference plane x=xk.
+  //  rho - density of the crossed matrial (g/cm^3)
+  //  x0  - radiation length of the crossed material (g/cm^2) 
   //-----------------------------------------------------------------
-  if (TMath::Abs(fP4*xk - fP2) >= AliTPCReconstructor::GetMaxSnpTrack()) {
-    //    Int_t n=GetNumberOfClusters();
-    //if (n>4) cerr<<n<<" AliTPCtrack warning: Propagation failed !\n";
-    return 0;
-  }
-  Double_t lcc=GetLocalConvConst();  
+  Double_t oldX=GetX(), oldY=GetY(), oldZ=GetZ();
 
-  // old position for time [SR, GSI 17.02.2003]
-  Double_t oldX = fX;
-  Double_t oldY = fP0;
-  Double_t oldZ = fP1;
-  //
+  Double_t bz=GetBz();
+  if (!AliExternalTrackParam::PropagateTo(xk,bz)) return kFALSE;
 
-  Double_t x1=fX, x2=x1+(xk-x1), dx=x2-x1, y1=fP0, z1=fP1;
-  Double_t c1=fP4*x1 - fP2, r1=sqrt(1.- c1*c1);
-  Double_t c2=fP4*x2 - fP2, r2=sqrt(1.- c2*c2);
-  
-  fP0 += dx*(c1+c2)/(r1+r2);
-  fP1 += dx*(c1+c2)/(c1*r2 + c2*r1)*fP3;
-
-  //f = F - 1
-  Double_t rr=r1+r2, cc=c1+c2, xx=x1+x2;
-  Double_t f02=-dx*(2*rr + cc*(c1/r1 + c2/r2))/(rr*rr);
-  Double_t f04= dx*(rr*xx + cc*(c1*x1/r1+c2*x2/r2))/(rr*rr);
-  Double_t cr=c1*r2+c2*r1;
-  Double_t f12=-dx*fP3*(2*cr + cc*(c2*c1/r1-r1 + c1*c2/r2-r2))/(cr*cr);
-  Double_t f13= dx*cc/cr; 
-  Double_t f14=dx*fP3*(cr*xx-cc*(r1*x2-c2*c1*x1/r1+r2*x1-c1*c2*x2/r2))/(cr*cr);
-
-  //b = C*ft
-  Double_t b00=f02*fC20 + f04*fC40, b01=f12*fC20 + f14*fC40 + f13*fC30;
-  Double_t b10=f02*fC21 + f04*fC41, b11=f12*fC21 + f14*fC41 + f13*fC31;
-  Double_t b20=f02*fC22 + f04*fC42, b21=f12*fC22 + f14*fC42 + f13*fC32;
-  Double_t b30=f02*fC32 + f04*fC43, b31=f12*fC32 + f14*fC43 + f13*fC33;
-  Double_t b40=f02*fC42 + f04*fC44, b41=f12*fC42 + f14*fC44 + f13*fC43;
-  
-  //a = f*b = f*C*ft
-  Double_t a00=f02*b20+f04*b40,a01=f02*b21+f04*b41,a11=f12*b21+f14*b41+f13*b31;
-
-  //F*C*Ft = C + (a + b + bt)
-  fC00 += a00 + 2*b00;
-  fC10 += a01 + b01 + b10; 
-  fC20 += b20;
-  fC30 += b30;
-  fC40 += b40;
-  fC11 += a11 + 2*b11;
-  fC21 += b21; 
-  fC31 += b31; 
-  fC41 += b41; 
-
-  fX=x2;
-
-  //Change of the magnetic field *************
-  SaveLocalConvConst();
-  cc=fP4;
-  fP4*=lcc/GetLocalConvConst();
-  fP2+=fX*(fP4-cc);
-
-  //Multiple scattering ******************
-  Double_t d=sqrt((x1-fX)*(x1-fX)+(y1-fP0)*(y1-fP0)+(z1-fP1)*(z1-fP1));
-  Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
-  Double_t beta2=p2/(p2 + GetMass()*GetMass());
-  beta2 = TMath::Min(beta2,0.99999999999);
-  //Double_t theta2=14.1*14.1/(beta2*p2*1e6)*d/x0*rho;
-  Double_t theta2=1.0259e-6*10*10/20/(beta2*p2)*d*rho;
-
-  Double_t ey=fP4*fX - fP2, ez=fP3;
-  Double_t xz=fP4*ez, zz1=ez*ez+1, xy=fP2+ey;
-    
-  fC22 += (2*ey*ez*ez*fP2+1-ey*ey+ez*ez+fP2*fP2*ez*ez)*theta2;
-  fC32 += ez*zz1*xy*theta2;
-  fC33 += zz1*zz1*theta2;
-  fC42 += xz*ez*xy*theta2;
-  fC43 += xz*zz1*theta2;
-  fC44 += xz*xz*theta2;
-  /*
-  //
-  //MI coeficients
-  Double_t dc22 = (1-ey*ey+xz*xz*fX*fX)*theta2;
-  Double_t dc32 = (xz*fX*zz1)*theta2;
-  Double_t dc33 = (zz1*zz1)*theta2;
-  Double_t dc42 = (xz*fX*xz)*theta2;
-  Double_t dc43 = (zz1*xz)*theta2;
-  Double_t dc44 = (xz*xz)*theta2; 
-  fC22 += dc22;
-  fC32 += dc32;
-  fC33 += dc33;
-  fC42 += dc42;
-  fC43 += dc43;
-  fC44 += dc44;
-  */
-  //Energy losses ************************
-  Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*d*rho;
-  if (x1 < x2) dE=-dE;
-  cc=fP4;
-
-  //Double_t E = sqrt(p2+GetMass()*GetMass());
-  //Double_t mifac  = TMath::Sqrt(1.+dE*dE/p2+2*E*dE/p2)-1;
-  //Double_t belfac = E*dE/p2;
-                              //
-  fP4*=(1.- sqrt(p2+GetMass()*GetMass())/p2*dE);
-  fP2+=fX*(fP4-cc);
-
-  // Integrated Time [SR, GSI, 17.02.2003]
- if (x1 < x2)
- if (IsStartedTimeIntegral()) {
-    Double_t l2 = (fX-oldX)*(fX-oldX)+(fP0-oldY)*(fP0-oldY)+(fP1-oldZ)*(fP1-oldZ);
-    AddTimeStep(TMath::Sqrt(l2));
-  }
-  //
+  Double_t d = TMath::Sqrt((GetX()-oldX)*(GetX()-oldX) + 
+                           (GetY()-oldY)*(GetY()-oldY) + 
+                           (GetZ()-oldZ)*(GetZ()-oldZ));
+  if (IsStartedTimeIntegral() && GetX()>oldX) AddTimeStep(d);
+
+  if (oldX < xk) d = -d;
+  if (!AliExternalTrackParam::CorrectForMaterial(d*rho/x0,x0,GetMass())) 
+     return kFALSE;
 
-  return 1;
+  return kTRUE;
 }
 
 //_____________________________________________________________________________
-Int_t AliTPCtrack::PropagateToVertex(Double_t x0,Double_t rho) 
+Bool_t 
+AliTPCtrack::PropagateToVertex(const AliESDVertex *v,Double_t d,Double_t x0) 
 {
   //-----------------------------------------------------------------
-  // This function propagates tracks to the "vertex".
+  // This function propagates tracks to the vertex.
   //-----------------------------------------------------------------
-  Double_t c=fP4*fX - fP2;
-  Double_t tgf=-fP2/(fP4*fP0 + sqrt(1-c*c));
-  Double_t snf=tgf/sqrt(1.+ tgf*tgf);
-  Double_t xv=(fP2+snf)/fP4;
-  return PropagateTo(xv,x0,rho);
+  Double_t bz=GetBz();
+  if (PropagateToDCA(v,bz,kVeryBig))
+   if (AliExternalTrackParam::CorrectForMaterial(d,x0,GetMass())) return kTRUE;
+  return kFALSE;
 }
 
 //_____________________________________________________________________________
-Int_t AliTPCtrack::Update(const AliCluster *c, Double_t chisq, UInt_t index) {
+Bool_t AliTPCtrack::Update(const AliCluster *c, Double_t chisq, Int_t index) {
   //-----------------------------------------------------------------
   // This function associates a cluster with this track.
   //-----------------------------------------------------------------
-  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 cur=fP4 + k40*dy + k41*dz, eta=fP2 + k20*dy + k21*dz;
-  if (TMath::Abs(cur*fX-eta) >= AliTPCReconstructor::GetMaxSnpTrack()) {
-    //    Int_t n=GetNumberOfClusters();
-    //if (n>4) cerr<<n<<" AliTPCtrack warning: Filtering failed !\n";
-    return 0;
-  }
-
-  fP0 += k00*dy + k01*dz;
-  fP1 += k10*dy + k11*dz;
-  fP2  = eta;
-  fP3 += k30*dy + k31*dz;
-  fP4  = cur;
-
-  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; 
-
-  fC22-=k20*c02+k21*c12;   fC32-=k20*c03+k21*c13;
-  fC42-=k20*c04+k21*c14; 
-
-  fC33-=k30*c03+k31*c13;
-  fC43-=k40*c03+k41*c13; 
+  Double_t p[2]={c->GetY(), c->GetZ()};
+  Double_t cov[3]={c->GetSigmaY2(), 0., c->GetSigmaZ2()};
 
-  fC44-=k40*c04+k41*c14; 
+  if (!AliExternalTrackParam::Update(p,cov)) return kFALSE;
 
   Int_t n=GetNumberOfClusters();
   fIndex[n]=index;
   SetNumberOfClusters(n+1);
   SetChi2(GetChi2()+chisq);
 
-  return 1;
+  return kTRUE;
 }
 
-//_____________________________________________________________________________
-Int_t AliTPCtrack::Rotate(Double_t alpha)
-{
-  //-----------------------------------------------------------------
-  // This function rotates this track.
-  //-----------------------------------------------------------------
-  fAlpha += alpha;
-  if (fAlpha<-TMath::Pi()) fAlpha += 2*TMath::Pi();
-  if (fAlpha>=TMath::Pi()) fAlpha -= 2*TMath::Pi();
-  
-  Double_t x1=fX, y1=fP0;
-  Double_t ca=cos(alpha), sa=sin(alpha);
-  Double_t r1=fP4*fX - fP2;
-  
-  if (TMath::Abs(r1)>=AliTPCReconstructor::GetMaxSnpTrack()) return 0; //patch 01 jan 06
-
-  fX = x1*ca + y1*sa;
-  fP0=-x1*sa + y1*ca;
-  fP2=fP2*ca + (fP4*y1 + sqrt(1.- r1*r1))*sa;
-  
-  Double_t r2=fP4*fX - fP2;
-  if (TMath::Abs(r2) >= AliTPCReconstructor::GetMaxSnpTrack()) {
-    //Int_t n=GetNumberOfClusters();
-    //    if (n>4) cerr<<n<<" AliTPCtrack warning: Rotation failed !\n";
-    return 0;
-  }
-  
-  Double_t y0=fP0 + sqrt(1.- r2*r2)/fP4;
-  if ((fP0-y0)*fP4 >= 0.) {
-    //Int_t n=GetNumberOfClusters();
-    //    if (n>4) cerr<<n<<" AliTPCtrack warning: Rotation failed !!!\n";
-    return 0;
-  }
-
-  //f = F - 1
-  Double_t f00=ca-1,    f24=(y1 - r1*x1/sqrt(1.- r1*r1))*sa, 
-           f20=fP4*sa,  f22=(ca + sa*r1/sqrt(1.- r1*r1))-1;
-
-  //b = C*ft
-  Double_t b00=fC00*f00, b02=fC00*f20+fC40*f24+fC20*f22;
-  Double_t b10=fC10*f00, b12=fC10*f20+fC41*f24+fC21*f22;
-  Double_t b20=fC20*f00, b22=fC20*f20+fC42*f24+fC22*f22;
-  Double_t b30=fC30*f00, b32=fC30*f20+fC43*f24+fC32*f22;
-  Double_t b40=fC40*f00, b42=fC40*f20+fC44*f24+fC42*f22;
-
-  //a = f*b = f*C*ft
-  Double_t a00=f00*b00, a02=f00*b02, a22=f20*b02+f24*b42+f22*b22;
-
-  // *** Double_t dy2=fCyy;
-
-  //F*C*Ft = C + (a + b + bt)
-  fC00 += a00 + 2*b00;
-  fC10 += b10;
-  fC20 += a02+b20+b02;
-  fC30 += b30;
-  fC40 += b40;
-  fC21 += b12;
-  fC32 += b32;
-  fC22 += a22 + 2*b22;
-  fC42 += b42; 
-
-  // *** fCyy+=dy2*sa*sa*r1*r1/(1.- r1*r1);
-  // *** fCzz+=d2y*sa*sa*fT*fT/(1.- r1*r1);
-
-  return 1;
-}
-
-void AliTPCtrack::ResetCovariance() {
-  //------------------------------------------------------------------
-  //This function makes a track forget its history :)  
-  //------------------------------------------------------------------
-
-  fC00*=10.;
-  fC10=0.;  fC11*=10.;
-  fC20=0.;  fC21=0.;  fC22*=10.;
-  fC30=0.;  fC31=0.;  fC32=0.;  fC33*=10.;
-  fC40=0.;  fC41=0.;  fC42=0.;  fC43=0.;  fC44*=10.;
-
-}
-
-////////////////////////////////////////////////////////////////////////
-Double_t AliTPCtrack::Phi() const {
-//
-//
-//
-  Double_t phi =  TMath::ASin(GetSnp()) + fAlpha;
-  if (phi<0) phi+=2*TMath::Pi();
-  if (phi>=2*TMath::Pi()) phi-=2*TMath::Pi();
-  return phi;
-}
-////////////////////////////////////////////////////////////////////////
-
-
-
 ////////////////////////////////////////////////////////////////////////
 // MI ADDITION
 
@@ -645,43 +296,6 @@ Float_t AliTPCtrack::Density2(Int_t row0, Int_t row1)
   return density;
 }
 
-
-Double_t AliTPCtrack::GetZat0() const
-{
-  //
-  // return virtual z - supposing that x = 0
-  if (TMath::Abs(fP2)>1) return 0;
-  if (TMath::Abs(fX*fP4-fP2)>1) return 0;
-  Double_t vz = fP1+fP3/fP4*(asin(-fP2)-asin(fX*fP4-fP2));
-  return vz;
-}
-
-
-Double_t AliTPCtrack::GetD(Double_t x, Double_t y) const {
-  //------------------------------------------------------------------
-  // This function calculates the transverse impact parameter
-  // with respect to a point with global coordinates (x,y)
-  //------------------------------------------------------------------
-  //Double_t xt=fX, yt=fP0;
-
-  Double_t sn=TMath::Sin(fAlpha), cs=TMath::Cos(fAlpha);
-  Double_t a = x*cs + y*sn;
-  y = -x*sn + y*cs; x=a;
-  //
-  Double_t r  = TMath::Abs(1/fP4);
-  Double_t x0 = TMath::Abs(fP2*r);
-  Double_t y0 = fP0;
-  y0= fP0+TMath::Sqrt(1-(fP4*fX-fP2)*(fP4*fX-fP2))/fP4;
-  
-  Double_t  delta = TMath::Sqrt((x-x0)*(x-x0)+(y-y0)*(y-y0));  
-  //  Double_t  delta = TMath::Sqrt(TMath::Abs(x*x-2*x0*x+x0*x0+ y*y-2*y*y0+y0*y0));
-  delta -= TMath::Abs(r);
-  return delta;  
-}
-
-//
-//
-
 void  AliTPCtrack::UpdatePoints()
 {
   //--------------------------------------------------
@@ -741,12 +355,12 @@ void  AliTPCtrack::UpdatePoints()
   //
 }
 
-Double_t AliTPCtrack::Get1Pt() const {
-  //--------------------------------------------------------------
-  // Returns the inverse Pt (1/GeV/c)
-  // (or 1/"most probable pt", if the field is too weak)
-  //--------------------------------------------------------------
-  if (TMath::Abs(GetLocalConvConst()) > kVeryBigConvConst)
-      return 1./kMostProbableMomentum/TMath::Sqrt(1.+ GetTgl()*GetTgl());
-  return (TMath::Sign(1e-9,fP4) + fP4)*GetLocalConvConst();
+Double_t AliTPCtrack::GetBz() const {
+  //
+  // returns Bz component of the magnetic field (kG)
+  //
+  if (AliTracker::UniformField()) return AliTracker::GetBz();
+  Double_t r[3]; GetXYZ(r);
+  return AliTracker::GetBz(r);
 }
+
index 4728308..9cc92c5 100644 (file)
 //
 //   Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch 
 //
-//                        December 18, 2000                                
-//  Internal view of the TPC track parametrisation as well as the order of   
-//           track parameters are subject for possible changes !             
-//  Use GetExternalParameters() and GetExternalCovariance() to access TPC    
-//      track information regardless of its internal representation.         
-// This formation is now fixed in the following way:                         
-//      external param0:   local Y-coordinate of a track (cm)                
-//      external param1:   local Z-coordinate of a track (cm)                
-//      external param2:   local sine of the track momentum azimuth angle    
-//      external param3:   tangent of the track momentum dip angle           
-//      external param4:   1/pt (1/(GeV/c))                                  
+// The track parameterization is fixed in the following way:                   
+//      param0:   local Y-coordinate of a track (cm)                
+//      param1:   local Z-coordinate of a track (cm)                
+//      param2:   local sine of the track momentum azimuth angle    
+//      param3:   tangent of the track momentum dip angle           
+//      param4:   1/pt (1/(GeV/c))                                  
 //
+//-------------------------------------------------------
+
 #include <AliKalmanTrack.h>
 #include <TMath.h>
 
 #include "AliTPCreco.h"
 #include "AliExternalTrackParam.h"
 class AliESDtrack;
+class AliESDVertex;
 
 //_____________________________________________________________________________
 class AliTPCtrack : public AliKalmanTrack {
 public:
   AliTPCtrack();
-  AliTPCtrack(UInt_t index, const Double_t xx[5], 
-              const Double_t cc[15], Double_t xr, Double_t alpha); 
+  AliTPCtrack(Double_t x, Double_t alpha, const Double_t p[5], 
+              const Double_t cov[15], Int_t index); 
   AliTPCtrack(const AliESDtrack& t);
   AliTPCtrack(const AliTPCtrack& t);
   virtual ~AliTPCtrack() {}
-  Int_t PropagateToVertex(Double_t x0=36.66,Double_t rho=1.2e-3);
-  Int_t Rotate(Double_t angle);
-  void SetdEdx(Double_t dedx) {fdEdx=dedx;}
-
-  Double_t GetYat(Double_t x) const ;
-  Double_t GetX()     const {return fX;}
-  Double_t GetAlpha() const {return fAlpha;}
-  Double_t GetdEdx()  const {return fdEdx;}
-  Double_t GetPIDsignal()  const {return GetdEdx();}
-
-  Double_t GetY()   const {return fP0;}
-  Double_t GetZ()   const {return fP1;}
-  Double_t GetSnp() const {return fX*fP4 - fP2;}
-  Double_t Get1Pt() const;
-  Double_t GetTgl() const {return fP3;}
-
-  Double_t GetSigmaY2() const {return fC00;}
-  Double_t GetSigmaZ2() const {return fC11;}
-
-// Some methods useful for users. Implementation is not
-// optimized for speed but for minimal maintanance effort
-  Double_t Phi() const;
-  Double_t Theta() const {return TMath::Pi()/2.-TMath::ATan(GetTgl());}
-  Double_t Px() const {return TMath::Cos(Phi())/TMath::Abs(Get1Pt());}
-  Double_t Py() const {return TMath::Sin(Phi())/TMath::Abs(Get1Pt());}
-  Double_t Pz() const {return GetTgl()/TMath::Abs(Get1Pt());}
-  Double_t Pt() const {return 1./TMath::Abs(Get1Pt());}
-  Double_t P() const {return TMath::Sqrt(Pt()*Pt()+Pz()*Pz());}
 
   Int_t Compare(const TObject *o) const;
 
-  void GetExternalParameters(Double_t& xr, Double_t x[5]) const ;
-  void GetExternalCovariance(Double_t cov[15]) const ;
-
-  // [SR, 01.04.2003]
-  Int_t GetNumber() const {return fNumber;}
-  void  SetNumber(Int_t n) {fNumber = n;} 
-  //
+  void SetdEdx(Double_t dedx) {fdEdx=dedx;}
+  Double_t GetdEdx()  const {return fdEdx;}
+  Double_t GetPIDsignal()  const {return GetdEdx();}
 
   Int_t GetClusterIndex(Int_t i) const {return fIndex[i];}
 
-//******** To be removed next release !!! **************
-  Double_t GetEta() const {return fP2;}
-  Double_t GetC()   const {return fP4;}
-  void GetCovariance(Double_t cc[15]) const {
-    cc[0 ]=fC00;
-    cc[1 ]=fC10;  cc[2 ]=fC11;
-    cc[3 ]=fC20;  cc[4 ]=fC21;  cc[5 ]=fC22;
-    cc[6 ]=fC40;  cc[7 ]=fC41;  cc[8 ]=fC42;  cc[9 ]=fC44;
-    cc[10]=fC30;  cc[11]=fC31;  cc[12]=fC32;  cc[13]=fC43;  cc[14]=fC33;
-  }
-//****************************************************** 
+  Double_t GetC() const {return AliExternalTrackParam::GetC(GetBz());}
 
-  virtual Double_t GetPredictedChi2(const AliCluster *cluster) const;
-  Int_t PropagateTo(Double_t xr,Double_t x0=28.94,Double_t rho=0.9e-3);
-  Int_t Update(const AliCluster* c, Double_t chi2, UInt_t i);
-  void ResetCovariance();
+  Double_t GetPredictedChi2(const AliCluster *cluster) const;
+  Bool_t PropagateTo(Double_t xr, Double_t rho=0.9e-3, Double_t x0=28.94);
+  Bool_t Update(const AliCluster *c, Double_t chi2, Int_t i);
+  Bool_t Rotate(Double_t alpha) {
+    return AliExternalTrackParam::Rotate(GetAlpha()+alpha);
+  }
+  
+  Bool_t PropagateToVertex(const AliESDVertex *v, 
+                           Double_t rho=1.2e-3, Double_t x0=36.66);
   void ResetClusters() {SetNumberOfClusters(0); SetChi2(0.);}
   void UpdatePoints();//update points 
   Float_t* GetPoints() {return fPoints;}
-  //
-  //  TClonesArray * fHelixIn;    //array of helixes  
-  //TClonesArray * fHelixOut;   //array of helixes 
-  //
+
   Float_t Density(Int_t row0, Int_t row1); //calculate cluster density
   Float_t Density2(Int_t row0, Int_t row1); //calculate cluster density
-  Double_t GetZat0() const;
-  Double_t GetD(Double_t x=0, Double_t y=0) const;
+  Double_t GetD(Double_t x=0, Double_t y=0) const {
+     return AliExternalTrackParam::GetD(x,y,GetBz());
+  }
   AliExternalTrackParam & GetReference(){ return fReference;}
   void UpdateReference(){ new (&fReference) AliExternalTrackParam(*this);}
   Int_t   GetKinkIndex(Int_t i) const{ return fKinkIndexes[i];}
   Int_t*  GetKinkIndexes() { return fKinkIndexes;}
   Int_t   GetV0Index(Int_t i) const{ return fV0Indexes[i];}
   Int_t*  GetV0Indexes() { return fV0Indexes;}
-protected: 
-  void GetXYZ(Float_t r[3]) const;
-
-  Double_t fX;              // X-coordinate of this track (reference plane)
-  Double_t fAlpha;          // Rotation angle the local (TPC sector)
-                            // coordinate system and the global ALICE one.
 
+protected: 
+  Double_t GetBz() const;
   Double_t fdEdx;           // dE/dx
 
-  Double_t fP0;             // Y-coordinate of a track
-  Double_t fP1;             // Z-coordinate of a track
-  Double_t fP2;             // C*x0
-  Double_t fP3;             // tangent of the track momentum dip angle
-  Double_t fP4;             // track curvature
-
-  Double_t fC00;                         // covariance
-  Double_t fC10, fC11;                   // matrix
-  Double_t fC20, fC21, fC22;             // of the
-  Double_t fC30, fC31, fC32, fC33;       // track
-  Double_t fC40, fC41, fC42, fC43, fC44; // parameters
-
   Int_t fIndex[kMaxRow];       // indices of associated clusters 
   Float_t fPoints[4];            //first, max dens row  end points of the track and max density
-  //[SR, 01.04.2003]
-  Int_t fNumber;         // magic number used for number of clusters
   // MI addition
   Float_t fSdEdx;           // sigma of dedx 
   //
@@ -152,25 +93,8 @@ protected:
   Int_t    fKinkIndexes[3];     // kink indexes - minus = mother + daughter
   Int_t    fV0Indexes[3];     // kink indexes - minus = mother + daughter
 
-  ClassDef(AliTPCtrack,2)   // Time Projection Chamber reconstructed tracks
+  ClassDef(AliTPCtrack,3)   // Time Projection Chamber reconstructed tracks
 };
 
-inline 
-void AliTPCtrack::GetExternalParameters(Double_t& xr, Double_t x[5]) const {
-  // This function return external TPC track representation
-     xr=fX;
-     x[0]=GetY(); x[1]=GetZ(); x[2]=GetSnp(); x[3]=GetTgl();
-     x[4]=(TMath::Sign(1e-9,fP4) + fP4)*GetLocalConvConst();
-}
-
-inline void AliTPCtrack::GetXYZ(Float_t r[3]) const {
-  //---------------------------------------------------------------------
-  // Returns the position of the track in the global coord. system 
-  //---------------------------------------------------------------------
-  Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
-  r[0]=fX*cs - fP0*sn; r[1]=fX*sn + fP0*cs; r[2]=fP1;
-}
-
-
 #endif
 
index e5891f8..b8d0e23 100644 (file)
 ClassImp(AliTPCtracker)
 
 //_____________________________________________________________________________
+AliTPCtracker::AliTPCtracker(): 
+  AliTracker(), 
+  fkNIS(0), 
+  fInnerSec(0),         
+  fkNOS(0),
+  fOuterSec(0),
+  fN(0),
+  fSectors(0),
+  fParam(0),
+  fSeeds(0)
+{
+  //
+  // The default TPC tracker constructor
+  //
+}
+
+//_____________________________________________________________________________
 AliTPCtracker::AliTPCtracker(const AliTPCParam *par): 
-AliTracker(), fkNIS(par->GetNInnerSector()/2), fkNOS(par->GetNOuterSector()/2)
+  AliTracker(), 
+  fkNIS(par->GetNInnerSector()/2), 
+  fInnerSec(new AliTPCSector[fkNIS]),         
+  fkNOS(par->GetNOuterSector()/2),
+  fOuterSec(new AliTPCSector[fkNOS]),
+  fN(0),
+  fSectors(0),
+  fParam((AliTPCParam*) par),
+  fSeeds(0)
 {
   //---------------------------------------------------------------------
   // The main TPC tracker constructor
   //---------------------------------------------------------------------
-  fInnerSec=new AliTPCSector[fkNIS];         
-  fOuterSec=new AliTPCSector[fkNOS];
 
   Int_t i;
   for (i=0; i<fkNIS; i++) fInnerSec[i].Setup(par,0);
   for (i=0; i<fkNOS; i++) fOuterSec[i].Setup(par,1);
 
-  fParam = (AliTPCParam*) par;
-  fSeeds=0;
-
 }
 
 //_____________________________________________________________________________
@@ -211,7 +231,7 @@ Int_t AliTPCtracker::FollowProlongation(AliTPCseed& t, Int_t rf) {
     UInt_t index=0;
     Double_t maxchi2=kMaxCHI2;
     const AliTPCRow &krow=fSectors[s][nr];
-    Double_t pt=t.GetConvConst()/(100/0.299792458/0.2)/t.Get1Pt();
+    Double_t pt=1./t.Get1Pt();
     Double_t sy2=AliTPCcluster::SigmaY2(t.GetX(),t.GetTgl(),pt);
     Double_t sz2=AliTPCcluster::SigmaZ2(t.GetX(),t.GetTgl());
     Double_t road=4.*sqrt(t.GetSigmaY2() + sy2), y=t.GetY(), z=t.GetZ();
@@ -321,7 +341,7 @@ Int_t AliTPCtracker::FollowBackProlongation
   Int_t s=Int_t(alpha/fSectors->GetAlpha())%fN;
 
   Int_t idx=-1, sec=-1, row=-1;
-  Int_t nc=seed.GetNumber();
+  Int_t nc=track.GetNumberOfClusters();
 
   if (nc--) {
      idx=track.GetClusterIndex(nc);
@@ -333,7 +353,8 @@ Int_t AliTPCtracker::FollowBackProlongation
   Int_t nr=fSectors->GetNRows();
   for (Int_t i=0; i<nr; i++) {
     Double_t x=fSectors->GetX(i), ymax=fSectors->GetMaxY(i);
-    Double_t y=seed.GetYat(x);
+    Double_t y;
+    if (!seed.GetYAt(x,GetBz(),y)) return 0;
  
     if (y > ymax) {
        s = (s+1) % fN;
@@ -348,7 +369,7 @@ Int_t AliTPCtracker::FollowBackProlongation
     AliTPCcluster *cl=0;
     Int_t index=0;
     Double_t maxchi2=kMaxCHI2;
-    Double_t pt=seed.GetConvConst()/(100/0.299792458/0.2)/seed.Get1Pt();
+    Double_t pt=1./seed.Get1Pt();
     Double_t sy2=AliTPCcluster::SigmaY2(seed.GetX(),seed.GetTgl(),pt);
     Double_t sz2=AliTPCcluster::SigmaZ2(seed.GetX(),seed.GetTgl());
     Double_t road=4.*sqrt(seed.GetSigmaY2() + sy2), z=seed.GetZ();
@@ -402,8 +423,6 @@ Int_t AliTPCtracker::FollowBackProlongation
 
   }
 
-  seed.SetNumber(nc);
-
   return 1;
 }
 
@@ -496,8 +515,8 @@ void AliTPCtracker::MakeSeeds(Int_t i1, Int_t i2) {
         c[13]=f30*sy1*f40+f32*sy2*f42;
         c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
 
-        UInt_t index=kr1.GetIndex(is);
-       AliTPCseed *track=new AliTPCseed(index, x, c, x1, ns*alpha+shift);
+        Int_t index=kr1.GetIndex(is);
+       AliTPCseed *track=new AliTPCseed(x1, ns*alpha+shift, x, c, index);
         Float_t l=fSectors->GetPadPitchWidth();
         track->SetSampledEdx(kr1[is]->GetQ()/l,0);
 
@@ -639,7 +658,7 @@ Int_t AliTPCtracker::RefitInward(AliESD* event) {
     AliTPCtrack* tpcTrack = new AliTPCtrack(*track);
     AliTPCseed* seed=new AliTPCseed(*tpcTrack); seed->ResetClusters(); 
 
-    if ( (status & AliESDtrack::kTRDrefit) == 0 ) seed->ResetCovariance();
+    if ( (status & AliESDtrack::kTRDrefit) == 0 ) seed->ResetCovariance(10.);
 
     fSectors = fOuterSec;
 
@@ -690,10 +709,7 @@ Int_t AliTPCtracker::PropagateBack(AliESD *event) {
     const AliTPCtrack t(*esd);
     AliTPCseed s(t); s.ResetClusters();
 
-    if ( (status & AliESDtrack::kITSout) == 0 ) s.ResetCovariance();
-
-    Int_t nc=t.GetNumberOfClusters();
-    s.SetNumber(nc); //set number of the cluster to start with
+    if ( (status & AliESDtrack::kITSout) == 0 ) s.ResetCovariance(10.);
 
     //inner sectors
     fSectors=fInnerSec; fN=fkNIS;
@@ -713,7 +729,7 @@ Int_t AliTPCtracker::PropagateBack(AliESD *event) {
     //outer sectors
     fSectors=fOuterSec; fN=fkNOS;
 
-    nc=s.GetNumberOfClusters();
+    Int_t nc=s.GetNumberOfClusters();
 
     alpha=s.GetAlpha() - fSectors->GetAlphaShift();
     if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
index 1c6ebd8..cd1bdaa 100644 (file)
@@ -25,10 +25,7 @@ class AliESD;
 
 class AliTPCtracker : public AliTracker {
 public:
-   AliTPCtracker():AliTracker(),fkNIS(0),fkNOS(0) {
-      fInnerSec=fOuterSec=0; fSeeds=0; 
-      fParam = 0;
-   }
+   AliTPCtracker();
    AliTPCtracker(const AliTPCParam *par);
   ~AliTPCtracker();
 
@@ -48,11 +45,9 @@ public:
 //**************** Internal tracker class ********************** 
    class AliTPCRow {
    public:
-     AliTPCRow() {
-       fN=0; 
-       fSize=kMaxClusterPerRow/8;
-       fClusterArray=new AliTPCcluster[fSize];
-     }
+     AliTPCRow():
+         fN(0), fSize(kMaxClusterPerRow/8),
+         fClusterArray(new AliTPCcluster[fSize]), fX(0) {}
      ~AliTPCRow() {delete[] fClusterArray;}
      void InsertCluster(const AliTPCcluster *c, Int_t sec, Int_t row);
      void ResetClusters() {fN=0; delete[] fClusterArray; fClusterArray=0;}
@@ -68,22 +63,22 @@ public:
      Double_t GetX() const {return fX;}
 
    private:
+     AliTPCRow(const AliTPCRow& r);            //dummy copy constructor
+     AliTPCRow &operator=(const AliTPCRow& r); //dummy assignment operator
      Int_t fN;                                          //number of clusters 
      const AliTPCcluster *fClusters[kMaxClusterPerRow]; //pointers to clusters
      Int_t fSize;                                 //size of array of clusters
      AliTPCcluster *fClusterArray;                      //array of clusters
      UInt_t fIndex[kMaxClusterPerRow];                  //indeces of clusters
      Double_t fX;                                 //X-coordinate of this row
-
-   private:
-     AliTPCRow(const AliTPCRow& r);            //dummy copy constructor
-     AliTPCRow &operator=(const AliTPCRow& r); //dummy assignment operator
    };
 
 //**************** Internal tracker class ********************** 
    class AliTPCSector {
    public:
-     AliTPCSector() { fN=0; fRow = 0; }
+     AliTPCSector(): 
+        fN(0),fRow(0),fAlpha(0),fAlphaShift(0),
+        fPadPitchWidth(0),f1PadPitchLength(0),f2PadPitchLength(0){}
     ~AliTPCSector() { delete[] fRow; }
      AliTPCRow& operator[](Int_t i) const { return *(fRow+i); }
      Int_t GetNRows() const { return fN; }
@@ -135,9 +130,9 @@ public:
    public:
      AliTPCseed():AliTPCtrack(){}
      AliTPCseed(const AliTPCtrack &t):AliTPCtrack(t){}
-     AliTPCseed(UInt_t index, const Double_t xx[5], 
-                const Double_t cc[15], Double_t xr, Double_t alpha): 
-                AliTPCtrack(index, xx, cc, xr, alpha) {}
+     AliTPCseed(Double_t xr, Double_t alpha, const Double_t xx[5], 
+                const Double_t cc[15], Int_t index): 
+                AliTPCtrack(xr, alpha, xx, cc, index) {}
      void SetSampledEdx(Float_t q, Int_t i) {
         Double_t s=GetSnp(), t=GetTgl();
         q *= TMath::Sqrt((1-s*s)/(1+t*t));
index ce18704..ceb6fdb 100644 (file)
 #include <TFile.h>
 #include <TObjArray.h>
 #include <TTree.h>
-#include "AliLog.h"
 
 #include "AliComplexCluster.h"
 #include "AliESD.h"
-#include "AliESDkink.h"
+#include "AliKink.h"
+#include "AliV0.h"
 #include "AliHelix.h"
 #include "AliRunLoader.h"
 #include "AliTPCClustersRow.h"
@@ -47,7 +47,6 @@
 #include "AliTPCtrackerMI.h"
 #include "TStopwatch.h"
 #include "AliTPCReconstructor.h"
-#include "AliESDkink.h"
 #include "AliPID.h"
 #include "TTreeStream.h"
 #include "AliAlignObj.h"
@@ -1443,16 +1442,6 @@ Int_t AliTPCtrackerMI::FollowToNext(AliTPCseed& t, Int_t nr) {
   y=t.GetY(); 
   Double_t z=t.GetZ();
   //
-  if (!IsActive(t.fRelativeSector,nr)) {
-    t.fInDead = kTRUE;
-    t.SetClusterIndex2(nr,-1); 
-    return 0;
-  }
-  //AliInfo(Form("A - Sector%d phi %f - alpha %f", t.fRelativeSector,y/x, t.GetAlpha()));
-  Bool_t isActive  = IsActive(t.fRelativeSector,nr);
-  Bool_t isActive2 = (nr>=fInnerSec->GetNRows()) ? fOuterSec[t.fRelativeSector][nr-fInnerSec->GetNRows()].GetN()>0:fInnerSec[t.fRelativeSector][nr].GetN()>0;
-  
-  if (!isActive || !isActive2) return 0;
   const AliTPCRow &krow=GetRow(t.fRelativeSector,nr);
   if ( (t.GetSigmaY2()<0) || t.GetSigmaZ2()<0) return 0;
   Double_t  roady  =1.;
@@ -1684,12 +1673,6 @@ Int_t AliTPCtrackerMI::UpdateClusters(AliTPCseed& t,  Int_t nr) {
   }
   //
   if (TMath::Abs(t.GetSnp())>AliTPCReconstructor::GetMaxSnpTracker()) return 0;
-  if (!IsActive(t.fRelativeSector,nr)) {
-    t.fInDead = kTRUE;
-    t.SetClusterIndex2(nr,-1); 
-    return 0;
-  }
-  //AliInfo(Form("A - Sector%d phi %f - alpha %f", t.fRelativeSector,y/x, t.GetAlpha()));
   AliTPCRow &krow=GetRow(t.fRelativeSector,nr);
 
   if (TMath::Abs(TMath::Abs(y)-ymax)<krow.fDeadZone){
@@ -1806,7 +1789,7 @@ Int_t AliTPCtrackerMI::FollowProlongation(AliTPCseed& t, Int_t rf, Int_t step) {
        if (index==0) break;
        if (index<0) continue;
        //
-       AliESDkink * kink = fEvent->GetKink(index-1);
+       AliKink * kink = (AliKink*)fEvent->GetKink(index-1);
        if (!kink){
          printf("PROBLEM\n");
        }
@@ -1884,7 +1867,7 @@ Int_t AliTPCtrackerMI::FollowBackProlongation(AliTPCseed& t, Int_t rf) {
        if (index==0) break;
        if (index>0) continue;
        index = TMath::Abs(index);
-       AliESDkink * kink = fEvent->GetKink(index-1);
+       AliKink * kink = (AliKink*)fEvent->GetKink(index-1);
        if (!kink){
          printf("PROBLEM\n");
        }
@@ -2668,6 +2651,7 @@ Int_t AliTPCtrackerMI::PropagateBack(AliESD *event)
   Info("PropagateBack","Number of back propagated tracks %d",ntracks);
   fEvent =0;
   //WriteTracks();
+
   return 0;
 }
 
@@ -2676,12 +2660,14 @@ void AliTPCtrackerMI::DeleteSeeds()
 {
   //
   //delete Seeds
+
   Int_t nseed = fSeeds->GetEntriesFast();
   for (Int_t i=0;i<nseed;i++){
     AliTPCseed * seed = (AliTPCseed*)fSeeds->At(i);
     if (seed) delete fSeeds->RemoveAt(i);
   }
   delete fSeeds;
+
   fSeeds =0;
 }
 
@@ -2725,8 +2711,8 @@ void AliTPCtrackerMI::ReadSeeds(AliESD *event, Int_t direction)
       }
 
     }
-    if (((status&AliESDtrack::kITSout)==0)&&(direction==1)) seed->ResetCovariance(); 
-    if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) == 0 ) seed->ResetCovariance();
+    if (((status&AliESDtrack::kITSout)==0)&&(direction==1)) seed->ResetCovariance(10.); 
+    if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) == 0 ) seed->ResetCovariance(10.);
     if ( direction ==2 && ((status & AliESDtrack::kTPCout) == 0) ) {
       fSeeds->AddAt(0,i);
       delete seed;
@@ -2742,7 +2728,7 @@ void AliTPCtrackerMI::ReadSeeds(AliESD *event, Int_t direction)
       if (esd->GetTRDncls()>0) trdchi2 = esd->GetTRDchi2()/esd->GetTRDncls();
       //reset covariance if suspicious 
       if ( (delta1>0.1) || (delta2>0.006) ||trdchi2>7.)
-       seed->ResetCovariance();
+       seed->ResetCovariance(10.);
     }
 
     //
@@ -3020,7 +3006,7 @@ void AliTPCtrackerMI::MakeSeeds3(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2,
        //      if (!BuildSeed(kr1[is],kcl,0,x1,x2,x3,x,c)) continue;
        
         UInt_t index=kr1.GetIndex(is);
-       AliTPCseed *track=new(seed) AliTPCseed(index, x, c, x1, ns*alpha+shift);
+       AliTPCseed *track=new(seed) AliTPCseed(x1, ns*alpha+shift, x, c, index);
        
        track->fIsSeeding = kTRUE;
        track->fSeed1 = i1;
@@ -3311,7 +3297,7 @@ void AliTPCtrackerMI::MakeSeeds5(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2,
       //       if (!BuildSeed(kr1[is],kcl,0,x1,x2,x3,x,c)) continue;
       
       UInt_t index=kr1.GetIndex(is);
-      AliTPCseed *track=new(seed) AliTPCseed(index, x, c, x1, sec*alpha+shift);
+      AliTPCseed *track=new(seed) AliTPCseed(x1, sec*alpha+shift, x, c, index);
       
       track->fIsSeeding = kTRUE;
 
@@ -3590,7 +3576,7 @@ void AliTPCtrackerMI::MakeSeeds2(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2,
 
        UInt_t index=0;
        //kr0.GetIndex(is);
-       AliTPCseed *track=new (seed) AliTPCseed(index, x, c, x1, sec*alpha+shift);
+       AliTPCseed *track=new (seed) AliTPCseed(x1,sec*alpha+shift,x,c,index);
        track->fIsSeeding = kTRUE;
        Int_t rc=FollowProlongation(*track, i2);        
        if (constrain) track->fBConstrain =1;
@@ -3739,7 +3725,7 @@ AliTPCseed *AliTPCtrackerMI::MakeSeed(AliTPCseed *track, Float_t r0, Float_t r1,
   c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
   
   //  Int_t row1 = fSectors->GetRowNumber(x2[0]);
-  AliTPCseed *seed=new  AliTPCseed(0, x, c, x2[0], sec2*fSectors->GetAlpha()+fSectors->GetAlphaShift());
+  AliTPCseed *seed=new  AliTPCseed(x2[0], sec2*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
   //  Double_t y0,z0,y1,z1, y2,z2;
   //seed->GetProlongation(x0[0],y0,z0);
   // seed->GetProlongation(x1[0],y1,z1);
@@ -3859,7 +3845,7 @@ AliTPCseed *AliTPCtrackerMI::ReSeed(AliTPCseed *track, Float_t r0, Float_t r1, F
   c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
   
   //  Int_t row1 = fSectors->GetRowNumber(xyz[2][0]);
-  AliTPCseed *seed=new  AliTPCseed(0, x, c, xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift());
+  AliTPCseed *seed=new  AliTPCseed(xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
   seed->fLastPoint  = row[2];
   seed->fFirstPoint = row[2];  
   return seed;
@@ -4008,7 +3994,7 @@ AliTPCseed *AliTPCtrackerMI::ReSeed(AliTPCseed *track,Int_t r0, Bool_t forward)
   c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
   
   //  Int_t row1 = fSectors->GetRowNumber(xyz[2][0]);
-  AliTPCseed *seed=new  AliTPCseed(0, x, c, xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift());
+  AliTPCseed *seed=new  AliTPCseed(xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
   seed->fLastPoint  = row[2];
   seed->fFirstPoint = row[2];  
   for (Int_t i=row[0];i<row[2];i++){
@@ -4032,7 +4018,7 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
   Int_t    *sign         = new Int_t[nentries];
   Int_t    *nclusters    = new Int_t[nentries];
   Float_t  *alpha        = new Float_t[nentries];
-  AliESDkink * kink      = new AliESDkink();
+  AliKink  *kink         = new AliKink();
   Int_t      * usage     = new Int_t[nentries];
   Float_t  *zm           = new Float_t[nentries];
   Float_t  *z0           = new Float_t[nentries]; 
@@ -4095,19 +4081,19 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
     AliTPCseed * track0 = (AliTPCseed*)array->At(i0);
     if (!track0) continue;    
     if (track0->fN<40) continue;
-    if (TMath::Abs(1./track0->fP4)>200) continue;
+    if (TMath::Abs(1./track0->GetC())>200) continue;
     for (Int_t i1=i0+1;i1<nentries;i1++){
       AliTPCseed * track1 = (AliTPCseed*)array->At(i1);
       if (!track1) continue;
       if (track1->fN<40)                  continue;
-      if ( TMath::Abs(track1->fP3+track0->fP3)>0.1) continue;
+      if ( TMath::Abs(track1->GetTgl()+track0->GetTgl())>0.1) continue;
       if (track0->fBConstrain&&track1->fBConstrain) continue;
-      if (TMath::Abs(1./track1->fP4)>200) continue;
-      if (track1->fP4*track0->fP4>0)      continue;
-      if (track1->fP3*track0->fP3>0)      continue;
-      if (max(TMath::Abs(1./track0->fP4),TMath::Abs(1./track1->fP4))>190) continue;
-      if (track0->fBConstrain&&TMath::Abs(track1->fP4)<TMath::Abs(track0->fP4)) continue; //returning - lower momenta
-      if (track1->fBConstrain&&TMath::Abs(track0->fP4)<TMath::Abs(track1->fP4)) continue; //returning - lower momenta
+      if (TMath::Abs(1./track1->GetC())>200) continue;
+      if (track1->Get1Pt()*track0->Get1Pt()>0)      continue;
+      if (track1->GetTgl()*track0->GetTgl()>0)      continue;
+      if (max(TMath::Abs(1./track0->GetC()),TMath::Abs(1./track1->GetC()))>190) continue;
+      if (track0->fBConstrain&&TMath::Abs(track1->Get1Pt())<TMath::Abs(track0->Get1Pt())) continue; //returning - lower momenta
+      if (track1->fBConstrain&&TMath::Abs(track0->Get1Pt())<TMath::Abs(track1->Get1Pt())) continue; //returning - lower momenta
       //
       Float_t mindcar = TMath::Min(TMath::Abs(dca[i0]),TMath::Abs(dca[i1]));
       if (mindcar<5)   continue;
@@ -4171,7 +4157,7 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
        if (sign){
          circular[i0] = kTRUE;
          circular[i1] = kTRUE;
-         if (TMath::Abs(track0->fP4)<TMath::Abs(track1->fP4)){
+         if (TMath::Abs(track0->Get1Pt())<TMath::Abs(track1->Get1Pt())){
            track0->fCircular += 1;
            track1->fCircular += 2;
          }
@@ -4346,7 +4332,7 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
 
       if (mpt<1){
        //for high momenta momentum not defined well in first iteration
-       Double_t qt   =  TMath::Sin(kink->GetAngle(2))*ktrack1->P();
+       Double_t qt   =  TMath::Sin(kink->GetAngle(2))*ktrack1->GetP();
        if (qt>0.35) continue; 
       }
       
@@ -4373,12 +4359,12 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
        //      angle and densities  not defined yet
        if (kink->GetTPCDensityFactor()<0.8) continue;
        if ((2-kink->GetTPCDensityFactor())*kink->GetDistance() >0.25) continue;
-       if (kink->GetAngle(2)*ktrack0->P()<0.003) continue; //too small angle
+       if (kink->GetAngle(2)*ktrack0->GetP()<0.003) continue; //too small angle
        if (kink->GetAngle(2)>0.2&&kink->GetTPCDensityFactor()<1.15) continue;
        if (kink->GetAngle(2)>0.2&&kink->GetTPCDensity(0,1)>0.05) continue;
 
-       Float_t criticalangle = track0->fC22+track0->fC33;
-       criticalangle+= track1->fC22+track1->fC33;
+       Float_t criticalangle = track0->GetSigmaSnp2()+track0->GetSigmaTgl2();
+       criticalangle+= track1->GetSigmaSnp2()+track1->GetSigmaTgl2();
        criticalangle= 3*TMath::Sqrt(criticalangle);
        if (criticalangle>0.02) criticalangle=0.02;
        if (kink->GetAngle(2)<criticalangle) continue;
@@ -4409,7 +4395,7 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
       }      
       //      esd->AddKink(kink);
       kinks->AddLast(kink);
-      kink = new AliESDkink;
+      kink = new AliKink;
       ncandidates++;
     }
   }
@@ -4425,7 +4411,7 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
   //
   for (Int_t i=0;i<nkinks;i++){
     quality[i] =100000;
-    AliESDkink *kink = (AliESDkink*)kinks->At(i);
+    AliKink *kink = (AliKink*)kinks->At(i);
     //
     // refit kinks towards vertex
     // 
@@ -4487,12 +4473,12 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
   //remove double find kinks
   //
   for (Int_t ikink0=1;ikink0<nkinks;ikink0++){
-    AliESDkink * kink0 = (AliESDkink*) kinks->At(indexes[ikink0]);
+    AliKink * kink0 = (AliKink*) kinks->At(indexes[ikink0]);
     if (!kink0) continue;
     //
     for (Int_t ikink1=0;ikink1<ikink0;ikink1++){
       if (!kink0) continue;
-      AliESDkink * kink1 = (AliESDkink*) kinks->At(indexes[ikink1]);
+      AliKink * kink1 = (AliKink*) kinks->At(indexes[ikink1]);
       if (!kink1) continue;
       // if not close kink continue
       if (TMath::Abs(kink1->GetPosition()[2]-kink0->GetPosition()[2])>10) continue;
@@ -4555,7 +4541,7 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
 
 
   for (Int_t i=0;i<nkinks;i++){
-    AliESDkink * kink = (AliESDkink*) kinks->At(indexes[i]);
+    AliKink * kink = (AliKink*) kinks->At(indexes[i]);
     if (!kink) continue;
     kink->SetTPCRow0(GetRowNumber(kink->GetR()));
     Int_t index0 = kink->GetIndex(0);
@@ -4610,7 +4596,7 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
   for (Int_t i=0;i<nentries;i++){
     AliTPCseed * track0 = (AliTPCseed*)array->At(i);
     if (!track0) continue;
-    if (track0->Pt()<1.4) continue;
+    if (track0->GetPt()<1.4) continue;
     //remove double high momenta tracks - overlapped with kink candidates
     Int_t shared=0;
     Int_t all   =0;
@@ -4630,11 +4616,11 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
 
     AliTPCseed *pmother = new AliTPCseed();
     AliTPCseed *pdaughter = new AliTPCseed();
-    AliESDkink *pkink = new AliESDkink;
+    AliKink *pkink = new AliKink;
 
     AliTPCseed & mother = *pmother;
     AliTPCseed & daughter = *pdaughter;
-    AliESDkink & kink = *pkink;
+    AliKink & kink = *pkink;
     if (CheckKinkPoint(track0,mother,daughter, kink)){
       if (mother.fN<30||daughter.fN<20) {
        delete pmother;
@@ -4642,7 +4628,7 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
        delete pkink;
        continue;  //too short tracks
       }
-      if (mother.Pt()<1.4) {
+      if (mother.GetPt()<1.4) {
        delete pmother;
        delete pdaughter;
        delete pkink;
@@ -4753,9 +4739,9 @@ void  AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd)
     // 
     // dca error parrameterezation + pulls
     //
-    sdcar[i]      = TMath::Sqrt(0.150*0.150+(100*track->fP4)*(100*track->fP4));
-    if (TMath::Abs(track->fP3)>1) sdcar[i]*=2.5;
-    cdcar[i]      = TMath::Exp((TMath::Abs(track->fP4)-0.0106)*525.3);
+    sdcar[i]      = TMath::Sqrt(0.150*0.150+(100*track->GetC())*(100*track->GetC()));
+    if (TMath::Abs(track->GetTgl())>1) sdcar[i]*=2.5;
+    cdcar[i]      = TMath::Exp((TMath::Abs(track->GetC())-0.0106)*525.3);
     pulldcar[i]   = (dca[i]-cdcar[i])/sdcar[i];
     pulldcaz[i]   = (z0[i]-zvertex)/sdcar[i];
     pulldca[i]    = TMath::Sqrt(pulldcar[i]*pulldcar[i]+pulldcaz[i]*pulldcaz[i]);
@@ -4784,7 +4770,7 @@ void  AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd)
   // //  
   TTreeSRedirector &cstream = *fDebugStreamer; 
   Float_t fprimvertex[3]={GetX(),GetY(),GetZ()};
-  AliESDV0MI vertex; 
+  AliV0 vertex; 
   Double_t cradius0 = 10*10;
   Double_t cradius1 = 200*200;
   Double_t cdist1=3.;
@@ -4811,7 +4797,7 @@ void  AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd)
        "\n";
     }
     //
-    if (track0->fP4<0) continue;
+    if (track0->Get1Pt()<0) continue;
     if (track0->GetKinkIndex(0)>0||isPrim[i]) continue;   //daughter kink
     //
     if (TMath::Abs(helixes[i].GetHelix(4))<0.000000001) continue;
@@ -5047,12 +5033,14 @@ void  AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd)
   timer.Print();
 }
 
-Int_t AliTPCtrackerMI::RefitKink(AliTPCseed &mother, AliTPCseed &daughter, AliESDkink &kink)
+Int_t AliTPCtrackerMI::RefitKink(AliTPCseed &mother, AliTPCseed &daughter, AliESDkink &knk)
 {
   //
   // refit kink towards to the vertex
   //
   //
+  AliKink &kink=(AliKink &)knk;
+
   Int_t row0 = GetRowNumber(kink.GetR());
   FollowProlongation(mother,0);
   mother.Reset(kFALSE);
@@ -5067,7 +5055,7 @@ Int_t AliTPCtrackerMI::RefitKink(AliTPCseed &mother, AliTPCseed &daughter, AliES
   const Int_t kNdiv =5;
   AliTPCseed  param0[kNdiv];  // parameters along the track
   AliTPCseed  param1[kNdiv];  // parameters along the track
-  AliESDkink   kinks[kNdiv];   // corresponding kink parameters
+  AliKink     kinks[kNdiv];   // corresponding kink parameters
   //
   Int_t rows[kNdiv];
   for (Int_t irow=0; irow<kNdiv;irow++){
@@ -5098,7 +5086,7 @@ Int_t AliTPCtrackerMI::RefitKink(AliTPCseed &mother, AliTPCseed &daughter, AliES
     if (TMath::Abs(kinks[irow].GetR())>240.) continue;
     if (TMath::Abs(kinks[irow].GetR())<100.) continue;
     //
-    Float_t normdist = TMath::Abs(param0[irow].fX-kinks[irow].GetR())*(0.1+kink.GetDistance());
+    Float_t normdist = TMath::Abs(param0[irow].GetX()-kinks[irow].GetR())*(0.1+kink.GetDistance());
     normdist/= (param0[irow].fN+param1[irow].fN+40.);
     if (normdist < mindist){
       mindist = normdist;
@@ -5189,7 +5177,7 @@ void AliTPCtrackerMI::UpdateKinkQualityD(AliTPCseed * seed){
 }
 
 
-Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTPCseed &daughter, AliESDkink &kink)
+Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTPCseed &daughter, AliESDkink &knk)
 {
   //
   // check kink point for given track
@@ -5197,6 +5185,7 @@ Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP
   // otherwise seed0 correspond to mother particle
   //           seed1 correspond to daughter particle
   //           kink  parameter of kink point
+  AliKink &kink=(AliKink &)knk;
 
   Int_t middlerow = (seed->fFirstPoint+seed->fLastPoint)/2;
   Int_t first = seed->fFirstPoint; 
@@ -5218,7 +5207,7 @@ Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP
   //
   AliTPCseed  param0[20];  // parameters along the track
   AliTPCseed  param1[20];  // parameters along the track
-  AliESDkink            kinks[20];   // corresponding kink parameters
+  AliKink     kinks[20];   // corresponding kink parameters
   Int_t rows[20];
   for (Int_t irow=0; irow<20;irow++){
     rows[irow] = first +((last-first)*irow)/19;
@@ -5245,7 +5234,7 @@ Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP
   for (Int_t irow=1;irow<19;irow++){
     if (TMath::Abs(kinks[irow].GetR())>240.) continue;
     if (TMath::Abs(kinks[irow].GetR())<110.) continue;
-    Float_t quality = TMath::Abs(kinks[irow].GetAngle(2))/(3.+TMath::Abs(kinks[irow].GetR()-param0[irow].fX));
+    Float_t quality = TMath::Abs(kinks[irow].GetAngle(2))/(3.+TMath::Abs(kinks[irow].GetR()-param0[irow].GetX()));
     if ( quality > maxchange){
       maxchange = quality;
       index = irow;
@@ -5261,15 +5250,15 @@ Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP
   seed1 = new AliTPCseed(param1[index]);
   seed0->Reset(kFALSE);
   seed1->Reset(kFALSE);
-  seed0->ResetCovariance();
-  seed1->ResetCovariance();
+  seed0->ResetCovariance(10.);
+  seed1->ResetCovariance(10.);
   FollowProlongation(*seed0,0);
   FollowBackProlongation(*seed1,158);
   new (&mother) AliTPCseed(*seed0);  // backup mother at position 0
   seed0->Reset(kFALSE);  
   seed1->Reset(kFALSE);
-  seed0->ResetCovariance();
-  seed1->ResetCovariance();
+  seed0->ResetCovariance(10.);
+  seed1->ResetCovariance(10.);
   //
   first = TMath::Max(row0-20,0);
   last  = TMath::Min(row0+20,158);
@@ -5301,7 +5290,7 @@ Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP
   for (Int_t irow=0;irow<20;irow++){
     if (TMath::Abs(kinks[irow].GetR())>250.) continue;
     if (TMath::Abs(kinks[irow].GetR())<90.) continue;
-    Float_t quality = TMath::Abs(kinks[irow].GetAngle(2))/(3.+TMath::Abs(kinks[irow].GetR()-param0[irow].fX));
+    Float_t quality = TMath::Abs(kinks[irow].GetAngle(2))/(3.+TMath::Abs(kinks[irow].GetR()-param0[irow].GetX()));
     if ( quality > maxchange){
       maxchange = quality;
       index = irow;
@@ -5459,7 +5448,7 @@ Int_t AliTPCtrackerMI::Clusters2Tracks() {
   }
   //
   RemoveUsed2(fSeeds,0.85,0.85,0);
-  if (AliTPCReconstructor::GetRecoParam()->GetDoKinks()) FindKinks(fSeeds,fEvent);
+  FindKinks(fSeeds,fEvent);
   RemoveUsed2(fSeeds,0.5,0.4,20);
  //  //
 //   // refit short tracks
@@ -5657,7 +5646,6 @@ TObjArray * AliTPCtrackerMI::Tracking()
 {
   //
   //
-  if (AliTPCReconstructor::GetRecoParam()->GetSpecialSeeding()) return TrackingSpecial();
   TStopwatch timer;
   timer.Start();
   Int_t nup=fOuterSec->GetNRows()+fInnerSec->GetNRows();
@@ -5808,49 +5796,6 @@ TObjArray * AliTPCtrackerMI::Tracking()
 }
 
 
-TObjArray * AliTPCtrackerMI::TrackingSpecial()
-{
-  //
-  // seeding adjusted for laser and cosmic tests - short tracks with big inclination angle
-  // no primary vertex seeding tried
-  //
-  TStopwatch timer;
-  timer.Start();
-  Int_t nup=fOuterSec->GetNRows()+fInnerSec->GetNRows();
-
-  TObjArray * seeds = new TObjArray;
-  TObjArray * arr=0;
-  
-  Int_t   gap  = 15;
-  Float_t cuts[4];
-  Float_t fnumber  = 3.0;
-  Float_t fdensity = 3.0;
-  
-  // find secondaries
-  cuts[0] = AliTPCReconstructor::GetRecoParam()->GetMaxC();   // max curvature
-  cuts[1] = 3.5;    // max tan(phi) angle for seeding
-  cuts[2] = 3.;     // not used (cut on z primary vertex)     
-  cuts[3] = 3.5;    // max tan(theta) angle for seeding
-
-  for (Int_t delta = 0; nup-delta-gap-1>0; delta+=3){
-    //
-    arr = Tracking(4,nup-1-delta,nup-1-delta-gap,cuts,-1);
-    SumTracks(seeds,arr);   
-    SignClusters(seeds,fnumber,fdensity);   
-  } 
-  if (fDebug>0){
-    Info("Tracking()","\n\nSecondary seeding\t%d\n\n",seeds->GetEntriesFast());
-    timer.Print();
-    timer.Start();
-  }
-
-  return seeds;
-  //
-      
-}
-
-
 void AliTPCtrackerMI::SumTracks(TObjArray *arr1,TObjArray *arr2) const
 {
   //
@@ -5860,13 +5805,6 @@ void AliTPCtrackerMI::SumTracks(TObjArray *arr1,TObjArray *arr2) const
   for (Int_t i=0;i<nseed;i++){
     AliTPCseed *pt=(AliTPCseed*)arr2->UncheckedAt(i);    
     if (pt){
-      //
-      // remove tracks with too big curvature
-      //
-      if (TMath::Abs(pt->GetC())>AliTPCReconstructor::GetRecoParam()->GetMaxC()){
-       delete arr2->RemoveAt(i);
-       continue;
-      }
        // REMOVE VERY SHORT  TRACKS
       if (pt->GetNumberOfClusters()<20){ 
        delete arr2->RemoveAt(i);
index 2b9c347..a9969e3 100644 (file)
@@ -36,8 +36,6 @@ public:
     fInnerSec=fOuterSec=0; fSeeds=0; 
   }
   AliTPCtrackerMI(const AliTPCParam *par); 
-  AliTPCtrackerMI(const AliTPCtrackerMI& r);           //dummy copy constructor
-  AliTPCtrackerMI &operator=(const AliTPCtrackerMI& r);//dummy assignment operator
   virtual ~AliTPCtrackerMI();
   //
   void SetIteration(Int_t iteration){fIteration = iteration;}
@@ -194,6 +192,8 @@ private:
    Int_t AcceptCluster(AliTPCseed * seed, AliTPCclusterMI * cluster, Float_t factor, Float_t cory=1., Float_t corz=1.);
 
 private:
+  AliTPCtrackerMI(const AliTPCtrackerMI& r);           //dummy copy constructor
+  AliTPCtrackerMI &operator=(const AliTPCtrackerMI& r);//dummy assignment operator
    inline AliTPCRow &GetRow(Int_t sec, Int_t row);
    inline Bool_t     IsActive(Int_t sec, Int_t row);
    inline Double_t  GetXrow(Int_t row) const;
index 3067362..bd4c3c7 100644 (file)
@@ -992,17 +992,17 @@ void AliTPCtrackerParam::BuildTrack(AliTPCseedGeant *s,Int_t ch) {
   // fAlpha = Alpha        Rotation angle the local (TPC sector) 
   // fP0    = YL           Y-coordinate of a track
   // fP1    = ZG           Z-coordinate of a track
-  // fP2    = C*x0         x0 is center x in rotated frame
+  // fP2    = sin(phi)     sine of the (local) azimuthal angle
   // fP3    = Tgl          tangent of the track momentum dip angle
   // fP4    = C            track curvature
   xx[0] = s->GetYL();
   xx[1] = s->GetZL();
+  xx[2] = ch/rho*(xref-x0);
   xx[3] = s->GetPz()/s->GetPt();
   xx[4] = ch/rho;
-  xx[2] = xx[4]*x0;
 
   // create the object AliTPCtrack    
-  AliTPCtrack track(0,xx,cc,xref,s->GetAlpha());
+  AliTPCtrack track(xref,s->GetAlpha(),xx,cc,0);
   new(&fTrack) AliTPCtrack(track);
 
   return;
@@ -1047,7 +1047,7 @@ void AliTPCtrackerParam::CompareTPCtracks(
   Double_t ptgener;
   Bool_t   usethis;
   Int_t    label;
-  Double_t cc[15],dAlpha;
+  Double_t dAlpha;
   Int_t    pi=0,ka=0,mu=0,el=0,pr=0;
   Int_t   *geaPi = new Int_t[effBins];
   Int_t   *geaKa = new Int_t[effBins];
@@ -1211,30 +1211,30 @@ void AliTPCtrackerParam::CompareTPCtracks(
       
       cmptrk.dP0 = kaltrack->GetY()-geatrack->GetY();
       cmptrk.dP1 = kaltrack->GetZ()-geatrack->GetZ();
-      cmptrk.dP2 = kaltrack->GetEta()-geatrack->GetEta();
+      cmptrk.dP2 = kaltrack->GetSnp()-geatrack->GetSnp();
       cmptrk.dP3 = kaltrack->GetTgl()-geatrack->GetTgl();
       cmptrk.dP4 = kaltrack->GetC()-geatrack->GetC();
       cmptrk.dpt = 1/kaltrack->Get1Pt()-1/geatrack->Get1Pt();
     
       // get covariance matrix
       // beware: lines 3 and 4 in the matrix are inverted!
-      kaltrack->GetCovariance(cc);
-
-      cmptrk.c00 = cc[0];
-      cmptrk.c10 = cc[1];
-      cmptrk.c11 = cc[2];
-      cmptrk.c20 = cc[3];
-      cmptrk.c21 = cc[4];
-      cmptrk.c22 = cc[5];
-      cmptrk.c30 = cc[10];
-      cmptrk.c31 = cc[11];
-      cmptrk.c32 = cc[12];
-      cmptrk.c33 = cc[14];
-      cmptrk.c40 = cc[6];
-      cmptrk.c41 = cc[7];
-      cmptrk.c42 = cc[8];
-      cmptrk.c43 = cc[13];
-      cmptrk.c44 = cc[9];
+      //kaltrack->GetCovariance(cc);
+
+      cmptrk.c00 = kaltrack->GetSigmaY2();
+      cmptrk.c10 = kaltrack->GetSigmaZY();
+      cmptrk.c11 = kaltrack->GetSigmaZ2();
+      cmptrk.c20 = kaltrack->GetSigmaSnpY();
+      cmptrk.c21 = kaltrack->GetSigmaSnpY();
+      cmptrk.c22 = kaltrack->GetSigmaSnp2();
+      cmptrk.c30 = kaltrack->GetSigmaTglY();
+      cmptrk.c31 = kaltrack->GetSigmaTglZ();
+      cmptrk.c32 = kaltrack->GetSigmaTglSnp();
+      cmptrk.c33 = kaltrack->GetSigmaTgl2();
+      cmptrk.c40 = kaltrack->GetSigma1PtY();
+      cmptrk.c41 = kaltrack->GetSigma1PtZ();
+      cmptrk.c42 = kaltrack->GetSigma1PtSnp();
+      cmptrk.c43 = kaltrack->GetSigma1PtTgl();
+      cmptrk.c44 = kaltrack->GetSigma1Pt2();
     
       // fill tree
       cmptrktree->Fill();
@@ -1414,7 +1414,7 @@ void AliTPCtrackerParam::CookTrack(Double_t pt,Double_t eta) {
   alpha=fTrack.GetAlpha();
   xx[0]=fTrack.GetY();
   xx[1]=fTrack.GetZ();
-  xx[2]=fTrack.GetX()*fTrack.GetC()-fTrack.GetSnp();
+  xx[2]=fTrack.GetSnp();
   xx[3]=fTrack.GetTgl();
   xx[4]=fTrack.GetC();
     
@@ -1422,7 +1422,7 @@ void AliTPCtrackerParam::CookTrack(Double_t pt,Double_t eta) {
   xxsm[0]=xref;
   SmearTrack(xx,xxsm,covMatSmear);
     
-  AliTPCtrack track(0,xxsm,cc,xref,alpha);
+  AliTPCtrack track(xref,alpha,xxsm,cc,0);
   new(&fTrack) AliTPCtrack(track);
   
   return; 
index f5efc94..be6a363 100644 (file)
@@ -19,6 +19,7 @@
 #include <TMath.h>
 #include <TVector2.h>
 
+#include "AliTracker.h"
 #include "AliESDtrack.h"
 #include "AliTRDgeometry.h" 
 #include "AliTRDcluster.h" 
@@ -34,482 +35,258 @@ ClassImp(AliTRDtrack)
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-//_____________________________________________________________________________
-AliTRDtrack::AliTRDtrack()
-  :AliKalmanTrack()
-  ,fSeedLab(-1)
-  ,fdEdx(0)
-  ,fDE(0)
-  ,fAlpha(0)
-  ,fX(0)
-  ,fStopped(kFALSE)
-  ,fY(0)
-  ,fZ(0)
-  ,fE(0)
-  ,fT(0)
-  ,fC(0)
-  ,fCyy(1e10)
-  ,fCzy(0)
-  ,fCzz(1e10)
-  ,fCey(0)
-  ,fCez(0)
-  ,fCee(1e10)
-  ,fCty(0)
-  ,fCtz(0)
-  ,fCte(0)
-  ,fCtt(1e10)
-  ,fCcy(0)
-  ,fCcz(0)
-  ,fCce(0)
-  ,fCct(0)
-  ,fCcc(1e10)
-  ,fLhElectron(0)
-  ,fNWrong(0)
-  ,fNRotate(0)
-  ,fNCross(0)
-  ,fNExpected(0)
-  ,fNLast(0)
-  ,fNExpectedLast(0)
-  ,fNdedx(0)
-  ,fChi2Last(1e10)
-  ,fBackupTrack(0x0)
+AliTRDtrack::AliTRDtrack():
+  AliKalmanTrack(),
+  fSeedLab(-1),
+  fdEdx(0),
+  fdEdxT(0),
+  fDE(0),
+  fStopped(kFALSE),
+  fLhElectron(0),
+  fNWrong(0),
+  fNRotate(0),
+  fNCross(0),
+  fNExpected(0),
+  fNLast(0),
+  fNExpectedLast(0),
+  fNdedx(0),
+  fChi2Last(1e10),
+  fBackupTrack(0x0)
 {
-  //
-  // AliTRDtrack default constructor
-  //
-
-  Int_t  i = 0;
-  Int_t  j = 0;
-  UInt_t k = 0;
-
-  for (i = 0; i < kNplane; i++) {
-    for (j = 0; j < kNslice; j++) {
+  for (Int_t i=0; i<kNplane; i++) {
+    for (Int_t j=0; j<kNslice; j++) {
       fdEdxPlane[i][j] = 0;
     }
     fTimBinPlane[i] = -1;
   }
-
-  for (k = 0; k < kMAXCLUSTERSPERTRACK; k++) {
-    fIndex[k]       = 0;
-    fIndexBackup[k] = 0;
-    fdQdl[k]        = 0;
-  }
-
-  for (i = 0; i < 3; i++) {
-    fBudget[i]      = 0;
+  for (UInt_t i=0; i<kMAXCLUSTERSPERTRACK; i++) {
+    fIndex[i] = 0;
+    fIndexBackup[i] = 0;
+    fdQdl[i] = 0;
   }
-
+  for (Int_t i=0; i<3; i++) fBudget[i] = 0;
 }
 
 //_____________________________________________________________________________
-AliTRDtrack::AliTRDtrack(const AliTRDcluster *c, UInt_t index, 
-                         const Double_t xx[5], const Double_t cc[15], 
-                         Double_t xref, Double_t alpha) 
-  :AliKalmanTrack() 
-  ,fSeedLab(-1)
-  ,fdEdx(0.0)
-  ,fDE(0.0)
-  ,fAlpha(alpha)
-  ,fX(xref)
-  ,fStopped(kFALSE)
-  ,fY(xx[0])
-  ,fZ(xx[1])
-  ,fE(xx[2])
-  ,fT(xx[3])
-  ,fC(xx[4])
-  ,fCyy(cc[0])
-  ,fCzy(cc[1])
-  ,fCzz(cc[2])
-  ,fCey(cc[3])  
-  ,fCez(cc[4])  
-  ,fCee(cc[5])
-  ,fCty(cc[6])  
-  ,fCtz(cc[7])  
-  ,fCte(cc[8])  
-  ,fCtt(cc[9])
-  ,fCcy(cc[10]) 
-  ,fCcz(cc[11]) 
-  ,fCce(cc[12]) 
-  ,fCct(cc[13]) 
-  ,fCcc(cc[14])  
-  ,fLhElectron(0.0)
-  ,fNWrong(0)
-  ,fNRotate(0)
-  ,fNCross(0)
-  ,fNExpected(0)
-  ,fNLast(0)
-  ,fNExpectedLast(0)
-  ,fNdedx(0)
-  ,fChi2Last(1e10)
-  ,fBackupTrack(0x0)
+AliTRDtrack::AliTRDtrack(const AliTRDcluster *c, Int_t index, 
+                         const Double_t p[5], const Double_t cov[15], 
+                         Double_t x, Double_t alpha) : 
+  AliKalmanTrack(),
+  fSeedLab(-1),
+  fdEdx(0),
+  fdEdxT(0),
+  fDE(0),
+  fStopped(kFALSE),
+  fLhElectron(0),
+  fNWrong(0),
+  fNRotate(0),
+  fNCross(0),
+  fNExpected(0),
+  fNLast(0),
+  fNExpectedLast(0),
+  fNdedx(0),
+  fChi2Last(1e10),
+  fBackupTrack(0x0) 
 {
-  //
-  // AliTRDtrack main constructor
-  //
-
-  Int_t  i = 0;
-  Int_t  j = 0;
-  UInt_t k = 0;
-
-  if (fAlpha <  -TMath::Pi()) {
-    fAlpha += 2.0 * TMath::Pi();
-  }
-  if (fAlpha >=  TMath::Pi()) {
-    fAlpha -= 2.0 * TMath::Pi();   
-  } 
+  //-----------------------------------------------------------------
+  // This is the main track constructor.
+  //-----------------------------------------------------------------
+  Double_t cnv=1./(GetBz()*kB2C);
+
+  Double_t pp[5]={
+    p[0],
+    p[1],
+    x*p[4] - p[2],
+    p[3],
+    p[4]*cnv
+  };
+
+  Double_t c22 = x*x*cov[14] - 2*x*cov[12] + cov[5];
+  Double_t c32 = x*cov[13] - cov[8];
+  Double_t c20 = x*cov[10] - cov[3], 
+           c21 = x*cov[11] - cov[4], c42 = x*cov[14] - cov[12];
+
+  Double_t cc[15]={
+    cov[0 ],
+    cov[1 ],     cov[2 ],
+    c20,         c21,         c22,
+    cov[6 ],     cov[7 ],     c32,     cov[9 ],
+    cov[10]*cnv, cov[11]*cnv, c42*cnv, cov[13]*cnv, cov[14]*cnv*cnv
+  };
+
+  Set(x,alpha,pp,cc);
 
-  SaveLocalConvConst();
-
-  fIndex[0] = index;
   SetNumberOfClusters(1);
+  fIndex[0]=index;
 
-  for (i = 0; i < kNplane; i++) {
-    for (j = 0; j < kNslice; j++) {
+  for (Int_t i=0;i<kNplane;i++){
+    for (Int_t j=0; j<kNslice; j++) {
       fdEdxPlane[i][j] = 0;
     }
     fTimBinPlane[i] = -1;
   }
 
   Double_t q = TMath::Abs(c->GetQ());
-  Double_t s = fX * fC - fE;
-  Double_t t = fT;
-  if (s*s < 1.0) {
-    q *= TMath::Sqrt((1-s*s)/(1+t*t));
-  }
-  fdQdl[0] = q;
-  
-  for (k = 1; k < kMAXCLUSTERSPERTRACK; k++) {
-    fdQdl[k]        = 0;
-    fIndex[k]       = 0;
-    fIndexBackup[k] = 0; 
-  }
+  Double_t s = GetSnp(), t=GetTgl();
+  if(s*s < 1) q *= TMath::Sqrt((1-s*s)/(1+t*t));
 
-  for (i = 0; i < 3; i++) { 
-    fBudget[i]      = 0;
+  fdQdl[0] = q;  
+  // initialisation [SR, GSI 18.02.2003] (i startd for 1)
+  for(UInt_t i=1; i<kMAXCLUSTERSPERTRACK; i++) {
+    fdQdl[i] = 0;
+    fIndex[i] = 0;
+    fIndexBackup[i] = 0;  //backup indexes MI    
   }
-
+  for (Int_t i=0;i<3;i++) fBudget[i]=0;
 }                              
            
 //_____________________________________________________________________________
-AliTRDtrack::AliTRDtrack(const AliTRDtrack &t) 
-  :AliKalmanTrack(t) 
-  ,fSeedLab(t.fSeedLab)
-  ,fdEdx(t.fdEdx)
-  ,fDE(t.fDE)
-  ,fAlpha(t.fAlpha)
-  ,fX(t.fX)
-  ,fStopped(t.fStopped)
-  ,fY(t.fY)
-  ,fZ(t.fZ)
-  ,fE(t.fE)
-  ,fT(t.fT)
-  ,fC(t.fC)
-  ,fCyy(t.fCyy)
-  ,fCzy(t.fCzy)
-  ,fCzz(t.fCzz)
-  ,fCey(t.fCey)  
-  ,fCez(t.fCez)  
-  ,fCee(t.fCee)
-  ,fCty(t.fCty)  
-  ,fCtz(t.fCtz)  
-  ,fCte(t.fCte)  
-  ,fCtt(t.fCtt)
-  ,fCcy(t.fCcy) 
-  ,fCcz(t.fCcz) 
-  ,fCce(t.fCce) 
-  ,fCct(t.fCct)
-  ,fCcc(t.fCcc)  
-  ,fLhElectron(0.0)
-  ,fNWrong(t.fNWrong)
-  ,fNRotate(t.fNRotate)
-  ,fNCross(t.fNCross)
-  ,fNExpected(t.fNExpected)
-  ,fNLast(t.fNLast)
-  ,fNExpectedLast(t.fNExpectedLast)
-  ,fNdedx(t.fNdedx)
-  ,fChi2Last(t.fChi2Last)
-  ,fBackupTrack(0x0)
+AliTRDtrack::AliTRDtrack(const AliTRDtrack& t) : 
+  AliKalmanTrack(t), 
+  fSeedLab(t.GetSeedLabel()),
+  fdEdx(t.fdEdx),
+  fdEdxT(t.fdEdx),
+  fDE(t.fDE),
+  fStopped(t.fStopped),
+  fLhElectron(0),
+  fNWrong(t.fNWrong),
+  fNRotate(t.fNRotate),
+  fNCross(t.fNCross),
+  fNExpected(t.fNExpected),
+  fNLast(t.fNLast),
+  fNExpectedLast(t.fNExpectedLast),
+  fNdedx(t.fNdedx),
+  fChi2Last(t.fChi2Last),
+  fBackupTrack(0x0) 
 {
   //
   // Copy constructor.
   //
-
-  Int_t  i = 0;
-  Int_t  j = 0;
-  UInt_t k = 0;
-
-  for (i = 0; i < kNplane; i++) {
-    for (j = 0; j < kNslice; j++) {
+  for (Int_t i=0;i<kNplane;i++){
+    for (Int_t j=0; j<kNslice; j++) {
       fdEdxPlane[i][j] = t.fdEdxPlane[i][j];
     }
     fTimBinPlane[i] = t.fTimBinPlane[i];
     fTracklets[i]   = t.fTracklets[i];
   }
 
-  Int_t n = t.GetNumberOfClusters(); 
-  for (i = 0; i < n; i++) {
-    fIndex[i]       = t.fIndex[i];
-    fIndexBackup[i] = t.fIndex[i];
-    fdQdl[i]        = t.fdQdl[i];
-  }
-  for (k = n; k < kMAXCLUSTERSPERTRACK; k++) {
-    fdQdl[k]        = 0;
-    fIndex[k]       = 0;
-    fIndexBackup[k] = 0; 
-  }
-
-  for (i = 0; i < 6; i++) {
-    fTracklets[i] = t.fTracklets[i];
+  Int_t n=t.GetNumberOfClusters(); 
+  SetNumberOfClusters(n);
+  for (Int_t i=0; i<n; i++) {
+    fIndex[i]=t.fIndex[i];
+    fIndexBackup[i]=t.fIndex[i];  // MI - backup indexes
+    fdQdl[i]=t.fdQdl[i];
   }
 
-  for (i = 0; i < 3; i++) { 
-    fBudget[i]    = t.fBudget[i];
+  // initialisation (i starts from n) [SR, GSI, 18.02.2003]
+  for(UInt_t i=n; i<kMAXCLUSTERSPERTRACK; i++) {
+    fdQdl[i] = 0;
+    fIndex[i] = 0;
+    fIndexBackup[i] = 0;  //MI backup indexes
   }
-
+  for (Int_t i=0;i<3;i++) fBudget[i]=t.fBudget[i];
 }                                
 
 //_____________________________________________________________________________
-AliTRDtrack::AliTRDtrack(const AliKalmanTrack &t, Double_t alpha) 
-  :AliKalmanTrack(t) 
-  ,fSeedLab(-1)
-  ,fdEdx(t.GetPIDsignal())
-  ,fDE(0)
-  ,fAlpha(alpha)
-  ,fX(0)
-  ,fStopped(kFALSE)
-  ,fY(0)
-  ,fZ(0)
-  ,fE(0)
-  ,fT(0)
-  ,fC(0)
-  ,fCyy(0)
-  ,fCzy(0)
-  ,fCzz(0)
-  ,fCey(0)
-  ,fCez(0)
-  ,fCee(0)
-  ,fCty(0)
-  ,fCtz(0)
-  ,fCte(0)
-  ,fCtt(0)
-  ,fCcy(0)
-  ,fCcz(0)
-  ,fCce(0)
-  ,fCct(0)
-  ,fCcc(0)
-  ,fLhElectron(0.0)
-  ,fNWrong(0)
-  ,fNRotate(0)
-  ,fNCross(0)
-  ,fNExpected(0)
-  ,fNLast(0)
-  ,fNExpectedLast(0)
-  ,fNdedx(0)
-  ,fChi2Last(0.0)
-  ,fBackupTrack(0x0)
+AliTRDtrack::AliTRDtrack(const AliKalmanTrack& t, Double_t /*alpha*/): 
+  AliKalmanTrack(t), 
+  fSeedLab(-1),
+  fdEdx(t.GetPIDsignal()),
+  fdEdxT(0),
+  fDE(0),
+  fStopped(kFALSE),
+  fLhElectron(0.0),
+  fNWrong(0),
+  fNRotate(0),
+  fNCross(0),
+  fNExpected(0),
+  fNLast(0),
+  fNExpectedLast(0),
+  fNdedx(0),
+  fChi2Last(0.0),
+  fBackupTrack(0x0)
 {
   //
   // Constructor from AliTPCtrack or AliITStrack .
   //
 
-  Int_t  i = 0;
-  Int_t  j = 0;
-  UInt_t k = 0;
-
-  SetChi2(0.0);
+  SetLabel(t.GetLabel());
+  SetChi2(0.);
+  SetMass(t.GetMass());
   SetNumberOfClusters(0);
 
-  for (i = 0; i < kNplane; i++) {
-    for (j = 0; j < kNslice; j++) {
+  for (Int_t i=0;i<kNplane;i++){
+    for (Int_t j=0;j<kNslice;j++){
       fdEdxPlane[i][j] = 0.0;
     }
     fTimBinPlane[i] = -1;
   }
 
-  if      (fAlpha < -TMath::Pi()) {
-    fAlpha += 2.0 * TMath::Pi();
-  }
-  else if (fAlpha >= TMath::Pi()) {
-    fAlpha -= 2.0 * TMath::Pi();
-  }
-
-  Double_t x;
-  Double_t p[5]; 
-  t.GetExternalParameters(x,p);
-  fX = x;
-  fY = p[0];
-  fZ = p[1];
-  fT = p[3]; 
-  x  = GetLocalConvConst();
-  fC = p[4] / x;
-  fE = fC * fX - p[2];   
-
-  // Conversion of the covariance matrix
-  Double_t c[15]; 
-  t.GetExternalCovariance(c);
-  c[10] /= x; 
-  c[11] /= x; 
-  c[12] /= x; 
-  c[13] /= x; 
-  c[14] /= x*x;
-
-  Double_t c22 = fX*fX * c[14] - 2.0*fX*c[12] + c[ 5];
-  Double_t c32 = fX    * c[13] -        c[ 8];
-  Double_t c20 = fX    * c[10] -        c[ 3]; 
-  Double_t c21 = fX    * c[11] -        c[ 4];
-  Double_t c42 = fX    * c[14] -        c[12];
-
-  fCyy = c[ 0];
-  fCzy = c[ 1];  fCzz = c[ 2];
-  fCey = c20;    fCez = c21;    fCee = c22;
-  fCty = c[ 6];  fCtz = c[ 7];  fCte = c32;  fCtt = c[ 9];
-  fCcy = c[10];  fCcz = c[11];  fCce = c42;  fCct = c[13];  fCcc = c[14];  
-
-  for (k = 0; k < kMAXCLUSTERSPERTRACK; k++) {
-    fdQdl[k]        = 0;
-    fIndex[k]       = 0;
-    fIndexBackup[k] = 0;
+  // Initialization [SR, GSI, 18.02.2003]
+  for(UInt_t i=0; i<kMAXCLUSTERSPERTRACK; i++) {
+    fdQdl[i] = 0;
+    fIndex[i] = 0;
+    fIndexBackup[i] = 0;  // MI backup indexes    
   }
   
-  for (i = 0; i < 3; i++) { 
-    fBudget[i]      = 0;
-  }
-
+  for (Int_t i=0;i<3;i++) { fBudget[i]=0;};
 }              
 
 //_____________________________________________________________________________
-AliTRDtrack::AliTRDtrack(const AliESDtrack &t) 
-  :AliKalmanTrack() 
-  ,fSeedLab(-1)
-  ,fdEdx(t.GetTRDsignal())
-  ,fDE(0)
-  ,fAlpha(t.GetAlpha())
-  ,fX(0)
-  ,fStopped(kFALSE)
-  ,fY(0)
-  ,fZ(0)
-  ,fE(0)
-  ,fT(0)
-  ,fC(0)
-  ,fCyy(1e10)
-  ,fCzy(0)
-  ,fCzz(1e10)
-  ,fCey(0)
-  ,fCez(0)
-  ,fCee(1e10)
-  ,fCty(0)
-  ,fCtz(0)
-  ,fCte(0)
-  ,fCtt(1e10)
-  ,fCcy(0)
-  ,fCcz(0)
-  ,fCce(0)
-  ,fCct(0)
-  ,fCcc(1e10)
-  ,fLhElectron(0.0)
-  ,fNWrong(0)
-  ,fNRotate(0)
-  ,fNCross(0)
-  ,fNExpected(0)
-  ,fNLast(0)
-  ,fNExpectedLast(0)
-  ,fNdedx(0)
-  ,fChi2Last(0.0)
-  ,fBackupTrack(0x0)
+AliTRDtrack::AliTRDtrack(const AliESDtrack &t):
+  AliKalmanTrack(), 
+  fSeedLab(-1),
+  fdEdx(t.GetTRDsignal()),
+  fdEdxT(0),
+  fDE(0),
+  fStopped(kFALSE),
+  fLhElectron(0),
+  fNWrong(0),
+  fNRotate(0),
+  fNCross(0),
+  fNExpected(0),
+  fNLast(0),
+  fNExpectedLast(0),
+  fNdedx(0),
+  fChi2Last(1e10),
+  fBackupTrack(0x0)
 {
   //
   // Constructor from AliESDtrack
   //
-
-  Int_t  i = 0;
-  Int_t  j = 0;
-  UInt_t k = 0;
-
   SetLabel(t.GetLabel());
   SetChi2(0.);
   SetMass(t.GetMass());
   SetNumberOfClusters(t.GetTRDclusters(fIndex)); 
 
   Int_t ncl = t.GetTRDclusters(fIndexBackup);
-  for (k = ncl; k < kMAXCLUSTERSPERTRACK; k++) {
-    fIndexBackup[k] = 0;
-    fIndex[k]       = 0;
+  for (UInt_t i=ncl;i<kMAXCLUSTERSPERTRACK;i++) {
+    fIndexBackup[i]=0;
+    fIndex[i] = 0; //MI store indexes
   }
-
-  for (i = 0; i < kNplane; i++) {
-    for (j = 0; j < kNslice; j++) {
+  for (Int_t i=0;i<kNplane;i++){
+    for (Int_t j=0;j<kNslice;j++){
       fdEdxPlane[i][j] = t.GetTRDsignals(i,j);
     }
     fTimBinPlane[i] = t.GetTRDTimBin(i);
   }
 
-  if      (fAlpha <  -TMath::Pi()) {
-    fAlpha += 2.0 * TMath::Pi();
-  }
-  else if (fAlpha >=  TMath::Pi()) {
-    fAlpha -= 2.0 * TMath::Pi();
-  }
 
-  // Conversion of the covariance matrix
-  Double_t x;
-  Double_t p[5]; 
-  t.GetExternalParameters(x,p);
-  Double_t c[15]; 
-  t.GetExternalCovariance(c);
-  if (t.GetStatus() & AliESDtrack::kTRDbackup) {
-    t.GetOuterExternalParameters(fAlpha,x,p);
-    t.GetOuterExternalCovariance(c);
-    if      (fAlpha <  -TMath::Pi()) {
-      fAlpha += 2.0 * TMath::Pi();
-    }
-    else if (fAlpha >=  TMath::Pi()) {
-      fAlpha -= 2.0 * TMath::Pi();
-    }
+  const AliExternalTrackParam *par=&t;
+  if (t.GetStatus()&AliESDtrack::kTRDbackup) { 
+    par=t.GetOuterParam();
+    if (!par) {AliError("***** No backup info !!! ****"); par=&t;}
   }
+  Set(par->GetX(),par->GetAlpha(),par->GetParameter(),par->GetCovariance());
 
-  fX = x;
-  fY = p[0];
-  fZ = p[1]; 
-  SaveLocalConvConst();
-  fT = p[3]; 
-  x  = GetLocalConvConst();
-  fC = p[4] / x;
-  fE = fC*fX - p[2];   
-
-  c[10] /= x; 
-  c[11] /= x; 
-  c[12] /= x; 
-  c[13] /= x;
-  c[14] /= x*x;
-
-  Double_t c22 = fX*fX * c[14] - 2.0*fX*c[12] + c[ 5];
-  Double_t c32 = fX    * c[13] - c[ 8];
-  Double_t c20 = fX    * c[10] - c[ 3];
-  Double_t c21 = fX    * c[11] - c[ 4];
-  Double_t c42 = fX    * c[14] - c[12];
-
-  fCyy = c[ 0];
-  fCzy = c[ 1];  fCzz = c[ 2];
-  fCey = c20;    fCez = c21;    fCee = c22;
-  fCty = c[ 6];  fCtz = c[ 7];  fCte = c32;  fCtt = c[ 9];
-  fCcy = c[10];  fCcz = c[11];  fCce = c42;  fCct = c[13];  fCcc = c[14];  
-
-  for (k = 0; k < kMAXCLUSTERSPERTRACK; k++) {
-    fdQdl[k] = 0;
-    //fIndex[k] = 0; //MI store indexes
-  }
+  
+  for (UInt_t i=0; i<kMAXCLUSTERSPERTRACK; i++) fdQdl[i] = 0;
 
-  for (i = 0; i < 3; i++) { 
-    fBudget[i] = 0;
-  }
-  if ((t.GetStatus() & AliESDtrack::kTIME) == 0) {
-    return;
-  }
+  for (Int_t i=0;i<3;i++) fBudget[i]=0;
 
+  if ((t.GetStatus()&AliESDtrack::kTIME) == 0) return;
   StartTimeIntegral();
-  Double_t times[10]; 
-  t.GetIntegratedTimes(times); 
-  SetIntegratedTimes(times);
+  Double_t times[10]; t.GetIntegratedTimes(times); SetIntegratedTimes(times);
   SetIntegratedLength(t.GetIntegratedLength());
 
 }  
@@ -521,115 +298,33 @@ AliTRDtrack::~AliTRDtrack()
   // Destructor
   //
 
-  if (fBackupTrack) {
-    delete fBackupTrack;
-  }
+  if (fBackupTrack) delete fBackupTrack;
   fBackupTrack = 0;
 
 }
 
 //____________________________________________________________________________
-AliTRDtrack &AliTRDtrack::operator=(const AliTRDtrack &t)
-{
-  //
-  // Assignment operator
-  //
-
-  fLhElectron    = 0.0;
-  fNWrong        = 0;
-  fStopped       = 0;
-  fNRotate       = 0;
-  fNExpected     = 0;
-  fNExpectedLast = 0;
-  fNdedx         = 0;
-  fNCross        = 0;
-  fNLast         = 0;
-  fChi2Last      = 0;
-  fBackupTrack   = 0;
-
-  fAlpha = t.GetAlpha();
-  if      (fAlpha <  -TMath::Pi()) {
-    fAlpha += 2.0 * TMath::Pi();
-  }
-  else if (fAlpha >=  TMath::Pi()) {
-    fAlpha -= 2.0 * TMath::Pi();
-  }
-
-  return *this;
-
-}
-
-//____________________________________________________________________________
 Float_t AliTRDtrack::StatusForTOF()
 {
   //
   // Defines the status of the TOF extrapolation
   //
 
-  // Definition of res ????
-  Float_t res = (0.2 + 0.8 * (fN / (fNExpected + 5.0)))
-              * (0.4 + 0.6 * fTracklets[5].GetN() / 20.0);
-  res *= (0.25 + 0.8 * 40.0 / (40.0 + fBudget[2]));
+  Float_t res = (0.2 + 0.8*(fN/(fNExpected+5.)))*(0.4+0.6*fTracklets[5].GetN()/20.);
+  res *= (0.25+0.8*40./(40.+fBudget[2]));
   return res;
 
-  // This part of the function is never reached ????
-  // What defines these parameters ????
-  Int_t status = 0;
-  if (GetNumberOfClusters()                <  20)  return 0;
-  if ((fN                                  > 110) && 
-      (fChi2/(Float_t(fN))                 < 3.0)) return 3; // Gold
-  if ((fNLast                              >  30) && 
-      (fChi2Last/(Float_t(fNLast))         < 3.0)) return 3; // Gold
-  if ((fNLast                              >  20) && 
-      (fChi2Last/(Float_t(fNLast))         < 2.0)) return 3; // Gold
-  if ((fNLast/(fNExpectedLast+3.0)         > 0.8) && 
-      (fChi2Last/Float_t(fNLast)           < 5.0) &&
-      (fNLast                              >  20)) return 2; // Silver
-  if ((fNLast                              >   5) &&  
-      (((fNLast+1.0)/(fNExpectedLast+1.0)) > 0.8) &&
-      (fChi2Last/(fNLast-5.0)              < 6.0)) return 1; 
+  Int_t status=0;
+  if (GetNumberOfClusters()<20) return 0;   //
+  if (fN>110&&fChi2/(Float_t(fN))<3) return 3;            //gold
+  if (fNLast>30&&fChi2Last/(Float_t(fNLast))<3) return 3; //gold
+  if (fNLast>20&&fChi2Last/(Float_t(fNLast))<2) return 3; //gold
+  if (fNLast/(fNExpectedLast+3.)>0.8 && fChi2Last/Float_t(fNLast)<5&&fNLast>20) return 2; //silber
+  if (fNLast>5 &&((fNLast+1.)/(fNExpectedLast+1.))>0.8&&fChi2Last/(fNLast-5.)<6)   return 1; 
   
   return status;
 
 }
-            
-//_____________________________________________________________________________
-void AliTRDtrack::GetExternalCovariance(Double_t cc[15]) const 
-{
-  //
-  // This function returns external representation of the covriance matrix.
-  //
-
-  Double_t a   = GetLocalConvConst();
-
-  Double_t c22 = fX*fX*fCcc  - 2.0*fX*fCce+fCee;
-  Double_t c32 = fX*fCct-fCte;
-  Double_t c20 = fX*fCcy-fCey;
-  Double_t c21 = fX*fCcz-fCez;
-  Double_t c42 = fX*fCcc-fCce;
-
-  cc[ 0]=fCyy;
-  cc[ 1]=fCzy;   cc[ 2]=fCzz;
-  cc[ 3]=c20;    cc[ 4]=c21;    cc[ 5]=c22;
-  cc[ 6]=fCty;   cc[ 7]=fCtz;   cc[ 8]=c32;   cc[ 9]=fCtt;
-  cc[10]=fCcy*a; cc[11]=fCcz*a; cc[12]=c42*a; cc[13]=fCct*a; cc[14]=fCcc*a*a; 
-  
-}               
-                       
-//_____________________________________________________________________________
-void AliTRDtrack::GetCovariance(Double_t cc[15]) const 
-{
-  //
-  // Returns the track covariance matrix
-  //
-
-  cc[ 0]=fCyy;
-  cc[ 1]=fCzy; cc[ 2]=fCzz;
-  cc[ 3]=fCey; cc[ 4]=fCez; cc[ 5]=fCee;
-  cc[ 6]=fCcy; cc[ 7]=fCcz; cc[ 8]=fCce; cc[ 9]=fCcc;
-  cc[10]=fCty; cc[11]=fCtz; cc[12]=fCte; cc[13]=fCct; cc[14]=fCtt;
-  
-}    
 
 //_____________________________________________________________________________
 Int_t AliTRDtrack::Compare(const TObject *o) const 
@@ -697,384 +392,128 @@ void AliTRDtrack::CookdEdx(Double_t low, Double_t up)
   dedx /= (nu - nl + 1.0);
   SetdEdx(dedx);
 
-  delete [] index;
-
 }                     
 
 //_____________________________________________________________________________
-Int_t AliTRDtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
+Bool_t AliTRDtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
 {
-  //
   // Propagates a track of particle with mass=pm to a reference plane 
   // defined by x=xk through media of density=rho and radiationLength=x0
-  //
 
-  if (xk == fX) {
-    return 1;
-  }
-
-  if (TMath::Abs(fC*xk - fE) >= 0.9) {
-    return 0;
-  }
+  if (xk == GetX()) return kTRUE;
 
-  Double_t lcc = GetLocalConvConst();
+  Double_t oldX=GetX(), oldY=GetY(), oldZ=GetZ();
 
-  Double_t oldX = fX;
-  Double_t oldY = fY;
-  Double_t oldZ = fZ;  
+  Double_t bz=GetBz();
+  if (!AliExternalTrackParam::PropagateTo(xk,bz)) return kFALSE;
 
-  Double_t x1 = fX;
-  Double_t x2 = x1 + (xk - x1);
-  Double_t dx = x2 - x1;
-  Double_t y1 = fY;
-  Double_t z1 = fZ;
-  Double_t c1 = fC*x1 - fE;
-  if ((c1*c1) > 1) {
-    return 0;
+  Double_t x=GetX(), y=GetY(), z=GetZ();
+ Double_t d=TMath::Sqrt((x-oldX)*(x-oldX)+(y-oldY)*(y-oldY)+(z-oldZ)*(z-oldZ));
+  if (oldX < xk)
+  if (IsStartedTimeIntegral()) {
+    Double_t l2=d;
+    Double_t crv=GetC();
+    if (TMath::Abs(l2*crv)>0.0001){
+      // make correction for curvature if neccesary
+      l2 = 0.5*TMath::Sqrt((x-oldX)*(x-oldX) + (y-oldY)*(y-oldY));
+      l2 = 2*TMath::ASin(l2*crv)/crv;
+      l2 = TMath::Sqrt(l2*l2+(z-oldZ)*(z-oldZ));
+    }
+    AddTimeStep(l2);
   }
 
-  Double_t r1 = TMath::Sqrt(1.0 - c1*c1);
-  Double_t c2 = fC*x2 - fE; 
-  if ((c2*c2) > 1) {
-    return 0;
-  }
+  Double_t ll = (oldX < xk) ? -d : d;
+  if (!AliExternalTrackParam::CorrectForMaterial(ll*rho/x0,x0,GetMass())) 
+     return kFALSE;
 
-  Double_t r2 = TMath::Sqrt(1.0 - c2*c2);
-
-  fY += dx*(c1+c2) / (r1+r2);
-  fZ += dx*(c1+c2) / (c1*r2 + c2*r1) * fT;
-
-  // f = F - 1
-  Double_t rr  =  r1+r2;
-  Double_t cc  =  c1+c2;
-  Double_t xx  =  x1+x2;
-  Double_t f02 = -dx*(2*rr + cc*(c1/r1 + c2/r2))/(rr*rr);
-  Double_t f04 =  dx*(rr*xx + cc*(c1*x1/r1+c2*x2/r2))/(rr*rr);
-  Double_t cr  =  c1*r2+c2*r1;
-  Double_t f12 = -dx*fT*(2*cr + cc*(c2*c1/r1-r1 + c1*c2/r2-r2))/(cr*cr);
-  Double_t f13 =  dx*cc/cr;
-  Double_t f14 =  dx*fT*(cr*xx-cc*(r1*x2-c2*c1*x1/r1+r2*x1-c1*c2*x2/r2))/(cr*cr);
-
-  // b = C*ft
-  Double_t b00 = f02*fCey + f04*fCcy;
-  Double_t b01 = f12*fCey + f14*fCcy + f13*fCty;
-  Double_t b10 = f02*fCez + f04*fCcz;
-  Double_t b11 = f12*fCez + f14*fCcz + f13*fCtz;
-  Double_t b20 = f02*fCee + f04*fCce;
-  Double_t b21 = f12*fCee + f14*fCce + f13*fCte;
-  Double_t b30 = f02*fCte + f04*fCct;
-  Double_t b31 = f12*fCte + f14*fCct + f13*fCtt;
-  Double_t b40 = f02*fCce + f04*fCcc;
-  Double_t b41 = f12*fCce + f14*fCcc + f13*fCct;
-
-  // a = f*b = f*C*ft
-  Double_t a00 = f02*b20 + f04*b40;
-  Double_t a01 = f02*b21 + f04*b41;
-  Double_t a11 = f12*b21 + f14*b41 + f13*b31;
-
-  // F*C*Ft = C + (a + b + bt)
-  fCyy += a00 + 2.0*b00;
-  fCzy += a01 + b01 + b10;
-  fCey += b20;
-  fCty += b30;
-  fCcy += b40;
-  fCzz += a11 + 2.0*b11;
-  fCez += b21;
-  fCtz += b31;
-  fCcz += b41;
-
-  fX = x2;                                                     
-
-  // Change of the magnetic field
-  SaveLocalConvConst();
-  cc =  fC;
-  fC *= lcc / GetLocalConvConst();
-  fE += fX  * (fC-cc);
-
-  // Multiple scattering
-  // What is 14.1 ????
-  Double_t d      = TMath::Sqrt((x1-fX)*(x1-fX) + (y1-fY)*(y1-fY) + (z1-fZ)*(z1-fZ));
-  Double_t p2     = (1.0 + GetTgl()*GetTgl()) / (Get1Pt()*Get1Pt());
-  Double_t beta2  = p2 / (p2 + GetMass()*GetMass());
-  Double_t theta2 = 14.1*14.1 / (beta2*p2*1e6) * d / x0 * rho;
-  Double_t ey     = fC*fX - fE;
-  Double_t ez     = fT;
-  Double_t xz     = fC*ez;
-  Double_t zz1    = ez*ez + 1.0;
-  Double_t xy     = fE + ey;
-  
-  fCee += (2.0*ey*ez*ez*fE + 1.0 - ey*ey + ez*ez + fE*fE*ez*ez) * theta2;
-  fCte += ez*zz1*xy*theta2;
-  fCtt += zz1*zz1*theta2;
-  fCce += xz*ez*xy*theta2;
-  fCct += xz*zz1*theta2;
-  fCcc += xz*xz*theta2;
-
-  // Energy losses
-  // What is 5940.0 ???? and 0.153e-3 ????
-  if ((5940.0*beta2 / (1.0 - beta2 + 1e-10) - beta2) < 0.0) {
-    return 0;
-  }
-  Double_t dE     = 0.153e-3/beta2 * (TMath::Log(5940.0*beta2 / (1.0 - beta2 + 1e-10)) - beta2) 
-                  * d * rho;
-  Float_t  budget = d * rho;
-  fBudget[0] +=budget;
-  // Suspicious part - think about it ????
+  {//Energy losses************************
+  Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
+  Double_t beta2=p2/(p2 + GetMass()*GetMass());
+  if ((5940*beta2/(1-beta2+1e-10) - beta2) < 0) return kFALSE;
+
+  Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2+1e-10)) - beta2)*d*rho;
+  Float_t budget = d*rho;
+  fBudget[0] += budget;
+  /*
+  // suspicious part - think about it ?
   Double_t kinE =  TMath::Sqrt(p2);
-  if (dE > 0.8 * kinE) {
-    dE = 0.8 * kinE;
-  }
-  if (dE <        0.0) {
-    dE = 0.0;       // Not valid region for Bethe bloch 
-  }
-  fDE += dE;
-  if (x1 < x2) {
-    dE = -dE;
-  }
-  cc  = fC;
-  fC *= (1.0 - TMath::Sqrt(p2 + GetMass()*GetMass()) / p2 * dE);
-  fE += fX * (fC - cc);    
-
-  // Energy loss fluctuation 
-  // Why 0.07 ????
-  Double_t sigmade = 0.07 * TMath::Sqrt(TMath::Abs(dE));  
-  Double_t sigmac2 = sigmade*sigmade * fC*fC * (p2 + GetMass()*GetMass()) / (p2*p2);
+  if (dE>0.8*kinE) dE = 0.8*kinE;  //      
+  if (dE<0)        dE = 0.0;       // not valid region for Bethe bloch 
+  */
+  //
+  fDE+=dE;
+  /*
+  // Suspicious ! I.B.
+  Double_t sigmade = 0.07*TMath::Sqrt(TMath::Abs(dE));   // energy loss fluctuation 
+  Double_t sigmac2 = sigmade*sigmade*fC*fC*(p2+GetMass()*GetMass())/(p2*p2);
   fCcc += sigmac2;
-  fCee += fX*fX * sigmac2;  
-
-  // Track time measurement
-  if (x1 < x2) {
-    if (IsStartedTimeIntegral()) {
-      Double_t l2 = TMath::Sqrt((fX-oldX)*(fX-oldX) 
-                              + (fY-oldY)*(fY-oldY) 
-                              + (fZ-oldZ)*(fZ-oldZ));
-      if (TMath::Abs(l2*fC) > 0.0001){
-        // <ake correction for curvature if neccesary
-        l2 = 0.5 * TMath::Sqrt((fX-oldX)*(fX-oldX) 
-                             + (fY-oldY)*(fY-oldY));
-        l2 = 2.0 * TMath::ASin(l2 * fC) / fC;
-        l2 = TMath::Sqrt(l2*l2 + (fZ-oldZ)*(fZ-oldZ));
-      }
-      AddTimeStep(l2);
-    }
+  fCee += fX*fX*sigmac2;  
+  */
   }
 
-  return 1;            
+  return kTRUE;            
 
 }     
 
 //_____________________________________________________________________________
-Int_t AliTRDtrack::Update(const AliTRDcluster *c, Double_t chisq
-                        , UInt_t index, Double_t h01)
+Bool_t AliTRDtrack::Update(const AliTRDcluster *c, Double_t chisq, Int_t index,
+                          Double_t h01)
 {
-  //
-  // Assignes a found cluster to the track and updates track information
-  //
+  // Assignes found cluster to the track and updates track information
 
   Bool_t fNoTilt = kTRUE;
-  // What is 0.003 ????
-  if (TMath::Abs(h01) > 0.003) {
-    fNoTilt = kFALSE;
-  }
-
-  // Add angular effect to the error contribution
-  Float_t tangent2  = (fC*fX-fE) * (fC*fX-fE);
+  if(TMath::Abs(h01) > 0.003) fNoTilt = kFALSE;
+  // add angular effect to the error contribution -  MI
+  Float_t tangent2 = GetSnp()*GetSnp();
   if (tangent2 < 0.90000){
-    tangent2 = tangent2 / (1.0 - tangent2);
-  }
-  // What is 0.04 ????
-  Float_t errang    = tangent2 * 0.04;
-  Float_t padlength = TMath::Sqrt(c->GetSigmaZ2() * 12.0);
-
-  Double_t r00 = c->GetSigmaY2() + errang;
-  Double_t r01 = 0.0;
-  Double_t r11 = c->GetSigmaZ2() * 100.0;
-  r00 += fCyy; 
-  r01 += fCzy; 
-  r11 += fCzz;
-  Double_t det = r00*r11 - r01*r01;
-  Double_t tmp = r00; 
-  r00 =  r11 / det; 
-  r11 =  tmp / det; 
-  r01 = -r01 / det;
-
-  Double_t k00 = fCyy*r00 + fCzy*r01;
-  Double_t k01 = fCyy*r01 + fCzy*r11;
-  Double_t k10 = fCzy*r00 + fCzz*r01;
-  Double_t k11 = fCzy*r01 + fCzz*r11;
-  Double_t k20 = fCey*r00 + fCez*r01; 
-  Double_t k21 = fCey*r01 + fCez*r11;
-  Double_t k30 = fCty*r00 + fCtz*r01;
-  Double_t k31 = fCty*r01 + fCtz*r11;
-  Double_t k40 = fCcy*r00 + fCcz*r01; 
-  Double_t k41 = fCcy*r01 + fCcz*r11;
-
-  Double_t dy  = c->GetY() - fY;
-  Double_t dz  = c->GetZ() - fZ;
-  Double_t cur = fC + k40*dy + k41*dz;
-  Double_t eta = fE + k20*dy + k21*dz;
-
-  if (fNoTilt) {
-
-    if (TMath::Abs(cur*fX-eta) >= 0.9) {
-      return 0;
-    }
-    fY += k00*dy + k01*dz;
-    fZ += k10*dy + k11*dz;
-    fE  = eta;
-    fC  = cur;
-
+    tangent2 = tangent2/(1.-tangent2);
   }
-  else {
+  //Float_t errang = tangent2*0.04; //
 
-    // Empirical factor set by C.Xu in the first tilt version      
-    // Is this factor still ok ???? 
-    Double_t xuFactor = 100.0;  
-    dy   = c->GetY() - fY; 
-    dz   = c->GetZ() - fZ;     
-    dy   = dy + h01*dz;
-
-    Float_t add = 0.0;
-    if (TMath::Abs(dz) > padlength/2.0) {
-      Float_t dy2  = c->GetY() - fY;
-      Float_t sign = (dz > 0.0) ? -1.0 : 1.0;
-      dy2 += h01 * sign * padlength/2.0;       
-      dy   = dy2;
-      add  = 0.0;
-    }
-  
-    r00  = c->GetSigmaY2() + errang + add;
-    r01  = 0.0;
-    r11  = c->GetSigmaZ2() * xuFactor; 
-    r00 += (fCyy + 2.0*h01*fCzy + h01*h01*fCzz);
-    r01 += (fCzy + h01*fCzz);
-    r11 += fCzz;
-
-    det  =  r00*r11 - r01*r01;
-    tmp  =  r00; 
-    r00  =  r11/det; 
-    r11  =  tmp/det; 
-    r01  = -r01/det;
-
-    k00  = fCyy*r00 + fCzy * (r01 + h01*r00);
-    k01  = fCyy*r01 + fCzy * (r11 + h01*r01);
-    k10  = fCzy*r00 + fCzz * (r01 + h01*r00);
-    k11  = fCzy*r01 + fCzz * (r11 + h01*r01);
-    k20  = fCey*r00 + fCez * (r01 + h01*r00);
-    k21  = fCey*r01 + fCez * (r11 + h01*r01);
-    k30  = fCty*r00 + fCtz * (r01 + h01*r00);
-    k31  = fCty*r01 + fCtz * (r11 + h01*r01);
-    k40  = fCcy*r00 + fCcz * (r01 + h01*r00);
-    k41  = fCcy*r01 + fCcz * (r11 + h01*r01);  
-
-    cur  = fC + k40*dy + k41*dz; 
-    eta  = fE + k20*dy + k21*dz;
-    if (TMath::Abs(cur*fX - eta) >= 0.9) {
-      return 0;
-    }                           
-
-    fY  += k00*dy + k01*dz;
-    fZ  += k10*dy + k11*dz;
-    fE   = eta;
-    fT  += k30*dy + k31*dz;
-    fC   = cur;
-    
-    k01 += h01*k00;
-    k11 += h01*k10;
-    k21 += h01*k20;
-    k31 += h01*k30;
-    k41 += h01*k40;  
-    
-  }
+  Double_t p[2]={c->GetY(), c->GetZ()};
+  //Double_t cov[3]={c->GetSigmaY2()+errang, 0., c->GetSigmaZ2()*100.};
+  Double_t sy2=c->GetSigmaY2()*4;
+  Double_t sz2=c->GetSigmaZ2()*4;
+  Double_t cov[3]={sy2 + h01*h01*sz2, h01*(sy2-sz2), sz2 + h01*h01*sy2};
 
-  Double_t c01 = fCzy;
-  Double_t c02 = fCey;
-  Double_t c03 = fCty;
-  Double_t c04 = fCcy;
-  Double_t c12 = fCez;
-  Double_t c13 = fCtz;
-  Double_t c14 = fCcz;
-
-  fCyy -= k00*fCyy + k01*fCzy; 
-  fCzy -= k00*c01  + k01*fCzz;
-  fCey -= k00*c02  + k01*c12; 
-  fCty -= k00*c03  + k01*c13;
-  fCcy -= k00*c04  + k01*c14;
-  
-  fCzz -= k10*c01  + k11*fCzz;
-  fCez -= k10*c02  + k11*c12;
-  fCtz -= k10*c03  + k11*c13;
-  fCcz -= k10*c04  + k11*c14;
-  
-  fCee -= k20*c02  + k21*c12;
-  fCte -= k20*c03  + k21*c13;
-  fCce -= k20*c04  + k21*c14;
-  
-  fCtt -= k30*c03  + k31*c13;
-  fCct -= k40*c03  + k41*c13;  
-  
-  fCcc -= k40*c04  + k41*c14;                 
+  if (!AliExternalTrackParam::Update(p,cov)) return kFALSE;
 
-  Int_t n = GetNumberOfClusters();
-  fIndex[n] = index;
+  Int_t n=GetNumberOfClusters();
+  fIndex[n]=index;
   SetNumberOfClusters(n+1);
 
   SetChi2(GetChi2()+chisq);
 
-  return 1;     
-
+  return kTRUE;     
 }                     
 
 //_____________________________________________________________________________
-Int_t AliTRDtrack::UpdateMI(const AliTRDcluster *c, Double_t chisq
-                          , UInt_t index, Double_t h01 
-                         , Int_t /*plane*/)
-{
-  //
+Int_t AliTRDtrack::UpdateMI(const AliTRDcluster *c, Double_t chisq, Int_t index,                            Double_t h01, Int_t /*plane*/) {
   // Assignes found cluster to the track and updates track information
-  //
-
   Bool_t fNoTilt = kTRUE;
-  if (TMath::Abs(h01) > 0.003) {
-    fNoTilt = kFALSE;
-  }
-
-  //
-  // Add angular effect to the error contribution and make correction
-  // Still needed ???? 
-  // AliTRDclusterCorrection *corrector = AliTRDclusterCorrection::GetCorrection();
+  if(TMath::Abs(h01) > 0.003) fNoTilt = kFALSE;
+  // add angular effect to the error contribution and make correction  -  MI
   // 
-
-  Double_t tangent2 = (fC*fX-fE) * (fC*fX-fE);
-  if (tangent2 < 0.9) {
-    tangent2 = tangent2 / (1.0 - tangent2);
-  }
-  Double_t tangent  = TMath::Sqrt(tangent2);
-  if ((fC*fX-fE) < 0.0) {
-    tangent *= -1.0;
+  Double_t tangent2 = GetSnp()*GetSnp();
+  if (tangent2 < 0.90000){
+    tangent2 = tangent2/(1.-tangent2);
   }
+  Double_t tangent = TMath::Sqrt(tangent2);
+  if (GetSnp()<0) tangent*=-1;
+  //  Double_t correction = 0*plane;
+  /*
+  Double_t errang = tangent2*0.04;  //
+  Double_t errsys =0.025*0.025*20;  //systematic error part 
 
-  // Where are the parameters from ????
-  Double_t errang = tangent2 * 0.04;
-  Double_t errsys = 0.025*0.025 * 20.0;  // Systematic error part 
-
-  Float_t  extend = 1.0;
-  if (c->GetNPads() == 4) extend = 2.0;
+  Float_t extend =1;
+  if (c->GetNPads()==4) extend=2;
+  */
+  //if (c->GetNPads()==5)  extend=3;
+  //if (c->GetNPads()==6)  extend=3;
+  //if (c->GetQ()<15) return 1;
 
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Is this still needed or will it be needed ????
-  //
-  //if (c->GetNPads() == 5) extend = 3.0;
-  //if (c->GetNPads() == 6) extend = 3.0;
-  //if (c->GetQ() < 15) {
-  //  return 1;
-  //}
-  //
-  // Will this be needed ????
   /*
-  if (corrector !=0 ) {
+  if (corrector!=0){
   //if (0){
     correction = corrector->GetCorrection(plane,c->GetLocalTimeBin(),tangent);
     if (TMath::Abs(correction)>0){
@@ -1085,223 +524,90 @@ Int_t AliTRDtrack::UpdateMI(const AliTRDcluster *c, Double_t chisq
     }
   }
   */
-  //  
-  //  Double_t padlength = TMath::Sqrt(c->GetSigmaZ2()*12.);
-  /////////////////////////////////////////////////////////////////////////////
-
-  Double_t r00 = (c->GetSigmaY2() + errang + errsys) * extend;
-  Double_t r01 = 0.0;
-  Double_t r11 = c->GetSigmaZ2()*10000.0;
-  r00 += fCyy; 
-  r01 += fCzy; 
-  r11 += fCzz;
-  Double_t det =r00*r11 - r01*r01;
-  Double_t tmp =r00;
-  r00  =  r11 / det; 
-  r11  =  tmp / det; 
-  r01  = -r01 / det;
-
-  Double_t k00 = fCyy*r00 + fCzy*r01;
-  Double_t k01 = fCyy*r01 + fCzy*r11;
-  Double_t k10 = fCzy*r00 + fCzz*r01;
-  Double_t k11 = fCzy*r01 + fCzz*r11;
-  Double_t k20 = fCey*r00 + fCez*r01;
-  Double_t k21 = fCey*r01 + fCez*r11;
-  Double_t k30 = fCty*r00 + fCtz*r01;
-  Double_t k31 = fCty*r01 + fCtz*r11;
-  Double_t k40 = fCcy*r00 + fCcz*r01;
-  Double_t k41 = fCcy*r01 + fCcz*r11;
-
-  Double_t dy  = c->GetY() - fY;
-  Double_t dz  = c->GetZ() - fZ;
-  Double_t cur = fC + k40*dy + k41*dz;
-  Double_t eta = fE + k20*dy + k21*dz;
-
-  if (fNoTilt) {
-
-    if (TMath::Abs(cur*fX - eta) >= 0.9) {
-      return 0;
-    }
-
-    fY += k00*dy + k01*dz;
-    fZ += k10*dy + k11*dz;
-    fE  = eta;
-    fC  = cur;
-
-  }
-  else {
-
-    Double_t padlength = TMath::Sqrt(c->GetSigmaZ2() * 12.0);
-    // Empirical factor set by C.Xu in the first tilt version 
-    Double_t xuFactor  = 1000.0;  
-
-    dy = c->GetY() - fY; 
-    dz = c->GetZ() - fZ;     
-    //dy = dy + h01*dz + correction; // Still needed ????
-    
-    Double_t tiltdz = dz;
-    if (TMath::Abs(tiltdz) > padlength/2.0) {
-      tiltdz = TMath::Sign(padlength/2.0,dz);
-    }
-    dy = dy + h01*tiltdz;
-
-    Double_t add = 0.0;
-    if (TMath::Abs(dz) > padlength/2.0) {
-      //Double_t dy2 = c->GetY() - fY;     // Still needed ????
-      //Double_t sign = (dz>0) ? -1.: 1.;
-      //dy2-=h01*sign*padlength/2.;    
-      //dy = dy2;
-      add = 1.0;
+  //
+  //Double_t padlength = TMath::Sqrt(c->GetSigmaZ2()*12.);
+  /*
+    {
+      Double_t dy=c->GetY() - GetY(), dz=c->GetZ() - GetZ();     
+      printf("%e %e %e %e\n",dy,dz,padlength/2,h01);
     }
+  */
+  Double_t p[2]={c->GetY(), c->GetZ()};
+  /*
+  Double_t cov[3]={(c->GetSigmaY2()+errang+errsys)*extend, 0., 
+                  c->GetSigmaZ2()*10000.};
+  */
+  Double_t sy2=c->GetSigmaY2()*4;
+  Double_t sz2=c->GetSigmaZ2()*4;
+  Double_t cov[3]={sy2 + h01*h01*sz2, h01*(sy2-sz2), sz2 + h01*h01*sy2};
 
-    Double_t s00 = (c->GetSigmaY2() + errang) * extend + errsys + add;  // Error pad
-    Double_t s11 = c->GetSigmaZ2() * xuFactor;                          // Error pad-row
-    //
-    r00  = fCyy + 2*fCzy*h01 + fCzz*h01*h01 + s00;
-    r01  = fCzy + fCzz*h01;
-    r11  = fCzz + s11;
-    det  = r00*r11 - r01*r01;
-
-    // Inverse matrix
-    tmp  =  r00; 
-    r00  =  r11 / det; 
-    r11  =  tmp / det; 
-    r01  = -r01 / det;
-
-    // K matrix
-    k00  = fCyy*r00 + fCzy * (r01 + h01*r00);
-    k01  = fCyy*r01 + fCzy * (r11 + h01*r01);
-    k10  = fCzy*r00 + fCzz * (r01 + h01*r00);
-    k11  = fCzy*r01 + fCzz * (r11 + h01*r01);
-    k20  = fCey*r00 + fCez * (r01 + h01*r00);
-    k21  = fCey*r01 + fCez * (r11 + h01*r01);
-    k30  = fCty*r00 + fCtz * (r01 + h01*r00);
-    k31  = fCty*r01 + fCtz * (r11 + h01*r01);
-    k40  = fCcy*r00 + fCcz * (r01 + h01*r00);
-    k41  = fCcy*r01 + fCcz * (r11 + h01*r01);  
-    
-    // Update measurement
-    cur  = fC + k40*dy + k41*dz; 
-    eta  = fE + k20*dy + k21*dz;
-    if (TMath::Abs(cur*fX - eta) >= 0.9) {
-      return 0;
-    }                           
-    fY  += k00*dy + k01*dz;
-    fZ  += k10*dy + k11*dz;
-    fE   = eta;
-    fT  += k30*dy + k31*dz;
-    fC   = cur;
-    
-    k01 += h01*k00;
-    k11 += h01*k10;
-    k21 += h01*k20;
-    k31 += h01*k30;
-    k41 += h01*k40;  
-    
-  }
-
-  // Update the covariance matrix
-  Double_t oldyy = fCyy;
-  Double_t oldzz = fCzz; 
-  //Double_t oldee = fCee;
-  //Double_t oldcc = fCcc;
-  Double_t oldzy = fCzy;
-  Double_t oldey = fCey;
-  Double_t oldty = fCty;
-  Double_t oldcy = fCcy;
-  Double_t oldez = fCez;
-  Double_t oldtz = fCtz;
-  Double_t oldcz = fCcz;
-  //Double_t oldte = fCte;
-  //Double_t oldce = fCce;
-  //Double_t oldct = fCct;
+  if (!AliExternalTrackParam::Update(p,cov)) return kFALSE;
 
-  fCyy -= k00*oldyy + k01*oldzy;   
-  fCzy -= k10*oldyy + k11*oldzy;
-  fCey -= k20*oldyy + k21*oldzy;   
-  fCty -= k30*oldyy + k31*oldzy;
-  fCcy -= k40*oldyy + k41*oldzy;  
-  
-  fCzz -= k10*oldzy + k11*oldzz;
-  fCez -= k20*oldzy + k21*oldzz;   
-  fCtz -= k30*oldzy + k31*oldzz;
-  fCcz -= k40*oldzy + k41*oldzz;
-  
-  fCee -= k20*oldey + k21*oldez;   
-  fCte -= k30*oldey + k31*oldez;
-  fCce -= k40*oldey + k41*oldez;
-  
-  fCtt -= k30*oldty + k31*oldtz;
-  fCct -= k40*oldty + k41*oldtz;
-  
-  fCcc -= k40*oldcy + k41*oldcz;                 
-
-  Int_t n = GetNumberOfClusters();
-  fIndex[n] = index;
+  Int_t n=GetNumberOfClusters();
+  fIndex[n]=index;
   SetNumberOfClusters(n+1);
+  SetChi2(GetChi2()+chisq);
 
-  SetChi2(GetChi2() + chisq);
-
-  return 1;      
-
+  return kTRUE;      
 }                     
-
+/*
 //_____________________________________________________________________________
 Int_t AliTRDtrack::UpdateMI(const AliTRDtracklet &tracklet)
 {
   //
   // Assignes found tracklet to the track and updates track information
   //
-  
-  Double_t r00 = (tracklet.GetTrackletSigma2());
-  Double_t r01 = 0.0;
-  Double_t r11 = 10000.0;
-  r00 += fCyy; 
-  r01 += fCzy; 
-  r11 += fCzz;
-  
-  Double_t det = r00*r11 - r01*r01;
-  Double_t tmp = r00; 
-  r00 =  r11 / det; 
-  r11 =  tmp / det; 
-  r01 = -r01 / det;
+  //
+  Double_t r00=(tracklet.GetTrackletSigma2()), r01=0., r11= 10000.;
+  r00+=fCyy; r01+=fCzy; r11+=fCzz;
+  //
+  Double_t det=r00*r11 - r01*r01;
+  Double_t tmp=r00; r00=r11/det; r11=tmp/det; r01=-r01/det;
+  //
 
-  Double_t dy  = tracklet.GetY() - fY;
-  Double_t dz  = tracklet.GetZ() - fZ;
+  Double_t dy=tracklet.GetY() - fY, dz=tracklet.GetZ() - fZ;
 
-  Double_t s00 = tracklet.GetTrackletSigma2();  // Error pad
-  Double_t s11 = 100000.0;                      // Error pad-row
-  Float_t  h01 = tracklet.GetTilt();
   
-  r00 = fCyy + fCzz*h01*h01 + s00;
-  r01 = fCzy;
+  Double_t s00 = tracklet.GetTrackletSigma2();  // error pad
+  Double_t s11 = 100000;   // error pad-row
+  Float_t  h01 = tracklet.GetTilt();
+  //
+  //  r00 = fCyy + 2*fCzy*h01 + fCzz*h01*h01+s00;
+  r00 = fCyy + fCzz*h01*h01+s00;
+  //  r01 = fCzy + fCzz*h01;
+  r01 = fCzy ;
   r11 = fCzz + s11;
   det = r00*r11 - r01*r01;
-
-  // Inverse matrix
-  tmp =  r00; 
-  r00 =  r11 / det; 
-  r11 =  tmp / det; 
-  r01 = -r01 / det;
-
-  // K matrix
-  Double_t k00 = fCyy*r00 + fCzy*r01;
-  Double_t k01 = fCyy*r01 + fCzy*r11;
-  Double_t k10 = fCzy*r00 + fCzz*r01;
-  Double_t k11 = fCzy*r01 + fCzz*r11;
-  Double_t k20 = fCey*r00 + fCez*r01;
-  Double_t k21 = fCey*r01 + fCez*r11;
-  Double_t k30 = fCty*r00 + fCtz*r01;
-  Double_t k31 = fCty*r01 + fCtz*r11;
-  Double_t k40 = fCcy*r00 + fCcz*r01;
-  Double_t k41 = fCcy*r01 + fCcz*r11;
+  // inverse matrix
+  tmp=r00; r00=r11/det; r11=tmp/det; r01=-r01/det;
+
+  Double_t k00=fCyy*r00+fCzy*r01, k01=fCyy*r01+fCzy*r11;
+  Double_t k10=fCzy*r00+fCzz*r01, k11=fCzy*r01+fCzz*r11;
+  Double_t k20=fCey*r00+fCez*r01, k21=fCey*r01+fCez*r11;
+  Double_t k30=fCty*r00+fCtz*r01, k31=fCty*r01+fCtz*r11;
+  Double_t k40=fCcy*r00+fCcz*r01, k41=fCcy*r01+fCcz*r11;
   
-  // Update measurement
-  Double_t cur = fC + k40*dy + k41*dz;
-  Double_t eta = fE + k20*dy + k21*dz;  
-  if (TMath::Abs(cur*fX-eta) >= 0.9) {
+  // K matrix
+//   k00=fCyy*r00+fCzy*(r01+h01*r00),k01=fCyy*r01+fCzy*(r11+h01*r01);
+//   k10=fCzy*r00+fCzz*(r01+h01*r00),k11=fCzy*r01+fCzz*(r11+h01*r01);
+//   k20=fCey*r00+fCez*(r01+h01*r00),k21=fCey*r01+fCez*(r11+h01*r01);
+//   k30=fCty*r00+fCtz*(r01+h01*r00),k31=fCty*r01+fCtz*(r11+h01*r01);
+//   k40=fCcy*r00+fCcz*(r01+h01*r00),k41=fCcy*r01+fCcz*(r11+h01*r01);  
+  //
+  //Update measurement
+  Double_t cur=fC + k40*dy + k41*dz, eta=fE + k20*dy + k21*dz;  
+  //  cur=fC + k40*dy + k41*dz; eta=fE + k20*dy + k21*dz;
+  if (TMath::Abs(cur*fX-eta) >= 0.90000) {
+    //Int_t n=GetNumberOfClusters();
+    //      if (n>4) cerr<<n<<" AliTRDtrack warning: Filtering failed !\n";
     return 0;
   }                           
+//   k01+=h01*k00;
+//   k11+=h01*k10;
+//   k21+=h01*k20;
+//   k31+=h01*k30;
+//   k41+=h01*k40;  
+
 
   fY += k00*dy + k01*dz;
   fZ += k10*dy + k11*dz;
@@ -1309,140 +615,67 @@ Int_t AliTRDtrack::UpdateMI(const AliTRDtracklet &tracklet)
   fT += k30*dy + k31*dz;
   fC  = cur;
     
-  // Update the covariance matrix
-  Double_t oldyy = fCyy;
-  Double_t oldzz = fCzz; 
-  //Double_t oldee = fCee;
-  //Double_t oldcc = fCcc;
-  Double_t oldzy = fCzy;
-  Double_t oldey = fCey;
-  Double_t oldty = fCty;
-  Double_t oldcy = fCcy;
-  Double_t oldez = fCez;
-  Double_t oldtz = fCtz;
-  Double_t oldcz = fCcz;
-  //Double_t oldte = fCte;
-  //Double_t oldce = fCce;
+  
+  //Update covariance
+  //
+  //
+  Double_t oldyy = fCyy, oldzz = fCzz; //, oldee=fCee, oldcc =fCcc;
+  Double_t oldzy = fCzy, oldey = fCey, oldty=fCty, oldcy =fCcy;
+  Double_t oldez = fCez, oldtz = fCtz, oldcz=fCcz;
+  //Double_t oldte = fCte, oldce = fCce;
   //Double_t oldct = fCct;
 
-  fCyy -= k00*oldyy + k01*oldzy;   
-  fCzy -= k10*oldyy + k11*oldzy;
-  fCey -= k20*oldyy + k21*oldzy;   
-  fCty -= k30*oldyy + k31*oldzy;
-  fCcy -= k40*oldyy + k41*oldzy;  
-  
-  fCzz -= k10*oldzy + k11*oldzz;
-  fCez -= k20*oldzy + k21*oldzz;   
-  fCtz -= k30*oldzy + k31*oldzz;
-  fCcz -= k40*oldzy + k41*oldzz;
-  
-  fCee -= k20*oldey + k21*oldez;   
-  fCte -= k30*oldey + k31*oldez;
-  fCce -= k40*oldey + k41*oldez;
-  
-  fCtt -= k30*oldty + k31*oldtz;
-  fCct -= k40*oldty + k41*oldtz;
+  fCyy-=k00*oldyy+k01*oldzy;   
+  fCzy-=k10*oldyy+k11*oldzy;
+  fCey-=k20*oldyy+k21*oldzy;   
+  fCty-=k30*oldyy+k31*oldzy;
+  fCcy-=k40*oldyy+k41*oldzy;  
+  //
+  fCzz-=k10*oldzy+k11*oldzz;
+  fCez-=k20*oldzy+k21*oldzz;   
+  fCtz-=k30*oldzy+k31*oldzz;
+  fCcz-=k40*oldzy+k41*oldzz;
+  //
+  fCee-=k20*oldey+k21*oldez;   
+  fCte-=k30*oldey+k31*oldez;
+  fCce-=k40*oldey+k41*oldez;
+  //
+  fCtt-=k30*oldty+k31*oldtz;
+  fCct-=k40*oldty+k41*oldtz;
+  //
+  fCcc-=k40*oldcy+k41*oldcz;                 
+  //
   
-  fCcc -= k40*oldcy + k41*oldcz;                 
+  //Int_t n=GetNumberOfClusters();
+  //fIndex[n]=index;
+  //SetNumberOfClusters(n+1);
+
+  //SetChi2(GetChi2()+chisq);
+  //  cerr<<"in update: fIndex["<<fN<<"] = "<<index<<endl;
 
   return 1;      
 
 }                     
+*/
 
 //_____________________________________________________________________________
-Int_t AliTRDtrack::Rotate(Double_t alpha, Bool_t absolute)
+Bool_t AliTRDtrack::Rotate(Double_t alpha, Bool_t absolute)
 {
-  //
-  // Rotates the track parameters in the R*phi plane,
-  // if the absolute rotation alpha is in global system.
-  // Otherwise the rotation is relative to the current rotation angle
-  //  
-
+  // Rotates track parameters in R*phi plane
+  // if absolute rotation alpha is in global system
+  // otherwise alpha rotation is relative to the current rotation angle
+  
   if (absolute) {
-    alpha -= fAlpha;
+    alpha -= GetAlpha();
   }
   else{
     fNRotate++;
   }
 
-  fAlpha += alpha;
-  if (fAlpha <  -TMath::Pi()) {
-    fAlpha += 2.0 * TMath::Pi();
-  }
-  if (fAlpha >=  TMath::Pi()) {
-    fAlpha -= 2.0 * TMath::Pi();
-  }
-
-  Double_t x1 = fX;
-  Double_t y1 = fY;
-  Double_t ca = TMath::Cos(alpha);
-  Double_t sa = TMath::Sin(alpha);
-  Double_t r1 = fC*fX - fE;
-
-  fX =  x1*ca + y1*sa;
-  fY = -x1*sa + y1*ca;
-  if ((r1*r1) > 1.0) {
-    return 0;
-  }
-  fE = fE*ca + (fC*y1 + TMath::Sqrt(1.0 - r1*r1)) * sa;
-
-  Double_t r2 = fC*fX - fE;
-  if (TMath::Abs(r2) >= 0.9) {
-    Int_t n = GetNumberOfClusters();
-    if (n > 4) {
-      AliError(Form("Rotation failed N = %d !\n",n));
-    }
-    return 0;
-  }
-
-  if ((r2*r2) > 1.0) {
-    return 0;
-  }
-  Double_t y0 = fY + TMath::Sqrt(1.0 - r2*r2) / fC;
-  if ((fY-y0)*fC >= 0.0) {
-    Int_t n = GetNumberOfClusters();
-    if (n > 4) {
-      AliError(Form("Rotation failed N = %d !\n",n));
-    }
-    return 0;
-  }
-
-  // f = F - 1
-  Double_t f00 = ca-1.0;
-  Double_t f24 = (y1 - r1*x1/TMath::Sqrt(1.0 - r1*r1)) * sa;
-  Double_t f20 = fC*sa; 
-  Double_t f22 = (ca + sa*r1/TMath::Sqrt(1.0 - r1*r1)) - 1.0;
-
-  // b = C*ft
-  Double_t b00 = fCyy*f00;
-  Double_t b02 = fCyy*f20 + fCcy*f24 + fCey*f22;
-  Double_t b10 = fCzy*f00;
-  Double_t b12 = fCzy*f20 + fCcz*f24 + fCez*f22;
-  Double_t b20 = fCey*f00;
-  Double_t b22 = fCey*f20 + fCce*f24 + fCee*f22;
-  Double_t b30 = fCty*f00;
-  Double_t b32 = fCty*f20 + fCct*f24 + fCte*f22;
-  Double_t b40 = fCcy*f00;
-  Double_t b42 = fCcy*f20 + fCcc*f24 + fCce*f22;
-
-  // a = f*b = f*C*ft
-  Double_t a00 = f00*b00;
-  Double_t a02 = f00*b02;
-  Double_t a22 = f20*b02  + f24*b42  + f22*b22;
-
-  // F*C*Ft = C + (a + b + bt)
-  fCyy += a00 + 2.0*b00;
-  fCzy += b10;
-  fCey += a02 +     b20 + b02;
-  fCty += b30;
-  fCcy += b40;
-  fCez += b12;
-  fCte += b32;
-  fCee += a22 + 2.0*b22;
-  fCce += b42;
-
-  return 1;                            
+  if (GetLabel()==277)
+    printf("Rotate %e %e %e %e\n",GetAlpha(),GetX(),GetY(),GetZ());
 
+  return AliExternalTrackParam::Rotate(GetAlpha()+alpha);
 }                         
 
 //_____________________________________________________________________________
@@ -1452,147 +685,56 @@ Double_t AliTRDtrack::GetPredictedChi2(const AliTRDcluster *c, Double_t h01) con
   // Returns the track chi2
   //  
 
-  Bool_t fNoTilt = kTRUE;
-  if (TMath::Abs(h01) > 0.003) {
-    fNoTilt = kFALSE;
-  }
+  Double_t p[2]={c->GetY(), c->GetZ()};
+  Double_t sy2=c->GetSigmaY2()*4;
+  Double_t sz2=c->GetSigmaZ2()*4;
+  Double_t cov[3]={sy2 + h01*h01*sz2, h01*(sy2-sz2), sz2 + h01*h01*sy2};
+
+  return AliExternalTrackParam::GetPredictedChi2(p,cov);
 
-  Double_t chi2;
-  Double_t dy;
-  Double_t r00;
-  Double_t r01;
-  Double_t r11;
+  /*
+  Bool_t fNoTilt = kTRUE;
+  if(TMath::Abs(h01) > 0.003) fNoTilt = kFALSE;
 
-  if (fNoTilt) {
+  return (c->GetY() - GetY())*(c->GetY() - GetY())/c->GetSigmaY2();
+  */
 
-    dy   = c->GetY() - fY;
-    r00  = c->GetSigmaY2();    
-    chi2 = (dy*dy) / r00;    
+  /*
+  Double_t chi2, dy, r00, r01, r11;
 
+  if(fNoTilt) {
+    dy=c->GetY() - fY;
+    r00=c->GetSigmaY2();    
+    chi2 = (dy*dy)/r00;    
   }
   else {
+    Double_t padlength = TMath::Sqrt(c->GetSigmaZ2()*12);
+    //
+    r00=c->GetSigmaY2(); r01=0.; r11=c->GetSigmaZ2();
+    r00+=fCyy; r01+=fCzy; r11+=fCzz;
 
-    Double_t padlength = TMath::Sqrt(c->GetSigmaZ2() * 12.0);
-
-    r00  = c->GetSigmaY2(); 
-    r01  = 0.0; 
-    r11  = c->GetSigmaZ2();
-    r00 += fCyy; 
-    r01 += fCzy; 
-    r11 += fCzz;
-
-    Double_t det = r00*r11 - r01*r01;
+    Double_t det=r00*r11 - r01*r01;
     if (TMath::Abs(det) < 1.e-10) {
-      Int_t n = GetNumberOfClusters(); 
-      if (n > 4) {
-        AliError(Form("Singular matrix N = %d!\n",n));
-      }
+      Int_t n=GetNumberOfClusters(); 
+      if (n>4) cerr<<n<<" AliTRDtrack warning: Singular matrix !\n";
       return 1e10;
     }
-
-    Double_t tmp = r00; 
-    r00  =  r11; 
-    r11  =  tmp; 
-    r01  = -r01;
-    Double_t dy     = c->GetY() - fY;
-    Double_t dz     = c->GetZ() - fZ;
+    Double_t tmp=r00; r00=r11; r11=tmp; r01=-r01;
+    Double_t dy=c->GetY() - fY, dz=c->GetZ() - fZ;
     Double_t tiltdz = dz;
-    if (TMath::Abs(tiltdz) > padlength/2.0) {
-      tiltdz = TMath::Sign(padlength/2.0,dz);
+    if (TMath::Abs(tiltdz)>padlength/2.) {
+      tiltdz = TMath::Sign(padlength/2,dz);
     }
-    dy = dy + h01*tiltdz;
-
-    chi2 = (dy*r00*dy + 2*r01*dy*dz + dz*r11*dz) / det; 
+    //    dy=dy+h01*dz;
+    dy=dy+h01*tiltdz;
 
+    chi2 = (dy*r00*dy + 2*r01*dy*dz + dz*r11*dz)/det; 
   }
 
   return chi2;
-
+  */
 }      
 
-//_________________________________________________________________________
-void AliTRDtrack::GetPxPyPz(Double_t& px, Double_t& py, Double_t& pz) const
-{
-  //
-  // Returns reconstructed track momentum in the global system.
-  //
-
-  Double_t pt = TMath::Abs(GetPt());
-  Double_t r  = fC*fX - fE;
-
-  Double_t y0; 
-  if      (r >  1) { 
-    py =  pt; 
-    px = 0.0;
-  }
-  else if (r < -1) { 
-    py = -pt; 
-    px = 0.0;
-  }
-  else {
-    y0 =  fY + TMath::Sqrt(1.0 - r*r) / fC;  
-    px = -pt * (fY - y0) * fC; //cos(phi);
-    py = -pt * (fE - fX*fC);   //sin(phi);
-  }
-
-  pz = pt*fT;
-  Double_t tmp = px * TMath::Cos(fAlpha) 
-               - py * TMath::Sin(fAlpha);
-  py = px * TMath::Sin(fAlpha) 
-     + py * TMath::Cos(fAlpha);
-  px = tmp;            
-
-}                                
-
-//_________________________________________________________________________
-void AliTRDtrack::GetGlobalXYZ(Double_t& x, Double_t& y, Double_t& z) const
-{
-  //
-  // Returns reconstructed track coordinates in the global system.
-  //
-
-  x = fX; 
-  y = fY; 
-  z = fZ
-; 
-  Double_t tmp = x * TMath::Cos(fAlpha)
-               - y * TMath::Sin(fAlpha);
-  y = x * TMath::Sin(fAlpha) 
-    + y * TMath::Cos(fAlpha);
-  x = tmp;            
-
-}                                
-
-//_________________________________________________________________________
-void AliTRDtrack::ResetCovariance() 
-{
-  //
-  // Resets covariance matrix
-  //
-
-  fCyy *= 10.0;
-  fCzy  =  0.0;  fCzz *= 10.0;
-  fCey  =  0.0;  fCez  =  0.0;  fCee *= 10.0;
-  fCty  =  0.0;  fCtz  =  0.0;  fCte  =  0.0;  fCtt *= 10.0;
-  fCcy  =  0.0;  fCcz  =  0.0;  fCce  =  0.0;  fCct  =  0.0;  fCcc *= 10.0;  
-
-}                                                         
-
-//_____________________________________________________________________________
-void AliTRDtrack::ResetCovariance(Float_t mult) 
-{
-  //
-  // Resets covariance matrix
-  //
-
-  fCyy *= mult;
-  fCzy *= 0.0;   fCzz *= 1.0;
-  fCey *= 0.0;   fCez *= 0.0;   fCee *= mult;
-  fCty *= 0.0;   fCtz *= 0.0;   fCte *= 0.0;   fCtt *= 1.0;
-  fCcy *= 0.0;   fCcz *= 0.0;   fCce *= 0.0;   fCct *= 0.0;   fCcc *= mult;  
-
-}                                                         
-
 //_____________________________________________________________________________
 void AliTRDtrack::MakeBackupTrack()
 {
@@ -1600,10 +742,7 @@ void AliTRDtrack::MakeBackupTrack()
   // Creates a backup track
   //
 
-  if (fBackupTrack) {
-    delete fBackupTrack;
-  }
-
+  if (fBackupTrack) delete fBackupTrack;
   fBackupTrack = new AliTRDtrack(*this);
   
 }
@@ -1613,74 +752,51 @@ Int_t AliTRDtrack::GetProlongation(Double_t xk, Double_t &y, Double_t &z)
 {
   //
   // Find prolongation at given x
-  // Return 0 if it does not exist
-  //
+  // return 0 if not exist
   
-  Double_t c1 = fC*fX - fE;
-  if (TMath::Abs(c1) > 1.0) {
-    return 0;
-  }
-
-  Double_t r1 = TMath::Sqrt(1.0 - c1*c1);
-  Double_t c2 = fC*xk - fE;
-  if (TMath::Abs(c2) > 1.0) {
-    return 0;  
-  }
+  Double_t bz=GetBz();
 
-  Double_t r2 = TMath::Sqrt(1.0 - c2*c2);
-  y = fY + (xk-fX)*(c1+c2)/(r1+r2);
-  z = fZ + (xk-fX)*(c1+c2)/(c1*r2 + c2*r1)*fT;
+  if (!AliExternalTrackParam::GetYAt(xk,bz,y)) return 0;
+  if (!AliExternalTrackParam::GetZAt(xk,bz,z)) return 0;
 
-  return 1;
-  
+  return 1;  
 }
 
 //_____________________________________________________________________________
-Int_t AliTRDtrack::PropagateToX(Double_t xr, Double_t step)
+Int_t   AliTRDtrack::PropagateToX(Double_t xr, Double_t step)
 {
   //
-  // Propagate track to a given x position 
-  // Works inside of the 20 degree segmentation
-  // (local cooordinate frame for TRD , TPC, TOF)
+  // Propagate track to given x  position 
+  // works inside of the 20 degree segmentation (local cooordinate frame for TRD , TPC, TOF)
   // 
-  // The material budget is taken from the geo manager
-  //
-  Double_t  xyz0[3];
-  Double_t  xyz1[3];
-  Double_t  y;
-  Double_t  z;
-
-  // Critical alpha  - cross sector indication
-  const Double_t kAlphac  = TMath::Pi()/9.0;   
+  // material budget from geo manager
+  // 
+  Double_t  xyz0[3], xyz1[3],y,z;
+  const Double_t kAlphac  = TMath::Pi()/9.;   
   const Double_t kTalphac = TMath::Tan(kAlphac*0.5);
-
-  // Direction +-
-  Double_t dir = (fX > xr) ? -1.0 : 1.0;
-
-  for (Double_t x = fX + dir*step; dir*x < dir*xr; x += dir*step) {
-    
-    GetGlobalXYZ(xyz0[0],xyz0[1],xyz0[2]);     
+  // critical alpha  - cross sector indication
+  //
+  Double_t dir = (GetX()>xr) ? -1.:1.;
+  // direction +-
+  for (Double_t x=GetX()+dir*step;dir*x<dir*xr;x+=dir*step){
+    //
+    GetXYZ(xyz0);      
     GetProlongation(x,y,z);
-    xyz1[0] = x * TMath::Cos(fAlpha) + y * TMath::Sin(fAlpha); 
-    xyz1[1] = x * TMath::Sin(fAlpha) - y * TMath::Cos(fAlpha);
+    xyz1[0] = x*TMath::Cos(GetAlpha())+y*TMath::Sin(GetAlpha()); 
+    xyz1[1] = x*TMath::Sin(GetAlpha())-y*TMath::Cos(GetAlpha());
     xyz1[2] = z;
     Double_t param[7];
     AliKalmanTrack::MeanMaterialBudget(xyz0,xyz1,param);
-    
-    if ((param[0] > 0) && 
-        (param[1] > 0)) {
-      PropagateTo(x,param[1],param[0]);
-    }
-    if (fY >  fX*kTalphac) {
+    //
+    if (param[0]>0&&param[1]>0) PropagateTo(x,param[1],param[0]);
+    if (GetY()>GetX()*kTalphac){
       Rotate(-kAlphac);
     }
-    if (fY < -fX*kTalphac) {
+    if (GetY()<-GetX()*kTalphac){
       Rotate(kAlphac);
     }
-
   }
-
+  //
   PropagateTo(xr);
 
   return 0;
@@ -1688,53 +804,42 @@ Int_t AliTRDtrack::PropagateToX(Double_t xr, Double_t step)
 }
 
 //_____________________________________________________________________________
-Int_t AliTRDtrack::PropagateToR(Double_t r,Double_t step)
+Int_t   AliTRDtrack::PropagateToR(Double_t r,Double_t step)
 {
   //
-  // Propagate a track to a given radial position
-  // The rotation is always connected to the last track position
+  // propagate track to the radial position
+  // rotation always connected to the last track position
   //
-
-  Double_t xyz0[3];
-  Double_t xyz1[3];
-  Double_t y;
-  Double_t z; 
-
-  // Direction +-
-  Double_t radius = TMath::Sqrt(fX*fX + fY*fY);
-  Double_t dir    = (radius > r) ? -1.0 : 1.0;   
-  
-  for (Double_t x = radius + dir*step; dir*x < dir*r; x += dir*step) {
-    GetGlobalXYZ(xyz0[0],xyz0[1],xyz0[2]);     
+  Double_t  xyz0[3], xyz1[3],y,z; 
+  Double_t radius = TMath::Sqrt(GetX()*GetX() + GetY()*GetY());
+  Double_t dir = (radius>r) ? -1.:1.;   // direction +-
+  //
+  for (Double_t x=radius+dir*step;dir*x<dir*r;x+=dir*step){
+    GetXYZ(xyz0);      
     Double_t alpha = TMath::ATan2(xyz0[1],xyz0[0]);
     Rotate(alpha,kTRUE);
-    GetGlobalXYZ(xyz0[0],xyz0[1],xyz0[2]);     
+    GetXYZ(xyz0);      
     GetProlongation(x,y,z);
-    xyz1[0] = x * TMath::Cos(alpha) + y * TMath::Sin(alpha); 
-    xyz1[1] = x * TMath::Sin(alpha) - y * TMath::Cos(alpha);
+    xyz1[0] = x*TMath::Cos(alpha)+y*TMath::Sin(alpha); 
+    xyz1[1] = x*TMath::Sin(alpha)-y*TMath::Cos(alpha);
     xyz1[2] = z;
     Double_t param[7];
     AliKalmanTrack::MeanMaterialBudget(xyz0,xyz1,param);
-    if (param[1] <= 0.0) {
-      param[1] = 100000000.0;
-    }
+    if (param[1]<=0) param[1] =100000000;
     PropagateTo(x,param[1],param[0]);
   } 
-
-  GetGlobalXYZ(xyz0[0],xyz0[1],xyz0[2]);       
+  GetXYZ(xyz0);        
   Double_t alpha = TMath::ATan2(xyz0[1],xyz0[0]);
   Rotate(alpha,kTRUE);
-  GetGlobalXYZ(xyz0[0],xyz0[1],xyz0[2]);       
+  GetXYZ(xyz0);        
   GetProlongation(r,y,z);
-  xyz1[0] = r * TMath::Cos(alpha) + y * TMath::Sin(alpha); 
-  xyz1[1] = r * TMath::Sin(alpha) - y * TMath::Cos(alpha);
+  xyz1[0] = r*TMath::Cos(alpha)+y*TMath::Sin(alpha); 
+  xyz1[1] = r*TMath::Sin(alpha)-y*TMath::Cos(alpha);
   xyz1[2] = z;
   Double_t param[7];
   AliKalmanTrack::MeanMaterialBudget(xyz0,xyz1,param);
-  
-  if (param[1] <= 0.0) {
-    param[1] = 100000000.0;
-  }
+  //
+  if (param[1]<=0) param[1] =100000000;
   PropagateTo(r,param[1],param[0]);
 
   return 0;
@@ -1748,59 +853,13 @@ Int_t AliTRDtrack::GetSector() const
   // Return the current sector
   //
 
-  return Int_t(TVector2::Phi_0_2pi(fAlpha)
+  return Int_t(TVector2::Phi_0_2pi(GetAlpha())
              / AliTRDgeometry::GetAlpha())
              % AliTRDgeometry::kNsect;
 
 }
 
 //_____________________________________________________________________________
-Double_t AliTRDtrack::Get1Pt() const                       
-{ 
-  //
-  // Returns the inverse Pt (1/GeV/c)
-  // (or 1/"most probable pt", if the field is too weak)
-  //
-
-  if (TMath::Abs(GetLocalConvConst()) > kVeryBigConvConst) {
-    return 1.0 / kMostProbableMomentum 
-               / TMath::Sqrt(1.0 + GetTgl()*GetTgl());
-  }
-
-  return (TMath::Sign(1.0e-9,fC) + fC) * GetLocalConvConst();
-
-}
-
-//_____________________________________________________________________________
-Double_t AliTRDtrack::GetP() const                         
-{ 
-  //
-  // Returns the total momentum
-  //
-
-  return TMath::Abs(GetPt()) * TMath::Sqrt(1.0 + GetTgl()*GetTgl());  
-
-}
-
-//_____________________________________________________________________________
-Double_t AliTRDtrack::GetYat(Double_t xk) const            
-{     
-  //
-  // This function calculates the Y-coordinate of a track at 
-  // the plane x = xk.
-  // Needed for matching with the TOF (I.Belikov)
-  //
-
-  Double_t c1 = fC*fX - fE;
-  Double_t r1 = TMath::Sqrt(1.0 - c1*c1);
-  Double_t c2 = fC*xk - fE;
-  Double_t r2 = TMath::Sqrt(1.0-  c2*c2);
-
-  return fY + (xk-fX)*(c1+c2)/(r1+r2);
-
-}
-
-//_____________________________________________________________________________
 void AliTRDtrack::SetSampledEdx(Float_t q, Int_t i)    
 {
   //
@@ -1809,8 +868,7 @@ void AliTRDtrack::SetSampledEdx(Float_t q, Int_t i)
 
   Double_t s = GetSnp();
   Double_t t = GetTgl();
-
-  q *= TMath::Sqrt((1.0 - s*s) / (1.0 + t*t));
+  q *= TMath::Sqrt((1-s*s)/(1+t*t));
   fdQdl[i] = q;
 
 }     
@@ -1824,24 +882,19 @@ void AliTRDtrack::SetSampledEdx(Float_t q)
 
   Double_t s = GetSnp();
   Double_t t = GetTgl();
-
-  q*= TMath::Sqrt((1.0 - s*s) / (1.0 + t*t));
+  q*= TMath::Sqrt((1-s*s)/(1+t*t));
   fdQdl[fNdedx] = q;
   fNdedx++;
 
 }     
 
-//_____________________________________________________________________________
-void AliTRDtrack::GetXYZ(Float_t r[3]) const 
-{
+Double_t AliTRDtrack::GetBz() const {
   //
-  // Returns the position of the track in the global coord. system 
+  // returns Bz component of the magnetic field (kG)
   //
+  if (AliTracker::UniformField()) return AliTracker::GetBz();
+  Double_t r[3]; GetXYZ(r);
+  return AliTracker::GetBz(r);
+}
 
-  Double_t cs = TMath::Cos(fAlpha);
-  Double_t sn = TMath::Sin(fAlpha);
-  r[0] = fX*cs - fY*sn; 
-  r[1] = fX*sn + fY*cs; 
-  r[2] = fZ;
 
-}
index 76a0aa6..19c1d47 100644 (file)
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "AliKalmanTrack.h"
-
 #include "AliTRDtracklet.h"
 
 class AliESDtrack;
 class AliTrackReference;
-class AliTPCtrack;
-
-class AliTRDcluster;
 
 const unsigned kMAXCLUSTERSPERTRACK = 210; 
 
@@ -38,150 +34,116 @@ class AliTRDtrack : public AliKalmanTrack {
 
  public:
 
-  AliTRDtrack();
-  AliTRDtrack(const AliTRDcluster *c, UInt_t index, const Double_t xx[5]
-            , const Double_t cc[15], Double_t xr, Double_t alpha);  
-  AliTRDtrack(const AliTRDtrack &t);    
-  AliTRDtrack(const AliKalmanTrack &t, Double_t alpha); 
-  AliTRDtrack(const AliESDtrack &t);
-  virtual         ~AliTRDtrack();
-  AliTRDtrack     &operator=(const AliTRDtrack &t);
-
-          Int_t    Compare(const TObject *o) const;
-          void     CookdEdx(Double_t low = 0.05, Double_t up = 0.7);   
-          Float_t  StatusForTOF();
-
-          Double_t GetAlpha() const                     { return fAlpha;            }
-          Int_t    GetSector() const;
-          Double_t GetC() const                         { return fC;                }
-          Int_t    GetClusterIndex(Int_t i) const       { return fIndex[i];         }    
-          Float_t  GetClusterdQdl(Int_t i) const        { return fdQdl[i];          }    
-          void     GetCovariance(Double_t cov[15]) const;  
-          Double_t GetdEdx() const                      { return fdEdx;             }
-          Double_t GetPIDsignal() const                 { return GetdEdx();         }
-          Float_t  GetPIDsignals(Int_t iPlane, Int_t iSlice) const 
-                                                        { return fdEdxPlane[iPlane][iSlice]; }
-          Int_t    GetPIDTimBin(Int_t i) const          { return fTimBinPlane[i];   }
-          Double_t GetEta() const                       { return fE;                }
-          void     GetExternalCovariance(Double_t cov[15]) const;   
-          void     GetExternalParameters(Double_t &xr, Double_t x[5]) const;
-          Double_t GetLikelihoodElectron() const        { return fLhElectron;       }
-          Double_t Get1Pt() const;
-          Double_t GetP() const;
-          Double_t GetPredictedChi2(const AliTRDcluster *c, Double_t h01) const;
-          Double_t GetPt() const                        { return 1.0 / Get1Pt();    }   
-          void     GetPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const;
-          void     GetGlobalXYZ(Double_t &x, Double_t &y, Double_t &z) const;
-          Int_t    GetSeedLabel() const                 { return fSeedLab;          }
-          Double_t GetSigmaC2() const                   { return fCcc;              }
-          Double_t GetSigmaTgl2() const                 { return fCtt;              }
-          Double_t GetSigmaY2() const                   { return fCyy;              }
-          Double_t GetSigmaZ2() const                   { return fCzz;              }
-          Double_t GetSnp() const                       { return fX * fC - fE;      }
-          Double_t GetTgl() const                       { return fT;                }
-          Double_t GetX() const                         { return fX;                }
-          Double_t GetY() const                         { return fY;                }
-          Double_t GetZ() const                         { return fZ;                }
-          Int_t   *GetBackupIndexes()                   { return fIndexBackup;      }
-          Int_t   *GetIndexes()                         { return fIndex;            }
-          Double_t GetYat(Double_t xk) const; 
-          Int_t    GetProlongation(Double_t xk, Double_t &y, Double_t &z);
-          Int_t    GetNWrong() const                    { return fNWrong;           }
-          Int_t    GetNRotate() const                   { return fNRotate;          }
-          Int_t    GetNCross() const                    { return fNCross;           }
-          Bool_t   GetStop() const                      { return fStopped;          }
-
-          void     SetdEdx(Float_t dedx)                { fdEdx           = dedx;   }  
-          void     SetPIDsignals(Float_t dedx, Int_t iPlane, Int_t iSlice) 
-                                                        { fdEdxPlane[iPlane][iSlice] = dedx; }
-          void     SetPIDTimBin(Int_t timbin, Int_t i)  { fTimBinPlane[i] = timbin; }
-          void     SetLikelihoodElectron(Float_t l)     { fLhElectron     = l;      }
-          void     SetSampledEdx(Float_t q, Int_t i);
-          void     SetSampledEdx(Float_t q);
-          void     SetSeedLabel(Int_t lab)              { fSeedLab        = lab;    }
-          void     SetStop(Bool_t stop)                 { fStopped        = stop;   }
-
-          Int_t    PropagateTo(Double_t xr, Double_t x0 = 8.72, Double_t rho = 5.86e-3);
-          Int_t    PropagateToX(Double_t xr, Double_t step);
-          Int_t    PropagateToR(Double_t xr, Double_t step);
-          void     ResetCovariance();   
-          void     ResetCovariance(Float_t mult);   
-          void     ResetClusters()                      { SetChi2(0.0); 
-                                                          SetNumberOfClusters(0);   }
-          Int_t    Rotate(Double_t angle, Bool_t absolute = kFALSE);
-          Int_t    Update(const AliTRDcluster *c, Double_t chi2, UInt_t i, Double_t h01);
-          Int_t    UpdateMI(const AliTRDcluster *c, Double_t chi2, UInt_t i, Double_t h01, Int_t plane); 
-          Int_t    UpdateMI(const AliTRDtracklet &tracklet);
-          void     AddNWrong()                          { fNWrong++;                }
-          void     IncCross()                           { fNCross++; 
-                                                          if (fBackupTrack) 
-                                                            fBackupTrack->IncCross();        }
-          AliTRDtrack *GetBackupTrack()                 { return fBackupTrack;      }
-          void     MakeBackupTrack();
+   AliTRDtrack();
+   AliTRDtrack(const AliTRDcluster *c, Int_t index, const Double_t xx[5],
+               const Double_t cc[15], Double_t xr, Double_t alpha);  
+   AliTRDtrack(const AliTRDtrack& t);    
+   AliTRDtrack(const AliESDtrack& t);
+   ~AliTRDtrack();
 
- protected:
+   AliTRDtrack(const AliKalmanTrack& t, Double_t alpha); 
 
-  inline  void     GetXYZ(Float_t r[3]) const;
-          Double_t GetPredictedChi2(const AliCluster*/*c*/) const                  { return 0.0; }
-          Int_t    Update(const AliCluster*/*c*/, Double_t /*chi2*/, UInt_t /*i*/) { return 0;   }
-
-          Int_t    fSeedLab;                               //  Track label taken from seeding  
-          Float_t  fdEdx;                                  //  dE/dx  - truncated mean
-          Float_t  fDE;                                    //  Integrated delta energy
-          Float_t  fdEdxPlane[kNplane][kNslice];           //  dE/dx from all 6 planes in 3 slices each
-          Int_t    fTimBinPlane[kNplane];                  //  Time bin of Max cluster from all 6 planes
-
-          Double_t fAlpha;                                 //  Rotation angle
-          Double_t fX;                                     //  Running local X-coordinate of the track (time bin)
-          Bool_t   fStopped;                               //  Track stop indication
-
-          Double_t fY;                                     //  Y-coordinate of the track
-          Double_t fZ;                                     //  Z-coordinate of the track
-          Double_t fE;                                     //  C*x0
-          Double_t fT;                                     //  Tangent of the track momentum dip angle
-          Double_t fC;                                     //  Track curvature
-
-          Double_t fCyy;                                   //  Covariance
-          Double_t fCzy, fCzz;                             //  matrix
-          Double_t fCey, fCez, fCee;                       //  of the
-          Double_t fCty, fCtz, fCte, fCtt;                 //  track
-          Double_t fCcy, fCcz, fCce, fCct, fCcc;           //  parameters   
-   
-          Int_t    fIndex[kMAXCLUSTERSPERTRACK];           //  Global indexes of clusters  
-          Int_t    fIndexBackup[kMAXCLUSTERSPERTRACK];     //  Backup indexes of clusters - used in iterations
-          Float_t  fdQdl[kMAXCLUSTERSPERTRACK];            //  Cluster amplitudes corrected for track angles    
+   Int_t           Compare(const TObject *o) const;
+
+   void SetdEdx(Double_t dedx) {fdEdx=dedx;}
+   Double_t GetdEdx()  const {return fdEdx;}
+   Double_t GetPIDsignal()  const {return GetdEdx();}
+
+   Int_t GetClusterIndex(Int_t i) const {return fIndex[i];}
+
+   Double_t GetC() const {return AliExternalTrackParam::GetC(GetBz());}
+
+   Double_t GetPredictedChi2(const AliTRDcluster* c, Double_t h01) const;
+   Bool_t PropagateTo(Double_t xr, Double_t x0=8.72, Double_t rho=5.86e-3);
+   Bool_t Update(const AliTRDcluster* c, Double_t chi2, Int_t i, Double_t h01);
+   Bool_t Rotate(Double_t angle, Bool_t absolute=kFALSE);
+
+   void ResetClusters() { SetChi2(0.); SetNumberOfClusters(0); }
+
+   void            CookdEdx(Double_t low=0.05, Double_t up=0.7);   
+   Float_t         StatusForTOF();
+   Int_t           GetSector() const;
+
+   Float_t         GetClusterdQdl(Int_t i) const { return fdQdl[i]; }    
+
+   Float_t GetPIDsignals(Int_t iPlane, Int_t iSlice) const 
+           { return fdEdxPlane[iPlane][iSlice]; }
+   Int_t  GetPIDTimBin(Int_t i) const { return fTimBinPlane[i];}
+
+   Double_t GetLikelihoodElectron() const { return fLhElectron;    }
+
+   Int_t   GetSeedLabel() const  { return fSeedLab; }
+
+   Int_t *GetBackupIndexes() { return fIndexBackup;   }
+   Int_t *GetIndexes()       { return fIndex;         }
+
+   Int_t           GetProlongation(Double_t xk, Double_t &y, Double_t &z);
+
+   void SetStop(Bool_t stop) { fStopped = stop; }
+   Bool_t GetStop() const    { return fStopped; }
+
+   Int_t           PropagateToX(Double_t xr, Double_t step);
+   Int_t           PropagateToR(Double_t xr, Double_t step);
+
+   void SetPIDsignals(Float_t dedx, Int_t iPlane, Int_t iSlice) 
+                      { fdEdxPlane[iPlane][iSlice] = dedx; }
+   void SetPIDTimBin(Int_t timbin, Int_t i)  { fTimBinPlane[i] = timbin; }
+   void SetLikelihoodElectron(Float_t l)     { fLhElectron     = l;      }
+
+   void SetSampledEdx(Float_t q, Int_t i);
+   void SetSampledEdx(Float_t q);
+   void SetSeedLabel(Int_t lab) { fSeedLab = lab; }
+
+   Int_t UpdateMI(const AliTRDcluster* c, Double_t chi2, Int_t i, Double_t h01, Int_t plane);
+  //Int_t  UpdateMI(const AliTRDtracklet & tracklet);
+
+   void AddNWrong() { fNWrong++; }
+  
+   Int_t GetNWrong() const  { return fNWrong;  }
+   Int_t GetNRotate() const { return fNRotate; }
+   Int_t GetNCross() const  { return fNCross;  }
+   void  IncCross() { fNCross++; if (fBackupTrack) fBackupTrack->IncCross(); }
+   AliTRDtrack *GetBackupTrack() { return fBackupTrack; }
+   void         MakeBackupTrack();
+
+ protected:
+   Double_t GetBz() const;
+   Bool_t Update(const AliCluster */*c*/, Double_t /*chi2*/, Int_t /*idx*/) {
+     return 0;
+   }
+   Double_t GetPredictedChi2(const AliCluster */*c*/) const {return 0.;}
+
+   AliTRDtrack     &operator=(const AliTRDtrack &t);
+
+   Int_t           fSeedLab;                               // track label taken from seeding  
+   Float_t         fdEdx;                                  // dE/dx 
+   Float_t         fdEdxT;                                 // dE/dx  - truncated mean
+   Float_t         fDE;                                    // integrated delta energy
+   Float_t         fdEdxPlane[kNplane][kNslice];           // dE/dx from all 6 planes in 3 slices each
+   Int_t           fTimBinPlane[kNplane];                  // time bin of Max cluster from all 6 planes
+
+   Bool_t          fStopped;                               // track stop indication
+   Int_t           fIndex[kMAXCLUSTERSPERTRACK];           // global indexes of clusters  
+   Int_t           fIndexBackup[kMAXCLUSTERSPERTRACK];     // backup indexes of clusters - used in iterations
+   Float_t         fdQdl[kMAXCLUSTERSPERTRACK];            // cluster amplitudes corrected for track angles    
                            
-          Float_t  fLhElectron;                            //  Likelihood to be an electron    
-          Int_t    fNWrong;                                //  Number of wrong clusters
-          Int_t    fNRotate;                               //  Number of rotation
-          Int_t    fNCross;                                //  Number of the cross materials
-          Int_t    fNExpected;                             //  Expected number of cluster
-          Int_t    fNLast;                                 //  Number of clusters in last 2 layers
-          Int_t    fNExpectedLast;                         //  Number of expected clusters on last 2 layers
-          Int_t    fNdedx;                                 //  Number of clusters for dEdx measurment
-          Float_t  fChi2Last;                              //  Chi2 in the  last 2 layers
-          AliTRDtracklet  fTracklets[6];                   //  Tracklets
-          Float_t  fBudget[3];                             //  Integrated material budget
-          AliTRDtrack    *fBackupTrack;                    //! Backup track
-
-  ClassDef(AliTRDtrack,6)                                  //  TRD reconstructed tracks
+   Float_t         fLhElectron;                            // Likelihood to be an electron    
+   Int_t           fNWrong;                                // number of wrong clusters
+   Int_t           fNRotate;                               // number of rotation
+   Int_t           fNCross;                                // number of the cross materials
+   Int_t           fNExpected;                             // expected number of cluster
+   Int_t           fNLast;                                 // number of clusters in last 2 layers
+   Int_t           fNExpectedLast;                         // number of expected clusters on last 2 layers
+   Int_t           fNdedx;                                 // number of clusters for dEdx measurment
+   Float_t         fChi2Last;                              // chi2 in the  last 2 layers
+   AliTRDtracklet  fTracklets[6];                          // tracklets
+   Float_t         fBudget[3];                             // integrated material budget
+   AliTRDtrack    *fBackupTrack;                           //! backup track
+
+   ClassDef(AliTRDtrack,7)                                 // TRD reconstructed tracks
 
 };                     
 
-//_____________________________________________________________________________
-inline void AliTRDtrack::GetExternalParameters(Double_t &xr, Double_t x[5]) const 
-{
-  //
-  // This function returns external TRD track representation
-  //
-
-  xr   = fX;
-  x[0] = GetY();  
-  x[1] = GetZ();  
-  x[2] = GetSnp();  
-  x[3] = GetTgl();
-  x[4] = (TMath::Sign(1.0e-9,fC) + fC) * GetLocalConvConst();
-
-}           
-
 #endif   
index a14a1a5..6575742 100644 (file)
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <Riostream.h>
-
 #include <TFile.h>
 #include <TBranch.h>
 #include <TTree.h>  
 #include <TObjArray.h> 
-#include <TTreeStream.h>
-#include <TGraph.h>
-#include <TLinearFitter.h>
-
-#include "AliESD.h"
-#include "AliRieman.h"
-#include "AliAlignObj.h"
-#include "AliTrackPointArray.h"
-#include "AliLog.h"
 
 #include "AliTRDgeometry.h"
 #include "AliTRDpadPlane.h"
 #include "AliTRDcluster.h" 
 #include "AliTRDtrack.h"
 #include "AliTRDseed.h"
+#include "AliESD.h"
+
 #include "AliTRDcalibDB.h"
 #include "AliTRDCommonParam.h"
+
+#include "TTreeStream.h"
+#include "TGraph.h"
 #include "AliTRDtracker.h"
+#include "TLinearFitter.h"
+#include "AliRieman.h"
+#include "AliTrackPointArray.h"
+#include "AliAlignObj.h"
 #include "AliTRDReconstructor.h"
 
 ClassImp(AliTRDtracker) 
@@ -58,38 +57,33 @@ ClassImp(AliTRDtracker)
   const  Double_t    AliTRDtracker::fgkMaxStep            = 2.;   // maximal step size in propagation 
 
 //_____________________________________________________________________________
-AliTRDtracker::AliTRDtracker()
-  :AliTracker()
-  ,fGeom(0)
-  ,fNclusters(0)
-  ,fClusters(0)
-  ,fNseeds(0)
-  ,fSeeds(0)
-  ,fNtracks(0)
-  ,fTracks(0)
-  ,fTimeBinsPerPlane(0)
-  ,fAddTRDseeds(kFALSE)
-  ,fNoTilt(kFALSE)
-  ,fDebugStreamer(0)
+AliTRDtracker::AliTRDtracker():
+  AliTracker(),
+  fGeom(0),
+  fNclusters(0),
+  fClusters(0),
+  fNseeds(0),
+  fSeeds(0),
+  fNtracks(0),
+  fTracks(0),
+  fTimeBinsPerPlane(0),
+  fAddTRDseeds(kFALSE),
+  fNoTilt(kFALSE),
+  fDebugStreamer(0)
 {
   //
   // Default constructor
   //
 
-  for (Int_t i = 0; i < kTrackingSectors; i++) {
-    fTrSec[i] = 0;
-  }
-  for (Int_t j = 0; j < 5; j++) {
-    for (Int_t k = 0; k < 18; k++) {
-      fHoles[j][k] = kFALSE;
-    }
-  }
+  for(Int_t i=0;i<kTrackingSectors;i++) fTrSec[i]=0;
+  for(Int_t j=0;j<5;j++)
+  for(Int_t k=0;k<18;k++) fHoles[j][k]=kFALSE;
 
 } 
 
 //_____________________________________________________________________________
-AliTRDtracker::AliTRDtracker(const AliTRDtracker &t) 
-  :AliTracker(t) 
+AliTRDtracker::AliTRDtracker(const AliTRDtracker &t)
+  :AliTracker(t)
   ,fGeom(0)
   ,fNclusters(0)
   ,fClusters(0)
@@ -101,11 +95,10 @@ AliTRDtracker::AliTRDtracker(const AliTRDtracker &t)
   ,fAddTRDseeds(kFALSE)
   ,fNoTilt(kFALSE)
   ,fDebugStreamer(0)
-{ 
+{
   //
   // Copy constructor
   //
-
 }
 
 //_____________________________________________________________________________
@@ -127,42 +120,44 @@ AliTRDtracker::AliTRDtracker(const TFile *geomfile)
   //  Main constructor
   //  
    
-  TDirectory *savedir = gDirectory; 
-  TFile      *in      = (TFile *) geomfile;  
-
+  TDirectory *savedir=gDirectory; 
+  TFile *in=(TFile*)geomfile;  
   if (!in->IsOpen()) {
-    AliWarning("Geometry file is not open!\n");
-    AliWarning("FULL TRD geometry and DEFAULT TRD parameter will be used\n");
+    printf("AliTRDtracker::AliTRDtracker(): geometry file is not open!\n");
+    printf("    FULL TRD geometry and DEFAULT TRD parameter will be used\n");
   }
   else {
     in->cd();  
-    fGeom = (AliTRDgeometry *) in->Get("TRDgeometry");
+    fGeom = (AliTRDgeometry*) in->Get("TRDgeometry");
   }
 
-  if (!fGeom) {
-    AliWarning("Can't find TRD geometry!\n");
+  if(fGeom) {
+    //    printf("Found geometry version %d on file \n", fGeom->IsVersion());
+  }
+  else { 
+    printf("AliTRDtracker::AliTRDtracker(): can't find TRD geometry!\n");
     fGeom = new AliTRDgeometry();
   } 
   fGeom->ReadGeoMatrices();
 
   savedir->cd();  
 
-  for (Int_t geomS = 0; geomS < kTrackingSectors; geomS++) {
+  for(Int_t geomS = 0; geomS < kTrackingSectors; geomS++) {
     Int_t trS = CookSectorIndex(geomS);
-    fTrSec[trS] = new AliTRDtrackingSector(fGeom,geomS);
-    for (Int_t icham = 0; icham < AliTRDgeometry::kNcham; icham++) {
-      fHoles[icham][trS] = fGeom->IsHole(0,icham,geomS);
+    fTrSec[trS] = new AliTRDtrackingSector(fGeom, geomS);
+    for (Int_t icham=0;icham<AliTRDgeometry::kNcham; icham++){
+      fHoles[icham][trS]=fGeom->IsHole(0,icham,geomS);
     }
   }
   AliTRDpadPlane *padPlane = AliTRDCommonParam::Instance()->GetPadPlane(0,0);
   Float_t tiltAngle = TMath::Abs(padPlane->GetTiltingAngle());
-  if (tiltAngle < 0.1) {
+  if(tiltAngle < 0.1) {
     fNoTilt = kTRUE;
   }
 
   fTimeBinsPerPlane =  AliTRDcalibDB::Instance()->GetNumberOfTimeBins();
 
-  fDebugStreamer    = new TTreeSRedirector("TRDdebug.root");
+  fDebugStreamer = new TTreeSRedirector("TRDdebug.root");
 
   savedir->cd();
 
@@ -193,6 +188,7 @@ AliTRDtracker::~AliTRDtracker()
     delete fTrSec[geomS];
   }
   if (fDebugStreamer) {    
+    //fDebugStreamer->Close();
     delete fDebugStreamer;
   }
 
@@ -205,9 +201,9 @@ Int_t  AliTRDtracker::LocalToGlobalID(Int_t lid)
   // Transform internal TRD ID to global detector ID
   //
 
-  Int_t  isector  = fGeom->GetSector(lid);
-  Int_t  ichamber = fGeom->GetChamber(lid);
-  Int_t  iplan    = fGeom->GetPlane(lid);
+  Int_t  isector = fGeom->GetSector(lid);
+  Int_t  ichamber= fGeom->GetChamber(lid);
+  Int_t  iplan   = fGeom->GetPlane(lid);
   //
   AliAlignObj::ELayerID iLayer = AliAlignObj::kTRD1;
   switch (iplan) {
@@ -230,8 +226,7 @@ Int_t  AliTRDtracker::LocalToGlobalID(Int_t lid)
     iLayer = AliAlignObj::kTRD6;
     break;
   };
-
-  Int_t    modId = isector * fGeom->Ncham() + ichamber;
+  Int_t modId = isector*fGeom->Ncham()+ichamber;
   UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,modId);
 
   return volid;
@@ -245,34 +240,34 @@ Int_t  AliTRDtracker::GlobalToLocalID(Int_t gid)
   // Transform global detector ID to local detector ID
   // 
 
-  Int_t modId = 0;
-  AliAlignObj::ELayerID layerId = AliAlignObj::VolUIDToLayer(gid,modId);
-  Int_t     isector  = modId / fGeom->Ncham();
-  Int_t     ichamber = modId % fGeom->Ncham();
-  Int_t     iLayer   = -1;
+  Int_t modId=0;
+  AliAlignObj::ELayerID  layerId  = AliAlignObj::VolUIDToLayer(gid, modId);
+  Int_t     isector  = modId/fGeom->Ncham();
+  Int_t     ichamber = modId%fGeom->Ncham();
+  Int_t     iLayer    = -1;
   switch (layerId) {
   case AliAlignObj::kTRD1:
-    iLayer =  0;
+    iLayer = 0;
     break;
   case AliAlignObj::kTRD2:
-    iLayer =  1;
+    iLayer = 1;
     break;
   case AliAlignObj::kTRD3:
-    iLayer =  2;
+    iLayer = 2;
     break;
   case AliAlignObj::kTRD4:
-    iLayer =  3;
+    iLayer = 3;
     break;
   case AliAlignObj::kTRD5:
-    iLayer =  4;
+    iLayer = 4;
     break;
   case AliAlignObj::kTRD6:
-    iLayer =  5;
+    iLayer = 5;
     break;
   default:
-    iLayer = -1;
+    iLayer =-1;
   }
-  if (iLayer < 0) return -1;
+  if (iLayer<0) return -1;
   Int_t lid = fGeom->GetDetector(iLayer,ichamber,isector);
 
   return lid;
@@ -280,74 +275,73 @@ Int_t  AliTRDtracker::GlobalToLocalID(Int_t gid)
 }
 
 //_____________________________________________________________________________
-Bool_t  AliTRDtracker::Transform(AliTRDcluster *cluster)
+Bool_t  AliTRDtracker::Transform(AliTRDcluster * cluster)
 {
   //
   // Transform something ... whatever ...
   //
 
-  // Magic constants for geo manager transformation
-  const Double_t kX0shift           = 2.52;    
-  const Double_t kX0shift5          = 3.05;
+  const Double_t kX0shift           = 2.52;    // magic constants for geo manager transformation
+  const Double_t kX0shift5          = 3.05;    // 
   //
-  // Apply alignment and calibration to transform cluster
   //
-  Int_t detector  = cluster->GetDetector();
-  Int_t plane     = fGeom->GetPlane(cluster->GetDetector());
-  Int_t chamber   = fGeom->GetChamber(cluster->GetDetector());
-  Int_t sector    = fGeom->GetSector(cluster->GetDetector());
-
-  Double_t dxAmp  = (Double_t) fGeom->CamHght();                // Amplification region
-  Double_t driftX = TMath::Max(cluster->GetX()-dxAmp*0.5,0.0);  // Drift distance
+  // apply alignment and calibration to transform cluster
+  //
+  //
+  Int_t detector = cluster->GetDetector();
+  Int_t plane   = fGeom->GetPlane(cluster->GetDetector());
+  Int_t chamber = fGeom->GetChamber(cluster->GetDetector());
+  Int_t sector  = fGeom->GetSector(cluster->GetDetector());
 
+  Double_t dxAmp  = (Double_t) fGeom->CamHght();          // Amplification region
+  Double_t driftX = TMath::Max(cluster->GetX()-dxAmp*0.5,0.);  // drift distance
   //
   // ExB correction
   //
   Double_t vdrift = AliTRDcalibDB::Instance()->GetVdrift(cluster->GetDetector(),0,0);
-  Double_t exB    = AliTRDcalibDB::Instance()->GetOmegaTau(vdrift);
-  
-  AliTRDCommonParam *commonParam = AliTRDCommonParam::Instance();  
-  AliTRDpadPlane    *padPlane    = commonParam->GetPadPlane(plane,chamber);
+  Double_t exB =   AliTRDcalibDB::Instance()->GetOmegaTau(vdrift);
+  //
+  AliTRDCommonParam* commonParam = AliTRDCommonParam::Instance();  
+  AliTRDpadPlane * padPlane = commonParam->GetPadPlane(plane,chamber);
   Double_t zshiftIdeal  = 0.5*(padPlane->GetRow0()+padPlane->GetRowEnd());
-  Double_t localPos[3];
-  Double_t localPosTracker[3];
+  Double_t localPos[3], localPosTracker[3];
   localPos[0] = -cluster->GetX();
   localPos[1] =  cluster->GetY() - driftX*exB;
-  localPos[2] =  cluster->GetZ() - zshiftIdeal;
-  
+  localPos[2] =  cluster->GetZ() -zshiftIdeal;
+  //
   cluster->SetY(cluster->GetY() - driftX*exB);
   Double_t xplane = (Double_t) AliTRDgeometry::GetTime0(plane); 
   cluster->SetX(xplane- cluster->GetX());
-  
-  TGeoHMatrix *matrix = fGeom->GetCorrectionMatrix(cluster->GetDetector());
+  //
+  TGeoHMatrix * matrix =  fGeom->GetCorrectionMatrix(cluster->GetDetector());
   if (!matrix){
-    // No matrix found - if somebody used geometry with holes
+    // no matrix found - if somebody used geometry with holes
     AliError("Invalid Geometry - Default Geometry used\n");
     return kTRUE;   
   }
   matrix->LocalToMaster(localPos, localPosTracker);  
-
-  if (AliTRDReconstructor::StreamLevel() > 1) {
-    (* fDebugStreamer) << "Transform"
-                       << "Cl.="      << cluster
-                       << "matrix.="  << matrix
-                       << "Detector=" << detector
-                       << "Sector="   << sector
-                       << "Plane="    << plane
-                       << "Chamber="  << chamber
-                       << "lx0="      << localPosTracker[0]
-                       << "ly0="      << localPosTracker[1]
-                       << "lz0="      << localPosTracker[2]
-                       << "\n";
+  //
+  //
+  //
+  if (AliTRDReconstructor::StreamLevel()>1){
+    (*fDebugStreamer)<<"Transform"<<
+      "Cl.="<<cluster<<
+      "matrix.="<<matrix<<
+      "Detector="<<detector<<
+      "Sector="<<sector<<
+      "Plane="<<plane<<
+      "Chamber="<<chamber<<
+      "lx0="<<localPosTracker[0]<<
+      "ly0="<<localPosTracker[1]<<
+      "lz0="<<localPosTracker[2]<<
+      "\n";
   }
-  
-  if (plane == 5) {
+  //
+  if (plane==5)
      cluster->SetX(localPosTracker[0]+kX0shift5);
-  }
-  else {
+  else
     cluster->SetX(localPosTracker[0]+kX0shift);
-  }
+    
   cluster->SetY(localPosTracker[1]);
   cluster->SetZ(localPosTracker[2]);
 
@@ -443,23 +437,18 @@ Bool_t AliTRDtracker::AdjustSector(AliTRDtrack *track)
   //
 
   Double_t alpha = AliTRDgeometry::GetAlpha(); 
-  Double_t y     = track->GetY();
-  Double_t ymax  = track->GetX() * TMath::Tan(0.5*alpha);
+  Double_t y = track->GetY();
+  Double_t ymax = track->GetX()*TMath::Tan(0.5*alpha);
 
   //Int_t ns = AliTRDgeometry::kNsect;
   //Int_t s=Int_t(track->GetAlpha()/alpha)%ns; 
 
-  if      (y >  ymax) {
+  if (y > ymax) {
     //s = (s+1) % ns;
-    if (!track->Rotate(alpha)) {
-      return kFALSE;
-    }
-  } 
-  else if (y < -ymax) {
+    if (!track->Rotate(alpha)) return kFALSE;
+  } else if (y <-ymax) {
     //s = (s-1+ns) % ns;                           
-    if (!track->Rotate(-alpha)) {
-      return kFALSE;   
-    }
+    if (!track->Rotate(-alpha)) return kFALSE;   
   } 
 
   return kTRUE;
@@ -474,21 +463,16 @@ AliTRDcluster *AliTRDtracker::GetCluster(AliTRDtrack *track, Int_t plane
   // Try to find cluster in the backup list
   //
 
-  AliTRDcluster *cl      = 0;
-  Int_t         *indexes = track->GetBackupIndexes();
-
-  for (UInt_t i = 0; i < kMaxTimeBinIndex; i++) {
-    if (indexes[i] == 0) break;  
-    AliTRDcluster *cli = (AliTRDcluster *) fClusters->UncheckedAt(indexes[i]);
-    if (!cli) {
-      break;
-    }
-    if (cli->GetLocalTimeBin() != timebin) {
-      continue;
-    }
+  AliTRDcluster * cl =0;
+  Int_t *indexes = track->GetBackupIndexes();
+  for (UInt_t i=0;i<kMaxTimeBinIndex;i++){
+    if (indexes[i]==0) break;  
+    AliTRDcluster * cli = (AliTRDcluster*)fClusters->UncheckedAt(indexes[i]);
+    if (!cli) break;
+    if (cli->GetLocalTimeBin()!=timebin) continue;
     Int_t iplane = fGeom->GetPlane(cli->GetDetector());
-    if (iplane == plane) {
-      cl    = cli;
+    if (iplane==plane) {
+      cl = cli;
       index = indexes[i];
       break;
     }