X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TOF%2FAliTOFtrack.cxx;h=dfca90b9d9082498219ee713cb999181401be774;hb=c50ee7ffd54bdadf52683585a599c50365450ba0;hp=fff4383adc55125beefb75a06a8ecc01444edda6;hpb=74ea065cb17914f492e2bda7cb15fb6ab0133189;p=u%2Fmrichter%2FAliRoot.git

diff --git a/TOF/AliTOFtrack.cxx b/TOF/AliTOFtrack.cxx
index fff4383adc5..dfca90b9d90 100644
--- a/TOF/AliTOFtrack.cxx
+++ b/TOF/AliTOFtrack.cxx
@@ -15,244 +15,250 @@
 
 /* $Id$ */
 
-#include <Riostream.h>
-#include <TObject.h>   
-#include "AliTOFGeometry.h" 
-#include "AliTOFtrack.h" 
+/////////////////////////////////////////////////////////////////////////////
+//                                                                         //
+// AliTOFtrack class                                                       //
+//                                                                         //
+// Authors: Bologna-CERN-ITEP-Salerno Group                                //
+//                                                                         //
+// Description: class for handling ESD extracted tracks for TOF matching.  //
+//                                                                         //
+/////////////////////////////////////////////////////////////////////////////
+
 #include "AliESDtrack.h" 
+#include "AliTracker.h" 
+
+#include "AliTOFGeometry.h"
+#include "AliTOFtrack.h" 
 
 ClassImp(AliTOFtrack)
 
 //_____________________________________________________________________________
-AliTOFtrack::AliTOFtrack(const AliTOFtrack& t) : AliKalmanTrack(t) {
+AliTOFtrack::AliTOFtrack() : 
+  AliKalmanTrack(),
+  fSeedInd(-1),
+  fSeedLab(-1)
+{
   //
-  // 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;  
-
-
 }                                
 
 //_____________________________________________________________________________
-AliTOFtrack::AliTOFtrack(const AliESDtrack& t) 
-           :AliKalmanTrack() {
+AliTOFtrack::AliTOFtrack(const AliTOFtrack& t) : 
+  AliKalmanTrack(t),
+  fSeedInd(t.fSeedInd),
+  fSeedLab(t.fSeedLab) 
+{
   //
-  // Constructor from AliESDtrack
+  // Copy constructor.
   //
+}                                
 
-  SetSeedIndex(-1);
+//____________________________________________________________________________
+AliTOFtrack& AliTOFtrack::operator=(const AliESDtrack& t)
+{
+  // ass. op.
   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);
+  SetMass(t.GetMassForTracking());
 
-  fX=x;
+  Set(t.GetX(),t.GetAlpha(),t.GetParameter(),t.GetCovariance());
 
-  x = GetConvConst();  
+  if ((t.GetStatus()&AliESDtrack::kTIME) == 0) return *this;
+  StartTimeIntegral();
+  Double_t times[10]; 
+  for(Int_t isp=0;isp<AliPID::kSPECIESC;isp++){
+    times[isp] = t.GetIntegratedTimesOld(isp); // in ps
+  }
 
-  fY=p[0];
-  fZ=p[1];
-  fT=p[3];
-  fC=p[4]/x;
-  fE=fC*fX - p[2];   
+  SetIntegratedTimes(times);
+  SetIntegratedLength(t.GetIntegratedLengthOld());
 
-  //Conversion of the covariance matrix
-  Double_t c[15]; t.GetExternalCovariance(c);
+  return *this;
 
-  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];
+//_____________________________________________________________________________
+AliTOFtrack::AliTOFtrack(const AliESDtrack& t) :
+  AliKalmanTrack(), 
+  fSeedInd(-1),
+  fSeedLab(-1) 
+{
+  //
+  // Constructor from AliESDtrack
+  //
+  SetLabel(t.GetLabel());
+  SetChi2(0.);
+  SetMass(t.GetMassForTracking());
 
-  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());
+  Double_t times[10]; 
+  for(Int_t isp=0;isp<AliPID::kSPECIESC;isp++){
+    times[isp] = t.GetIntegratedTimesOld(isp); // in ps
+  }
 
+  SetIntegratedTimes(times);
+  SetIntegratedLength(t.GetIntegratedLengthOld());
 
 }              
+
 //____________________________________________________________________________
-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();
-}           
+AliTOFtrack& AliTOFtrack::operator=(const AliTOFtrack &/*source*/)
+{
+  // ass. op.
+
+  return *this;
+
+}
 
 //_____________________________________________________________________________
-void AliTOFtrack::GetExternalCovariance(Double_t cc[15]) const {
+Bool_t AliTOFtrack::PropagateTo(Double_t xk,Double_t /*x0*/,Double_t /*rho*/)
+ {
   //
-  // This function returns external representation of the covriance matrix.
+  // Propagates a track of particle with mass=pm to a reference plane 
+  // defined by x=xk through media of density=rho and radiationLength=x0
   //
-  Double_t a=GetConvConst();
-  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; 
+
+  if (xk == GetX()) return kTRUE;
   
-}               
-                       
+  Double_t oldX=GetX();//, oldY=GetY(), oldZ=GetZ();
+  Double_t start[3], end[3], mparam[7];
+
+  /* get start position */
+  GetXYZ(start);
+
+  /* propagate the track */
+  Double_t b[3];GetBxByBz(b);
+  if (!AliExternalTrackParam::PropagateToBxByBz(xk,b)) return kFALSE;
+  // OLD used code
+  //Double_t bz=GetBz();
+  //if (!AliExternalTrackParam::PropagateTo(xk,bz)) return kFALSE;
+
+  /* get end position */
+  GetXYZ(end);
+
+  /* add time step to integral */
+#if 0 /*** OLD ***/
+  Double_t d = TMath::Sqrt((GetX()-oldX)*(GetX()-oldX) + 
+                           (GetY()-oldY)*(GetY()-oldY) + 
+                           (GetZ()-oldZ)*(GetZ()-oldZ));
+  if (IsStartedTimeIntegral() && GetX()>oldX) AddTimeStep(d);
+#endif
+  Double_t d = 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]));
+  if (IsStartedTimeIntegral() && GetX()>oldX) AddTimeStep(d);
+
+  /* get material budget from tracker */
+  AliTracker::MeanMaterialBudget(start, end, mparam);
+  Double_t xTimesRho = mparam[4]*mparam[0];
+  if (oldX < xk) { // CZ
+    xTimesRho = -xTimesRho; // it should be negative in case of outward
+                            // propagation (--> energy decreases)
+  } // CZ
+  Double_t xOverX0   = mparam[1];
+
+  /* correct for mean material */
+  if (!AliExternalTrackParam::CorrectForMeanMaterial(xOverX0,xTimesRho,GetMass())) return kFALSE;
+
+
+#if 0 /*** OLD ***/
+  if (!AliExternalTrackParam::CorrectForMaterial(d*rho/x0,x0,GetMass())) 
+     return kFALSE;
+#endif
 
-//_____________________________________________________________________________
-void AliTOFtrack::GetCovariance(Double_t cc[15]) const {
+  /*
+  //Energy losses************************
+  if((5940*beta2/(1-beta2+1e-10) - beta2) < 0){return 0;}
 
-  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;
-  
-}    
+  Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2+1e-10)) - beta2)*d*rho;
+  //
+  // suspicious part - think about it ?
+  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 
+  */
 
+  return kTRUE;            
+}     
 
 //_____________________________________________________________________________
-Int_t AliTOFtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
+Bool_t AliTOFtrack::PropagateToInnerTOF()
 {
   // 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.90000) {
-    return 0;
-  }
+  //const Double_t kAlphac  = TMath::Pi()/9.0; // 20 degree
+  const Double_t kAlphac  = AliTOFGeometry::GetAlpha(); // 20 degree
+  const Double_t kTalphac = TMath::Tan(kAlphac*0.5);
+
+  //const Double_t kStepSize = 0.1; // [cm] Step size
+  const Double_t kStepSize = 0.5; // [cm] Step size
+
+  Double_t x = GetX();
+  //Double_t bz = GetBz();
+
+  //Double_t xyz0[3];
+  //Double_t xyz1[3];
+  //Double_t y;
+  //Double_t z;
 
-  // track Length measurement [SR, GSI, 17.02.2003]
+  Int_t nsteps = (Int_t)((AliTOFGeometry::Rmin()-x)/kStepSize);
+  for (Int_t istep=0; istep<nsteps; istep++){
 
-  Double_t oldX = fX, oldY = fY, oldZ = fZ;  
+    // Critical alpha  - cross sector indication
+
+    Double_t dir = (GetX() > AliTOFGeometry::Rmin()) ? -1.0 : 1.0;
+
+    x = GetX()+dir*kStepSize;
+    if ( x<GetX() && GetX()<AliTOFGeometry::Rmin()) {
+      AliDebug(1,Form("Track doesn't reach rho=%f",AliTOFGeometry::Rmin()));
+      return kFALSE;
+    }
+
+    //GetXYZ(xyz0);
+    //bz = GetBz();
+    //GetXYZAt(x,bz,xyz1);
+    //AliExternalTrackParam::GetYAt(x,bz,y);
+    //AliExternalTrackParam::GetZAt(x,bz,z);
+ 
+    if (!(PropagateTo(x,0.,0.))) { /* passing 0.,0. as arguments since now
+				      this method queries TGeo for material budget
+				   */
+      return kFALSE;
+    }
+    
+    if (GetY() >  GetX()*kTalphac) {
+      if (!(Rotate(kAlphac))) return kFALSE;
+    } else if (GetY() < -GetX()*kTalphac) {
+      if (!(Rotate(-kAlphac))) 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;                                                     
-
-  //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;}
 
-  Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2+1e-10)) - beta2)*d*rho;
-  if (x1 < x2) dE=-dE;
-  cc=fC;
-  fC*=(1.- sqrt(p2+GetMass()*GetMass())/p2*dE);
-  fE+=fX*(fC-cc);    
+  //Bool_t check = PropagateTo(AliTOFGeometry::RinTOF());
+  Bool_t check = PropagateTo(AliTOFGeometry::RinTOF(),0.,0.); /* passing 0.,0. as arguments since now
+								 this method queries TGeo for material budget
+							      */
 
-  // 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));
+  if (!check) return kFALSE;
+
+  if (GetY() >  GetX()*kTalphac) {
+    if (!(Rotate(kAlphac))) return kFALSE;
+  } else if (GetY() < -GetX()*kTalphac) {
+    if (!(Rotate(-kAlphac))) return kFALSE;
   }
 
-  return 1;            
+  return kTRUE;
+  
 }     
 
 //_____________________________________________________________________________
-Int_t AliTOFtrack::PropagateToInnerTOF( Bool_t holes)
+Bool_t AliTOFtrack::PropagateToInnerTOFold()
 {
   // Propagates a track of particle with mass=pm to a reference plane 
   // defined by x=xk through media of density=rho and radiationLength=x0
@@ -260,160 +266,84 @@ Int_t AliTOFtrack::PropagateToInnerTOF( Bool_t holes)
 
   Double_t ymax=AliTOFGeometry::RinTOF()*TMath::Tan(0.5*AliTOFGeometry::GetAlpha());
   Bool_t skip = kFALSE;
-  Double_t y=this->GetYat(AliTOFGeometry::RinTOF(),skip);
-  if(skip){
-    return 0;
+  Double_t y=GetYat(AliTOFGeometry::RinTOF(),skip);
+  if (skip) {
+    return kFALSE;
   }
   if (y > ymax) {
-    if (!this->Rotate(AliTOFGeometry::GetAlpha())) {
-      return 0;
-    }
+    if (!Rotate(AliTOFGeometry::GetAlpha())) return kFALSE;
   } else if (y <-ymax) {
-    if (!this->Rotate(-AliTOFGeometry::GetAlpha())) {
-      return 0;
-    }
+    if (!Rotate(-AliTOFGeometry::GetAlpha())) return kFALSE;
   }
   
-  
-  Double_t x = this->GetX();
-  Int_t nsteps=Int_t((370.-x)/0.5); // 0.5 cm Steps
+  Double_t x = GetX();
+  Int_t nsteps=Int_t((AliTOFGeometry::Rmin()-x)/0.5); // 0.5 cm Steps
   for (Int_t istep=0;istep<nsteps;istep++){
     Float_t xp = x+istep*0.5; 
-    Double_t param[2];  
-    this->GetPropagationParameters(holes,param);  
-    this->PropagateTo(xp,param[0],param[1]);
+    //    GetPropagationParameters(param);  
+    if (!(PropagateTo(xp,0.,0.))) { /* passing 0.,0. as arguments since now
+				       this method queries TGeo for material budget
+				    */
+      return kFALSE;
+    }
     
   }
   
-  if(!this->PropagateTo(AliTOFGeometry::RinTOF()))return 0;
-  
-  return 1;
-  
-}     
+  if (!(PropagateTo(AliTOFGeometry::RinTOF()))) return kFALSE;
 
-//_____________________________________________________________________________
-Int_t AliTOFtrack::Rotate(Double_t alpha)
-{
-  // Rotates track parameters in R*phi plane
+  return kTRUE;
   
-
-  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) {
-    cerr<<" AliTOFtrack warning: Rotation failed !\n";
-    return 0;
-  }
-
-  if((r2*r2) > 1) return 0;
-  Double_t y0=fY + sqrt(1.- r2*r2)/fC;
-  if ((fY-y0)*fC >= 0.) {
-    cerr<<" AliTOFtrack warning: Rotation failed !!!\n";
-    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;                            
-}                         
-
-
-
-//_________________________________________________________________________
-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;            
-
-}                                
+Double_t AliTOFtrack::GetPredictedChi2(const AliCluster3D *c) const {
+  //
+  // Estimate the chi2 of the space point "c" with its cov. matrix elements
+  //
 
+  Double_t p[3]={c->GetX(), c->GetY(), c->GetZ()};
+  Double_t covyz[3]={c->GetSigmaY2(), c->GetSigmaYZ(), c->GetSigmaZ2()};
+  Double_t covxyz[3]={c->GetSigmaX2(), c->GetSigmaXY(), c->GetSigmaXZ()};
+  return AliExternalTrackParam::GetPredictedChi2(p, covyz, covxyz);
+}
 //_________________________________________________________________________
-void AliTOFtrack::ResetCovariance() {
+Bool_t AliTOFtrack::PropagateTo(const AliCluster3D *c) {
   //
-  // Resets covariance matrix
+  // Propagates a track to the plane containing cluster 'c'
   //
+  Double_t oldX=GetX(), oldY=GetY(), oldZ=GetZ();
+  Double_t p[3]={c->GetX(), c->GetY(), c->GetZ()};
+  Double_t covyz[3]={c->GetSigmaY2(), c->GetSigmaYZ(), c->GetSigmaZ2()};
+  Double_t covxyz[3]={c->GetSigmaX2(), c->GetSigmaXY(), c->GetSigmaXZ()};
+  Double_t bz=GetBz();
+  if (!AliExternalTrackParam::PropagateTo(p, covyz, covxyz, bz)) return kFALSE;
+  if (IsStartedTimeIntegral()) {
+    Double_t d = TMath::Sqrt((GetX()-oldX)*(GetX()-oldX) +
+			     (GetY()-oldY)*(GetY()-oldY) +
+			     (GetZ()-oldZ)*(GetZ()-oldZ));
+    if (GetX()<oldX) d=-d;
+    AddTimeStep(d);
 
-  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.;  
-}                                                         
+  }
 
+  if (GetY() >  GetX()*TMath::Tan(0.5*AliTOFGeometry::GetAlpha())) {
+    if (!(Rotate(AliTOFGeometry::GetAlpha()))) return kFALSE;
+  } else if (GetY() < -GetX()*TMath::Tan(0.5*AliTOFGeometry::GetAlpha())) {
+    if (!(Rotate(-AliTOFGeometry::GetAlpha()))) return kFALSE;
+  }
 
+  return kTRUE;
+}
 //_________________________________________________________________________
-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;  
-}                                                         
+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)
+//-----------------------------------------------------------------
+     Double_t y=0.;
+     skip=(!GetYAt(xk,GetBz(),y));
+     return y;
+}
 
 //_____________________________________________________________________________
 Int_t AliTOFtrack::Compare(const TObject *o) const {
@@ -428,20 +358,27 @@ Int_t AliTOFtrack::Compare(const TObject *o) const {
   return 0;
 }
 
+
 //_____________________________________________________________________________
-void AliTOFtrack::GetPropagationParameters(Bool_t holes, Double_t *param) {
+void AliTOFtrack::GetPropagationParameters(Double_t *param) {
 
+ //Get average medium density, x0 while propagating the track
 
+  //For TRD holes description
+  /*
   Double_t thetamin = (90.-31.1) * TMath::Pi()/180.;
   Double_t thetamax = (90.+31.1) * TMath::Pi()/180.;
 
   Double_t zmin = -55.;
   Double_t zmax =  55.;
+  */
 
+  // Detector inner/outer radii
   Double_t rTPC    = 261.53;
   Double_t rTPCTRD = 294.5;
   Double_t rTRD    = 369.1;
 
+  // Medium parameters
   Double_t x0TPC = 40.;
   Double_t rhoTPC =0.06124;
 
@@ -451,11 +388,11 @@ void AliTOFtrack::GetPropagationParameters(Bool_t holes, Double_t *param) {
   Double_t x0TRD = 171.7;
   Double_t rhoTRD =0.33;
 
-  Int_t isec = this->GetSector();
-  Double_t xtr,ytr,ztr;
-  this->GetGlobalXYZ(xtr,ytr,ztr);
-  Float_t thetatr = TMath::ATan2(TMath::Sqrt(xtr*xtr+ytr*ytr),ztr);
+  //  Int_t isec = GetSector();
+  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 ) {
       if( thetatr>=thetamin && thetatr<=thetamax){ 
@@ -464,20 +401,19 @@ 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;
       }
     }
   }
-
-  if(this->GetX() <= rTPC)
+  */
+  if(GetX() <= rTPC)
     {param[0]=x0TPC;param[1]=rhoTPC;}
-  else if(this->GetX() > rTPC &&  this->GetX() < rTPCTRD)
+  else if(GetX() > rTPC &&  GetX() < rTPCTRD)
     {param[0]=x0Air;param[1]=rhoAir;}
-  else if(this->GetX() >= rTPCTRD &&  this->GetX() < rTRD)
+  else if(GetX() >= rTPCTRD &&  GetX() < rTRD)
     {param[0]=x0TRD;param[1]=rhoTRD;}
-  else if(this->GetX() >= rTRD )
+  else if(GetX() >= rTRD )
     {param[0]=x0Air;param[1]=rhoAir;}
-
 }