Tracking in non-uniform nmagnetic field (Yu.Belikov)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 8 Jul 2005 14:01:37 +0000 (14:01 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 8 Jul 2005 14:01:37 +0000 (14:01 +0000)
40 files changed:
ANALYSIS/AliD0toKpiAnalysis.cxx
ANALYSIS/AliD0toKpiAnalysis.h
ANALYSIS/AliD0toKpiTest.C
ANALYSIS/AliReaderESD.cxx
ANALYSIS/AliTrackPoints.cxx
HLT/comp/AliL3OfflineDataCompressor.cxx
HLT/hough/AliL3HoughKalmanTrack.cxx
ITS/AliCascadeFindVertices.C
ITS/AliITSComparisonV2.C
ITS/AliITSTrackerV1.cxx
ITS/AliITSVertexerTracks.cxx
ITS/AliITSVertexerTracks.h
ITS/AliITSVertexerTracksTest.C
ITS/AliITStrackV2.cxx
ITS/AliITStrackV2.h
ITS/AliV0FindVertices.C
PHOS/AliPHOSTrackSegmentMakerv1.cxx
RAW/AliHoughFilter.cxx
RICH/AliRICH.cxx
STEER/AliESDtrack.cxx
STEER/AliESDtrack.h
STEER/AliKalmanTrack.cxx
STEER/AliKalmanTrack.h
STEER/AliReconstruction.cxx
STEER/AliReconstruction.h
STEER/AliTracker.cxx
STEER/AliTracker.h
TOF/AliTOFtrack.cxx
TOF/AliTOFtrack.h
TPC/AliTPCComparison2.C
TPC/AliTPCFindTracksMI.C
TPC/AliTPCPid.cxx
TPC/AliTPCPid.h
TPC/AliTPCSavePID.C
TPC/AliTPCtrack.cxx
TPC/AliTPCtrack.h
TPC/AliTPCtrackerParam.cxx
TRD/AliTRDtrack.cxx
TRD/AliTRDtrack.h
macros/mcminiesd.C

index cafbe6a..4da29ec 100644 (file)
@@ -53,7 +53,7 @@ ClassImp(AliD0toKpiAnalysis)
 AliD0toKpiAnalysis::AliD0toKpiAnalysis() {
   // Default constructor
 
-  SetBz();
+  fBz=-9999;
   SetPtCut();
   Setd0Cut();
   SetMassCut();
@@ -144,7 +144,6 @@ void AliD0toKpiAnalysis::FindCandidates(Int_t evFirst,Int_t evLast,
     printf("AliD0toKpiAnalysis::FindCandidates():  Set B!\n");
     return;
   }
-  AliKalmanTrack::SetConvConst(100/0.299792458/fBz);
 
   TString trkName("AliITStracksV2.root");
   if(gSystem->AccessPathName(trkName.Data(),kFileExists)) {
@@ -375,7 +374,6 @@ void AliD0toKpiAnalysis::FindCandidatesESD(Int_t evFirst,Int_t evLast,
     printf("AliD0toKpiAnalysis::FindCandidatesESD():  Set B!\n");
     return;
   }
-  AliKalmanTrack::SetConvConst(100/0.299792458/fBz);
 
   TString esdName("AliESDs.root");
   if(gSystem->AccessPathName(esdName.Data(),kFileExists)) {
index 4fb01ca..397c052 100644 (file)
@@ -13,6 +13,7 @@
 #include <TString.h>
 #include <TNamed.h>
 #include "AliESD.h"
+#include "AliMagF.h"
 #include "AliITStrackV2.h"
 
 //-----------------------------------------------------------------------------
@@ -29,7 +30,9 @@ class AliD0toKpiAnalysis : public TNamed {
   void FindCandidatesESD(Int_t evFirst=0,Int_t evLast=0,
                         const Char_t *outName="AliD0toKpi.root");
   void PrintStatus() const;
-  void SetBz(Double_t bz=-9999.) { fBz=bz; }
+  void SetBz(const AliMagF *map) { 
+     AliKalmanTrack::SetFieldMap(map); fBz=map->SolenoidField()/10.; 
+  }
   void SetVertexOnTheFly() { fVertexOnTheFly=kTRUE; }
   void SetSimulation() { fSim=kTRUE; }
   void SetOnlySignal() { fOnlySignal=kTRUE; }
index 5cb127e..e3cca46 100644 (file)
@@ -18,8 +18,9 @@ void AliD0toKpiReco() {
   if(!gSystem->AccessPathName("galice.root",kFileExists)) {
     AliRunLoader *rl = AliRunLoader::Open("galice.root");
     rl->LoadgAlice();
-    field=(Double_t)(gAlice->Field()->SolenoidField())/10.;
-    printf(" B = %3.1f T read from gAlice and set\n",field);
+    field=gAlice->Field();
+    Double_t bz=field->SolenoidField()/10.;
+    printf("B = %3.1f T read from gAlice and set\n",bz);
     delete gAlice->GetRunLoader();
     delete gAlice; 
     gAlice=0;
index 6c67639..09cf797 100644 (file)
@@ -36,6 +36,9 @@
 #include <TString.h>
 #include <TTree.h>
 
+#include "AliAnalysis.h"
+#include "AliAODRun.h"
+
 #include "AliAOD.h"
 #include "AliAODParticle.h"
 #include "AliAODParticleCut.h"
@@ -267,7 +270,7 @@ Int_t AliReaderESD::ReadESDCentral(AliESD* esd)
   if (fITSTrackPoints)
    {
      Info("ReadESD","Magnetic Field is %f",mf);
-     AliKalmanTrack::SetMagneticField(mf);
+     //AliKalmanTrack::SetMagneticField(mf);
    }
  
   AliStack* stack = 0x0;
index 0a2b510..1a6c6c6 100644 (file)
@@ -579,7 +579,7 @@ void AliTrackPoints::Testtpc(Int_t entr)
   AliRunLoader* rl = AliRunLoader::Open();
   AliLoader* l = rl->GetLoader("TPCLoader");
   rl->LoadgAlice();
-  AliKalmanTrack::SetConvConst(100/0.299792458/0.2/rl->GetAliRun()->Field()->Factor());
+  AliKalmanTrack::SetFieldMap(rl->GetAliRun()->Field());
   l->LoadTracks();
   AliTPCtrack* t = new AliTPCtrack();
   TBranch* b=l->TreeT()->GetBranch("tracks");
index d5ce7e1..08c9415 100644 (file)
@@ -83,7 +83,7 @@ void AliL3OfflineDataCompressor::LoadData(Int_t event,Bool_t sp)
   fEvent = event;
 
   char filename[1024];
-  AliKalmanTrack::SetConvConst(1000/0.299792458/AliL3Transform::GetSolenoidField());
+  //AliKalmanTrack::SetConvConst(1000/0.299792458/AliL3Transform::GetSolenoidField());
   if(fMarian==kFALSE)
     sprintf(filename,"%s/offline/AliTPCclusters.root",fPath);
   else
@@ -102,7 +102,7 @@ void AliL3OfflineDataCompressor::LoadData(Int_t event,Bool_t sp)
     fTracker = new AliTPCtracker(param);
   else
     fTracker = new AliTPCtrackerMI(param);
-  fTracker->SetEventNumber(event);
+  //fTracker->SetEventNumber(event);
 #ifdef asvversion
   fTracker->LoadClusters();
 #endif  
index a6e4015..eaffbb9 100644 (file)
@@ -65,6 +65,8 @@ AliL3HoughKalmanTrack::AliL3HoughKalmanTrack(const AliL3HoughTrack& t) throw (co
   fP3=xx[3];
   fP4=xx[4];
 
+  SaveLocalConvConst();
+
   //and covariance matrix
   //For the moment estimate the covariance matrix numerically
   Double_t xx1[5];
index b85e761..cad12d6 100644 (file)
@@ -8,7 +8,7 @@
   #include "AliRun.h"
   #include "AliMagF.h"
   #include "AliESD.h"
-  #include "AliKalmanTrack.h"
+  #include "AliTracker.h"
   #include "AliRunLoader.h"
 #endif
 
@@ -32,10 +32,8 @@ Int_t AliCascadeFindVertices(Int_t nev=5) {
       return 3;
    }
 
-   AliKalmanTrack::SetConvConst(
-      1000/0.299792458/rl->GetAliRun()->Field()->SolenoidField()
-   );
-       
+   // Magnetic field
+   AliTracker::SetFieldMap(gAlice->Field(),1); // 1 means uniform magnetic field
    Double_t cuts[]={33.,    // max. allowed chi2
                     0.05,   // min. allowed V0 impact parameter 
                     0.008,  // window around the Lambda mass 
index d82b716..9e483b7 100644 (file)
@@ -33,7 +33,6 @@
 
   #include "AliITS.h"
   #include "AliITSgeom.h"
-  #include "AliITStrackV2.h"
   #include "AliITSclusterV2.h"
   #include "AliITSLoader.h"
 #endif
@@ -159,9 +158,6 @@ Int_t AliITSComparisonV2
    while (esdTree->GetEvent(e)) {
      cout<<endl<<endl<<"********* Processing event number: "<<e<<"*******\n";
  
-     Float_t field=event->GetMagneticField();
-     AliKalmanTrack::SetConvConst(1000/0.299792458/field);
      Int_t nentr=event->GetNumberOfTracks();
      allfound+=nentr;
 
@@ -192,16 +188,12 @@ Int_t AliITSComparisonV2
 
         AliESDtrack *esd=0;
         Int_t cnt=0;
-        Int_t pipe=0;
         for (Int_t i=0; i<nentr; i++) {
            AliESDtrack *t=event->GetTrack(i);
           UInt_t status=t->GetStatus();
-          UInt_t flags=AliESDtrack::kTPCin|AliESDtrack::kITSin;
 
            if ((status&AliESDtrack::kITSrefit)==0) continue;
 
-           if ((status&flags)==status) pipe=1;
-
            Int_t lbl=t->GetLabel();
            if (lab==TMath::Abs(lbl)) {
              if (cnt==0) {esd=t; tlab=lbl;}
@@ -224,14 +216,8 @@ Int_t AliITSComparisonV2
           hfake->Fill(ptg); 
         }
 
-        AliITStrackV2 track(*esd);
-        if (pipe!=0) {
-           track.PropagateTo(3.,0.0028,65.19);
-           track.PropagateToVertex();  // This is not "exactly" the vertex 
-        }
-
-        Double_t xv,par[5]; track.GetExternalParameters(xv,par);
-        Float_t phi=TMath::ASin(par[2]) + track.GetAlpha();
+        Double_t xv,par[5]; esd->GetExternalParameters(xv,par);
+        Float_t phi=TMath::ASin(par[2]) + esd->GetAlpha();
         if (phi<-TMath::Pi()) phi+=2*TMath::Pi();
         if (phi>=TMath::Pi()) phi-=2*TMath::Pi();
         Float_t lam=TMath::ATan(par[3]); 
@@ -243,16 +229,14 @@ Int_t AliITSComparisonV2
         Float_t lamg=TMath::ATan2(ref->Pz(),ptg);
         hl->Fill((lam - lamg)*1000.);
 
-        Double_t d=10000*track.GetD(ref->X(),ref->Y());
-        hmpt->Fill(d);
-
-        Double_t z=10000*(track.GetZ()-ref->Z());
-        hz->Fill(z);
+        Float_t d,z; esd->GetImpactParameters(d,z);
+        hmpt->Fill(10000*d);
+        hz->Fill(10000*(z-ref->Z()));
 
         hpt->Fill((pt_1 - 1/ptg)/(1/ptg)*100.);
 
         Float_t mom=1./(pt_1*TMath::Cos(lam));
-        Float_t dedx=track.GetdEdx();
+        Float_t dedx=esd->GetITSsignal();
         hep->Fill(mom,dedx,1.);
 
         Int_t pdg=(Int_t)ref->GetLength();  //this is particle's PDG !
index be8b485..95b61ba 100644 (file)
@@ -514,7 +514,7 @@ void AliITSTrackerV1::DoTracking(Int_t evNumber,Int_t minTr,Int_t maxTr,
 
     gAlice->GetEvent(evNumber);  //modificato per gestire hbt
  
-    AliKalmanTrack::SetConvConst(1000/0.299792458/gAlice->Field()->SolenoidField());
+    AliKalmanTrack::SetFieldMap(gAlice->Field());
    // cout<<" field = "<<gAlice->Field()->SolenoidField()<<endl;
 
 
index e542b73..5b772cf 100644 (file)
@@ -57,7 +57,7 @@ AliITSVertexerTracks::AliITSVertexerTracks():AliITSVertexer() {
 }
 //----------------------------------------------------------------------------
 AliITSVertexerTracks::AliITSVertexerTracks(TFile *inFile,TFile *outFile,
-                                           Double_t field,
+                                           const AliMagF *map,
                                            Int_t fEv,Int_t lEv,
                                            Double_t xStart,Double_t yStart) {
 //
@@ -68,7 +68,7 @@ AliITSVertexerTracks::AliITSVertexerTracks(TFile *inFile,TFile *outFile,
   fOutFile = outFile;
   SetFirstEvent(fEv);
   SetLastEvent(lEv);
-  SetField(field);
+  SetFieldMap(map);
   SetVtxStart(xStart,yStart);
   SetMinTracks();
   fTrksToSkip = 0;
@@ -77,7 +77,7 @@ AliITSVertexerTracks::AliITSVertexerTracks(TFile *inFile,TFile *outFile,
   SetDebug();
 }
 //----------------------------------------------------------------------------
-AliITSVertexerTracks::AliITSVertexerTracks(Double_t field, TString fn,
+AliITSVertexerTracks::AliITSVertexerTracks(const AliMagF *map, TString fn,
                                           Double_t xStart,Double_t yStart)
                                           :AliITSVertexer(fn) {
 //
@@ -85,7 +85,7 @@ AliITSVertexerTracks::AliITSVertexerTracks(Double_t field, TString fn,
 //
   fInFile  = 0;
   fOutFile = 0;
-  SetField(field);
+  SetFieldMap(map);
   SetVtxStart(xStart,yStart);
   SetMinTracks();
   fTrksToSkip = 0;
@@ -345,7 +345,7 @@ AliESDVertex* AliITSVertexerTracks::FindVertexForCurrentEvent(AliESD *esdEvent)
 
   for(Int_t i=0; i<entr; i++) {
     AliESDtrack *esdTrack = (AliESDtrack*)esdEvent->GetTrack(i);
-    if(!(esdTrack->GetStatus()&AliESDtrack::kITSin))
+    if(!esdTrack->GetStatus()&AliESDtrack::kITSin)
       { delete esdTrack; continue; }
     try {
       itstrack = new AliITStrackV2(*esdTrack);
index f37c68a..f51939e 100644 (file)
@@ -41,10 +41,10 @@ class AliITSVertexerTracks : public AliITSVertexer {
   AliITSVertexerTracks();  
   // standard constructor     
   AliITSVertexerTracks(TFile *inFile,TFile *outFile,
-                      Double_t field=0.4,Int_t fEv=0,Int_t lEv=0,
+               const AliMagF *map,Int_t fEv=0,Int_t lEv=0,
                       Double_t xStart=0.,Double_t yStart=0.);
   // alternative constructor
-  AliITSVertexerTracks(Double_t field, TString fn,
+  AliITSVertexerTracks(const AliMagF *map, TString fn,
                       Double_t xStart=0,Double_t yStart=0); 
   // destructor
   virtual ~AliITSVertexerTracks();
@@ -59,8 +59,7 @@ class AliITSVertexerTracks : public AliITSVertexer {
   // computes the vertex for each event and stores it in the ESD
   void FindVerticesESD();
   virtual void  PrintStatus() const;
-  void  SetField(Double_t field) const
-    { AliKalmanTrack::SetConvConst(100./0.299792458/field); return; }
+  void  SetFieldMap(const AliMagF *map)const{AliKalmanTrack::SetFieldMap(map);}
   void  SetMinTracks(Int_t n=2) { fMinTracks = n; return; }
   void  SetSkipTracks(Int_t n,Int_t *skipped); 
   void  SetVtxStart(Double_t x=0,Double_t y=0) 
index e70ac0f..22d8c5d 100644 (file)
 #include "AliRun.h"
 #include "AliRunLoader.h"
 #include "AliMagF.h"
-#include "AliKalmanTrack.h"
 #include "AliESDVertex.h"
 #include "AliITSVertexer.h"
 #include "AliITSVertexerTracks.h"
+#include "AliTracker.h"
 //-------------------------------------
 #endif
 void AliITSVertexerTracksTest(Int_t evFirst=0,Int_t evLast=0,Bool_t esd=kTRUE,
@@ -53,8 +53,9 @@ void AliITSVertexerTracksTest(Int_t evFirst=0,Int_t evLast=0,Bool_t esd=kTRUE,
     rl->LoadgAlice();
     AliMagF *fiel = (AliMagF*)gAlice->Field();
     field=(Double_t)fiel->SolenoidField()/10.;
-    AliKalmanTrack::SetConvConst(100/0.299792458/field);
     printf(" B = %3.1f read from gAlice and set\n",field);
+
+    AliTracker::SetFieldMap(gAlice->Field(),1); // 1 means uniform magnetic field
   } else {
     printf(" File galice.root not found: default 0.4 T being used!\n");
   }
@@ -97,8 +98,11 @@ void VertexRecoInESDChain() {
     rl->LoadgAlice();
     AliMagF *fiel = (AliMagF*)gAlice->Field();
     field=(Double_t)fiel->SolenoidField()/10.;
-    AliKalmanTrack::SetConvConst(100/0.299792458/field);
     printf(" B = %3.1f read from gAlice and set\n",field);
+
+    AliTracker::SetFieldMap(gAlice->Field(),1); // 1 means uniform magnetic field
+
+
   } else {
     printf(" File galice.root not found: default 0.4 T being used!\n");
   }
index af3a54b..5b2ba58 100644 (file)
@@ -83,11 +83,11 @@ AliKalmanTrack() {
   Double_t x,p[5]; 
   if (c) t.GetConstrainedExternalParameters(x,p);
   else t.GetExternalParameters(x,p);
-  fX=x;    x=GetConvConst();
+  fX=x;   
   fP0=p[0]; 
-  fP1=p[1]; 
+  fP1=p[1];   SaveLocalConvConst(); 
   fP2=p[2];
-  fP3=p[3];
+  fP3=p[3];   x=GetLocalConvConst();
   fP4=p[4]/x; 
 
   //Conversion of the covariance matrix
@@ -109,7 +109,6 @@ AliKalmanTrack() {
 
   //  if (!Invariant()) throw "AliITStrackV2: conversion failed !\n";
   for(Int_t i=0; i<4; i++) fdEdxSample[i]=0;
-
 }
 
 void AliITStrackV2::UpdateESDtrack(ULong_t flags) const {
@@ -165,7 +164,7 @@ void AliITStrackV2::GetExternalCovariance(Double_t cc[15]) const {
   // This function returns an external representation of the covriance matrix.
   //   (See comments in AliTPCtrack.h about external track representation)
   //-------------------------------------------------------------------------
-  Double_t a=GetConvConst();
+  Double_t a=GetLocalConvConst();
 
   cc[0 ]=fC00;
   cc[1 ]=fC10;   cc[2 ]=fC11;
@@ -278,14 +277,15 @@ Int_t AliITStrackV2::PropagateTo(Double_t xk, Double_t d, Double_t x0) {
   //------------------------------------------------------------------
   Double_t x1=fX, x2=xk, dx=x2-x1;
   Double_t f1=fP2, f2=f1 + fP4*dx;
-  if (TMath::Abs(f2) >= 0.98) {   
+  if (TMath::Abs(f2) >= 0.98) {
     // MI change  - don't propagate highly inclined tracks
     //              covariance matrix distorted
-    // Int_t n=GetNumberOfClusters();
-    //     if (n>kWARN) 
-    //        Warning("PropagateTo","Propagation failed !\n",n);
+    //Int_t n=GetNumberOfClusters();
+    //if (n>kWARN) 
+    //   Warning("PropagateTo","Propagation failed !\n",n);
     return 0;
   }
+  Double_t lcc=GetLocalConvConst();  
 
   // old position [SR, GSI, 17.02.2003]
   Double_t oldX = fX, oldY = fP0, oldZ = fP1;
@@ -338,6 +338,10 @@ Int_t AliITStrackV2::PropagateTo(Double_t xk, Double_t d, Double_t x0) {
 
   fX=x2;
 
+  //Change of the magnetic field *************
+  SaveLocalConvConst();
+  fP4*=lcc/GetLocalConvConst();
+
   if (!CorrectForMaterial(d,x0)) return 0;
 
   // Integrated Time [SR, GSI, 17.02.2003]
@@ -506,23 +510,28 @@ Int_t AliITStrackV2::Propagate(Double_t alp,Double_t xk) {
   {
   Double_t dx=xk-fX;
   Double_t f1=fP2, f2=f1 + fP4*dx;
-  if (TMath::Abs(f2) >= 0.98) {  
+  if (TMath::Abs(f2) >= 0.98) {
     // don't propagate highly inclined tracks MI
     return 0;
   }
- //  if (TMath::Abs(f2) >= 0.9999) {
-//     Int_t n=GetNumberOfClusters();
-//     if (n>kWARN) 
-//        Warning("Propagate","Propagation failed (%d) !\n",n);
-//     return 0;
-//   }
+  //    Int_t n=GetNumberOfClusters();
+  //  if (n>kWARN) 
+  //     Warning("Propagate","Propagation failed (%d) !\n",n);
+  //  return 0;
+  //}
+  Double_t lcc=GetLocalConvConst();  
+
   Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
-  
+
   fX=xk;
   fP0 += dx*(f1+f2)/(r1+r2);
   fP1 += dx*(f1+f2)/(f1*r2 + f2*r1)*fP3;
   fP2 += dx*fP4;
 
+  //Change of the magnetic field *************
+  SaveLocalConvConst();
+  fP4*=lcc/GetLocalConvConst();
+
   //f = F - 1
   
   Double_t f02=    dx/(r1*r1*r1);
index c197964..a9b4772 100644 (file)
@@ -64,8 +64,9 @@ public:
   Double_t GetSnp()  const {return fP2;}
   Double_t GetTgl()  const {return fP3;}
   Double_t GetC()    const {return fP4;}
-  Double_t
-    Get1Pt() const { return (1e-9*TMath::Abs(fP4)/fP4 + fP4)*GetConvConst(); }
+  Double_t Get1Pt() const {
+      return (TMath::Sign(1e-9,fP4) + fP4)*GetLocalConvConst();
+  }
   Double_t GetD(Double_t x=0, Double_t y=0) const;
   Double_t GetZat(Double_t x=0) const;
 
@@ -80,6 +81,8 @@ public:
    Int_t Invariant() const;
  
 protected:
+  void GetXYZ(Float_t r[3]) const;
+
   Double_t fX;              // X-coordinate of this track (reference plane)
   Double_t fAlpha;          // rotation angle
 
@@ -125,6 +128,15 @@ void AliITStrackV2::SetSampledEdx(Float_t q, Int_t i) {
   q *= TMath::Sqrt((1-s*s)/(1+t*t));
   fdEdxSample[i]=q;
 }
+
+inline void AliITStrackV2::GetXYZ(Float_t r[3]) const {
+  //---------------------------------------------------------------------
+  // Returns the position of the track in the global coord. system 
+  //---------------------------------------------------------------------
+  Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
+  r[0]=fX*cs - fP0*sn; r[1]=fX*sn + fP0*cs; r[2]=fP1;
+}
+
 #endif
 
 
index 338ae94..5c917ec 100644 (file)
@@ -10,7 +10,7 @@
   #include "TStopwatch.h"
 
   #include "AliRun.h"
-  #include "AliKalmanTrack.h"
+  #include "AliTracker.h"
   #include "AliMagF.h"
   #include "AliESD.h"
   #include "AliRunLoader.h"
@@ -39,9 +39,8 @@ Int_t AliV0FindVertices(Int_t nev=5) {
       return 3;
    }
 
-   AliKalmanTrack::SetConvConst(
-      1000/0.299792458/rl->GetAliRun()->Field()->SolenoidField()
-   );
+   // Magnetic field
+   AliTracker::SetFieldMap(gAlice->Field(),1); // 1 means uniform magnetic field
        
    Double_t cuts[]={33,  // max. allowed chi2
                     0.16,// min. allowed negative daughter's impact parameter 
index c8f6b66..dae9b9a 100644 (file)
@@ -17,6 +17,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.73  2005/05/28 14:19:05  schutz
+ * Compilation warnings fixed by T.P.
+ *
  */
 
 //_________________________________________________________________________
@@ -169,11 +172,11 @@ Float_t  AliPHOSTrackSegmentMakerv1::GetDistanceInPHOSPlane(AliPHOSEmcRecPoint *
        track = fESD->GetTrack(iTrack);
        if (track->IsPHOS()) 
          continue ; 
-       if (!track->GetXYZAt(rPHOS,xyz))
+       if (!track->GetXYZAt(rPHOS, fESD->GetMagneticField(), xyz))
            continue; //track coord on the cylinder of PHOS radius
        if ((TMath::Abs(xyz[0])+TMath::Abs(xyz[1])+TMath::Abs(xyz[2]))<=0)
           continue;
-       if (!track->GetPxPyPzAt(rPHOS,pxyz))
+       if (!track->GetPxPyPzAt(rPHOS, fESD->GetMagneticField(), pxyz))
            continue; // track momentum ibid.
        vecDist = PropagateToPlane(xyz,pxyz,"CPV",cpvClu->GetPHOSMod());
        //      Info("GetDistanceInPHOSPlane","Track %d propagation to CPV = (%f,%f,%f)",
@@ -189,7 +192,7 @@ Float_t  AliPHOSTrackSegmentMakerv1::GetDistanceInPHOSPlane(AliPHOSEmcRecPoint *
 
       if (iClosestTrack != -1) {
        track = fESD->GetTrack(iClosestTrack);
-       if (track->GetPxPyPzAt(rPHOS,pxyz)) { // track momentum ibid.
+       if (track->GetPxPyPzAt(rPHOS, fESD->GetMagneticField(), pxyz)) { // track momentum ibid.
        TVector3 vecCpvGlobal; // Global position of the CPV recpoint
        AliPHOSGetter * gime = AliPHOSGetter::Instance() ; 
        const AliPHOSGeometry * geom = gime->PHOSGeometry() ; 
index 29b04f8..7064e0b 100644 (file)
@@ -62,11 +62,8 @@ AliHoughFilter::AliHoughFilter()
     AliError("HLT initialization failed!");
 
   // Init magnetic field
-  AliKalmanTrack::SetConvConst(
-     1000/0.299792458/AliL3Transform::GetSolenoidField()
-  );
   AliMagF* field = new AliMagFMaps("Maps","Maps", 2, 1., 10., AliMagFMaps::k5kG);
-  AliTracker::SetFieldMap(field);
+  AliTracker::SetFieldMap(field,kTRUE);
   fPtmin = 0.1*AliL3Transform::GetSolenoidField();
 
   // Init ITS geometry
index 951ccd0..ff38f6f 100644 (file)
@@ -960,7 +960,7 @@ void AliRICH::CheckPR()const
 //  printf("\n\n");
 //  printf("Pattern Recognition done for event %5i",0);
   AliMagF * magf = gAlice->Field();
-  AliTracker::SetFieldMap(magf);
+  AliTracker::SetFieldMap(magf,kTRUE);
   for(Int_t iEvtN=0;iEvtN<GetLoader()->GetRunLoader()->GetNumberOfEvents();iEvtN++) {
     GetLoader()->GetRunLoader()->GetEvent(iEvtN);
     AliRICHTracker *tr = new AliRICHTracker();
index 6cc1016..9299585 100644 (file)
@@ -518,13 +518,15 @@ void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
 }
 
 //_______________________________________________________________________
-Bool_t AliESDtrack::GetExternalParametersAt(Double_t x, Double_t p[5]) const {
+Bool_t AliESDtrack::
+GetExternalParametersAt(Double_t x, Double_t b, Double_t p[5]) const {
   //---------------------------------------------------------------------
-  // This function returns external representation of the track parameters
-  // at the position given by the first argument 
+  // This function returns external track parameters extrapolated to
+  // the radial position "x" (cm) in the magnetic field "b" (kG)  
   //---------------------------------------------------------------------
+  Double_t convconst=0.299792458*b/1000.;
   Double_t dx=x-fRx;
-  Double_t f1=fRp[2], f2=f1 + dx*fRp[4]/AliKalmanTrack::GetConvConst();
+  Double_t f1=fRp[2], f2=f1 + dx*fRp[4]*convconst;
 
   if (TMath::Abs(f2) >= 0.9999) return kFALSE;
   
@@ -577,12 +579,14 @@ Double_t AliESDtrack::GetP() const {
 }
 
 //_______________________________________________________________________
-Double_t AliESDtrack::GetD(Double_t x, Double_t y) const {
+Double_t AliESDtrack::GetD(Double_t b, Double_t x, Double_t y) const {
   //------------------------------------------------------------------
   // This function calculates the transverse impact parameter
   // with respect to a point with global coordinates (x,y)
+  // in the magnetic field "b" (kG)
   //------------------------------------------------------------------
-  Double_t rp4=fRp[4]/AliKalmanTrack::GetConvConst();
+  Double_t convconst=0.299792458*b/1000.;
+  Double_t rp4=fRp[4]*convconst;
 
   Double_t xt=fRx, yt=fRp[0];
 
@@ -779,24 +783,26 @@ void  AliESDtrack::GetTRDExternalParameters(Double_t &x, Double_t&alpha, Double_
   for (Int_t i=0; i<15; i++) cov[i]=fTc[i];
 }
 
-Bool_t AliESDtrack::GetPxPyPzAt(Double_t x,Double_t *p) const {
+Bool_t AliESDtrack::GetPxPyPzAt(Double_t x, Double_t b, Double_t *p) const {
   //---------------------------------------------------------------------
-  // This function returns the global track momentum components
-  // at the position "x" using the helix track approximation
+  // This function returns the global track momentum extrapolated to
+  // the radial position "x" (cm) in the magnetic field "b" (kG)
   //---------------------------------------------------------------------
+  Double_t convconst=0.299792458*b/1000.;
   p[0]=fRp[4]; 
-  p[1]=fRp[2]+(x-fRx)*fRp[4]/AliKalmanTrack::GetConvConst(); 
+  p[1]=fRp[2]+(x-fRx)*fRp[4]*convconst; 
   p[2]=fRp[3];
   return Local2GlobalMomentum(p,fRalpha);
 }
 
-Bool_t AliESDtrack::GetXYZAt(Double_t x, Double_t *r) const {
+Bool_t AliESDtrack::GetXYZAt(Double_t x, Double_t b, Double_t *r) const {
   //---------------------------------------------------------------------
-  // This function returns the global track position
-  // af the radius "x" using the helix track approximation
+  // This function returns the global track position extrapolated to
+  // the radial position "x" (cm) in the magnetic field "b" (kG)
   //---------------------------------------------------------------------
+  Double_t convconst=0.299792458*b/1000.;
   Double_t dx=x-fRx;
-  Double_t f1=fRp[2], f2=f1 + dx*fRp[4]/AliKalmanTrack::GetConvConst();
+  Double_t f1=fRp[2], f2=f1 + dx*fRp[4]*convconst;
 
   if (TMath::Abs(f2) >= 0.9999) return kFALSE;
   
@@ -871,25 +877,11 @@ Float_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
   if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
   return density;
 }
+
 //_______________________________________________________________________
 void AliESDtrack::SetTPCpid(const Double_t *p) {  
   // Sets values for the probability of each particle type (in TPC)
-  // normalize probabiluty to 1
-  // 
-  //
-//   Double_t sump=0;
-//   for (Int_t i=0; i<AliPID::kSPECIES; i++) {
-//     sump+=p[i];
-//   }
-//   for (Int_t i=0; i<AliPID::kSPECIES; i++) {
-//     if (sump>0){
-//       fTPCr[i]=p[i]/sump;
-//     }
-//     else{
-//       fTPCr[i]=p[i];
-//     }
-//   }
-  for (Int_t i=0; i<AliPID::kSPECIES; i++) fTPCr[i] = p[i];
+  for (Int_t i=0; i<AliPID::kSPECIES; i++) fTPCr[i]=p[i];
   SetStatus(AliESDtrack::kTPCpid);
 }
 
index c3ba585..738fb11 100644 (file)
@@ -55,12 +55,12 @@ public:
   void GetExternalParameters(Double_t &x, Double_t p[5]) const;
   void GetExternalCovariance(Double_t cov[15]) const;
 
-  Bool_t GetExternalParametersAt(Double_t x, Double_t p[5]) const;
-  Bool_t GetPxPyPzAt(Double_t x, Double_t p[3]) const;
-  Bool_t GetXYZAt(Double_t x, Double_t r[3]) const;
+  Bool_t GetExternalParametersAt(Double_t x, Double_t b, Double_t p[5]) const;
+  Bool_t GetPxPyPzAt(Double_t x, Double_t b, Double_t p[3]) const;
+  Bool_t GetXYZAt(Double_t x, Double_t b, Double_t r[3]) const;
 
   void GetImpactParameters(Float_t &xy,Float_t &z) const {xy=fD; z=fZ;}
-  Double_t GetD(Double_t x=0, Double_t y=0) const; //calculate the transverse impact parameter w.r.t. (x,y)
+  Double_t GetD(Double_t b, Double_t x=0, Double_t y=0) const; 
   Double_t GetIntegratedLength() const {return fTrackLength;}
   void GetIntegratedTimes(Double_t *times) const;
   Double_t GetMass() const;
@@ -261,7 +261,7 @@ protected:
   // TPC related track information
   Float_t fTPCchi2;        // chi2 in the TPC
   Int_t   fTPCncls;        // number of clusters assigned in the TPC
-  Int_t   fTPCindex[180];  //! indices of the assigned TPC clusters
+  Int_t  fTPCindex[180];  //! indices of the assigned TPC clusters
   TBits   fTPCClusterMap;  // Map of clusters, one bit per padrow; 1 if has a cluster on given padrow
   Float_t fTPCsignal;      // detector's PID signal
   Float_t fTPCr[AliPID::kSPECIES]; // "detector response probabilities" (for the PID)
@@ -289,7 +289,7 @@ protected:
   Float_t fTOFsignal;      // detector's PID signal
   Float_t fTOFr[AliPID::kSPECIES]; // "detector response probabilities" (for the PID)
   Int_t   fTOFLabel[3];       // TOF label 
-  Float_t fTOFInfo[10];       // TOF informations
+  Float_t fTOFInfo[10];       //! TOF informations
 
   // PHOS related track information 
   Float_t fPHOSpos[3]; // position localised by PHOS in global coordinate system
index 8bc4e04..ee81e63 100644 (file)
 //-------------------------------------------------------------------------
 
 #include "AliKalmanTrack.h"
-#include "AliLog.h"
 
 ClassImp(AliKalmanTrack)
 
-Double_t AliKalmanTrack::fgConvConst = 0;
+const AliMagF *AliKalmanTrack::fgkFieldMap=0;
+Double_t AliKalmanTrack::fgConvConst=0.;
 
 //_______________________________________________________________________
 AliKalmanTrack::AliKalmanTrack():
-  TObject(),
   fLab(-3141593),
   fFakeRatio(0),
   fChi2(0),
   fMass(AliPID::ParticleMass(AliPID::kPion)),
   fN(0),
+  fLocalConvConst(0),
   fStartTimeIntegral(kFALSE),
   fIntegratedLength(0)
 {
   //
   // Default constructor
   //
-    if (fgConvConst==0) {
+    if (fgkFieldMap==0) {
       AliFatal("The magnetic field has not been set!");
     }
-    
-    for(Int_t i=0; i<5; i++) fIntegratedTime[i] = 0;
+
+    for(Int_t i=0; i<AliPID::kSPECIES; i++) fIntegratedTime[i] = 0;
 }
 
 //_______________________________________________________________________
@@ -57,19 +57,19 @@ AliKalmanTrack::AliKalmanTrack(const AliKalmanTrack &t):
   fChi2(t.fChi2),
   fMass(t.fMass),
   fN(t.fN),
+  fLocalConvConst(t.fLocalConvConst),
   fStartTimeIntegral(t.fStartTimeIntegral),
   fIntegratedLength(t.fIntegratedLength)
 {
   //
   // Copy constructor
   //
-  if (fgConvConst==0) {
+  if (fgkFieldMap==0) {
     AliFatal("The magnetic field has not been set!");
   }
-
   
-  for (Int_t i=0; i<5; i++) 
-    fIntegratedTime[i] = t.fIntegratedTime[i];
+  for (Int_t i=0; i<AliPID::kSPECIES; i++)
+      fIntegratedTime[i] = t.fIntegratedTime[i];
 }
 
 //_______________________________________________________________________
@@ -190,12 +190,12 @@ void AliKalmanTrack::PrintTime() const
   printf("\n");  
 }
 
-static void External2Helix(const AliKalmanTrack *t, Double_t helix[6]) { 
+void AliKalmanTrack::External2Helix(Double_t helix[6]) const { 
   //--------------------------------------------------------------------
   // External track parameters -> helix parameters 
   //--------------------------------------------------------------------
   Double_t alpha,x,cs,sn;
-  t->GetExternalParameters(x,helix); alpha=t->GetAlpha();
+  GetExternalParameters(x,helix); alpha=GetAlpha();
 
   cs=TMath::Cos(alpha); sn=TMath::Sin(alpha);
   helix[5]=x*cs - helix[0]*sn;            // x0
@@ -203,7 +203,7 @@ static void External2Helix(const AliKalmanTrack *t, Double_t helix[6]) {
 //helix[1]=                               // z0
   helix[2]=TMath::ASin(helix[2]) + alpha; // phi0
 //helix[3]=                               // tgl
-  helix[4]=helix[4]/t->GetConvConst();    // C
+  helix[4]=helix[4]/GetLocalConvConst();  // C
 }
 
 static void Evaluate(const Double_t *h, Double_t t,
@@ -240,9 +240,9 @@ GetDCA(const AliKalmanTrack *p, Double_t &xthis, Double_t &xp) const {
 
   //dx2=dy2=dz2=1.;
 
-  Double_t p1[8]; External2Helix(this,p1);
+  Double_t p1[8]; External2Helix(p1);
   p1[6]=TMath::Sin(p1[2]); p1[7]=TMath::Cos(p1[2]);
-  Double_t p2[8]; External2Helix(p,p2);
+  Double_t p2[8]; p->External2Helix(p2);
   p2[6]=TMath::Sin(p2[2]); p2[7]=TMath::Cos(p2[2]);
 
 
@@ -346,3 +346,4 @@ PropagateToDCA(AliKalmanTrack *p, Double_t d, Double_t x0) {
 
   return dca;
 }
+
index c453e50..6055afe 100644 (file)
@@ -13,7 +13,9 @@
 //-------------------------------------------------------------------------
 
 #include <TObject.h>
+#include "AliLog.h"
 #include "AliPID.h"
+#include "AliMagF.h"
 
 class AliCluster;
 
@@ -33,11 +35,11 @@ public:
   Double_t GetMass()    const {return fMass;}
   Int_t    GetNumberOfClusters() const {return fN;}
   virtual Int_t GetClusterIndex(Int_t) const { //reserved for AliTracker
-    Warning("GetClusterIndex(Int_t)","Method must be overloaded !\n");
+    AliWarning("Method must be overloaded !\n");
     return 0;
   } 
   virtual Double_t GetPIDsignal() const {
-    Warning("GetPIDsignal()","Method must be overloaded !\n");
+    AliWarning("Method must be overloaded !\n");
     return 0.;
   }
 
@@ -45,39 +47,42 @@ public:
   virtual 
   Double_t PropagateToDCA(AliKalmanTrack *p, Double_t d=0., Double_t x0=0.); 
   virtual Double_t GetAlpha() const {
-    Warning("GetAlpha()","Method must be overloaded !\n");
+    AliWarning("Method must be overloaded !\n");
     return 0.;
   }
   virtual Double_t GetSigmaY2() const {
-    Warning("GetSigmaY2()","Method must be overloaded !\n");
+    AliWarning("Method must be overloaded !\n");
     return 0.;
   }
   virtual Double_t GetSigmaZ2() const {
-    Warning("GetSigmaZ2()","Method must be overloaded !\n");
+    AliWarning("Method must be overloaded !\n");
     return 0.;
   }
 
   virtual Int_t Compare(const TObject *) const {return 0;} 
 
-  virtual void GetExternalParameters(Double_t &/*xr*/, Double_t /*x*/[5]) const {}
-  virtual void GetExternalCovariance(Double_t /*cov*/[15]) const {}
+  virtual void GetExternalParameters(Double_t&/*xr*/,Double_t/*x*/[5]) const=0;
+  virtual void GetExternalCovariance(Double_t /*cov*/[15]) const = 0;
 
-  virtual Double_t GetPredictedChi2(const AliCluster *) const {return 0.;}
-  virtual Int_t 
-  PropagateTo(Double_t /*xr*/, Double_t /*x0*/, Double_t /*rho*/) {return 0;}
-  virtual Int_t PropagateToVertex(Double_t /*d*/=0., Double_t /*x0*/=0.) 
-    {return 0;}
-  virtual Int_t 
-  Update(const AliCluster*, Double_t /*chi2*/, UInt_t) {return 0;}
+  virtual Double_t GetPredictedChi2(const AliCluster *) const = 0;
+  virtual Int_t PropagateTo(Double_t/*xr*/,Double_t/*x0*/,Double_t/*rho*/) = 0;
+  //virtual Int_t PropagateToVertex(Double_t /*d*/=0., Double_t /*x0*/=0.) = 0; 
+  virtual Int_t Update(const AliCluster*, Double_t /*chi2*/, UInt_t) = 0;
 
-  static void SetConvConst(Double_t cc) {fgConvConst=cc;}
-  static Double_t GetConvConst() {return fgConvConst;}
+  static void SetFieldMap(const AliMagF *map) { fgkFieldMap=map; }
+  static const AliMagF *GetFieldMap() { return fgkFieldMap; }
 
-  static void SetMagneticField(Double_t f) {// f - Magnetic field in T
-    fgConvConst=100/0.299792458/f;
+  static void SetUniformFieldTracking() {
+     if (fgkFieldMap==0) {
+        printf("AliKalmanTrack: Field map has not been set !\n"); 
+        exit(1);
+     } 
+     fgConvConst=1000/0.299792458/(fgkFieldMap->SolenoidField()+1e-13);
   }
-  Double_t GetMagneticField() const {return 100/0.299792458/fgConvConst;}
+  static void SetNonuniformFieldTracking() { fgConvConst=0.; }
 
+  static Double_t GetConvConst();
   // Time integration (S.Radomski@gsi.de)
   void   StartTimeIntegral();
   void SetIntegratedLength(Double_t l) {fIntegratedLength=l;}
@@ -91,6 +96,12 @@ public:
   void PrintTime() const;
 
 protected:
+  virtual void GetXYZ(Float_t r[3]) const = 0;
+  void     SaveLocalConvConst();
+  Double_t GetLocalConvConst() const;
+
+  void External2Helix(Double_t helix[6]) const;
+
   void SetChi2(Double_t chi2) {fChi2=chi2;} 
   void SetMass(Double_t mass) {fMass=mass;}
   void SetNumberOfClusters(Int_t n) {fN=n;} 
@@ -100,17 +111,46 @@ protected:
   Double_t fChi2;         // total chi2 value for this track
   Double_t fMass;         // mass hypothesis
   Int_t fN;               // number of associated clusters
- private:
-  static Double_t fgConvConst; //conversion constant cm -> GeV/c
+
+private:
+  static const AliMagF *fgkFieldMap;//pointer to the magnetic field map
+  static Double_t fgConvConst;      //conversion "curvature(1/cm) -> pt(GeV/c)"
+  Double_t fLocalConvConst;   //local conversion "curvature(1/cm) -> pt(GeV/c)"
 
   // variables for time integration (S.Radomski@gsi.de)
   Bool_t  fStartTimeIntegral;       // indicator wether integrate time
   Double_t fIntegratedTime[AliPID::kSPECIES];       // integrated time
   Double_t fIntegratedLength;        // integrated length
   
-  ClassDef(AliKalmanTrack,3)    // Reconstructed track
+  ClassDef(AliKalmanTrack,4)    // Reconstructed track
 };
 
+inline Double_t AliKalmanTrack::GetConvConst() {
+//
+//  For backward compatibility only !
+//
+    if (fgConvConst > 0 || fgConvConst < 0) return fgConvConst; 
+    return 1000/0.299792458/(fgkFieldMap->SolenoidField()+1e-13);
+}
+
+inline void AliKalmanTrack::SaveLocalConvConst() {
+  //---------------------------------------------------------------------
+  // Saves local conversion constant "curvature (1/cm) -> pt (GeV/c)" 
+  //---------------------------------------------------------------------
+     if (fgConvConst > 0 || fgConvConst < 0) return; //uniform field tracking
+     Float_t r[3]={0.,0.,0.}; GetXYZ(r);
+     Float_t b[3]; fgkFieldMap->Field(r,b);
+     fLocalConvConst=1000/0.299792458/(1e-13 - b[2]);
+} 
+
+inline Double_t AliKalmanTrack::GetLocalConvConst() const {
+  //---------------------------------------------------------------------
+  // Returns conversion constant "curvature (1/cm) -> pt (GeV/c)" 
+  //---------------------------------------------------------------------
+     if (fgConvConst > 0 || fgConvConst < 0) return fgConvConst; //uniform field tracking
+     return fLocalConvConst;
+} 
+
 #endif
 
 
index 0031677..0a5bac7 100644 (file)
 //                                                                           //
 //   rec.SetRunTracking("...");                                              //
 //                                                                           //
+// Uniform/nonuniform field tracking switches (default: uniform field)       //
+//                                                                           //
+//   rec.SetUniformFieldTracking();  ( rec.SetNonuniformFieldTracking(); )   //
+//                                                                           //
 // The filling of additional ESD information can be steered by               //
 //                                                                           //
 //   rec.SetFillESD("...");                                                  //
 #include "AliRawReaderFile.h"
 #include "AliRawReaderDate.h"
 #include "AliRawReaderRoot.h"
-#include "AliTracker.h"
 #include "AliESD.h"
 #include "AliESDVertex.h"
+#include "AliTracker.h"
 #include "AliVertexer.h"
 #include "AliHeader.h"
 #include "AliGenEventHeader.h"
@@ -138,6 +142,7 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename,
   TNamed(name, title),
 
   fRunLocalReconstruction("ALL"),
+  fUniformField(kTRUE),
   fRunVertexFinder(kTRUE),
   fRunHLTTracking(kFALSE),
   fRunTracking("ALL"),
@@ -170,6 +175,7 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
   TNamed(rec),
 
   fRunLocalReconstruction(rec.fRunLocalReconstruction),
+  fUniformField(rec.fUniformField),
   fRunVertexFinder(rec.fRunVertexFinder),
   fRunHLTTracking(rec.fRunHLTTracking),
   fRunTracking(rec.fRunTracking),
@@ -886,7 +892,7 @@ Bool_t AliReconstruction::InitRunLoader()
     if (gFile->GetKey(AliRunLoader::GetGAliceName())) {
       if (fRunLoader->LoadgAlice() == 0) {
        gAlice = fRunLoader->GetAliRun();
-       AliTracker::SetFieldMap(gAlice->Field());
+       AliTracker::SetFieldMap(gAlice->Field(),fUniformField);
       }
     }
     if (!gAlice && !fRawReader) {
index 4aa168e..2954329 100644 (file)
@@ -25,8 +25,8 @@ class AliReconstructor;
 class AliRunLoader;
 class AliRawReader;
 class AliLoader;
-class AliVertexer;
 class AliTracker;
+class AliVertexer;
 class AliESD;
 class TFile;
 
@@ -57,6 +57,9 @@ public:
     SetRunTracking(detectors);
     SetFillESD(detectors);};
 
+   void SetUniformFieldTracking(){fUniformField=kTRUE;} 
+   void SetNonuniformFieldTracking(){fUniformField=kFALSE;} 
+
   void           SetStopOnError(Bool_t stopOnError) 
     {fStopOnError = stopOnError;}
   void           SetCheckPointLevel(Int_t checkPointLevel)
@@ -88,6 +91,7 @@ private:
   void           WriteESD(AliESD* esd, const char* recStep) const;
 
   TString        fRunLocalReconstruction; // run the local reconstruction for these detectors
+  Bool_t         fUniformField;       // uniform field tracking flag
   Bool_t         fRunVertexFinder;    // run the vertex finder
   Bool_t         fRunHLTTracking;     // run the HLT tracking
   TString        fRunTracking;        // run the tracking for these detectors
@@ -110,7 +114,7 @@ private:
   AliVertexer*   fVertexer;                //! vertexer for ITS
   AliTracker*    fTracker[fgkNDetectors];  //! trackers
 
-  ClassDef(AliReconstruction, 4)      // class for running the reconstruction
+  ClassDef(AliReconstruction, 5)      // class for running the reconstruction
 };
 
 #endif
index 746745b..690c62d 100644 (file)
@@ -24,8 +24,8 @@
 #include <TMath.h>
 
 #include "AliTracker.h"
-#include "AliCluster.h"
 #include "AliKalmanTrack.h"
+#include "AliCluster.h"
 #include "AliLog.h"
 #include "AliRun.h"
 #include "AliMagF.h"
@@ -35,8 +35,6 @@ const AliMagF *AliTracker::fgkFieldMap=0;
 ClassImp(AliTracker)
 
 AliTracker::AliTracker():
-  fEventN(0),
-  fStoreBarrel(1),
   fX(0),
   fY(0),
   fZ(0),
@@ -50,12 +48,13 @@ AliTracker::AliTracker():
   if (!fgkFieldMap) AliWarning("Field map is not set. Call AliTracker::SetFieldMap before creating a tracker!");
 }
 
-void AliTracker::SetFieldMap(const AliMagF* map) {
+void AliTracker::SetFieldMap(const AliMagF* map, Bool_t uni) {
   //--------------------------------------------------------------------
   //This passes the field map to the reconstruction.
   //--------------------------------------------------------------------
   if (map==0) AliFatalClass("Can't access the field map !");
-  AliKalmanTrack::SetConvConst(1000/0.299792458/(map->SolenoidField()+1e-13));
+  AliKalmanTrack::SetFieldMap(map);
+  if (uni) AliKalmanTrack::SetUniformFieldTracking();
   fgkFieldMap=map;
 }
 
index cd35f9a..57300f7 100644 (file)
 //       Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch 
 //-------------------------------------------------------------------------
 #include <TObject.h>
-//#include "TError.h"
 
-class AliKalmanTrack;
 class AliCluster;
 class TTree;
+class AliKalmanTrack;
 class AliESD;
 class AliMagF;
 
@@ -37,7 +36,6 @@ public:
      fX=xyz[0]; fY=xyz[1]; fZ=xyz[2];
      if (ers) { fSigmaX=ers[0]; fSigmaY=ers[1]; fSigmaZ=ers[2]; } 
   }
-  void SetEventNumber(Int_t ev) { fEventN=ev; }
 
 //protected:
   virtual Int_t LoadClusters(TTree *)=0;
@@ -51,22 +49,15 @@ public:
   Double_t GetSigmaX() const {return fSigmaX;}
   Double_t GetSigmaY() const {return fSigmaY;}
   Double_t GetSigmaZ() const {return fSigmaZ;}
-  Int_t GetEventNumber() const {return fEventN;}
 
-  static void SetFieldMap(const AliMagF* map);
+  static void SetFieldMap(const AliMagF* map, Bool_t uni);
   static const AliMagF *GetFieldMap() {return fgkFieldMap;}
-  
-  Int_t IsStoringBarrel() const {return fStoreBarrel;}
-  void  SetStoreBarrel(Int_t s) {fStoreBarrel = s;}
 
 private:
 
   AliTracker & operator=(const AliTracker & atr);
 
   static const AliMagF *fgkFieldMap; //field map
-  Int_t fEventN;//event number
-
-  Int_t fStoreBarrel; //Store Barrel information
 
   Double_t fX;  //X-coordinate of the primary vertex
   Double_t fY;  //Y-coordinate of the primary vertex
@@ -76,7 +67,7 @@ private:
   Double_t fSigmaY; // error of the primary vertex position in Y
   Double_t fSigmaZ; // error of the primary vertex position in Z
 
-  ClassDef(AliTracker,1) //abstract tracker
+  ClassDef(AliTracker,2) //abstract tracker
 };
 
 #endif
index 32d63e3..28afcb8 100644 (file)
@@ -73,11 +73,9 @@ AliTOFtrack::AliTOFtrack(const AliESDtrack& t)
 
   fX=x;
 
-  x = GetConvConst();  
-
   fY=p[0];
-  fZ=p[1];
-  fT=p[3];
+  fZ=p[1]; SaveLocalConvConst();
+  fT=p[3]; x=GetLocalConvConst();
   fC=p[4]/x;
   fE=fC*fX - p[2];   
 
@@ -121,7 +119,7 @@ void AliTOFtrack::GetExternalCovariance(Double_t cc[15]) const {
   //
   // This function returns external representation of the covriance matrix.
   //
-  Double_t a=GetConvConst();
+  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;
@@ -161,6 +159,7 @@ Int_t AliTOFtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
   if (TMath::Abs(fC*xk - fE) >= 0.90000) {
     return 0;
   }
+  Double_t lcc=GetLocalConvConst();
 
   // track Length measurement [SR, GSI, 17.02.2003]
 
@@ -212,6 +211,12 @@ Int_t AliTOFtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
 
   fX=x2;                                                     
 
+  //Change of the magnetic field *************
+  SaveLocalConvConst();
+  cc=fC;
+  fC*=lcc/GetLocalConvConst();
+  fE+=fX*(fC-cc);
+
   //Multiple scattering  ******************
   Double_t d=sqrt((x1-fX)*(x1-fX)+(y1-fY)*(y1-fY)+(z1-fZ)*(z1-fZ));
   Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
index 8de94e3..ac834cd 100644 (file)
@@ -32,7 +32,9 @@ public:
    Double_t GetSigmaY2() const {return fCyy;}
    Double_t GetSigmaZ2() const {return fCzz;}
 
-   Double_t Get1Pt()   const {return (1e-9*TMath::Abs(fC)/fC + fC)*GetConvConst();} 
+   Double_t Get1Pt() const {
+      return (TMath::Sign(1e-9,fC) + fC)*GetLocalConvConst();
+   }
    Double_t GetP()     const {  
      return TMath::Abs(GetPt())*sqrt(1.+GetTgl()*GetTgl());
    }
@@ -59,11 +61,14 @@ public:
    void     ResetCovariance(Float_t mult);   
    Int_t    Rotate(Double_t angle);
 
-
-
 protected:
-
+   void GetXYZ(Float_t r[3]) const;
   
+   Int_t Update(const AliCluster */*c*/, Double_t /*chi2*/, UInt_t /*idx*/) { 
+     return 0;
+   }
+   Double_t GetPredictedChi2(const AliCluster */*c*/) const {return 0.;}
+
    Int_t    fSeedInd;     // ESD seed track index  
    Int_t    fSeedLab;     // track label taken from seeding  
    Double_t fAlpha;       // rotation angle
@@ -89,4 +94,12 @@ protected:
 
 };                     
 
+inline void AliTOFtrack::GetXYZ(Float_t r[3]) const {
+  //---------------------------------------------------------------------
+  // Returns the position of the track in the global coord. system 
+  //---------------------------------------------------------------------
+  Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
+  r[0]=fX*cs - fY*sn; r[1]=fX*sn + fY*cs; r[2]=fZ;
+}
+
 #endif
index 4d9d77f..d7ab133 100644 (file)
@@ -59,7 +59,7 @@ Int_t AliTPCComparison2(Int_t firstev=0, Int_t eventn=1) {
   //  if(gAlice)delete gAlice;   COMMENTED BECAUSE OF A BUG (IN COMPILED MODE)
   gAlice = (AliRun*)inkin->Get("gAlice");
   cout<<"AliRun object found on file "<<gAlice<<endl;
-  AliKalmanTrack::SetConvConst(1000/0.299792458/gAlice->Field()->SolenoidField());
+  AliKalmanTrack::SetFieldMap(gAlice->Field());
   inkin->Close();
   /*
     delete gAlice;  COMMENTED BECAUSE OF A BUG IN COMPILED MODE
index eed68fc..08788fe 100644 (file)
@@ -48,7 +48,7 @@ Int_t AliTPCFindTracksMI(Int_t N=-1) {
       cerr<<"Error occured while l"<<endl;
       return 1;
     }
-   AliKalmanTrack::SetConvConst(1000/0.299792458/rl->GetAliRun()->Field()->SolenoidField());
+   AliKalmanTrack::SetFieldMap(rl->GetAliRun()->Field());
    
    rl->CdGAFile();
    
index 8c2b99c..6c713df 100644 (file)
@@ -201,7 +201,7 @@ Int_t   AliTPCPid::GetPcode(AliTPCtrack *track)
     cout<<"TPCtrack dedx,mom,pcode="<<dedx<<","<<mom<<","<<pcode<<endl;
     return pcode?pcode:211;
     }
-
+/*
 //-----------------------------------------------------------
 Int_t   AliTPCPid::GetPcode(AliKalmanTrack *track)
 {
@@ -223,7 +223,7 @@ Int_t   AliTPCPid::GetPcode(AliKalmanTrack *track)
     cout<<"ITS V2 dedx,mom,pcode="<<dedx<<","<<mom<<","<<pcode<<endl;
 return pcode?pcode:211;
 }
-
+*/
 //-----------------------------------------------------------
 Int_t  AliTPCPid::GetPcode(Float_t q,Float_t pm)
 {
index 48a4a7a..9baad89 100644 (file)
@@ -36,8 +36,7 @@ public:
        Int_t   GetPcode(TClonesArray* ,Float_t) const;
        Int_t   GetPcode(Float_t q,Float_t pm);
        Int_t   GetPcode(AliTPCtrack*track);
-//        Int_t   GetPcode(AliITSIOTrack*); 
-        Int_t   GetPcode(AliKalmanTrack* track);
+        //Int_t   GetPcode(AliKalmanTrack* track);
        void    SetCut(Int_t n, Float_t pm, Float_t pilo, Float_t pihi,
                            Float_t klo, Float_t khi, Float_t plo, 
                             Float_t phi);
index 334f8dd..e276710 100644 (file)
@@ -11,7 +11,7 @@ if (!inkin->IsOpen()) {
 gAlice = (AliRun*)inkin->Get("gAlice");
 cout<<"AliRun object found on file "<<gAlice<<endl;
 cout<<"!!!! field ="<<gAlice->Field()->SolenoidField()<<endl;
-AliKalmanTrack::SetConvConst(1000/0.299792458/gAlice->Field()->SolenoidField());
+AliKalmanTrack::SetFieldMap(gAlice->Field());
 inkin->Close();                                  
  cout<<" Convconst="<<AliKalmanTrack::GetConvConst()<<endl;
 /////////////////////////////////////// 
index 32c780d..ebf21fd 100644 (file)
@@ -38,7 +38,7 @@ AliTPCtrack::AliTPCtrack(): AliKalmanTrack()
   fX = fP0 = fP1 = fP2 = fP3 = fP3 = fP4 = 0.0;
   fAlpha = fdEdx = 0.0;
   fNumber = 0;  // [SR, 01.04.2003]
-  for (Int_t i=0; i<3;i++) {fKinkIndexes[i]=0; fV0Indexes[i]=0;}
+  for (Int_t i=0; i<3;i++) fKinkIndexes[i]=0;
 }
 
 //_________________________________________________________________________
@@ -58,6 +58,8 @@ const Double_t cc[15], Double_t xref, Double_t alpha) : AliKalmanTrack() {
 
   fP0=xx[0]; fP1=xx[1]; fP2=xx[2]; fP3=xx[3]; fP4=xx[4];
 
+  SaveLocalConvConst();
+
   fC00=cc[0];
   fC10=cc[1];  fC11=cc[2];
   fC20=cc[3];  fC21=cc[4];  fC22=cc[5];
@@ -100,10 +102,10 @@ AliTPCtrack::AliTPCtrack(const AliESDtrack& t) : AliKalmanTrack() {
   Double_t x,p[5]; t.GetExternalParameters(x,p);
   Double_t c[15]; t.GetExternalCovariance(c);
 
-  fX=x;    x=GetConvConst();
+  fX=x;    
   fP0=p[0];
-  fP1=p[1];
-  fP3=p[3];
+  fP1=p[1];    SaveLocalConvConst();
+  fP3=p[3];    x=GetLocalConvConst();
   fP4=p[4]/x;
   fP2=fP4*fX - p[2];
 
@@ -187,11 +189,11 @@ Int_t AliTPCtrack::Compare(const TObject *o) const {
 
 //_____________________________________________________________________________
 void AliTPCtrack::GetExternalCovariance(Double_t cc[15]) const {
-  //-------------------------------------------------------------------------
+ //-------------------------------------------------------------------------
   // This function returns an external representation of the covriance matrix.
   //   (See comments in AliTPCtrack.h about external track representation)
   //-------------------------------------------------------------------------
-  Double_t a=GetConvConst();
+  Double_t a=GetLocalConvConst();
 
   Double_t c22=fX*fX*fC44-2*fX*fC42+fC22;
   Double_t c32=fX*fC43-fC32;
@@ -252,7 +254,8 @@ Int_t AliTPCtrack::PropagateTo(Double_t xk,Double_t /*x0*/,Double_t rho) {
     //if (n>4) cerr<<n<<" AliTPCtrack warning: Propagation failed !\n";
     return 0;
   }
-  
+  Double_t lcc=GetLocalConvConst();  
+
   // old position for time [SR, GSI 17.02.2003]
   Double_t oldX = fX;
   Double_t oldY = fP0;
@@ -298,7 +301,13 @@ Int_t AliTPCtrack::PropagateTo(Double_t xk,Double_t /*x0*/,Double_t rho) {
 
   fX=x2;
 
-  //Multiple scattering******************
+  //Change of the magnetic field *************
+  SaveLocalConvConst();
+  cc=fP4;
+  fP4*=lcc/GetLocalConvConst();
+  fP2+=fX*(fP4-cc);
+
+  //Multiple scattering ******************
   Double_t d=sqrt((x1-fX)*(x1-fX)+(y1-fP0)*(y1-fP0)+(z1-fP1)*(z1-fP1));
   Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
   Double_t beta2=p2/(p2 + GetMass()*GetMass());
@@ -331,7 +340,7 @@ Int_t AliTPCtrack::PropagateTo(Double_t xk,Double_t /*x0*/,Double_t rho) {
   fC43 += dc43;
   fC44 += dc44;
   */
-  //Energy losses************************
+  //Energy losses ************************
   Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*d*rho;
   if (x1 < x2) dE=-dE;
   cc=fP4;
index a99cdad..3fff581 100644 (file)
@@ -50,8 +50,9 @@ public:
   Double_t GetY()   const {return fP0;}
   Double_t GetZ()   const {return fP1;}
   Double_t GetSnp() const {return fX*fP4 - fP2;}
-  Double_t 
-    Get1Pt() const { return (1e-9*TMath::Abs(fP4)/fP4 + fP4)*GetConvConst(); }
+  Double_t Get1Pt() const {
+    return (TMath::Sign(1e-9,fP4) + fP4)*GetLocalConvConst();
+  }
   Double_t GetTgl() const {return fP3;}
 
   Double_t GetSigmaY2() const {return fC00;}
@@ -113,6 +114,8 @@ public:
   Int_t   GetV0Index(Int_t i) const{ return fV0Indexes[i];}
   Int_t*  GetV0Indexes() { return fV0Indexes;}
 protected: 
+  void GetXYZ(Float_t r[3]) const;
+
   Double_t fX;              // X-coordinate of this track (reference plane)
   Double_t fAlpha;          // Rotation angle the local (TPC sector)
                             // coordinate system and the global ALICE one.
@@ -161,5 +164,14 @@ void AliTPCtrack::GetExternalParameters(Double_t& xr, Double_t x[5]) const {
      x[0]=GetY(); x[1]=GetZ(); x[2]=GetSnp(); x[3]=GetTgl(); x[4]=Get1Pt();
 }
 
+inline void AliTPCtrack::GetXYZ(Float_t r[3]) const {
+  //---------------------------------------------------------------------
+  // Returns the position of the track in the global coord. system 
+  //---------------------------------------------------------------------
+  Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
+  r[0]=fX*cs - fP0*sn; r[1]=fX*sn + fP0*cs; r[2]=fP1;
+}
+
+
 #endif
 
index 7b3695c..41402a7 100644 (file)
@@ -300,7 +300,7 @@ Int_t AliTPCtrackerParam::BuildTPCtracks(const TFile *inp, TFile *out) {
   tpc->SetParam(digp);
 
   // Set the conversion constant between curvature and Pt
-  AliKalmanTrack::SetConvConst(100/0.299792458/fBz);
+  AliKalmanTrack::SetFieldMap(fiel);
 
   TParticle       *part=0;
   AliTPCseedGeant *seed=0;
index ed98e59..782a160 100644 (file)
@@ -48,6 +48,8 @@ AliTRDtrack::AliTRDtrack(const AliTRDcluster *c, UInt_t index,
   fX=xref;
 
   fY=xx[0]; fZ=xx[1]; fE=xx[2]; fT=xx[3]; fC=xx[4];
+  SaveLocalConvConst();
 
   fCyy=cc[0];
   fCzy=cc[1];  fCzz=cc[2];
@@ -142,9 +144,6 @@ AliTRDtrack::AliTRDtrack(const AliTRDtrack& t) : AliKalmanTrack(t) {
     fIndex[i] = 0;
     fIndexBackup[i] = 0;  //MI backup indexes
   }
-  for (Int_t i=0;i<6;i++){
-    fTracklets[i]=t.fTracklets[i];
-  }
 }                                
 
 //_____________________________________________________________________________
@@ -185,11 +184,9 @@ AliTRDtrack::AliTRDtrack(const AliKalmanTrack& t, Double_t alpha)
 
   fX=x;
 
-  x = GetConvConst();  
-
   fY=p[0];
   fZ=p[1];
-  fT=p[3];
+  fT=p[3]; x=GetLocalConvConst();
   fC=p[4]/x;
   fE=fC*fX - p[2];   
 
@@ -265,11 +262,9 @@ AliTRDtrack::AliTRDtrack(const AliESDtrack& t)
 
   fX=x;
 
-  x = GetConvConst();  
-
   fY=p[0];
-  fZ=p[1];
-  fT=p[3];
+  fZ=p[1]; SaveLocalConvConst();
+  fT=p[3]; x=GetLocalConvConst();
   fC=p[4]/x;
   fE=fC*fX - p[2];   
 
@@ -313,15 +308,13 @@ AliTRDtrack::~AliTRDtrack()
 Float_t    AliTRDtrack::StatusForTOF()
 {
   Int_t status=0;
-  if (fNRotate>2) return -1;   // sure it's stopped
   if (GetNumberOfClusters()<20) return 0;   //
-
-  //comp->fTree->SetAlias("nlast2","track.fTracklets[5].fNFound+track.fTracklets[4].fNFound");
-  //comp->fTree->SetAlias("goldtrack","abs((track.fTracklets[5].fP1+track.fTracklets[4].fP1))<0.5&&nlast2>14");
-  Int_t nlast2 = fTracklets[5].fNFound+fTracklets[4].fNFound;
-  if (TMath::Abs((fTracklets[5].fP1+fTracklets[4].fP1))<0.3 &&nlast2>20) return 3;
-  if (TMath::Abs((fTracklets[5].fP1+fTracklets[4].fP1))<0.3 &&nlast2>14) return 2;
-  if (TMath::Abs((fTracklets[5].fP1+fTracklets[4].fP1))<0.5 &&nlast2>14) return 1;
+  if (fN>110&&fChi2/(Float_t(fN))<3) return 3;            //gold
+  if (fNLast>30&&fChi2Last/(Float_t(fNLast))<3) return 3; //gold
+  if (fNLast>20&&fChi2Last/(Float_t(fNLast))<2) return 3; //gold
+  if (fNLast/(fNExpectedLast+3.)>0.8 && fChi2Last/Float_t(fNLast)<5&&fNLast>20) return 2; //silber
+  if (fNLast>5 &&((fNLast+1.)/(fNExpectedLast+1.))>0.8&&fChi2Last/(fNLast-5.)<6)   return 1; 
+  //
 
   return status;
 }
@@ -345,7 +338,7 @@ void AliTRDtrack::GetExternalCovariance(Double_t cc[15]) const {
   //
   // This function returns external representation of the covriance matrix.
   //
-  Double_t a=GetConvConst();
+  Double_t a=GetLocalConvConst();
 
   Double_t c22=fX*fX*fCcc-2*fX*fCce+fCee;
   Double_t c32=fX*fCct-fCte;
@@ -404,15 +397,27 @@ void AliTRDtrack::CookdEdx(Double_t low, Double_t up) {
 
   Float_t sorted[kMAX_CLUSTERS_PER_TRACK];
   for (i=0; i < nc; i++) {
-    sorted[i]=TMath::Abs(fdQdl[i]);
+    sorted[i]=fdQdl[i];
   }
-  Int_t * index = new Int_t[nc];
-  TMath::Sort(nc, sorted, index,kFALSE);
-
+  /*
+  Int_t swap; 
+
+  do {
+    swap=0;
+    for (i=0; i<nc-1; i++) {
+      if (sorted[i]<=sorted[i+1]) continue;
+      Float_t tmp=sorted[i];
+      sorted[i]=sorted[i+1]; sorted[i+1]=tmp;
+      swap++;
+    }
+  } while (swap);
+  */
   Int_t nl=Int_t(low*nc), nu=Int_t(up*nc);
   Float_t dedx=0;
-  for (i=nl; i<=nu; i++) dedx += sorted[index[i]];
-  dedx /= (nu-nl+1);
+  //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);
 }                     
@@ -432,6 +437,7 @@ Int_t AliTRDtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
     //              << GetPt() << "\t" << GetLabel() << "\t" << GetMass() << endl;
     return 0;
   }
+  Double_t lcc=GetLocalConvConst();
 
   // track Length measurement [SR, GSI, 17.02.2003]
   Double_t oldX = fX, oldY = fY, oldZ = fZ;  
@@ -479,14 +485,18 @@ Int_t AliTRDtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
 
   fX=x2;                                                     
 
+  //Change of the magnetic field *************
+  SaveLocalConvConst();
+  cc=fC;
+  fC*=lcc/GetLocalConvConst();
+  fE+=fX*(fC-cc);
+
   //Multiple scattering  ******************
   Double_t d=sqrt((x1-fX)*(x1-fX)+(y1-fY)*(y1-fY)+(z1-fZ)*(z1-fZ));
   Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
   Double_t beta2=p2/(p2 + GetMass()*GetMass());
   Double_t theta2=14.1*14.1/(beta2*p2*1e6)*d/x0*rho;
-  theta2*= 3.;                                      // magic const - to normalize pools - waiting for geo manager
-  if (p2>2.) beta2*= 0.4;                           // magic const - theta2 for relativistic particles 
-                                                    // - not valid for electrons
+
   Double_t ey=fC*fX - fE, ez=fT;
   Double_t xz=fC*ez, zz1=ez*ez+1, xy=fE+ey;
   
@@ -513,18 +523,12 @@ Int_t AliTRDtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
   //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; 
-  dE *= 1.2;                                      // magic const - to normalize pools - waiting for geo manager
+  Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2+1e-10)) - beta2)*d*rho;
   if (x1 < x2) dE=-dE;
   cc=fC;
   fC*=(1.- sqrt(p2+GetMass()*GetMass())/p2*dE);
   fE+=fX*(fC-cc);    
-  //
-  Double_t deltac = fC-cc;
-  fCcc   += 4*deltac*deltac;                    // fluctuation of energy losses
-  fCee   += 4*fX*fX*deltac*deltac;              // local angle unchanged
-  fCce   += 4*fX*deltac*deltac;                 // correlation 1
-  //
+
   // track time measurement [SR, GSI 17.02.2002]
   if (x1 < x2)
   if (IsStartedTimeIntegral()) {
@@ -674,7 +678,14 @@ Int_t AliTRDtrack::UpdateMI(const AliTRDcluster *c, Double_t chisq, UInt_t index
   }
   Double_t tangent = TMath::Sqrt(tangent2);
   if ((fC*fX-fE)<0) tangent*=-1;
-  Double_t errsys =(0.025*0.025*20)*(1+tangent2);  //systematic error part 
+  //  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;
 
   /*
   if (corrector!=0){
@@ -689,7 +700,9 @@ Int_t AliTRDtrack::UpdateMI(const AliTRDcluster *c, Double_t chisq, UInt_t index
   }
   */
   //
-  Double_t r00=(c->GetSigmaY2()+errsys), r01=0., r11=c->GetSigmaZ2()*10000.;
+  //  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;
@@ -717,16 +730,29 @@ Int_t AliTRDtrack::UpdateMI(const AliTRDcluster *c, Double_t chisq, UInt_t index
     fC  = cur;
   }
   else {
-    //    Double_t padlength = TMath::Sqrt(c->GetSigmaZ2()*12);
+    Double_t padlength = TMath::Sqrt(c->GetSigmaZ2()*12);
   
     Double_t xu_factor = 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 tiltdz = dz;
+    if (TMath::Abs(tiltdz)>padlength/2.) {
+      tiltdz = TMath::Sign(padlength/2,dz);
+    }
+    //    dy=dy+h01*dz;
     dy=dy+h01*tiltdz;
 
-    Double_t s00 = c->GetSigmaY2()+errsys;  // error pad
+    Double_t add=0;
+    if (TMath::Abs(dz)>padlength/2.){
+      //Double_t dy2 = c->GetY() - fY;
+      //Double_t sign = (dz>0) ? -1.: 1.;
+      //dy2-=h01*sign*padlength/2.;    
+      //dy = dy2;
+      add =1;
+    }
+    Double_t s00 = (c->GetSigmaY2()+errang)*extend+errsys+add;  // error pad
     Double_t s11 = c->GetSigmaZ2()*xu_factor;   // error pad-row
     //
     r00 = fCyy + 2*fCzy*h01 + fCzz*h01*h01+s00;
@@ -805,8 +831,6 @@ Int_t AliTRDtrack::UpdateMI(const AliTRDcluster *c, Double_t chisq, UInt_t index
 
 
 
-
-
 //_____________________________________________________________________________
 Int_t AliTRDtrack::UpdateMI(const AliTRDtracklet &tracklet)
 {
@@ -913,6 +937,7 @@ Int_t AliTRDtrack::UpdateMI(const AliTRDtracklet &tracklet)
 }                     
 
 
+
 //_____________________________________________________________________________
 Int_t AliTRDtrack::Rotate(Double_t alpha)
 {
@@ -1096,10 +1121,10 @@ Int_t  AliTRDtrack::GetProlongation(Double_t xk, Double_t &y, Double_t &z){
   // return 0 if not exist
   
   Double_t c1=fC*fX - fE;
-  if (TMath::Abs(c1)>0.9) return 0;
+  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)>0.9) return 0;  
+  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;
index d592e91..0dab5ca 100644 (file)
@@ -62,8 +62,6 @@ class AliTRDtracklet :public TObject{
 };
 
 
-
-
 class AliTRDtrack : public AliKalmanTrack {
 
 // Represents reconstructed TRD track
@@ -101,7 +99,9 @@ public:
 
    Double_t GetLikelihoodElectron() const { return fLhElectron; };
 
-   Double_t Get1Pt()   const {return (1e-9*TMath::Abs(fC)/fC + fC)*GetConvConst(); } 
+   Double_t Get1Pt() const {
+      return (TMath::Sign(1e-9,fC) + fC)*GetLocalConvConst();
+   }
    Double_t GetP()     const {  
      return TMath::Abs(GetPt())*sqrt(1.+GetTgl()*GetTgl());
    }
@@ -179,6 +179,12 @@ public:
 
 
 protected:
+   void GetXYZ(Float_t r[3]) const;
+
+   Double_t GetPredictedChi2(const AliCluster*/*c*/) const {return 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 
@@ -220,5 +226,12 @@ protected:
    ClassDef(AliTRDtrack,2) // TRD reconstructed tracks
 };                     
 
+inline 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), sn=TMath::Sin(fAlpha);
+  r[0]=fX*cs - fY*sn; r[1]=fX*sn + fY*cs; r[2]=fZ;
+}
 
 #endif   
index 244abf0..a3fd5c8 100644 (file)
@@ -38,6 +38,7 @@
 #include "AliHeader.h"
 #include "AliGenEventHeader.h"
 #include "AliTPCtrack.h"
+#include "AliTracker.h"
 
 #endif
 
@@ -378,9 +379,6 @@ void kinetree(AliRunLoader* runLoader, AliESD* &esdOut, TClonesArray* &ministack
 
   copyGeneralESDInfo(esdOut,esdNew);
 
-  // Needed by the TPC track
-  AliKalmanTrack::SetConvConst(1000/0.299792458/esdOut->GetMagneticField());
-
   // Tracks
   Int_t nrec = esdOut->GetNumberOfTracks();
   for(Int_t irec=0; irec<nrec; irec++) {
@@ -536,6 +534,9 @@ void mcminiesd() {
   runLoader->LoadgAlice();
   gAlice = runLoader->GetAliRun();
 
+  // Magnetic field
+  AliTracker::SetFieldMap(gAlice->Field(),1); // 1 means uniform magnetic field
+
   // Now load kinematics and event header
   runLoader->LoadKinematics();
   runLoader->LoadHeader();