ESD track based on AliExternalTrackParam. Class redesign and clean-up (Yu.Belikov)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 7 Feb 2006 18:37:25 +0000 (18:37 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 7 Feb 2006 18:37:25 +0000 (18:37 +0000)
12 files changed:
STEER/AliESDV0MI.cxx
STEER/AliESDtrack.cxx
STEER/AliESDtrack.h
STEER/AliExternalTrackParam.cxx
STEER/AliExternalTrackParam.h
STEER/AliHelix.cxx
STEER/AliReconstruction.cxx
STEER/AliTrackReference.cxx
STEER/AliTracker.cxx
STEER/AliTracker.h
TPC/AliTPCtrackerMI.cxx
TRD/AliTRDtrack.cxx

index 5258eb5..4d9ae02 100644 (file)
@@ -84,7 +84,7 @@ Double_t AliESDV0MI::GetSigmaY(){
   //
   const Double_t * cp  = fParamP.GetCovariance();
   const Double_t * cm  = fParamM.GetCovariance();
-  Double_t sigmay = cp[0]+cm[0]+ cp[5]*(fParamP.X()-fRr)*(fParamP.X()-fRr)+ cm[5]*(fParamM.X()-fRr)*(fParamM.X()-fRr);
+  Double_t sigmay = cp[0]+cm[0]+ cp[5]*(fParamP.GetX()-fRr)*(fParamP.GetX()-fRr)+ cm[5]*(fParamM.GetX()-fRr)*(fParamM.GetX()-fRr);
   return (sigmay>0) ? TMath::Sqrt(sigmay):100;
 }
 
@@ -94,7 +94,7 @@ Double_t AliESDV0MI::GetSigmaZ(){
   //
   const Double_t * cp  = fParamP.GetCovariance();
   const Double_t * cm  = fParamM.GetCovariance();
-  Double_t sigmaz = cp[2]+cm[2]+ cp[9]*(fParamP.X()-fRr)*(fParamP.X()-fRr)+ cm[9]*(fParamM.X()-fRr)*(fParamM.X()-fRr);
+  Double_t sigmaz = cp[2]+cm[2]+ cp[9]*(fParamP.GetX()-fRr)*(fParamP.GetX()-fRr)+ cm[9]*(fParamM.GetX()-fRr)*(fParamM.GetX()-fRr);
   return (sigmaz>0) ? TMath::Sqrt(sigmaz):100;
 }
 
@@ -110,8 +110,8 @@ Double_t AliESDV0MI::GetSigmaD0(){
   const Double_t * cp      = fParamP.GetCovariance();
   const Double_t * cm      = fParamM.GetCovariance();
   Double_t sigmaD0   = cp[0]+cm[0]+cp[2]+cm[2]+fgkParams.fPSigmaOffsetD0*fgkParams.fPSigmaOffsetD0;
-  sigmaD0           += ((fParamP.X()-fRr)*(fParamP.X()-fRr))*(cp[5]+cp[9]);
-  sigmaD0           += ((fParamM.X()-fRr)*(fParamM.X()-fRr))*(cm[5]+cm[9]);
+  sigmaD0           += ((fParamP.GetX()-fRr)*(fParamP.GetX()-fRr))*(cp[5]+cp[9]);
+  sigmaD0           += ((fParamM.GetX()-fRr)*(fParamM.GetX()-fRr))*(cm[5]+cm[9]);
   return (sigmaD0>0)? TMath::Sqrt(sigmaD0):100;
 }
 
@@ -438,7 +438,7 @@ void  AliESDV0MI::Update(Float_t vertex[3])
   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.X()-TMath::Sqrt(radius[0])<3) && TMath::Abs(fParamM.X()-TMath::Sqrt(radius[0])<3)){
+    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
@@ -461,7 +461,7 @@ void  AliESDV0MI::Update(Float_t vertex[3])
   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.X()-TMath::Sqrt(radius[1])<3) && TMath::Abs(fParamM.X()-TMath::Sqrt(radius[1])<3)){
+    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
index 9e93710..0fb1e88 100644 (file)
@@ -58,7 +58,7 @@ void SetPIDValues(Float_t * dest, const Double_t * src, Int_t n) {
 
 //_______________________________________________________________________
 AliESDtrack::AliESDtrack() : 
-  TObject(),
+  AliExternalTrackParam(),
   fFlags(0),
   fLabel(0),
   fID(0),
@@ -66,15 +66,10 @@ AliESDtrack::AliESDtrack() :
   fD(0),
   fZ(0),
   fStopVertex(0),
-  fRalpha(0),
-  fRx(0),
-  fCalpha(0),
-  fCx(0),
+  fCp(0),
   fCchi2(1e10),
-  fIalpha(0),
-  fIx(0),
-  fTalpha(0),
-  fTx(0),
+  fIp(0),
+  fOp(0),
   fITSchi2(0),
   fITSncls(0),
   fITSsignal(0),
@@ -131,21 +126,16 @@ AliESDtrack::AliESDtrack() :
   fPHOSpos[0]=fPHOSpos[1]=fPHOSpos[2]=0.;
   fEMCALpos[0]=fEMCALpos[1]=fEMCALpos[2]=0.;
   Int_t i;
-  for (i=0; i<5; i++)  { 
-    fRp[i]=fCp[i]=fIp[i]=fTp[i]=0.;
-  }
-  for (i=0; i<15; i++) { 
-    fRc[i]=fCc[i]=fIc[i]=fTc[i]=0.;  
-  }
+  for (i=0;i<12;i++) fITSchi2MIP[i] =1e10;
   for (i=0; i<6; i++)  { fITSindex[i]=0; }
   for (i=0; i<180; i++){ fTPCindex[i]=0; }
   for (i=0; i<3;i++)   { fKinkIndexes[i]=0;}
   for (i=0; i<3;i++)   { fV0Indexes[i]=-1;}
   for (i=0; i<130; i++) { fTRDindex[i]=0; }
   for (i=0;i<kNPlane;i++) {fTRDsignals[i]=0.; fTRDTimBin[i]=-1;}
-  for (Int_t i=0;i<4;i++) {fTPCPoints[i]=-1;}
-  for (Int_t i=0;i<3;i++) {fTOFLabel[i]=-1;}
-  for (Int_t i=0;i<10;i++) {fTOFInfo[i]=-1;}
+  for (i=0;i<4;i++) {fTPCPoints[i]=-1;}
+  for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
+  for (i=0;i<10;i++) {fTOFInfo[i]=-1;}
   fTPCLabel = 0;
   fTRDLabel = 0;
   fTRDQuality =0;
@@ -157,7 +147,7 @@ AliESDtrack::AliESDtrack() :
 
 //_______________________________________________________________________
 AliESDtrack::AliESDtrack(const AliESDtrack& track):
-  TObject(track),
+  AliExternalTrackParam(track),
   fFlags(track.fFlags),
   fLabel(track.fLabel),
   fID(track.fID),
@@ -165,15 +155,10 @@ AliESDtrack::AliESDtrack(const AliESDtrack& track):
   fD(track.fD),
   fZ(track.fZ),
   fStopVertex(track.fStopVertex),
-  fRalpha(track.fRalpha),
-  fRx(track.fRx),
-  fCalpha(track.fCalpha),
-  fCx(track.fCx),
+  fCp(0),
   fCchi2(track.fCchi2),
-  fIalpha(track.fIalpha),
-  fIx(track.fIx),
-  fTalpha(track.fTalpha),
-  fTx(track.fTx),
+  fIp(0),
+  fOp(0),
   fITSchi2(track.fITSchi2),
   fITSncls(track.fITSncls),
   fITSsignal(track.fITSsignal),
@@ -214,18 +199,6 @@ AliESDtrack::AliESDtrack(const AliESDtrack& track):
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] =track.fTrackTime[i];
   for (Int_t i=0;i<AliPID::kSPECIES;i++)  fR[i] =track.fR[i];
   //
-  for (Int_t i=0;i<5;i++) fRp[i] =track.fRp[i];
-  for (Int_t i=0;i<15;i++) fRc[i] =track.fRc[i];
-  //
-  for (Int_t i=0;i<5;i++) fCp[i] =track.fCp[i];
-  for (Int_t i=0;i<15;i++)  fCc[i] =track.fCc[i];
-  //
-  for (Int_t i=0;i<5;i++) fIp[i] =track.fIp[i];
-  for (Int_t i=0;i<15;i++)  fIc[i] =track.fIc[i];
-  //
-  for (Int_t i=0;i<5;i++) fTp[i] =track.fTp[i];
-  for (Int_t i=0;i<15;i++)  fTc[i] =track.fTc[i];
-  //
   for (Int_t i=0;i<12;i++) fITSchi2MIP[i] =track.fITSchi2MIP[i];
   for (Int_t i=0;i<6;i++) fITSindex[i]=track.fITSindex[i];    
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i]; 
@@ -254,6 +227,10 @@ AliESDtrack::AliESDtrack(const AliESDtrack& track):
   for (Int_t i=0;i<AliPID::kSPECIESN;i++) fEMCALr[i]=track.fEMCALr[i]; 
   //
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fRICHr[i]=track.fRICHr[i];
+
+  if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
+  if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
+  if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
 }
 //_______________________________________________________________________
 AliESDtrack::~AliESDtrack(){ 
@@ -261,6 +238,9 @@ AliESDtrack::~AliESDtrack(){
   // This is destructor according Coding Conventrions 
   //
   //printf("Delete track\n");
+  delete fIp; 
+  delete fOp;
+  delete fCp; 
   delete fITStrack;
   delete fTRDtrack; 
   delete fPoints;
@@ -286,23 +266,14 @@ void AliESDtrack::MakeMiniESDtrack(){
   fStopVertex = 0;
 
   // Reset track parameters constrained to the primary vertex
-  fCalpha = 0;
-  fCx = 0;
-  for (Int_t i=0;i<5;i++) fCp[i] = 0;
-  for (Int_t i=0;i<15;i++)  fCc[i] = 0;
+  fCp = 0;
   fCchi2 = 0;
 
   // Reset track parameters at the inner wall of TPC
-  fIalpha = 0;
-  fIx = 0;
-  for (Int_t i=0;i<5;i++) fIp[i] = 0;
-  for (Int_t i=0;i<15;i++)  fIc[i] = 0;
+  fIp = 0;
 
   // Reset track parameters at the inner wall of the TRD
-  fTalpha = 0;
-  fTx = 0;
-  for (Int_t i=0;i<5;i++) fTp[i] = 0;
-  for (Int_t i=0;i<15;i++)  fTc[i] = 0;
+  fOp = 0;
 
   // Reset ITS track related information
   fITSchi2 = 0;
@@ -399,7 +370,7 @@ Double_t AliESDtrack::GetMass() const {
 }
 
 //_______________________________________________________________________
-Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags) {
+Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
   //
   // This function updates track's running parameters 
   //
@@ -414,9 +385,7 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags) {
     SetIntegratedLength(t->GetIntegratedLength());
   }
 
-  fRalpha=t->GetAlpha();
-  t->GetExternalParameters(fRx,fRp);
-  t->GetExternalCovariance(fRc);
+  Set(*t);
 
   switch (flags) {
     
@@ -431,13 +400,9 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags) {
     
   case kTPCin: case kTPCrefit:
     fTPCLabel = t->GetLabel();
-    fIalpha=fRalpha;
-    fIx=fRx;    
-    {
-      Int_t i;
-      for (i=0; i<5; i++) fIp[i]=fRp[i];
-      for (i=0; i<15;i++) fIc[i]=fRc[i];
-    }
+    if (!fIp) fIp=new AliExternalTrackParam(*t);
+    else fIp->Set(*t);
+
   case kTPCout:
   
     fTPCncls=t->GetNumberOfClusters();
@@ -508,9 +473,8 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags) {
     fTRDsignal=t->GetPIDsignal();
     break;
   case kTRDbackup:
-    t->GetExternalParameters(fTx,fTp);
-    t->GetExternalCovariance(fTc);
-    fTalpha = t->GetAlpha();
+    if (!fOp) fOp=new AliExternalTrackParam(*t);
+    else fOp->Set(*t);
     fTRDncls0 = t->GetNumberOfClusters(); 
     break;
   case kTOFin: 
@@ -530,16 +494,11 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags) {
 //_______________________________________________________________________
 void 
 AliESDtrack::SetConstrainedTrackParams(const AliKalmanTrack *t, Double_t chi2) {
-  //
+  // 
   // This function sets the constrained track parameters 
   //
-  Int_t i;
-  Double_t x,buf[15];
-  fCalpha=t->GetAlpha();
-  t->GetExternalParameters(x,buf); fCx=x;
-  for (i=0; i<5; i++) fCp[i]=buf[i];
-  t->GetExternalCovariance(buf);
-  for (i=0; i<15; i++) fCc[i]=buf[i];
+  if (!fCp) fCp=new AliExternalTrackParam(*t);
+  else fCp->Set(*t);
   fCchi2=chi2;
 }
 
@@ -549,31 +508,8 @@ void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
   //---------------------------------------------------------------------
   // This function returns external representation of the track parameters
   //---------------------------------------------------------------------
-  x=fRx;
-  for (Int_t i=0; i<5; i++) p[i]=fRp[i];
-}
-
-//_______________________________________________________________________
-Bool_t AliESDtrack::
-GetExternalParametersAt(Double_t x, Double_t b, Double_t p[5]) const {
-  //---------------------------------------------------------------------
-  // This function returns external track parameters extrapolated to
-  // the radial position "x" (cm) in the magnetic field "b" (kG)  
-  //---------------------------------------------------------------------
-  Double_t convconst=0.299792458*b/1000.;
-  Double_t dx=x-fRx;
-  Double_t f1=fRp[2], f2=f1 + dx*fRp[4]*convconst;
-
-  if (TMath::Abs(f2) >= 0.9999) return kFALSE;
-  
-  Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
-  p[0] = fRp[0] + dx*(f1+f2)/(r1+r2);
-  p[1] = fRp[1] + dx*(f1+f2)/(f1*r2 + f2*r1)*fRp[3];
-  p[2] = f2;
-  p[3] = fRp[3];
-  p[4] = fRp[4];
-
-  return kTRUE;
+  x=GetX();
+  for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
 }
 
 //_______________________________________________________________________
@@ -581,231 +517,70 @@ void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
   //---------------------------------------------------------------------
   // This function returns external representation of the cov. matrix
   //---------------------------------------------------------------------
-  for (Int_t i=0; i<15; i++) cov[i]=fRc[i];
+  for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
 }
 
-
 //_______________________________________________________________________
 void 
 AliESDtrack::GetConstrainedExternalParameters(Double_t &x, Double_t p[5])const{
   //---------------------------------------------------------------------
   // This function returns the constrained external track parameters
   //---------------------------------------------------------------------
-  x=fCx;
-  for (Int_t i=0; i<5; i++) p[i]=fCp[i];
+  if (!fCp) return;
+  x=fCp->GetX();
+  for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
 }
+
 //_______________________________________________________________________
 void 
 AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
   //---------------------------------------------------------------------
   // This function returns the constrained external cov. matrix
   //---------------------------------------------------------------------
-  for (Int_t i=0; i<15; i++) c[i]=fCc[i];
+  if (!fCp) return;
+  for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
 }
 
-
-Double_t AliESDtrack::GetP() const {
-  //---------------------------------------------------------------------
-  // This function returns the track momentum
-  // Results for (nearly) straight tracks are meaningless !
-  //---------------------------------------------------------------------
-  if (TMath::Abs(fRp[4])<=0) return 0;
-  Double_t pt=1./TMath::Abs(fRp[4]);
-  return pt*TMath::Sqrt(1.+ fRp[3]*fRp[3]);
-}
-
-//_______________________________________________________________________
-Double_t AliESDtrack::GetD(Double_t b, Double_t x, Double_t y) const {
-  //------------------------------------------------------------------
-  // This function calculates the transverse impact parameter
-  // with respect to a point with global coordinates (x,y)
-  // in the magnetic field "b" (kG)
-  //------------------------------------------------------------------
-  Double_t convconst=0.299792458*b/1000.;
-  Double_t rp4=fRp[4]*convconst;
-
-  Double_t xt=fRx, yt=fRp[0];
-
-  Double_t sn=TMath::Sin(fRalpha), cs=TMath::Cos(fRalpha);
-  Double_t a = x*cs + y*sn;
-  y = -x*sn + y*cs; x=a;
-  xt-=x; yt-=y;
-
-  sn=rp4*xt - fRp[2]; cs=rp4*yt + TMath::Sqrt(1.- fRp[2]*fRp[2]);
-  a=2*(xt*fRp[2] - yt*TMath::Sqrt(1.- fRp[2]*fRp[2]))-rp4*(xt*xt + yt*yt);
-  if (rp4<0) a=-a;
-  return a/(1 + TMath::Sqrt(sn*sn + cs*cs));
-}
-
-Bool_t Local2GlobalMomentum(Double_t p[3],Double_t alpha) {
-  //----------------------------------------------------------------
-  // This function performs local->global transformation of the
-  // track momentum.
-  // When called, the arguments are:
-  //    p[0] = 1/pt of the track;
-  //    p[1] = sine of local azim. angle of the track momentum;
-  //    p[2] = tangent of the track momentum dip angle;
-  //   alpha - rotation angle. 
-  // The result is returned as:
-  //    p[0] = px
-  //    p[1] = py
-  //    p[2] = pz
-  // Results for (nearly) straight tracks are meaningless !
-  //----------------------------------------------------------------
-  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(alpha), sn=TMath::Sin(alpha);
-  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;
-}
-
-Bool_t Local2GlobalPosition(Double_t r[3],Double_t alpha) {
-  //----------------------------------------------------------------
-  // This function performs local->global transformation of the
-  // track position.
-  // When called, the arguments are:
-  //    r[0] = local x
-  //    r[1] = local y
-  //    r[2] = local z
-  //   alpha - rotation angle. 
-  // The result is returned as:
-  //    r[0] = global x
-  //    r[1] = global y
-  //    r[2] = global z
-  //----------------------------------------------------------------
-  Double_t cs=TMath::Cos(alpha), sn=TMath::Sin(alpha), x=r[0];
-  r[0]=x*cs - r[1]*sn; r[1]=x*sn + r[1]*cs;
-
-  return kTRUE;
-}
-
-Bool_t AliESDtrack::GetConstrainedPxPyPz(Double_t *p) const {
-  //---------------------------------------------------------------------
-  // This function returns the constrained global track momentum components
-  // Results for (nearly) straight tracks are meaningless !
-  //---------------------------------------------------------------------
-  p[0]=fCp[4]; p[1]=fCp[2]; p[2]=fCp[3];
-  return Local2GlobalMomentum(p,fCalpha);
-}  
-
-Bool_t AliESDtrack::GetConstrainedXYZ(Double_t *r) const {
-  //---------------------------------------------------------------------
-  // This function returns the constrained global track position
-  //---------------------------------------------------------------------
-  r[0]=fCx; r[1]=fCp[0]; r[2]=fCp[1];
-  return Local2GlobalPosition(r,fCalpha);
-}
-
-Bool_t AliESDtrack::GetPxPyPz(Double_t *p) const {
-  //---------------------------------------------------------------------
-  // This function returns the global track momentum components
-  // Results for (nearly) straight tracks are meaningless !
-  //---------------------------------------------------------------------
-  p[0]=fRp[4]; p[1]=fRp[2]; p[2]=fRp[3];
-  return Local2GlobalMomentum(p,fRalpha);
-}
-
-Bool_t AliESDtrack::GetXYZ(Double_t *r) const {
-  //---------------------------------------------------------------------
-  // This function returns the global track position
-  //---------------------------------------------------------------------
-  r[0]=fRx; r[1]=fRp[0]; r[2]=fRp[1];
-  return Local2GlobalPosition(r,fRalpha);
-}
-
-void AliESDtrack::GetCovariance(Double_t cv[21]) const {
-  //---------------------------------------------------------------------
-  // This function returns the global covariance matrix of the track params
-  // 
-  // Cov(x,x) ... :   cv[0]
-  // Cov(y,x) ... :   cv[1]  cv[2]
-  // Cov(z,x) ... :   cv[3]  cv[4]  cv[5]
-  // Cov(px,x)... :   cv[6]  cv[7]  cv[8]  cv[9]
-  // Cov(py,x)... :   cv[10] cv[11] cv[12] cv[13] cv[14]
-  // Cov(pz,x)... :   cv[15] cv[16] cv[17] cv[18] cv[19] cv[20]
-  //
-  // Results for (nearly) straight tracks are meaningless !
-  //---------------------------------------------------------------------
-  if (TMath::Abs(fRp[4])<=0) {
-     for (Int_t i=0; i<21; i++) cv[i]=0.;
-     return;
-  }
-  if (TMath::Abs(fRp[2]) > 0.999999) {
-     for (Int_t i=0; i<21; i++) cv[i]=0.;
-     return;
-  }
-  Double_t pt=1./TMath::Abs(fRp[4]);
-  Double_t cs=TMath::Cos(fRalpha), sn=TMath::Sin(fRalpha);
-  Double_t r=TMath::Sqrt(1-fRp[2]*fRp[2]);
-
-  Double_t m00=-sn, m10=cs;
-  Double_t m23=-pt*(sn + fRp[2]*cs/r), m43=-pt*pt*(r*cs - fRp[2]*sn);
-  Double_t m24= pt*(cs - fRp[2]*sn/r), m44=-pt*pt*(r*sn + fRp[2]*cs);
-  Double_t m35=pt, m45=-pt*pt*fRp[3];
-
-  cv[0]=fRc[0]*m00*m00;
-  cv[1]=fRc[0]*m00*m10; 
-  cv[2]=fRc[0]*m10*m10;
-  cv[3]=fRc[1]*m00; 
-  cv[4]=fRc[1]*m10; 
-  cv[5]=fRc[2];
-  cv[6]=m00*(fRc[3]*m23+fRc[10]*m43); 
-  cv[7]=m10*(fRc[3]*m23+fRc[10]*m43); 
-  cv[8]=fRc[4]*m23+fRc[11]*m43; 
-  cv[9]=m23*(fRc[5]*m23+fRc[12]*m43)+m43*(fRc[12]*m23+fRc[14]*m43);
-  cv[10]=m00*(fRc[3]*m24+fRc[10]*m44); 
-  cv[11]=m10*(fRc[3]*m24+fRc[10]*m44); 
-  cv[12]=fRc[4]*m24+fRc[11]*m44; 
-  cv[13]=m23*(fRc[5]*m24+fRc[12]*m44)+m43*(fRc[12]*m24+fRc[14]*m44);
-  cv[14]=m24*(fRc[5]*m24+fRc[12]*m44)+m44*(fRc[12]*m24+fRc[14]*m44);
-  cv[15]=m00*(fRc[6]*m35+fRc[10]*m45); 
-  cv[16]=m10*(fRc[6]*m35+fRc[10]*m45); 
-  cv[17]=fRc[7]*m35+fRc[11]*m45; 
-  cv[18]=m23*(fRc[8]*m35+fRc[12]*m45)+m43*(fRc[13]*m35+fRc[14]*m45);
-  cv[19]=m24*(fRc[8]*m35+fRc[12]*m45)+m44*(fRc[13]*m35+fRc[14]*m45); 
-  cv[20]=m35*(fRc[9]*m35+fRc[13]*m45)+m45*(fRc[13]*m35+fRc[14]*m45);
-}
-
-Bool_t AliESDtrack::GetInnerPxPyPz(Double_t *p) const {
-  //---------------------------------------------------------------------
-  // This function returns the global track momentum components
-  // af the entrance of the TPC
+void AliESDtrack::GetInnerExternalParameters(Double_t &x, Double_t p[5]) const 
+{
+ //---------------------------------------------------------------------
+  // This function returns external representation of the track parameters 
+  // at the inner layer of TPC
   //---------------------------------------------------------------------
-  p[0]=fIp[4]; p[1]=fIp[2]; p[2]=fIp[3];
-  return Local2GlobalMomentum(p,fIalpha);
+  if (!fIp) return;
+  x=fIp->GetX();
+  for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
 }
 
-Bool_t AliESDtrack::GetInnerXYZ(Double_t *r) const {
-  //---------------------------------------------------------------------
-  // This function returns the global track position
-  // af the entrance of the TPC
-  //---------------------------------------------------------------------
-  if (fIx==0) return kFALSE;
-  r[0]=fIx; r[1]=fIp[0]; r[2]=fIp[1];
-  return Local2GlobalPosition(r,fIalpha);
+void AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const
+{
+ //---------------------------------------------------------------------
+ // This function returns external representation of the cov. matrix 
+ // at the inner layer of TPC
+ //---------------------------------------------------------------------
+  if (!fIp) return;
+  for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
 }
 
-void AliESDtrack::GetInnerExternalParameters(Double_t &x, Double_t p[5]) const 
+void AliESDtrack::GetOuterExternalParameters(Double_t &x, Double_t p[5]) const 
 {
-  //skowron
  //---------------------------------------------------------------------
-  // This function returns external representation of the track parameters at Inner Layer of TPC
+  // This function returns external representation of the track parameters 
+  // at the inner layer of TRD
   //---------------------------------------------------------------------
-  x=fIx;
-  for (Int_t i=0; i<5; i++) p[i]=fIp[i];
+  if (!fOp) return;
+  x=fOp->GetX();
+  for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
 }
-void AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const
+
+void AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const
 {
- //skowron
  //---------------------------------------------------------------------
- // This function returns external representation of the cov. matrix at Inner Layer of TPC
+ // This function returns external representation of the cov. matrix 
+ // at the inner layer of TRD
  //---------------------------------------------------------------------
for (Int_t i=0; i<15; i++) cov[i]=fIc[i];
 if (!fOp) return;
+  for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
 }
 
 Int_t AliESDtrack::GetNcls(Int_t idet) const
@@ -860,47 +635,6 @@ Int_t AliESDtrack::GetClusters(Int_t idet, UInt_t *idx) const
   return ncls;
 }
 
-void  AliESDtrack::GetTRDExternalParameters(Double_t &x, Double_t&alpha, Double_t p[5], Double_t cov[15]) const
-{
-  //
-  //this function returns TRD parameters
-  //
-  x=fTx;
-  alpha = fTalpha; 
-  for (Int_t i=0; i<5; i++) p[i]=fTp[i];
-  for (Int_t i=0; i<15; i++) cov[i]=fTc[i];
-}
-
-Bool_t AliESDtrack::GetPxPyPzAt(Double_t x, Double_t b, Double_t *p) const {
-  //---------------------------------------------------------------------
-  // This function returns the global track momentum extrapolated to
-  // the radial position "x" (cm) in the magnetic field "b" (kG)
-  //---------------------------------------------------------------------
-  Double_t convconst=0.299792458*b/1000.;
-  p[0]=fRp[4]; 
-  p[1]=fRp[2]+(x-fRx)*fRp[4]*convconst; 
-  p[2]=fRp[3];
-  return Local2GlobalMomentum(p,fRalpha);
-}
-
-Bool_t AliESDtrack::GetXYZAt(Double_t x, Double_t b, Double_t *r) const {
-  //---------------------------------------------------------------------
-  // This function returns the global track position extrapolated to
-  // the radial position "x" (cm) in the magnetic field "b" (kG)
-  //---------------------------------------------------------------------
-  Double_t convconst=0.299792458*b/1000.;
-  Double_t dx=x-fRx;
-  Double_t f1=fRp[2], f2=f1 + dx*fRp[4]*convconst;
-
-  if (TMath::Abs(f2) >= 0.9999) return kFALSE;
-  
-  Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
-  r[0] = x;
-  r[1] = fRp[0] + dx*(f1+f2)/(r1+r2);
-  r[2] = fRp[1] + dx*(f1+f2)/(f1*r2 + f2*r1)*fRp[3];
-  return Local2GlobalPosition(r,fRalpha);
-}
-
 //_______________________________________________________________________
 void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
   // Returns the array with integrated times for each particle hypothesis
index 3fba245..cc8c916 100644 (file)
@@ -23,7 +23,7 @@
  *****************************************************************************/
 
 #include <TBits.h>
-#include <TObject.h>
+#include "AliExternalTrackParam.h"
 #include "AliPID.h"
 #include <TVector3.h>
 
@@ -32,7 +32,7 @@ class AliTrackPointArray;
 
 const Int_t kNPlane = 6;
 
-class AliESDtrack : public TObject {
+class AliESDtrack : public AliExternalTrackParam {
 public:
   AliESDtrack();
   AliESDtrack(const AliESDtrack& track);
@@ -52,43 +52,58 @@ public:
   ULong_t GetStatus() const {return fFlags;}
   Int_t GetLabel() const {return fLabel;}
   void SetLabel(Int_t label) {fLabel = label;}
-  Double_t GetAlpha() const {return fRalpha;}
+
   void GetExternalParameters(Double_t &x, Double_t p[5]) const;
   void GetExternalCovariance(Double_t cov[15]) const;
 
-  Bool_t GetExternalParametersAt(Double_t x, Double_t b, Double_t p[5]) const;
-  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;
-
   void GetImpactParameters(Float_t &xy,Float_t &z) const {xy=fD; z=fZ;}
-  Double_t GetD(Double_t b, Double_t x=0, Double_t y=0) const; 
   Double_t GetIntegratedLength() const {return fTrackLength;}
   void GetIntegratedTimes(Double_t *times) const;
   Double_t GetMass() const;
-  Double_t GetP() const;
-  Bool_t GetPxPyPz(Double_t *p) const;
   TVector3 P3() const {Double_t p[3]; GetPxPyPz(p); return TVector3(p[0],p[1],p[2]);} //running track momentum
-  Bool_t GetXYZ(Double_t *r) const;
   TVector3 X3() const {Double_t x[3]; GetXYZ(x); return TVector3(x[0],x[1],x[2]);}    //running track position 
-  void GetCovariance(Double_t cov[21]) const;
-  Int_t GetSign() const {return (fRp[4]>0) ? 1 : -1;} 
 
   void SetConstrainedTrackParams(const AliKalmanTrack *t, Double_t chi2);
 
-  Double_t GetConstrainedAlpha() const {return fCalpha;}
-  Double_t GetConstrainedChi2() const {return fCchi2;}
+  Double_t GetConstrainedAlpha() const {
+    if (!fCp) return 720;
+    return fCp->GetAlpha();
+  }
+  Bool_t GetConstrainedPxPyPz(Double_t *p) const {
+    if (!fCp) return kFALSE;
+    return fCp->GetPxPyPz(p);
+  }
+  Bool_t GetConstrainedXYZ(Double_t *r) const {
+    if (!fCp) return kFALSE;
+    return fCp->GetXYZ(r);
+  }
   void GetConstrainedExternalParameters(Double_t &x, Double_t p[5]) const;
   void GetConstrainedExternalCovariance(Double_t cov[15]) const;
+  Double_t GetConstrainedChi2() const {return fCchi2;}
 
-  Bool_t GetConstrainedPxPyPz(Double_t *p) const;
-  Bool_t GetConstrainedXYZ(Double_t *r) const;
 
-  Bool_t GetInnerPxPyPz(Double_t *p) const;
-  Bool_t GetInnerXYZ(Double_t *r) const;
-  void GetInnerExternalParameters(Double_t &x, Double_t p[5]) const;//skowron
-  void GetInnerExternalCovariance(Double_t cov[15]) const;//skowron
-  Double_t GetInnerAlpha() const {return fIalpha;}
+  Double_t GetInnerAlpha() const {
+    if (!fIp) return 720;
+    return fIp->GetAlpha();
+  }
+  Bool_t GetInnerPxPyPz(Double_t *p) const {
+    if (!fIp) return kFALSE;
+    return fIp->GetPxPyPz(p);
+  }
+  Bool_t GetInnerXYZ(Double_t *r) const {
+    if (!fIp) return kFALSE;
+    return fIp->GetXYZ(r);
+  }
+  void GetInnerExternalParameters(Double_t &x, Double_t p[5]) const;
+  void GetInnerExternalCovariance(Double_t cov[15]) const;
  
+  Double_t GetOuterAlpha() const {
+    if (!fOp) return 720;
+    return fOp->GetAlpha();
+  }
+  void GetOuterExternalParameters(Double_t &x, Double_t p[5]) const;
+  void GetOuterExternalCovariance(Double_t cov[15]) const;
+
   Int_t GetNcls(Int_t idet) const;
   Int_t GetClusters(Int_t idet, UInt_t *idx) const;
  
@@ -136,7 +151,8 @@ public:
   void    SetTRDpid(Int_t iSpecies, Float_t p);
   Float_t GetTRDpid(Int_t iSpecies) const;
   Int_t GetTRDLabel() const {return fTRDLabel;}
-  void GetTRDExternalParameters(Double_t &x, Double_t &alpha, Double_t p[5], Double_t cov[15]) const;//MI
+
+
   AliKalmanTrack * GetTRDtrack(){return fTRDtrack;}
 
   void SetTOFsignal(Double_t tof) {fTOFsignal=tof;}
@@ -228,34 +244,19 @@ protected:
   Float_t   fD;            // Impact parameter in XY-plane
   Float_t   fZ;            // Impact parameter in Z 
   Float_t   fTrackTime[AliPID::kSPECIES]; // TOFs estimated by the tracking
-  Float_t   fR[AliPID::kSPECIES];         // combined "detector response probability"
-
-  Int_t     fStopVertex;          // Index of stop vertex
+  Float_t   fR[AliPID::kSPECIES]; // combined "detector response probability"
 
-//Running track parameters
-  Double_t fRalpha;  // track rotation angle
-  Double_t fRx;      // X-coordinate of the track reference plane 
-  Double_t fRp[5];   // external track parameters  
-  Double_t fRc[15];  // external cov. matrix of the track parameters
+  Int_t     fStopVertex;  // Index of stop vertex
 
 //Track parameters constrained to the primary vertex
-  Double_t fCalpha;   // Track rotation angle
-  Double_t fCx;       // x-coordinate of the track reference plane
-  Double_t fCp[5];    // external track parameters
-  Double_t fCc[15];   // external cov. matrix of the track parameters
+  AliExternalTrackParam *fCp; 
   Double_t fCchi2; //chi2 at the primary vertex
 
 //Track parameters at the inner wall of the TPC
-  Double_t fIalpha;   // Track rotation angle
-  Double_t fIx;       // x-coordinate of the track reference plane
-  Double_t fIp[5];    // external track parameters
-  Double_t fIc[15];   // external cov. matrix of the track parameters
+  AliExternalTrackParam *fIp;
 
 //Track parameters at the inner wall of the TRD 
-  Double_t fTalpha;   // Track rotation angle
-  Double_t fTx;       // x-coordinate of the track reference plane
-  Double_t fTp[5];    // external track parameters
-  Double_t fTc[15];   // external cov. matrix of the track parameters
+  AliExternalTrackParam *fOp;
 
   // ITS related track information
   Float_t fITSchi2;        // chi2 in the ITS
@@ -325,7 +326,7 @@ protected:
 
   AliTrackPointArray *fPoints; // Array which contains the track space points in the global frame
 
-  ClassDef(AliESDtrack,18)  //ESDtrack 
+  ClassDef(AliESDtrack,20)  //ESDtrack 
 };
 
 #endif 
index b8ca267..f6bc241 100644 (file)
 // between different detectors.                                              //
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
-
-#include <TMath.h>
-#include <TVector3.h>
-
 #include "AliExternalTrackParam.h"
 #include "AliKalmanTrack.h"
-#include "AliTrackReference.h"
-#include "AliLog.h"
 
 ClassImp(AliExternalTrackParam)
 
-const AliMagF *AliExternalTrackParam::fgkFieldMap=0;
-Double_t AliExternalTrackParam::fgConvConst=0.;
-
-
 //_____________________________________________________________________________
 AliExternalTrackParam::AliExternalTrackParam() :
-  fMass(-1),
   fX(0),
-  fAlpha(0),
-  fLocalConvConst(0)
+  fAlpha(0)
 {
   //
   // default constructor
   //
-  for (Int_t i = 0; i < 5; i++) fParam[i] = 0;
-  for (Int_t i = 0; i < 15; i++) fCovar[i] = 0;
+  for (Int_t i = 0; i < 5; i++) fP[i] = 0;
+  for (Int_t i = 0; i < 15; i++) fC[i] = 0;
 }
 
 //_____________________________________________________________________________
 AliExternalTrackParam::AliExternalTrackParam(Double_t x, Double_t alpha, 
                                             const Double_t param[5], 
                                             const Double_t covar[15]) :
-  fMass(-1),
   fX(x),
-  fAlpha(alpha),
-  fLocalConvConst(0)
+  fAlpha(alpha)
 {
   //
   // create external track parameters from given arguments
   //
-  for (Int_t i = 0; i < 5; i++) fParam[i] = param[i];
-  for (Int_t i = 0; i < 15; i++) fCovar[i] = covar[i];
+  for (Int_t i = 0; i < 5; i++)  fP[i] = param[i];
+  for (Int_t i = 0; i < 15; i++) fC[i] = covar[i];
 }
 
 //_____________________________________________________________________________
 AliExternalTrackParam::AliExternalTrackParam(const AliKalmanTrack& track) :
-  fMass(track.GetMass()),
-  fX(0),
-  fAlpha(track.GetAlpha()),
-  fLocalConvConst(0)
+  fAlpha(track.GetAlpha())
 {
   //
   //
-  track.GetExternalParameters(fX,fParam);
-  track.GetExternalCovariance(fCovar);
-  SaveLocalConvConst();
+  track.GetExternalParameters(fX,fP);
+  track.GetExternalCovariance(fC);
 }
 
-
-
 //_____________________________________________________________________________
-const Double_t* AliExternalTrackParam::GetParameter() const
-{
-// get a pointer to the array of track parameters
-
-  return fParam;
+void AliExternalTrackParam::Set(const AliKalmanTrack& track) {
+  //
+  //
+  fAlpha=track.GetAlpha();
+  track.GetExternalParameters(fX,fP);
+  track.GetExternalCovariance(fC);
 }
 
 //_____________________________________________________________________________
-const Double_t* AliExternalTrackParam::GetCovariance() const
-{
-// get a pointer to the array of the track parameter covariance matrix
-
-  return fCovar;
+void AliExternalTrackParam::Reset() {
+  fX=fAlpha=0.;
+  for (Int_t i = 0; i < 5; i++) fP[i] = 0;
+  for (Int_t i = 0; i < 15; i++) fC[i] = 0;
 }
 
-//_____________________________________________________________________________
-AliExternalTrackParam* AliExternalTrackParam::CreateExternalParam() const
-{
-// copy this instance
-
-  return new AliExternalTrackParam(fX, fAlpha, fParam, fCovar);
+Double_t AliExternalTrackParam::GetP() const {
+  //---------------------------------------------------------------------
+  // This function returns the track momentum
+  // Results for (nearly) straight tracks are meaningless !
+  //---------------------------------------------------------------------
+  if (TMath::Abs(fP[4])<=0) return 0;
+  return TMath::Sqrt(1.+ fP[3]*fP[3])/TMath::Abs(fP[4]);
 }
 
-//_____________________________________________________________________________
-void AliExternalTrackParam::ResetCovariance(Double_t factor,
-                                           Bool_t clearOffDiagonal)
-{
-// reset the covariance matrix ("forget" track history)
-
-  Int_t k = 0;
-  for (Int_t i = 0; i < 5; i++) {
-    for (Int_t j = 0; j < i; j++) {  // off diagonal elements
-      if (clearOffDiagonal) {
-       fCovar[k++] = 0;
-      } else {
-       fCovar[k++] *= factor;
-      }
-    }
-    fCovar[k++] *= factor;     // diagonal elements
-  }
+//_______________________________________________________________________
+Double_t AliExternalTrackParam::GetD(Double_t b,Double_t x,Double_t y) const {
+  //------------------------------------------------------------------
+  // This function calculates the transverse impact parameter
+  // with respect to a point with global coordinates (x,y)
+  // in the magnetic field "b" (kG)
+  //------------------------------------------------------------------
+  Double_t convconst=0.299792458*b/1000.;
+  Double_t rp4=fP[4]*convconst;
+
+  Double_t xt=fX, yt=fP[0];
+
+  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=rp4*xt - fP[2]; cs=rp4*yt + TMath::Sqrt(1.- fP[2]*fP[2]);
+  a=2*(xt*fP[2] - yt*TMath::Sqrt(1.- fP[2]*fP[2]))-rp4*(xt*xt + yt*yt);
+  if (rp4<0) a=-a;
+  return a/(1 + TMath::Sqrt(sn*sn + cs*cs));
 }
 
-
-//_____________________________________________________________________________
-Bool_t AliExternalTrackParam::PropagateTo(Double_t xk, Double_t x0, Double_t rho)
-{
-  //
-  // Propagate the track parameters to the given x coordinate assuming vacuum.
-  // If length is not NULL, the change of track length is added to it.
-  //
-  
-  Double_t lcc=GetLocalConvConst();  
-  Double_t cur = fParam[4]/lcc;
-  Double_t x1=fX, x2=xk, dx=x2-x1;
-  Double_t f1=fParam[2], f2=f1 + cur*dx;
-  if (TMath::Abs(f2) >= 0.98) {
-    // MI change  - don't propagate highly inclined tracks
-    //              covariance matrix distorted
-    return kFALSE;
-  }
-
-  // old position [SR, GSI, 17.02.2003]
-  Double_t oldX = fX, oldY = fParam[0], oldZ = fParam[1];
-  Double_t r1=sqrt(1.- f1*f1), r2=sqrt(1.- f2*f2);  
-  fParam[0] += dx*(f1+f2)/(r1+r2);
-  fParam[1] += dx*(f1+f2)/(f1*r2 + f2*r1)*fParam[3];
-  fParam[2] += dx*cur;
-  // transform error matrix to the curvature
-  fCovar[10]/=lcc;
-  fCovar[11]/=lcc;
-  fCovar[12]/=lcc;
-  fCovar[13]/=lcc;
-  fCovar[14]/=lcc*lcc;
-
-  //f = F - 1
-  
-  Double_t f02=    dx/(r1*r1*r1);
-  Double_t f04=0.5*dx*dx/(r1*r1*r1);
-  Double_t f12=    dx*fParam[3]*f1/(r1*r1*r1);
-  Double_t f14=0.5*dx*dx*fParam[3]*f1/(r1*r1*r1);
-  Double_t f13=    dx/r1;
-  Double_t f24=    dx; 
-  
-  //b = C*ft
-  Double_t b00=f02*fCovar[3] + f04*fCovar[10], b01=f12*fCovar[3] + f14*fCovar[10] + f13*fCovar[6];
-  Double_t b02=f24*fCovar[10];
-  Double_t b10=f02*fCovar[4] + f04*fCovar[11], b11=f12*fCovar[4] + f14*fCovar[11] + f13*fCovar[7];
-  Double_t b12=f24*fCovar[11];
-  Double_t b20=f02*fCovar[5] + f04*fCovar[12], b21=f12*fCovar[5] + f14*fCovar[12] + f13*fCovar[8];
-  Double_t b22=f24*fCovar[12];
-  Double_t b40=f02*fCovar[12] + f04*fCovar[14], b41=f12*fCovar[12] + f14*fCovar[14] + f13*fCovar[13];
-  Double_t b42=f24*fCovar[14];
-  Double_t b30=f02*fCovar[8] + f04*fCovar[13], b31=f12*fCovar[8] + f14*fCovar[13] + f13*fCovar[9];
-  Double_t b32=f24*fCovar[13];
-  
-  //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)
-  fCovar[0] += b00 + b00 + a00;
-  fCovar[1] += b10 + b01 + a01; 
-  fCovar[2] += b11 + b11 + a11;
-  fCovar[3] += b20 + b02 + a02;
-  fCovar[4] += b21 + b12 + a12;
-  fCovar[5] += b22 + b22 + a22;
-  fCovar[6] += b30;
-  fCovar[7] += b31; 
-  fCovar[8] += b32;
-  fCovar[10] += b40;
-  fCovar[11] += b41;
-  fCovar[12] += b42;
-
-  fX=x2;
-
-  //Change of the magnetic field *************
-  SaveLocalConvConst();
-  // transform back error matrix from curvature to the 1/pt
-  fCovar[10]*=lcc;
-  fCovar[11]*=lcc;
-  fCovar[12]*=lcc;
-  fCovar[13]*=lcc;
-  fCovar[14]*=lcc*lcc;
-
-  Double_t dist = TMath::Sqrt((fX-oldX)*(fX-oldX)+(fParam[0]-oldY)*(fParam[0]-oldY)+
-                             (fParam[1]-oldZ)*(fParam[1]-oldZ));
-  if (!CorrectForMaterial(dist,x0,rho)) return 0;
-
-  // Integrated Time [SR, GSI, 17.02.2003]
- //  if (IsStartedTimeIntegral() && fX>oldX) {
-//     Double_t l2 = (fX-oldX)*(fX-oldX)+(fParam[0]-oldY)*(fParam[0]-oldY)+
-//                   (fParam[1]-oldZ)*(fParam[1]-oldZ);
-//     AddTimeStep(TMath::Sqrt(l2));
-//   }
-  //
+Bool_t Local2GlobalMomentum(Double_t p[3],Double_t alpha) {
+  //----------------------------------------------------------------
+  // This function performs local->global transformation of the
+  // track momentum.
+  // When called, the arguments are:
+  //    p[0] = 1/pt of the track;
+  //    p[1] = sine of local azim. angle of the track momentum;
+  //    p[2] = tangent of the track momentum dip angle;
+  //   alpha - rotation angle. 
+  // The result is returned as:
+  //    p[0] = px
+  //    p[1] = py
+  //    p[2] = pz
+  // Results for (nearly) straight tracks are meaningless !
+  //----------------------------------------------------------------
+  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(alpha), sn=TMath::Sin(alpha);
+  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;
 }
 
-Bool_t     AliExternalTrackParam::PropagateToDCA(Double_t xd, Double_t yd,  Double_t x0, Double_t rho){
-  //
-  // Propagate the track parameters to the nearest point of given xv yv coordinate
-  //
-  Double_t a=fAlpha;
-  Double_t cs=TMath::Cos(a),sn=TMath::Sin(a);
-
-  Double_t xv= xd*cs + yd*sn;
-  Double_t yv=-xd*sn + yd*cs;   // vertex position in local frame
-  //  
-  Double_t c=fParam[4]/GetLocalConvConst(), snp=fParam[2];
-  //
-  Double_t x=fX, y=fParam[1];
-  Double_t tgfv=-(c*(x-xv)-snp)/(c*(y-yv) + TMath::Sqrt(1.-snp*snp));
-  Double_t fv=TMath::ATan(tgfv);
-  cs=TMath::Cos(fv); sn=TMath::Sin(fv);
-  x = xv*cs + yv*sn;
-  yv=-xv*sn + yv*cs; xv=x;
-  RotateTo(fv+a);
-  return PropagateTo(xv,x0,rho);  
-}
-
+Bool_t Local2GlobalPosition(Double_t r[3],Double_t alpha) {
+  //----------------------------------------------------------------
+  // This function performs local->global transformation of the
+  // track position.
+  // When called, the arguments are:
+  //    r[0] = local x
+  //    r[1] = local y
+  //    r[2] = local z
+  //   alpha - rotation angle. 
+  // The result is returned as:
+  //    r[0] = global x
+  //    r[1] = global y
+  //    r[2] = global z
+  //----------------------------------------------------------------
+  Double_t cs=TMath::Cos(alpha), sn=TMath::Sin(alpha), x=r[0];
+  r[0]=x*cs - r[1]*sn; r[1]=x*sn + r[1]*cs;
 
-//_____________________________________________________________________________
-Bool_t AliExternalTrackParam::RotateTo(Double_t alp)
-{
-  // Rotate the reference axis for the parametrisation to the given angle.
-  //
-  Double_t  x=fX;
-  Double_t p0=fParam[0];
-  //
-  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=fParam[2], cf=TMath::Sqrt(1.- fParam[2]*fParam[2]);
-  // **** rotation **********************
-  
-  fAlpha = alp;
-  fX =  x*ca + p0*sa;
-  fParam[0]= -x*sa + p0*ca;
-  fParam[2]=  sf*ca - cf*sa;
-  Double_t rr=(ca+sf/cf*sa);  
-  //
-  fCovar[0] *= (ca*ca);
-  fCovar[1] *= ca; 
-  fCovar[3] *= ca*rr;
-  fCovar[6] *= ca;
-  fCovar[10] *= ca;
-  fCovar[4] *= rr;
-  fCovar[5] *= rr*rr;
-  fCovar[7] *= rr;
-  fCovar[11] *= rr;
   return kTRUE;
 }
 
-//_____________________________________________________________________________
-Bool_t AliExternalTrackParam::CorrectForMaterial(Double_t d, Double_t x0, Double_t rho)
-{
-  //
-  // Take into account material effects assuming:
-  // x0  - mean rad length
-  // rho - mean density
-
-  //
-  // multiple scattering
-  //
-  if (fMass<=0) {
-    AliError("Non-positive mass");
-    return kFALSE;
-  }
-  Double_t p2=(1.+ fParam[3]*fParam[3])/(fParam[4]*fParam[4]);
-  Double_t beta2=p2/(p2 + fMass*fMass);
-  Double_t theta2=14.1*14.1/(beta2*p2*1e6)*d/x0*rho;
-  //
-  fCovar[5] += theta2*(1.- fParam[2]*fParam[2])*(1. + fParam[3]*fParam[3]);
-  fCovar[9] += theta2*(1. + fParam[3]*fParam[3])*(1. + fParam[3]*fParam[3]);
-  fCovar[13] += theta2*fParam[3]*fParam[4]*(1. + fParam[3]*fParam[3]);
-  fCovar[14] += theta2*fParam[3]*fParam[4]*fParam[3]*fParam[4];
-  
-  Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2+1e-10)) - beta2)*d*rho;  
-  fParam[4] *=(1.- TMath::Sqrt(p2+fMass*fMass)/p2*dE);
-  //
-  Double_t sigmade = 0.02*TMath::Sqrt(TMath::Abs(dE));   // energy loss fluctuation 
-  Double_t sigmac2 = sigmade*sigmade*fParam[4]*fParam[4]*(p2+fMass*fMass)/(p2*p2);
-  fCovar[14] += sigmac2;
-  //
-  //
-  
-
+Bool_t AliExternalTrackParam::GetPxPyPz(Double_t *p) const {
+  //---------------------------------------------------------------------
+  // This function returns the global track momentum components
+  // Results for (nearly) straight tracks are meaningless !
+  //---------------------------------------------------------------------
+  p[0]=fP[4]; p[1]=fP[2]; p[2]=fP[3];
+  return Local2GlobalMomentum(p,fAlpha);
+}
 
-  return kTRUE;
+Bool_t AliExternalTrackParam::GetXYZ(Double_t *r) const {
+  //---------------------------------------------------------------------
+  // This function returns the global track position
+  //---------------------------------------------------------------------
+  r[0]=fX; r[1]=fP[0]; r[2]=fP[1];
+  return Local2GlobalPosition(r,fAlpha);
 }
 
-//_____________________________________________________________________________
-Bool_t AliExternalTrackParam::GetProlongationAt(Double_t xk, 
-                                               Double_t& y, 
-                                               Double_t& z) const
-{
-  //
-  // Get the local y and z coordinates at the given x value
+Bool_t AliExternalTrackParam::GetCovarianceXYZPxPyPz(Double_t cv[21]) const {
+  //---------------------------------------------------------------------
+  // This function returns the global covariance matrix of the track params
+  // 
+  // Cov(x,x) ... :   cv[0]
+  // Cov(y,x) ... :   cv[1]  cv[2]
+  // Cov(z,x) ... :   cv[3]  cv[4]  cv[5]
+  // Cov(px,x)... :   cv[6]  cv[7]  cv[8]  cv[9]
+  // Cov(py,x)... :   cv[10] cv[11] cv[12] cv[13] cv[14]
+  // Cov(pz,x)... :   cv[15] cv[16] cv[17] cv[18] cv[19] cv[20]
   //
-  Double_t lcc=GetLocalConvConst();  
-  Double_t cur = fParam[4]/lcc;
-  Double_t x1=fX, x2=xk, dx=x2-x1; 
-  Double_t f1=fParam[2], f2=f1 + cur*dx;
-  //  
-  if (TMath::Abs(f2) >= 0.98) {
-    // MI change  - don't propagate highly inclined tracks
-    //              covariance matrix distorted
-    return kFALSE;
+  // Results for (nearly) straight tracks are meaningless !
+  //---------------------------------------------------------------------
+  if (TMath::Abs(fP[4])<=0) {
+     for (Int_t i=0; i<21; i++) cv[i]=0.;
+     return kFALSE;
   }
-  Double_t r1=sqrt(1.- f1*f1), r2=sqrt(1.- f2*f2);
-  y = fParam[0] + dx*(f1+f2)/(r1+r2);
-  z = fParam[1] + dx*(f1+f2)/(f1*r2 + f2*r1)*fParam[3];
-  return kTRUE;
-}
-
-//_____________________________________________________________________________
-Double_t AliExternalTrackParam::GetXAtVertex(Double_t /*x*/, 
-                                            Double_t /*y*/) const
-{
-// Get the x coordinate at the given vertex (x,y)
-//
-// NOT IMPLEMENTED for this class
-
-  return 0;
-}
-
-
-// //_____________________________________________________________________________
-// Double_t AliExternalTrackParam::GetPredictedChi2(const AliCluster* /*cluster*/)
-// {
-// // calculate the chi2 contribution of the given cluster
-// //
-// // NOT IMPLEMENTED for this class
-
-//   return -1;
-// }
-
-// //_____________________________________________________________________________
-// Bool_t AliExternalTrackParam::Update(const AliCluster* /*cluster*/)
-// {
-// // update the track parameters using the position and error 
-// // of the given cluster
-// //
-// // NOT IMPLEMENTED for this class
-
-//   return kFALSE;
-// }
-
-
-//_____________________________________________________________________________
-Double_t AliExternalTrackParam::SigmaPhi() const
-{
-// get the error of the azimuthal angle
-
-  return TMath::Sqrt(TMath::Abs(fCovar[5] / (1. - fParam[2]*fParam[2])));
-}
-
-//_____________________________________________________________________________
-Double_t AliExternalTrackParam::SigmaTheta() const
-{
-// get the error of the polar angle
-
-  return TMath::Sqrt(TMath::Abs(fCovar[9])) / (1. + fParam[3]*fParam[3]);
-}
-
-//_____________________________________________________________________________
-Double_t AliExternalTrackParam::SigmaPt() const
-{
-// get the error of the transversal component of the momentum
+  if (TMath::Abs(fP[2]) > 0.999999) {
+     for (Int_t i=0; i<21; i++) cv[i]=0.;
+     return kFALSE;
+  }
+  Double_t pt=1./TMath::Abs(fP[4]);
+  Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
+  Double_t r=TMath::Sqrt(1-fP[2]*fP[2]);
+
+  Double_t m00=-sn, m10=cs;
+  Double_t m23=-pt*(sn + fP[2]*cs/r), m43=-pt*pt*(r*cs - fP[2]*sn);
+  Double_t m24= pt*(cs - fP[2]*sn/r), m44=-pt*pt*(r*sn + fP[2]*cs);
+  Double_t m35=pt, m45=-pt*pt*fP[3];
+
+  cv[0 ] = fC[0]*m00*m00;
+  cv[1 ] = fC[0]*m00*m10; 
+  cv[2 ] = fC[0]*m10*m10;
+  cv[3 ] = fC[1]*m00; 
+  cv[4 ] = fC[1]*m10; 
+  cv[5 ] = fC[2];
+  cv[6 ] = m00*(fC[3]*m23 + fC[10]*m43); 
+  cv[7 ] = m10*(fC[3]*m23 + fC[10]*m43); 
+  cv[8 ] = fC[4]*m23 + fC[11]*m43; 
+  cv[9 ] = m23*(fC[5]*m23 + fC[12]*m43)  +  m43*(fC[12]*m23 + fC[14]*m43);
+  cv[10] = m00*(fC[3]*m24 + fC[10]*m44); 
+  cv[11] = m10*(fC[3]*m24 + fC[10]*m44); 
+  cv[12] = fC[4]*m24 + fC[11]*m44; 
+  cv[13] = m23*(fC[5]*m24 + fC[12]*m44)  +  m43*(fC[12]*m24 + fC[14]*m44);
+  cv[14] = m24*(fC[5]*m24 + fC[12]*m44)  +  m44*(fC[12]*m24 + fC[14]*m44);
+  cv[15] = m00*(fC[6]*m35 + fC[10]*m45); 
+  cv[16] = m10*(fC[6]*m35 + fC[10]*m45); 
+  cv[17] = fC[7]*m35 + fC[11]*m45; 
+  cv[18] = m23*(fC[8]*m35 + fC[12]*m45)  +  m43*(fC[13]*m35 + fC[14]*m45);
+  cv[19] = m24*(fC[8]*m35 + fC[12]*m45)  +  m44*(fC[13]*m35 + fC[14]*m45); 
+  cv[20] = m35*(fC[9]*m35 + fC[13]*m45)  +  m45*(fC[13]*m35 + fC[14]*m45);
 
-  return TMath::Sqrt(fCovar[14]) / TMath::Abs(fParam[4]);
+  return kTRUE;
 }
 
-//_____________________________________________________________________________
-TVector3 AliExternalTrackParam::Momentum() const
-{
-// get the momentum vector
 
-  Double_t phi = TMath::ASin(fParam[2]) + fAlpha;
-  Double_t pt = 1. / TMath::Abs(fParam[4]);
-  return TVector3(pt * TMath::Cos(phi), 
-                 pt * TMath::Sin(phi), 
-                 pt * fParam[3]);
+Bool_t 
+AliExternalTrackParam::GetPxPyPzAt(Double_t x, Double_t b, Double_t *p) const {
+  //---------------------------------------------------------------------
+  // This function returns the global track momentum extrapolated to
+  // the radial position "x" (cm) in the magnetic field "b" (kG)
+  //---------------------------------------------------------------------
+  Double_t convconst=0.299792458*b/1000.;
+  p[0]=fP[4]; 
+  p[1]=fP[2]+(x-fX)*fP[4]*convconst; 
+  p[2]=fP[3];
+  return Local2GlobalMomentum(p,fAlpha);
 }
 
-//_____________________________________________________________________________
-TVector3 AliExternalTrackParam::Position() const
-{
-// get the current spatial position in global coordinates
-
-  return TVector3(fX * TMath::Cos(fAlpha) - fParam[0] * TMath::Sin(fAlpha),
-                 fX * TMath::Sin(fAlpha) + fParam[0] * TMath::Cos(fAlpha),
-                 fParam[1]);
+Bool_t 
+AliExternalTrackParam::GetXYZAt(Double_t x, Double_t b, Double_t *r) const {
+  //---------------------------------------------------------------------
+  // This function returns the global track position extrapolated to
+  // the radial position "x" (cm) in the magnetic field "b" (kG)
+  //---------------------------------------------------------------------
+  Double_t convconst=0.299792458*b/1000.;
+  Double_t dx=x-fX;
+  Double_t f1=fP[2], f2=f1 + dx*fP[4]*convconst;
+
+  if (TMath::Abs(f2) >= 0.9999) return kFALSE;
+  
+  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*(f1+f2)/(f1*r2 + f2*r1)*fP[3];
+  return Local2GlobalPosition(r,fAlpha);
 }
 
 
@@ -439,12 +280,12 @@ void AliExternalTrackParam::Print(Option_t* /*option*/) const
 
   printf("AliExternalTrackParam: x = %-12g  alpha = %-12g\n", fX, fAlpha);
   printf("  parameters: %12g %12g %12g %12g %12g\n",
-        fParam[0], fParam[1], fParam[2], fParam[3], fParam[4]);
-  printf("  covariance: %12g\n", fCovar[0]);
-  printf("              %12g %12g\n", fCovar[1], fCovar[2]);
-  printf("              %12g %12g %12g\n", fCovar[3], fCovar[4], fCovar[5]);
+        fP[0], fP[1], fP[2], fP[3], fP[4]);
+  printf("  covariance: %12g\n", fC[0]);
+  printf("              %12g %12g\n", fC[1], fC[2]);
+  printf("              %12g %12g %12g\n", fC[3], fC[4], fC[5]);
   printf("              %12g %12g %12g %12g\n", 
-        fCovar[6], fCovar[7], fCovar[8], fCovar[9]);
+        fC[6], fC[7], fC[8], fC[9]);
   printf("              %12g %12g %12g %12g %12g\n", 
-        fCovar[10], fCovar[11], fCovar[12], fCovar[13], fCovar[14]);
+        fC[10], fC[11], fC[12], fC[13], fC[14]);
 }
index 1548935..b262506 100644 (file)
@@ -7,8 +7,6 @@
 
 
 #include "TObject.h"
-#include "AliMagF.h"
-#include "TVector3.h"
 
 class AliKalmanTrack;
 
@@ -19,106 +17,31 @@ class AliExternalTrackParam: public TObject {
                        const Double_t param[5], const Double_t covar[15]);
   AliExternalTrackParam(const AliKalmanTrack& track);
 
-  virtual void SetMass(Double_t mass) {fMass=mass;}
-  virtual Double_t GetMass() const {return fMass;}
-
-  virtual const Double_t* GetParameter() const;
-  virtual const Double_t* GetCovariance() const;
-  virtual Double_t     X() const {return fX;};
-  virtual Double_t     Alpha() const {return fAlpha;};
-  virtual AliExternalTrackParam* CreateExternalParam() const;
-  virtual void         ResetCovariance(Double_t factor = 10.,
-                                      Bool_t clearOffDiagonal = kTRUE);
-  virtual Double_t     Y() const {return fParam[0];};
-  virtual Double_t     Z() const {return fParam[1];};
-  virtual void         GetXYZ(Float_t r[3]) const;
-  virtual void         GetGlobalXYZ(Double_t &x, Double_t &y, Double_t &z ) const;
-  virtual Bool_t       PropagateTo(Double_t x,  Double_t x0, Double_t rho);
-  virtual Bool_t       PropagateToDCA(Double_t x, Double_t y,  Double_t x0, Double_t rho);
-  virtual Bool_t       RotateTo(Double_t alpha);
-  virtual Bool_t       CorrectForMaterial(Double_t d, Double_t x0, Double_t rho);
-  virtual Bool_t       GetProlongationAt(Double_t x, Double_t& y, 
-                                        Double_t& z) const;
-  virtual Double_t     GetXAtVertex(Double_t x = 0, Double_t y = 0) const;
-
-  //  virtual Double_t     GetPredictedChi2(const AliCluster* cluster);
-  //  virtual Bool_t       Update(const AliCluster* cluster);
-
-  virtual Double_t     SigmaPhi() const;
-  virtual Double_t     SigmaTheta() const;
-  virtual Double_t     SigmaPt() const;
-  virtual TVector3     Momentum() const;
-  virtual TVector3     Position() const;
-
-  virtual void         Print(Option_t* option = "") const;
-  // local magnetic field manipulation 
-  void     SaveLocalConvConst();
-  Double_t GetLocalConvConst() const;
-  
-  static void SetFieldMap(const AliMagF *map) { fgkFieldMap=map; }
-  static const AliMagF *GetFieldMap() { return fgkFieldMap; }
-
-  static void SetUniformFieldTracking() {
-     if (fgkFieldMap==0) {
-        printf("AliKalmanTrack: Field map has not been set !\n"); 
-        exit(1);
-     } 
-     fgConvConst=1000/0.299792458/(fgkFieldMap->SolenoidField()+1e-13);
-  }
-  static void SetNonuniformFieldTracking() { fgConvConst=0.; }
-
- private:
-  Double_t             fMass;       // mass associated to the particle
-  Double_t             fX;          // x coordinate for the parametrisation
-  Double_t             fAlpha;      // azimuthal angle for the parametrisation
-  Double_t             fParam[5];   // track parameter (y, z, sin(azimuthal angel), tan(dip angle), 1/pt)
-  Double_t             fCovar[15];  // track parameter covariance
-  //
-  static const AliMagF *fgkFieldMap;//pointer to the magnetic field map
-  static Double_t fgConvConst;      //conversion "curvature(1/cm) -> pt(GeV/c)"
-  Double_t fLocalConvConst;         //local conversion "curvature(1/cm) -> pt(GeV/c)"
-
-
-  ClassDef(AliExternalTrackParam, 3)
+  void Reset();
+  void Set(const AliKalmanTrack& track);
+
+  const Double_t* GetParameter() const {return fP;}
+  const Double_t* GetCovariance() const {return fC;}
+  virtual Double_t GetX() const {return fX;}
+  virtual Double_t GetAlpha() const {return fAlpha;}
+  Double_t GetSign() const {return (fP[4]>0) ? 1 : -1;}
+  Double_t GetP() const;
+  Double_t GetD(Double_t b, Double_t x=0, Double_t y=0) const; 
+  Bool_t GetPxPyPz(Double_t *p) const;
+  Bool_t GetXYZ(Double_t *p) const;
+  Bool_t GetCovarianceXYZPxPyPz(Double_t cv[21]) const;
+  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;
+
+  void Print(Option_t* option = "") const;
+
+private:
+  Double_t             fX;      // x coordinate for the parametrisation
+  Double_t             fAlpha;  // azimuthal angle for the parametrisation
+  Double_t             fP[5];   // track parameter (y, z, sin(azimuthal angel), tan(dip angle), 1/pt)
+  Double_t             fC[15];  // track parameter covariance
+
+  ClassDef(AliExternalTrackParam, 4)
 };
 
-
-inline void AliExternalTrackParam::SaveLocalConvConst() {
-  //---------------------------------------------------------------------
-  // Saves local conversion constant "curvature (1/cm) -> pt (GeV/c)" 
-  //---------------------------------------------------------------------
-     if (fgConvConst > 0 || fgConvConst < 0) return; //uniform field tracking
-     Float_t r[3]={0.,0.,0.}; GetXYZ(r);
-     Float_t b[3]; fgkFieldMap->Field(r,b);
-     fLocalConvConst=1000/0.299792458/(1e-13 - b[2]);
-} 
-
-inline Double_t AliExternalTrackParam::GetLocalConvConst() const {
-  //---------------------------------------------------------------------
-  // Returns conversion constant "curvature (1/cm) -> pt (GeV/c)" 
-  //---------------------------------------------------------------------
-     if (fgConvConst > 0 || fgConvConst < 0) return fgConvConst; //uniform field tracking
-     return fLocalConvConst;
-} 
-
-
-inline void AliExternalTrackParam::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 - fParam[0]*sn; r[1]=fX*sn + fParam[0]*cs; r[2]=fParam[1];
-}
-
-inline void AliExternalTrackParam::GetGlobalXYZ(Double_t &x, Double_t &y, Double_t &z) const {
-  //---------------------------------------------------------------------
-  // Returns the position of the track in the global coord. system 
-  //---------------------------------------------------------------------
-  Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
-  x=fX*cs - fParam[0]*sn; y=fX*sn + fParam[0]*cs; z=fParam[1];
-}
-
-
-
-
 #endif
index dc9c65b..3a5bd52 100644 (file)
@@ -88,8 +88,8 @@ AliHelix::AliHelix(const AliExternalTrackParam &t)
   Double_t alpha,x,cs,sn;
   const Double_t *param =t.GetParameter(); 
   for (Int_t i=0;i<5;i++) fHelix[i]=param[i]; 
-  x = t.X();
-  alpha=t.Alpha();
+  x = t.GetX();
+  alpha=t.GetAlpha();
   //
   //circle parameters
   fHelix[4]=fHelix[4]/AliKalmanTrack::GetConvConst();    // C
index 4d11ded..2424ed3 100644 (file)
 #include "AliGenEventHeader.h"
 #include "AliPID.h"
 #include "AliESDpid.h"
-//#include "AliMagF.h"
-
-
 
 #include "AliRunTag.h"
 //#include "AliLHCTag.h"
@@ -917,11 +914,6 @@ Bool_t AliReconstruction::InitRunLoader()
       if (fRunLoader->LoadgAlice() == 0) {
        gAlice = fRunLoader->GetAliRun();
        AliTracker::SetFieldMap(gAlice->Field(),fUniformField);
-       AliExternalTrackParam::SetFieldMap(gAlice->Field());
-       if(fUniformField)
-         AliExternalTrackParam::SetUniformFieldTracking();
-       else
-         AliExternalTrackParam::SetNonuniformFieldTracking();
       }
     }
     if (!gAlice && !fRawReader) {
index 870cde8..ba9d83a 100644 (file)
@@ -125,23 +125,14 @@ AliExternalTrackParam * AliTrackReference::MakeTrack(const AliTrackReference *re
   xx[0] = 0;
   xx[1] = z;
   xx[3] = ref->Pz()/ref->Pt();
-  Float_t b[3];
-  Float_t xyz[3]={x,y,z};
-  Float_t convConst = 0;
-  (AliKalmanTrack::GetFieldMap())->Field(xyz,b);
-  convConst=1000/0.299792458/(1e-13 - b[2]);
-  xx[4] = 1./(convConst*ref->Pt()); // curvature rpresentation
+  xx[4] = 1./ref->Pt(); 
   if (mass<0) xx[4]*=-1.;  // negative mass - negative direction
   Double_t alphap = TMath::ATan2(ref->Py(),ref->Px())-alpha;
   if (alphap> TMath::Pi()) alphap-=TMath::Pi();
   if (alphap<-TMath::Pi()) alphap+=TMath::Pi();
   xx[2] = TMath::Sin(alphap);
-  xx[4]*=convConst;   // 1/pt representation 
-  //  AliExternalTrackParam * track = new  AliExternalTrackParam(xx,cc,xr,alpha);
+
   AliExternalTrackParam * track = new  AliExternalTrackParam(xr,alpha,xx,cc);
-  track->SetMass(TMath::Abs(mass));
-  //track->StartTimeIntegral();  
-  track->SaveLocalConvConst(); 
   return track;
 }
 
index 690c62d..9956a3b 100644 (file)
 #include <TMath.h>
 
 #include "AliTracker.h"
-#include "AliKalmanTrack.h"
 #include "AliCluster.h"
-#include "AliLog.h"
 #include "AliRun.h"
-#include "AliMagF.h"
 
 const AliMagF *AliTracker::fgkFieldMap=0;
 
@@ -48,16 +45,6 @@ AliTracker::AliTracker():
   if (!fgkFieldMap) AliWarning("Field map is not set. Call AliTracker::SetFieldMap before creating a tracker!");
 }
 
-void AliTracker::SetFieldMap(const AliMagF* map, Bool_t uni) {
-  //--------------------------------------------------------------------
-  //This passes the field map to the reconstruction.
-  //--------------------------------------------------------------------
-  if (map==0) AliFatalClass("Can't access the field map !");
-  AliKalmanTrack::SetFieldMap(map);
-  if (uni) AliKalmanTrack::SetUniformFieldTracking();
-  fgkFieldMap=map;
-}
-
 //__________________________________________________________________________
 void AliTracker::CookLabel(AliKalmanTrack *t, Float_t wrong) const {
   //--------------------------------------------------------------------
index ae02d81..a8562ac 100644 (file)
 //       Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch 
 //-------------------------------------------------------------------------
 #include <TObject.h>
+#include <TClass.h>
+#include "AliKalmanTrack.h"
+#include "AliMagF.h"
+#include "AliLog.h"
 
 class AliCluster;
 class TTree;
-class AliKalmanTrack;
 class AliESD;
-class AliMagF;
 class AliTrackPoint;
 
 class AliTracker : public TObject {
@@ -73,6 +75,18 @@ private:
   ClassDef(AliTracker,2) //abstract tracker
 };
 
+inline void AliTracker::SetFieldMap(const AliMagF* map, Bool_t uni) {
+  //--------------------------------------------------------------------
+  //This passes the field map to the reconstruction.
+  //--------------------------------------------------------------------
+  if (map==0) AliFatalClass("Can't access the field map !");
+  AliKalmanTrack::SetFieldMap(map);
+  if (uni) AliKalmanTrack::SetUniformFieldTracking();
+  fgkFieldMap=map;
+}
+
+
+
 #endif
 
 
index e12bfd1..5fd71bf 100644 (file)
@@ -4192,7 +4192,7 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
       if (TMath::Abs(ktrack0->GetC())>5) continue; // cut on the curvature for mother particle
       AliExternalTrackParam paramm(*ktrack0);
       AliExternalTrackParam paramd(*ktrack1);
-      if (row0>60&&ktrack1->GetReference().X()>90.) new (&paramd) AliExternalTrackParam(ktrack1->GetReference()); 
+      if (row0>60&&ktrack1->GetReference().GetX()>90.) new (&paramd) AliExternalTrackParam(ktrack1->GetReference()); 
       //
       //
       kink->SetMother(paramm);
index e721b77..f24f52e 100644 (file)
@@ -267,7 +267,9 @@ AliTRDtrack::AliTRDtrack(const AliESDtrack& t)
   //Conversion of the covariance matrix
   Double_t c[15]; t.GetExternalCovariance(c);
   if (t.GetStatus()&AliESDtrack::kTRDbackup){
-    t.GetTRDExternalParameters(x,fAlpha,p,c);
+    fAlpha=t.GetOuterAlpha();
+    t.GetOuterExternalParameters(x,p);
+    t.GetOuterExternalCovariance(c);
     if      (fAlpha < -TMath::Pi()) fAlpha += 2*TMath::Pi();
     else if (fAlpha >= TMath::Pi()) fAlpha -= 2*TMath::Pi();
   }