Another round of effc++ changes
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 12 Aug 2006 17:05:09 +0000 (17:05 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 12 Aug 2006 17:05:09 +0000 (17:05 +0000)
TRD/AliTRDclusterCorrection.cxx
TRD/AliTRDclusterCorrection.h
TRD/AliTRDtrack.cxx
TRD/AliTRDtrack.h
TRD/AliTRDtracklet.cxx
TRD/AliTRDtracklet.h

index 7530294..291a8cd 100644 (file)
@@ -16,7 +16,8 @@
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
 //  TRD clusterCorrection                                                    //
-//  marian.ivanov@cern.ch                                                    //
+//  Author:                                                                  //
+//    Marian Ivanov (marian.ivanov@cern.ch)                                  //
 //                                                                           //
 /////////////////////////////////////////////////////////////////////////////// 
 
 
 ClassImp(AliTRDclusterCorrection)
 
-AliTRDclusterCorrection * gAliTRDclusterCorrection=0;
+AliTRDclusterCorrection *gAliTRDclusterCorrection = 0;
 
 //_____________________________________________________________________________
 AliTRDclusterCorrection::AliTRDclusterCorrection()
+  :TObject()
+  ,fOffsetAngle(0)
 {
   //
-  //default constructor for correction
+  // Default constructor for AliTRDclusterCorrection
   //
 
-  for (Int_t iplane=0;iplane<6;iplane++) {
-    for (Int_t itime=0;itime<30;itime++) {
-      for(Int_t iangle=0;iangle<20;iangle++){  
-       fCorrections[iplane][itime][iangle][0]=0;
-       fCorrections[iplane][itime][iangle][1]=0;
+  for (Int_t iplane = 0; iplane <  6; iplane++) {
+    for (Int_t itime  = 0; itime  < 30; itime++) {
+      for (Int_t iangle = 0; iangle < 20; iangle++) {  
+       fCorrections[iplane][itime][iangle][0] = 0.0;
+       fCorrections[iplane][itime][iangle][1] = 0.0;
       }
     }
   }
 
-  fOffsetAngle =0;
+}
+
+//_____________________________________________________________________________
+AliTRDclusterCorrection::~AliTRDclusterCorrection()
+{
+  //
+  // Destructor
+  //
 
 }
 
 //_____________________________________________________________________________
-void AliTRDclusterCorrection::SetCorrection(Int_t plane,Int_t timebin, Float_t angle, 
-                                           Float_t value, Float_t sigma)
+void AliTRDclusterCorrection::SetCorrection(Int_t plane,Int_t timebin, Float_t angle
+                                         , Float_t value, Float_t sigma)
 {
   //
   // Set the correction factors
   //
 
-  Int_t iangle = int( (angle-fOffsetAngle+1.)*10.+0.5);
-  if (iangle<0) return;
-  if (iangle>=20) return;
+  Int_t iangle = Int_t((angle - fOffsetAngle + 1.0) * 10.0 + 0.5);
+  if (iangle <   0) return;
+  if (iangle >= 20) return;
   fCorrections[plane][timebin][iangle][0] = value;
   fCorrections[plane][timebin][iangle][1] = sigma;
 
@@ -70,9 +80,10 @@ Float_t AliTRDclusterCorrection::GetCorrection(Int_t plane, Int_t timebin, Float
   // Get the correction factors
   //
 
-  Int_t iangle = int( (angle-fOffsetAngle+1.)*10.+0.5);
-  if (iangle<0) return 0.;
-  if (iangle>=20) return 0.;
+  Int_t iangle = Int_t((angle - fOffsetAngle + 1.0) * 10.0 + 0.5);
+  if (iangle <   0) return 0.0;
+  if (iangle >= 20) return 0.0;
+
   return fCorrections[plane][timebin][iangle][0];
 
 }
@@ -84,31 +95,37 @@ Float_t AliTRDclusterCorrection::GetSigma(Int_t plane, Int_t timebin, Float_t an
   // Returns the sigma
   //
 
-  Int_t iangle = int( (angle-fOffsetAngle+1.)*10.+0.5);
-  if (iangle<0) return 1.;
-  if (iangle>=20) return 1.;
+  Int_t iangle = Int_t((angle - fOffsetAngle + 1.0) * 10.0 + 0.5);
+  if (iangle <   0) return 1.0;
+  if (iangle >= 20) return 1.0;
+
   return fCorrections[plane][timebin][iangle][1];
 
 }
 
 //_____________________________________________________________________________
-AliTRDclusterCorrection *  AliTRDclusterCorrection::GetCorrection()
+AliTRDclusterCorrection *AliTRDclusterCorrection::GetCorrection()
 {
   //
-  // Return an instance of AliTRDclusterCorrection
+  // Return an instance of AliTRDclusterCorrection and sets the global
+  // pointer gAliTRDclusterCorrection (Is this needed somewhere ????)
   //
 
-  if (gAliTRDclusterCorrection!=0) return gAliTRDclusterCorrection;
-  //
-  TFile * f  = new TFile("$ALICE_ROOT/TRD/TRDcorrection.root");
-  if (!f){
-    ////
+  if (gAliTRDclusterCorrection != 0) {
+    return gAliTRDclusterCorrection;
+  }
+
+  TFile *fileIn = new TFile("$ALICE_ROOT/TRD/TRDcorrection.root");
+  if (!fileIn){
     gAliTRDclusterCorrection = new AliTRDclusterCorrection();
     return gAliTRDclusterCorrection;
   }
-  gAliTRDclusterCorrection = (AliTRDclusterCorrection*) f->Get("TRDcorrection");
-  if (gAliTRDclusterCorrection==0)  
+
+  gAliTRDclusterCorrection = (AliTRDclusterCorrection *) 
+                             fileIn->Get("TRDcorrection");
+  if (gAliTRDclusterCorrection == 0) {  
     gAliTRDclusterCorrection = new AliTRDclusterCorrection();
+  }
 
   return gAliTRDclusterCorrection;
   
index f3b2161..16cfb47 100644 (file)
@@ -3,6 +3,7 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
+/* $Id$ */
 
 #include "TObject.h"
 
@@ -17,20 +18,24 @@ class AliTRDclusterCorrection : public TObject {
  public:  
 
   AliTRDclusterCorrection();
-  Float_t GetCorrection(Int_t plane, Int_t timebin, Float_t angle) const;
-  Float_t GetSigma(Int_t plane, Int_t timebin, Float_t angle) const;
-  Float_t GetOffsetAngle() const { return fOffsetAngle; }
-  void    SetOffsetAngle(Float_t angle){fOffsetAngle=angle;}
-  void    SetCorrection(Int_t plane,Int_t timebin, Float_t angle, Float_t value,Float_t sigma);
-  Float_t GetAngle(Int_t i){return (i-10.)/10.+fOffsetAngle;}
-  static  AliTRDclusterCorrection * GetCorrection();
+  virtual ~AliTRDclusterCorrection();
+
+          Float_t  GetCorrection(Int_t plane, Int_t timebin, Float_t angle) const;
+          Float_t  GetOffsetAngle() const            { return fOffsetAngle;  }
+          Float_t  GetAngle(Int_t i)                 { return (i - 10.0) / 10.0 + fOffsetAngle; }
+          Float_t  GetSigma(Int_t plane, Int_t timebin, Float_t angle) const;
+
+          void     SetCorrection(Int_t plane,Int_t timebin, Float_t angle, Float_t value,Float_t sigma);
+          void     SetOffsetAngle(Float_t angle)     { fOffsetAngle = angle; }
+
+  static  AliTRDclusterCorrection *GetCorrection();
 
  protected:
 
-  Float_t  fCorrections[6][30][20][2]; // Correction values
-  Float_t  fOffsetAngle;               // Offset angle
+          Float_t  fCorrections[6][30][20][2];   //  Correction values
+          Float_t  fOffsetAngle;                 //  Offset angle
                                 
-  ClassDef(AliTRDclusterCorrection,1)  // ClusterCorrection for the TRD
+  ClassDef(AliTRDclusterCorrection,1)            //  ClusterCorrection for the TRD
  
 };
 
index 488ec45..60776b1 100644 (file)
@@ -34,349 +34,483 @@ ClassImp(AliTRDtrack)
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-AliTRDtrack::AliTRDtrack():
-  AliKalmanTrack(),
-  fSeedLab(-1),
-  fdEdx(0),
-  fdEdxT(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)
+  ,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)
 {
-  for (Int_t i=0; i<kNplane; i++) {
-    for (Int_t j=0; j<kNslice; j++) {
+  //
+  // 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++) {
       fdEdxPlane[i][j] = 0;
     }
     fTimBinPlane[i] = -1;
   }
-  for (UInt_t i=0; i<kMAXCLUSTERSPERTRACK; i++) {
-    fIndex[i] = 0;
-    fIndexBackup[i] = 0;
-    fdQdl[i] = 0;
+
+  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 (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() {
-  //-----------------------------------------------------------------
-  // This is the main track constructor.
-  //-----------------------------------------------------------------
-
-  fSeedLab = -1;
-
-  fAlpha=alpha;
-  if (fAlpha<-TMath::Pi()) fAlpha += 2*TMath::Pi();
-  if (fAlpha>=TMath::Pi()) fAlpha -= 2*TMath::Pi();   
+                         Double_t xref, Double_t alpha) 
+  :AliKalmanTrack() 
+  ,fSeedLab(-1)
+  ,fdEdx(0.0)
+  ,fdEdxT(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 main constructor
+  //
 
-  fX=xref;
+  Int_t  i = 0;
+  Int_t  j = 0;
+  UInt_t k = 0;
 
-  fY=xx[0]; fZ=xx[1]; fE=xx[2]; fT=xx[3]; fC=xx[4];
+  if (fAlpha <  -TMath::Pi()) fAlpha += 2.0 * TMath::Pi();
+  if (fAlpha >=  TMath::Pi()) fAlpha -= 2.0 * TMath::Pi();   
  
   SaveLocalConvConst();
 
-  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];  
-  
-  fIndex[0]=index;
+  fIndex[0] = index;
   SetNumberOfClusters(1);
 
-  fdEdx=0.;
-  fdEdxT=0.;
-  fDE=0.;
-  for (Int_t i=0;i<kNplane;i++){
-    for (Int_t j=0; j<kNslice; j++) {
+  for (i = 0; i < kNplane; i++) {
+    for (j = 0; j < kNslice; j++) {
       fdEdxPlane[i][j] = 0;
     }
     fTimBinPlane[i] = -1;
   }
 
-  fLhElectron = 0.0;
-  fNWrong = 0;
-  fNRotate = 0;
-  fStopped = 0;
-  fNCross =0;
-  fNLast  =0;
-  fChi2Last=0;
-  fNExpected=0;
-  fNExpectedLast=0;
-  fNdedx=0;
   Double_t q = TMath::Abs(c->GetQ());
-  Double_t s = fX*fC - fE, t=fT;
-  if(s*s < 1) q *= TMath::Sqrt((1-s*s)/(1+t*t));
-
+  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;
   
-  // 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 (k = 1; k < kMAXCLUSTERSPERTRACK; k++) {
+    fdQdl[k]        = 0;
+    fIndex[k]       = 0;
+    fIndexBackup[k] = 0; 
   }
-  for (Int_t i=0;i<3;i++) { fBudget[i]=0;};
 
-  fBackupTrack = 0;  
+  for (i = 0; i < 3; i++) { 
+    fBudget[i]      = 0;
+  }
 
 }                              
            
 //_____________________________________________________________________________
-AliTRDtrack::AliTRDtrack(const AliTRDtrack& t) : AliKalmanTrack(t) 
+AliTRDtrack::AliTRDtrack(const AliTRDtrack &t) 
+  :AliKalmanTrack(t) 
+  ,fSeedLab(t.fSeedLab)
+  ,fdEdx(t.fdEdx)
+  ,fdEdxT(t.fdEdxT)
+  ,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)
 {
   //
   // Copy constructor.
   //
-  
-  SetLabel(t.GetLabel());
-  fSeedLab=t.GetSeedLabel();
-
-  SetChi2(t.GetChi2());
-  fdEdx=t.fdEdx;
-  fdEdxT=t.fdEdxT;
-  fDE=t.fDE;
-  for (Int_t i=0;i<kNplane;i++){
-    for (Int_t j=0; j<kNslice; j++) {
+
+  Int_t  i = 0;
+  Int_t  j = 0;
+  UInt_t k = 0;
+
+  for (i = 0; i < kNplane; i++) {
+    for (j = 0; j < kNslice; j++) {
       fdEdxPlane[i][j] = t.fdEdxPlane[i][j];
     }
     fTimBinPlane[i] = t.fTimBinPlane[i];
     fTracklets[i]   = t.fTracklets[i];
   }
 
-  fLhElectron = 0.0;
-  fNWrong = t.fNWrong;
-  fNRotate = t.fNRotate;
-  fStopped = t.fStopped;
-  fNCross  = t.fNCross;
-  fNExpected = t.fNExpected;
-  fNExpectedLast = t.fNExpectedLast;
-  fNdedx         = t.fNdedx;
-  fNLast     = t.fNLast;
-  fChi2Last  = t.fChi2Last;
-  fBackupTrack =0;
-  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;  
-
-  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];
-  }
-
-  // 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<6;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];
   }
-  for (Int_t i=0;i<3;i++) { fBudget[i]=t.fBudget[i];};
+
+  for (i = 0; i < 3; i++) { 
+    fBudget[i]    = t.fBudget[i];
+  }
+
 }                                
 
 //_____________________________________________________________________________
-AliTRDtrack::AliTRDtrack(const AliKalmanTrack& t, Double_t alpha) 
-           :AliKalmanTrack(t) 
+AliTRDtrack::AliTRDtrack(const AliKalmanTrack &t, Double_t alpha) 
+  :AliKalmanTrack(t) 
+  ,fSeedLab(-1)
+  ,fdEdx(t.GetPIDsignal())
+  ,fdEdxT(0)
+  ,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)
 {
   //
   // Constructor from AliTPCtrack or AliITStrack .
   //
 
-  SetLabel(t.GetLabel());
-  SetChi2(0.);
-  SetMass(t.GetMass());
+  Int_t  i = 0;
+  Int_t  j = 0;
+  UInt_t k = 0;
+
+  SetChi2(0.0);
   SetNumberOfClusters(0);
 
-  fdEdx=t.GetPIDsignal();
-  fDE  = 0;
-  for (Int_t i=0;i<kNplane;i++){
-    for (Int_t j=0;j<kNslice;j++){
+  for (i = 0; i < kNplane; i++) {
+    for (j = 0; j < kNslice; j++) {
       fdEdxPlane[i][j] = 0.0;
     }
     fTimBinPlane[i] = -1;
   }
 
-  fLhElectron = 0.0;
-  fNWrong = 0;
-  fNRotate = 0;
-  fStopped = 0;
-  fNExpected=0;
-  fNExpectedLast=0;  
-  fNdedx        =0;
-  fNCross =0;
-  fNLast  =0;
-  fChi2Last =0;
-  fBackupTrack =0;
-
-  fAlpha = alpha;
-  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];
-  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];  
+  if      (fAlpha < -TMath::Pi()) {
+    fAlpha += 2.0 * TMath::Pi();
+  }
+  else if (fAlpha >= TMath::Pi()) {
+    fAlpha -= 2.0 * TMath::Pi();
+  }
 
-  // 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    
+  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;
   }
   
-  for (Int_t i=0;i<3;i++) { fBudget[i]=0;};
+  for (i = 0; i < 3; i++) { 
+    fBudget[i]      = 0;
+  }
+
 }              
 
 //_____________________________________________________________________________
-AliTRDtrack::AliTRDtrack(const AliESDtrack& t) 
-           :AliKalmanTrack() 
+AliTRDtrack::AliTRDtrack(const AliESDtrack &t) 
+  :AliKalmanTrack() 
+  ,fSeedLab(-1)
+  ,fdEdx(t.GetTRDsignal())
+  ,fdEdxT(0)
+  ,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)
 {
   //
   // 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 (UInt_t i=ncl;i<kMAXCLUSTERSPERTRACK;i++) {
-    fIndexBackup[i]=0;
-    fIndex[i] = 0; //MI store indexes
-  }
-  fdEdx=t.GetTRDsignal();  
-  fDE =0;     
-  for (Int_t i=0;i<kNplane;i++){
-    for (Int_t j=0;j<kNslice;j++){
+  for (k = ncl; k < kMAXCLUSTERSPERTRACK; k++) {
+    fIndexBackup[k] = 0;
+    fIndex[k]       = 0;
+  }
+
+  for (i = 0; i < kNplane; i++) {
+    for (j = 0; j < kNslice; j++) {
       fdEdxPlane[i][j] = t.GetTRDsignals(i,j);
     }
     fTimBinPlane[i] = t.GetTRDTimBin(i);
   }
 
-  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*TMath::Pi();
-  else if (fAlpha >= TMath::Pi()) fAlpha -= 2*TMath::Pi();
+  if      (fAlpha <  -TMath::Pi()) {
+    fAlpha += 2.0 * TMath::Pi();
+  }
+  else if (fAlpha >=  TMath::Pi()) {
+    fAlpha -= 2.0 * TMath::Pi();
+  }
 
-  Double_t x, p[5]; t.GetExternalParameters(x,p);
-  //Conversion of the covariance matrix
-  Double_t c[15]; t.GetExternalCovariance(c);
-  if (t.GetStatus()&AliESDtrack::kTRDbackup){
+  // 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*TMath::Pi();
-    else if (fAlpha >= TMath::Pi()) fAlpha -= 2*TMath::Pi();
+    if      (fAlpha <  -TMath::Pi()) {
+      fAlpha += 2.0 * TMath::Pi();
+    }
+    else if (fAlpha >=  TMath::Pi()) {
+      fAlpha -= 2.0 * TMath::Pi();
+    }
   }
 
-  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*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];  
+  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
+  }
 
-  // Initialization [SR, GSI, 18.02.2003]
-  for(UInt_t i=0; i<kMAXCLUSTERSPERTRACK; i++) {
-    fdQdl[i] = 0;
-    //    fIndex[i] = 0; //MI store indexes
+  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());
 
 }  
@@ -388,7 +522,9 @@ AliTRDtrack::~AliTRDtrack()
   // Destructor
   //
 
-  if (fBackupTrack) delete fBackupTrack;
+  if (fBackupTrack) {
+    delete fBackupTrack;
+  }
   fBackupTrack = 0;
 
 }
@@ -400,21 +536,25 @@ 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;
+  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*TMath::Pi();
-  else if (fAlpha >= TMath::Pi()) fAlpha -= 2*TMath::Pi();
+  if      (fAlpha <  -TMath::Pi()) {
+    fAlpha += 2.0 * TMath::Pi();
+  }
+  else if (fAlpha >=  TMath::Pi()) {
+    fAlpha -= 2.0 * TMath::Pi();
+  }
 
   return *this;
 
@@ -427,17 +567,28 @@ Float_t AliTRDtrack::StatusForTOF()
   // Defines the status of the TOF extrapolation
   //
 
-  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]));
+  // 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]));
   return res;
 
-  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; 
+  // 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; 
   
   return status;
 
@@ -450,16 +601,18 @@ void AliTRDtrack::GetExternalCovariance(Double_t cc[15]) const
   // This function returns external representation of the covriance matrix.
   //
 
-  Double_t a=GetLocalConvConst();
+  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;
+  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[ 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; 
   
 }               
@@ -471,10 +624,10 @@ 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[ 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;
   
 }    
@@ -500,179 +653,225 @@ Int_t AliTRDtrack::Compare(const TObject *o) const
 }                
 
 //_____________________________________________________________________________
-void AliTRDtrack::CookdEdx(Double_t low, Double_t up) {
-  //-----------------------------------------------------------------
-  // Calculates dE/dX within the "low" and "up" cuts.
-  //-----------------------------------------------------------------
-
-  Int_t i;
-  //Int_t nc=GetNumberOfClusters(); 
-  Int_t nc=fNdedx; 
-  if (nc<10)  {
+void AliTRDtrack::CookdEdx(Double_t low, Double_t up) 
+{
+  //
+  // Calculates the dE/dX within the "low" and "up" cuts.
+  //
+
+  Int_t i = 0;
+
+  // Number of clusters used for dedx
+  Int_t nc = fNdedx; 
+  // Require at least 10 clusters for a dedx measurement
+  // Should fdEdxT not also be set here ????
+  if (nc < 10) {
     SetdEdx(0);
     return;
   }
 
+  // Get the charge deposits from each cluster
   Float_t sorted[kMAXCLUSTERSPERTRACK];
-  for (i=0; i < nc; i++) {
-    sorted[i]=fdQdl[i];
-  }
-  Int_t nl=Int_t(low*nc), nu=Int_t(up*nc);
-  Float_t dedx=0;
-  //for (i=nl; i<=nu; i++) dedx += sorted[i];
-  //dedx /= (nu-nl+1);
-  for (i=0; i<nc; i++) dedx += sorted[i];       // ADDED by PS
-  if((nu-nl)) dedx /= (nu-nl);                  // ADDED by PS
-
-  //SetdEdx(dedx);
-  //
-  // now real truncated mean
-  for (i=0; i < nc; i++) {
-    sorted[i]=TMath::Abs(fdQdl[i]);
-  }
-  Int_t * index = new Int_t[nc];
-  TMath::Sort(nc, sorted, index,kFALSE);
-  dedx=0;
-  for (i=nl; i<=nu; i++) dedx += sorted[index[i]];
-  dedx /= (nu-nl+1);
+  for (i = 0; i < nc; i++) {
+    sorted[i] = fdQdl[i];
+  }
+
+  // Lower and upper bound
+  Int_t nl = Int_t(low * nc);
+  Int_t nu = Int_t( up * nc);
+
+  // Sum up the total energy deposit
+  Float_t dedx = 0.0;
+  for (i = 0; i < nc; i++) {
+    dedx += sorted[i];
+  }
+  // Why is dedx divided by (nu - nl) ????
+  // And why is it not saved ????
+  if ((nu - nl) != 0) {
+    dedx /= (nu - nl);
+  }
+
+  // Calculate the truncated mean
+  // Can fdQdl be negative ???? Why is it nor checked above ????
+  for (i = 0; i < nc; i++) {
+    sorted[i] = TMath::Abs(fdQdl[i]);
+  }
+
+  // Sort the dedx values by amplitude
+  Int_t *index = new Int_t[nc];
+  TMath::Sort(nc,sorted,index,kFALSE);
+  // Sum up the truncated charge between nl and nu  
+  dedx = 0.0;
+  for (i = nl; i <= nu; i++) {
+    dedx += sorted[index[i]];
+  }
+  dedx /= (nu - nl + 1);
+
+  // Why are fdEdx and fdEdxT set to the same value ????
   fdEdxT = dedx;
-  delete [] index;
   SetdEdx(dedx);
 
+  delete [] index;
+
 }                     
 
 //_____________________________________________________________________________
 Int_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;
+  }
+
+  Double_t lcc = GetLocalConvConst();
 
-  if (xk == fX) return 1;
+  Double_t oldX = fX;
+  Double_t oldY = fY;
+  Double_t oldZ = fZ;  
 
-  if (TMath::Abs(fC*xk - fE) >= 0.90000) {
-    //    Int_t n=GetNumberOfClusters();
-    //if (n>4) cerr << n << " AliTRDtrack: Propagation failed, \tPt = " 
-    //              << GetPt() << "\t" << GetLabel() << "\t" << GetMass() << endl;
+  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 lcc=GetLocalConvConst();
-
-  // track Length measurement [SR, GSI, 17.02.2003]
-  Double_t oldX = fX, oldY = fY, oldZ = fZ;  
-
-  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;
+
+  Double_t r1 = TMath::Sqrt(1.0 - c1*c1);
+  Double_t c2 = fC*x2 - fE; 
+  if ((c2*c2) > 1) {
+    return 0;
+  }
+
+  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*b11;
+  fCzz += a11 + 2.0*b11;
   fCez += b21;
   fCtz += b31;
   fCcz += b41;
 
-  fX=x2;                                                     
+  fX = x2;                                                     
 
-  //Change of the magnetic field *************
+  // 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;
+  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*ey*ez*ez*fE+1-ey*ey+ez*ez+fE*fE*ez*ez)*theta2;
+  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;
-  /*
-  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;
-  Float_t budget = d* rho;
+  // 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 ?
+  // 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 
-  //
-  //
-  fDE+=dE;
-  if (x1 < x2) dE=-dE;
-  cc=fC;
-  fC*=(1.- sqrt(p2+GetMass()*GetMass())/p2*dE);
-  fE+=fX*(fC-cc);    
-  //  Double_t sigmade = 0.1*dE*TMath::Sqrt(TMath::Sqrt(1+fT*fT)*90./(d+0.0001));   // 20 percent fluctuation - normalized to some length 
-  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);
+  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);
   fCcc += sigmac2;
-  fCee += fX*fX*sigmac2;  
-
-  // track time measurement [SR, GSI 17.02.2002]
-  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){
-      // make correction for curvature if neccesary
-      l2 = 0.5*TMath::Sqrt((fX-oldX)*(fX-oldX) + (fY-oldY)*(fY-oldY));
-      l2 = 2*TMath::ASin(l2*fC)/fC;
-      l2 = TMath::Sqrt(l2*l2+(fZ-oldZ)*(fZ-oldZ));
+  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);
     }
-    AddTimeStep(l2);
   }
 
   return 1;            
@@ -680,158 +879,216 @@ Int_t AliTRDtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
 }     
 
 //_____________________________________________________________________________
-Int_t AliTRDtrack::Update(const AliTRDcluster *c, Double_t chisq, UInt_t index
-                        , Double_t h01)
+Int_t AliTRDtrack::Update(const AliTRDcluster *c, Double_t chisq
+                        , UInt_t index, Double_t h01)
 {
-  // Assignes found cluster to the track and updates track information
+  //
+  // Assignes a 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 -  MI
-  Float_t tangent2 = (fC*fX-fE)*(fC*fX-fE);
-  if (tangent2 < 0.90000){
-    tangent2 = tangent2/(1.-tangent2);
+  // What is 0.003 ????
+  if (TMath::Abs(h01) > 0.003) {
+    fNoTilt = kFALSE;
   }
-  Float_t errang = tangent2*0.04; //
-  Float_t padlength = TMath::Sqrt(c->GetSigmaZ2()*12.);
-
-  Double_t r00=c->GetSigmaY2() +errang, r01=0., r11=c->GetSigmaZ2()*100.;
-  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, 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;
 
-  Double_t dy=c->GetY() - fY, dz=c->GetZ() - fZ;
-  Double_t cur=fC + k40*dy + k41*dz, eta=fE + k20*dy + k21*dz;
-
-
-  if(fNoTilt) {
-    if (TMath::Abs(cur*fX-eta) >= 0.90000) {
-      //      Int_t n=GetNumberOfClusters();
-      //if (n>4) cerr<<n<<" AliTRDtrack warning: Filtering failed !\n";
+  // Add angular effect to the error contribution
+  Float_t tangent2  = (fC*fX-fE) * (fC*fX-fE);
+  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;
-    //fT += k30*dy + k31*dz;
     fC  = cur;
+
   }
   else {
-    Double_t xuFactor = 100.;  // empirical factor set by C.Xu
-                                // in the first tilt version      
-    dy=c->GetY() - fY; dz=c->GetZ() - fZ;     
-    dy=dy+h01*dz;
-    Float_t add=0;
-    if (TMath::Abs(dz)>padlength/2.){
-      Float_t dy2 = c->GetY() - fY;
-      Float_t sign = (dz>0) ? -1.: 1.;
-      dy2+=h01*sign*padlength/2.;      
-      dy  = dy2;
-      add = 0;
-    }
-   
-
-
-    r00=c->GetSigmaY2()+errang+add, r01=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.90000) {
-      //      Int_t n=GetNumberOfClusters();
-      //if (n>4) cerr<<n<<" AliTRDtrack warning: Filtering failed !\n";
+    // 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;
+
+    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;  
+    k01 += h01*k00;
+    k11 += h01*k10;
+    k21 += h01*k20;
+    k31 += h01*k30;
+    k41 += h01*k40;  
     
   }
-  Double_t c01=fCzy, c02=fCey, c03=fCty, c04=fCcy;
-  Double_t c12=fCez, c13=fCtz, 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;
+  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;
+  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;
+  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;  
-  //fCct-=k30*c04+k31*c14;  // symmetric formula MI  
+  fCtt -= k30*c03  + k31*c13;
+  fCct -= k40*c03  + k41*c13;  
   
-  fCcc-=k40*c04+k41*c14;                 
+  fCcc -= k40*c04  + k41*c14;                 
 
-  Int_t n=GetNumberOfClusters();
-  fIndex[n]=index;
+  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::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
+                          , UInt_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  -  MI
-  //AliTRDclusterCorrection *corrector = AliTRDclusterCorrection::GetCorrection();
+  if (TMath::Abs(h01) > 0.003) {
+    fNoTilt = kFALSE;
+  }
+
+  //
+  // Add angular effect to the error contribution and make correction
+  // Still needed ???? 
+  // AliTRDclusterCorrection *corrector = AliTRDclusterCorrection::GetCorrection();
   // 
-  Double_t tangent2 = (fC*fX-fE)*(fC*fX-fE);
-  if (tangent2 < 0.90000){
-    tangent2 = tangent2/(1.-tangent2);
-  }
-  Double_t tangent = TMath::Sqrt(tangent2);
-  if ((fC*fX-fE)<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 
-  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;
 
+  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;
+  }
+
+  // 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;
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // 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){
@@ -842,132 +1099,162 @@ Int_t AliTRDtrack::UpdateMI(const AliTRDcluster *c, Double_t chisq, UInt_t index
     }
   }
   */
-  //
+  //  
   //  Double_t padlength = TMath::Sqrt(c->GetSigmaZ2()*12.);
-
-  Double_t r00=(c->GetSigmaY2() +errang+errsys)*extend, r01=0., r11=c->GetSigmaZ2()*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 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;
-
-  Double_t dy=c->GetY() - fY, dz=c->GetZ() - fZ;
-  Double_t cur=fC + k40*dy + k41*dz, eta=fE + k20*dy + k21*dz;
-
-
-  if(fNoTilt) {
-    if (TMath::Abs(cur*fX-eta) >= 0.90000) {
-      //      Int_t n=GetNumberOfClusters();
-      //if (n>4) cerr<<n<<" AliTRDtrack warning: Filtering failed !\n";
+  /////////////////////////////////////////////////////////////////////////////
+
+  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;
-    //fT += k30*dy + k31*dz;
     fC  = cur;
+
   }
   else {
-    Double_t padlength = TMath::Sqrt(c->GetSigmaZ2()*12);
-  
-    Double_t xuFactor = 1000.;  // empirical factor set by C.Xu
-                                // in the first tilt version      
-    dy=c->GetY() - fY; dz=c->GetZ() - fZ;     
-    //dy=dy+h01*dz+correction;
+
+    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.) {
-      tiltdz = TMath::Sign(padlength/2,dz);
+    if (TMath::Abs(tiltdz) > padlength/2.0) {
+      tiltdz = TMath::Sign(padlength/2.0,dz);
     }
-    //    dy=dy+h01*dz;
-    dy=dy+h01*tiltdz;
+    dy = dy + h01*tiltdz;
 
-    Double_t add=0;
-    if (TMath::Abs(dz)>padlength/2.){
-      //Double_t dy2 = c->GetY() - fY;
+    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;
+      add = 1.0;
     }
-    Double_t s00 = (c->GetSigmaY2()+errang)*extend+errsys+add;  // error pad
-    Double_t s11 = c->GetSigmaZ2()*xuFactor;   // error pad-row
+
+    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;
+    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.90000) {
-      //Int_t n=GetNumberOfClusters();
-      //      if (n>4) cerr<<n<<" AliTRDtrack warning: Filtering failed !\n";
+    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;
+    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;  
+    k01 += h01*k00;
+    k11 += h01*k10;
+    k21 += h01*k20;
+    k31 += h01*k30;
+    k41 += h01*k40;  
     
   }
-  //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;
+
+  // 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;
 
-  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;                 
-  //
+  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);
-  //  cerr<<"in update: fIndex["<<fN<<"] = "<<index<<endl;
+  SetChi2(GetChi2() + chisq);
 
   return 1;      
 
@@ -979,57 +1266,56 @@ Int_t AliTRDtrack::UpdateMI(const AliTRDtracklet &tracklet)
   //
   // Assignes found tracklet to the track and updates track information
   //
-  //
-  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 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 dy=tracklet.GetY() - fY, dz=tracklet.GetZ() - fZ;
+  Double_t dy  = tracklet.GetY() - fY;
+  Double_t dz  = tracklet.GetZ() - fZ;
 
-  
-  Double_t s00 = tracklet.GetTrackletSigma2();  // error pad
-  Double_t s11 = 100000;   // error pad-row
+  Double_t s00 = tracklet.GetTrackletSigma2();  // Error pad
+  Double_t s11 = 100000.0;                      // 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 ;
+  
+  r00 = fCyy + fCzz*h01*h01 + s00;
+  r01 = fCzy;
   r11 = fCzz + s11;
   det = r00*r11 - r01*r01;
-  // 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;
-  
+
+  // 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
-  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";
+  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;
+  
+  // 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) {
     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;
@@ -1037,44 +1323,41 @@ Int_t AliTRDtrack::UpdateMI(const AliTRDtracklet &tracklet)
   fT += k30*dy + k31*dz;
   fC  = cur;
     
-  
-  //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;
+  // 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;
 
-  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;
-  SetNumberOfClusters(n+1);
-
-  SetChi2(GetChi2()+chisq);
-  //  cerr<<"in update: fIndex["<<fN<<"] = "<<index<<endl;
-  */
+  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;                 
 
   return 1;      
 
@@ -1083,10 +1366,12 @@ Int_t AliTRDtrack::UpdateMI(const AliTRDtracklet &tracklet)
 //_____________________________________________________________________________
 Int_t AliTRDtrack::Rotate(Double_t alpha, Bool_t absolute)
 {
-  // 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
-  
+  //
+  // 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
+  //  
+
   if (absolute) {
     alpha -= fAlpha;
   }
@@ -1095,56 +1380,79 @@ Int_t AliTRDtrack::Rotate(Double_t alpha, Bool_t absolute)
   }
 
   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) {
-    Int_t n=GetNumberOfClusters();
-    if (n>4) cerr<<n<<" AliTRDtrack warning: Rotation failed !\n";
-    return 0;
+  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;
 
-  if((r2*r2) > 1) return 0;
-  Double_t y0=fY + sqrt(1.- r2*r2)/fC;
-  if ((fY-y0)*fC >= 0.) {
-    Int_t n=GetNumberOfClusters();
-    if (n>4) cerr<<n<<" AliTRDtrack warning: Rotation failed !!!\n";
+  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;
 
-  //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;
+  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;
+  }
 
-  //a = f*b = f*C*ft
-  Double_t a00=f00*b00, a02=f00*b02, a22=f20*b02+f24*b42+f22*b22;
+  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*C*Ft = C + (a + b + bt)
-  fCyy += a00 + 2*b00;
+  // 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;
+  fCey += a02 +     b20 + b02;
   fCty += b30;
   fCcy += b40;
   fCez += b12;
   fCte += b32;
-  fCee += a22 + 2*b22;
+  fCee += a22 + 2.0*b22;
   fCce += b42;
 
   return 1;                            
@@ -1159,36 +1467,57 @@ Double_t AliTRDtrack::GetPredictedChi2(const AliTRDcluster *c, Double_t h01) con
   //  
 
   Bool_t fNoTilt = kTRUE;
-  if(TMath::Abs(h01) > 0.003) fNoTilt = kFALSE;
-  Double_t chi2, dy, r00, r01, r11;
+  if (TMath::Abs(h01) > 0.003) {
+    fNoTilt = kFALSE;
+  }
+
+  Double_t chi2;
+  Double_t dy;
+  Double_t r00;
+  Double_t r01;
+  Double_t r11;
+
+  if (fNoTilt) {
+
+    dy   = c->GetY() - fY;
+    r00  = c->GetSigmaY2();    
+    chi2 = (dy*dy) / r00;    
 
-  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 det=r00*r11 - r01*r01;
+    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;
     if (TMath::Abs(det) < 1.e-10) {
-      Int_t n=GetNumberOfClusters(); 
-      if (n>4) cerr<<n<<" AliTRDtrack warning: Singular matrix !\n";
+      Int_t n = GetNumberOfClusters(); 
+      if (n > 4) {
+        AliError(Form("Singular matrix N = %d!\n",n));
+      }
       return 1e10;
     }
-    Double_t tmp=r00; r00=r11; r11=tmp; r01=-r01;
-    Double_t dy=c->GetY() - fY, dz=c->GetZ() - fZ;
+
+    Double_t tmp = r00; 
+    r00  =  r11; 
+    r11  =  tmp; 
+    r01  = -r01;
+    Double_t dy     = c->GetY() - fY;
+    Double_t dz     = c->GetZ() - fZ;
     Double_t tiltdz = dz;
-    if (TMath::Abs(tiltdz)>padlength/2.) {
-      tiltdz = TMath::Sign(padlength/2,dz);
+    if (TMath::Abs(tiltdz) > padlength/2.0) {
+      tiltdz = TMath::Sign(padlength/2.0,dz);
     }
-    //    dy=dy+h01*dz;
-    dy=dy+h01*tiltdz;
+    dy = dy + h01*tiltdz;
+
+    chi2 = (dy*r00*dy + 2*r01*dy*dz + dz*r11*dz) / det; 
 
-    chi2 = (dy*r00*dy + 2*r01*dy*dz + dz*r11*dz)/det; 
   }
 
   return chi2;
@@ -1198,35 +1527,53 @@ Double_t AliTRDtrack::GetPredictedChi2(const AliTRDcluster *c, Double_t h01) con
 //_________________________________________________________________________
 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()); // GeV/c
-  Double_t r=fC*fX-fE;
+  Double_t pt = TMath::Abs(GetPt());
+  Double_t r  = fC*fX - fE;
 
   Double_t y0; 
-  if(r > 1) { py = pt; px = 0; }
-  else if(r < -1) { py = -pt; px = 0; }
+  if      (r >  1) { 
+    py =  pt; 
+    px = 0.0;
+  }
+  else if (r < -1) { 
+    py = -pt; 
+    px = 0.0;
+  }
   else {
-    y0=fY + sqrt(1.- r*r)/fC;  
-    px=-pt*(fY-y0)*fC;    //cos(phi);
-    py=-pt*(fE-fX*fC);   //sin(phi);
+    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;            
+
+  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;            
+  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;            
 
 }                                
 
@@ -1237,11 +1584,11 @@ void AliTRDtrack::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.;  
+  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;  
 
 }                                                         
 
@@ -1252,11 +1599,11 @@ void AliTRDtrack::ResetCovariance(Float_t mult)
   // Resets covariance matrix
   //
 
-  fCyy*=mult;
-  fCzy*=0.;  fCzz*=1.;
-  fCey*=0.;  fCez*=0.;  fCee*=mult;
-  fCty*=0.;  fCtz*=0.;  fCte*=0.;  fCtt*=1.;
-  fCcy*=0.;  fCcz*=0.;  fCce*=0.;  fCct*=0.;  fCcc*=mult;  
+  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;  
 
 }                                                         
 
@@ -1267,7 +1614,10 @@ void AliTRDtrack::MakeBackupTrack()
   // Creates a backup track
   //
 
-  if (fBackupTrack) delete fBackupTrack;
+  if (fBackupTrack) {
+    delete fBackupTrack;
+  }
+
   fBackupTrack = new AliTRDtrack(*this);
   
 }
@@ -1277,56 +1627,74 @@ Int_t AliTRDtrack::GetProlongation(Double_t xk, Double_t &y, Double_t &z)
 {
   //
   // Find prolongation at given x
-  // return 0 if not exist
+  // Return 0 if it does not exist
+  //
   
-  Double_t c1=fC*fX - fE;
-  if (TMath::Abs(c1)>1.) return 0;
-  Double_t r1=TMath::Sqrt(1.- c1*c1);
-  Double_t c2=fC*xk - fE;
-  if (TMath::Abs(c2)>1.) return 0;  
-  Double_t r2=TMath::Sqrt(1.- c2*c2);
-  y =fY + (xk-fX)*(c1+c2)/(r1+r2);
-  z =fZ + (xk-fX)*(c1+c2)/(c1*r2 + c2*r1)*fT;
+  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 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;
 
   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 given x  position 
-  // works inside of the 20 degree segmentation (local cooordinate frame for TRD , TPC, TOF)
+  // Propagate track to a given x position 
+  // Works inside of the 20 degree segmentation
+  // (local cooordinate frame for TRD , TPC, TOF)
   // 
-  // 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);
-  // critical alpha  - cross sector indication
+  // The material budget is taken from the geo manager
   //
-  Double_t dir = (fX>xr) ? -1.:1.;
-  // direction +-
-  for (Double_t x=fX+dir*step;dir*x<dir*xr;x+=dir*step){
-    //
+  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;   
+  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]);     
     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(fAlpha) + y * TMath::Sin(fAlpha); 
+    xyz1[1] = x * TMath::Sin(fAlpha) - y * TMath::Cos(fAlpha);
     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 (fY >  fX*kTalphac) {
       Rotate(-kAlphac);
     }
-    if (fY<-fX*kTalphac){
+    if (fY < -fX*kTalphac) {
       Rotate(kAlphac);
     }
+
   }
-  //
+
   PropagateTo(xr);
 
   return 0;
@@ -1334,42 +1702,53 @@ 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 track to the radial position
-  // rotation always connected to the last track position
-  //
-  Double_t  xyz0[3], xyz1[3],y,z; 
-  Double_t radius = TMath::Sqrt(fX*fX+fY*fY);
-  Double_t dir = (radius>r) ? -1.:1.;   // direction +-
+  // Propagate a track to a given radial position
+  // The rotation is always connected to the last track position
   //
-  for (Double_t x=radius+dir*step;dir*x<dir*r;x+=dir*step){
+
+  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 alpha = TMath::ATan2(xyz0[1],xyz0[0]);
     Rotate(alpha,kTRUE);
     GetGlobalXYZ(xyz0[0],xyz0[1],xyz0[2]);     
     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) param[1] =100000000;
+    if (param[1] <= 0.0) {
+      param[1] = 100000000.0;
+    }
     PropagateTo(x,param[1],param[0]);
   } 
+
   GetGlobalXYZ(xyz0[0],xyz0[1],xyz0[2]);       
   Double_t alpha = TMath::ATan2(xyz0[1],xyz0[0]);
   Rotate(alpha,kTRUE);
   GetGlobalXYZ(xyz0[0],xyz0[1],xyz0[2]);       
   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) param[1] =100000000;
+  
+  if (param[1] <= 0.0) {
+    param[1] = 100000000.0;
+  }
   PropagateTo(r,param[1],param[0]);
 
   return 0;
@@ -1390,25 +1769,30 @@ Int_t AliTRDtrack::GetSector() const
 }
 
 //_____________________________________________________________________________
-Double_t  AliTRDtrack::Get1Pt() const                       
+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./kMostProbableMomentum/TMath::Sqrt(1.+ GetTgl()*GetTgl());
-  return (TMath::Sign(1e-9,fC) + fC)*GetLocalConvConst();
+  //
+
+  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                         
+Double_t AliTRDtrack::GetP() const                         
 { 
   //
   // Returns the total momentum
   //
 
-  return TMath::Abs(GetPt())*sqrt(1.+GetTgl()*GetTgl());  
+  return TMath::Abs(GetPt()) * TMath::Sqrt(1.0 + GetTgl()*GetTgl());  
 
 }
 
@@ -1425,6 +1809,7 @@ Double_t AliTRDtrack::GetYat(Double_t xk) const
   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);
 
 }
@@ -1438,7 +1823,8 @@ void AliTRDtrack::SetSampledEdx(Float_t q, Int_t i)
 
   Double_t s = GetSnp();
   Double_t t = GetTgl();
-  q *= TMath::Sqrt((1-s*s)/(1+t*t));
+
+  q *= TMath::Sqrt((1.0 - s*s) / (1.0 + t*t));
   fdQdl[i] = q;
 
 }     
@@ -1452,7 +1838,8 @@ void AliTRDtrack::SetSampledEdx(Float_t q)
 
   Double_t s = GetSnp();
   Double_t t = GetTgl();
-  q*= TMath::Sqrt((1-s*s)/(1+t*t));
+
+  q*= TMath::Sqrt((1.0 - s*s) / (1.0 + t*t));
   fdQdl[fNdedx] = q;
   fNdedx++;
 
@@ -1461,10 +1848,9 @@ void AliTRDtrack::SetSampledEdx(Float_t q)
 //_____________________________________________________________________________
 void AliTRDtrack::GetXYZ(Float_t r[3]) const 
 {
-
-  //---------------------------------------------------------------------
+  //
   // Returns the position of the track in the global coord. system 
-  //---------------------------------------------------------------------
+  //
 
   Double_t cs = TMath::Cos(fAlpha);
   Double_t sn = TMath::Sin(fAlpha);
index 535ff43..2fd7973 100644 (file)
@@ -4,15 +4,7 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-#include <AliKalmanTrack.h>
-#include <AliTRDtracklet.h>
-
-class AliTRDcluster;
-class AliTPCtrack;
-class AliESDtrack;
-class AliTrackReference;
-
-const unsigned kMAXCLUSTERSPERTRACK = 210; 
+/* $Id$ */
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
@@ -20,167 +12,177 @@ const unsigned kMAXCLUSTERSPERTRACK = 210;
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
+#include "AliKalmanTrack.h"
+
+#include "AliTRDtracklet.h"
+
+class AliESDtrack;
+class AliTrackReference;
+class AliTPCtrack;
+
+class AliTRDcluster;
+
+const unsigned kMAXCLUSTERSPERTRACK = 210; 
+
 class AliTRDtrack : public AliKalmanTrack {
    
   enum { kNdet      = 540
-       , kNstacks   = 90
-       , kNplane    = 6
-       , kNcham     = 5
-       , kNsect     = 18
-       , kNslice    = 3
-       , kNtimeBins = 22 };
+       , kNstacks   =  90
+       , kNplane    =   6
+       , kNcham     =   5
+       , kNsect     =  18
+       , kNslice    =   3
+       , kNtimeBins =  22 };
 
   friend class AliTRDtracker;
 
  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);
-   ~AliTRDtrack();
-
-   AliTRDtrack     &operator=(const AliTRDtrack &t);
-
-   //static AliTRDtrack* MakeTrack(const AliTrackReference *ref, Double_t mass);
-   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 
+  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);
-
-   void            SetStop(Bool_t stop)                 { fStopped        = stop;   }
-   Bool_t          GetStop() const                      { return fStopped;          }
-
-   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.); SetNumberOfClusters(0); }
-   Int_t           Rotate(Double_t angle, Bool_t absolute=kFALSE);
-
-   void            SetdEdx(Float_t dedx)                { fdEdx           = dedx;   }  
-   void            SetPIDsignals(Float_t dedx, Int_t iPlane, Int_t 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;    }
-
-   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++;                }
-  
-   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();
+          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.); 
+                                                          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();
 
  protected:
 
-   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 
-   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
-
-   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   
+  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 
+          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
+
+          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    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,5)                                 // 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,5)                                  //  TRD reconstructed tracks
 
 };                     
 
-inline
-void AliTRDtrack::GetExternalParameters(Double_t& xr, Double_t x[5]) const 
+//_____________________________________________________________________________
+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(1e-9,fC) + fC)*GetLocalConvConst();
+  x[0] = GetY();  
+  x[1] = GetZ();  
+  x[2] = GetSnp();  
+  x[3] = GetTgl();
+  x[4] = (TMath::Sign(1e-9,fC) + fC) * GetLocalConvConst();
+
 }           
 
 #endif   
index 7f19395..2237c8b 100644 (file)
 
 /* $Id$ */
 
+////////////////////////////////////////////////////////////////////////////
+//                                                                        //
+//  A TRD tracklet                                                        //
+//                                                                        //
+////////////////////////////////////////////////////////////////////////////
+
 #include "AliTRDtracklet.h"
 
 ClassImp(AliTRDtracklet)
 
 //_____________________________________________________________________________
-AliTRDtracklet::AliTRDtracklet():fY(0),fZ(0),fX(0),fAlpha(0),fSigma2(0),fP0(0),fP1(0),fNFound(0),fNCross(0),fPlane(0),fExpectedSigma2(0),fChi2(0),fTilt(0),fMaxPos(0),fMaxPos4(0),fMaxPos5(0) 
+AliTRDtracklet::AliTRDtracklet()
+  :TObject()
+  ,fY(0)
+  ,fZ(0)
+  ,fX(0)
+  ,fAlpha(0)
+  ,fSigma2(0)
+  ,fP0(0)
+  ,fP1(0)
+  ,fNFound(0)
+  ,fNCross(0)
+  ,fPlane(0)
+  ,fExpectedSigma2(0)
+  ,fChi2(0)
+  ,fTilt(0)
+  ,fMaxPos(0)
+  ,fMaxPos4(0)
+  ,fMaxPos5(0) 
 { 
   //
-  // Main contructor
+  // Default contructor
+  //
+
+}
+
+//_____________________________________________________________________________
+AliTRDtracklet::~AliTRDtracklet()
+{
+  //
+  // Destructor
   //
 
 }
index 89bc7c3..5a7d393 100644 (file)
@@ -4,63 +4,71 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
+/* $Id$ */
+
 #include <TObject.h>
 
+////////////////////////////////////////////////////////////////////////////
+//                                                                        //
+//  A TRD tracklet                                                        //
+//                                                                        //
+////////////////////////////////////////////////////////////////////////////
+
 class AliTRDtracklet : public TObject {
  
-  //friend class AliTRDtrack;
-
  public:
 
   AliTRDtracklet();
+  virtual          ~AliTRDtracklet();
 
-  void       Set(Float_t x, Float_t y, Float_t z, Float_t alpha, Float_t error2)
-                                                    { fX=x; fY=y; fZ=z; fAlpha=alpha; fSigma2= error2; }
-  void       SetP0(Float_t p0)                      { fP0             = p0;     }
-  void       SetP1(Float_t p1)                      { fP1             = p1;     }
-  void       SetN(Int_t n)                          { fNFound         = n;      }
-  void       SetNCross(Int_t nc)                    { fNCross         = nc;     }
-  void       SetPlane(Int_t plane)                  { fPlane          = plane;  }
-  void       SetSigma2(Float_t sigma2)              { fExpectedSigma2 = sigma2; }
-  void       SetChi2(Float_t chi2)                  { fChi2           = chi2;   }
-  void       SetTilt(Float_t tilt)                  { fTilt           = tilt;   }
-  void       SetMaxPos(Short_t pos, Short_t pos4, Short_t pos5)
-                                                    { fMaxPos = pos; fMaxPos4 = pos4; fMaxPos5 = pos5; }
+           void     Set(Float_t x, Float_t y, Float_t z, Float_t alpha, Float_t error2);
+           void     SetP0(Float_t p0)                      { fP0             = p0;     }
+           void     SetP1(Float_t p1)                      { fP1             = p1;     }
+           void     SetN(Int_t n)                          { fNFound         = n;      }
+           void     SetNCross(Int_t nc)                    { fNCross         = nc;     }
+           void     SetPlane(Int_t plane)                  { fPlane          = plane;  }
+           void     SetSigma2(Float_t sigma2)              { fExpectedSigma2 = sigma2; }
+           void     SetChi2(Float_t chi2)                  { fChi2           = chi2;   }
+           void     SetTilt(Float_t tilt)                  { fTilt           = tilt;   }
+           void     SetMaxPos(Short_t pos, Short_t pos4, Short_t pos5)
+                                                           { fMaxPos         = pos; 
+                                                             fMaxPos4        = pos4; 
+                                                             fMaxPos5        = pos5;   }
 
-  Float_t    GetX() const                           { return fX;                }
-  Float_t    GetY() const                           { return fY;                }
-  Float_t    GetZ() const                           { return fZ;                }
-  Float_t    GetAlpha() const                       { return fAlpha;            }
-  Float_t    GetTrackletSigma2() const              { return fSigma2;           }
-  Float_t    GetP0() const                          { return fP0;               }
-  Float_t    GetP1() const                          { return fP1;               }
-  Int_t      GetN() const                           { return fNFound;           }
-  Int_t      GetNCross() const                      { return fNCross;           }  
-  Int_t      GetPlane() const                       { return fPlane;            }
-  Float_t    GetClusterSigma2() const               { return fExpectedSigma2;   }
-  Float_t    GetChi2() const                        { return fChi2;             }
-  Float_t    GetTilt() const                        { return fTilt;             }
+           Float_t  GetX() const                           { return fX;                }
+           Float_t  GetY() const                           { return fY;                }
+           Float_t  GetZ() const                           { return fZ;                }
+           Float_t  GetAlpha() const                       { return fAlpha;            } 
+           Float_t  GetTrackletSigma2() const              { return fSigma2;           }
+           Float_t  GetP0() const                          { return fP0;               }
+           Float_t  GetP1() const                          { return fP1;               }
+           Int_t    GetN() const                           { return fNFound;           }
+           Int_t    GetNCross() const                      { return fNCross;           }  
+           Int_t    GetPlane() const                       { return fPlane;            }
+           Float_t  GetClusterSigma2() const               { return fExpectedSigma2;   }
+           Float_t  GetChi2() const                        { return fChi2;             }
+           Float_t  GetTilt() const                        { return fTilt;             }
 
  protected:
 
-  Float_t    fY;                  // y position
-  Float_t    fZ;                  // z position
-  Float_t    fX;                  // x position
-  Float_t    fAlpha;              // rotation angle
-  Float_t    fSigma2;             // expected error of tracklet position
-  Float_t    fP0;                 // offset in y
-  Float_t    fP1;                 // offset in tangent
-  Int_t      fNFound;             // number of found clusters
-  Int_t      fNCross;             // number of crosses
-  Int_t      fPlane;              // plane number
-  Float_t    fExpectedSigma2;     // expected sigma of residual distribution of clusters
-  Float_t    fChi2;               // chi2 of the tracklet
-  Float_t    fTilt;               // tilt factor 
-  Short_t    fMaxPos;             // time bin with max charge
-  Short_t    fMaxPos4;            // time bin with max charge
-  Short_t    fMaxPos5;            // time bin with max charge
+           Float_t  fY;                  //  Y position
+           Float_t  fZ;                  //  Z position
+           Float_t  fX;                  //  X position
+           Float_t  fAlpha;              //  Rotation angle
+           Float_t  fSigma2;             //  Expected error of tracklet position
+           Float_t  fP0;                 //  Offset in y
+           Float_t  fP1;                 //  Offset in tangent
+           Int_t    fNFound;             //  Number of found clusters
+           Int_t    fNCross;             //  Number of crosses
+           Int_t    fPlane;              //  Plane number
+           Float_t  fExpectedSigma2;     //  Expected sigma of residual distribution of clusters
+           Float_t  fChi2;               //  Chi2 of the tracklet
+           Float_t  fTilt;               //  Tilt factor 
+           Short_t  fMaxPos;             //  Time bin with max charge
+           Short_t  fMaxPos4;            //  Time bin with max charge
+           Short_t  fMaxPos5;            //  Time bin with max charge
 
-  ClassDef(AliTRDtracklet,2)      // The TRD tracklet in one ROC
+  ClassDef(AliTRDtracklet,2)             //  The TRD tracklet in one ROC
 
 };