Update of the tracking by Sergei
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 8 Dec 2000 16:07:02 +0000 (16:07 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 8 Dec 2000 16:07:02 +0000 (16:07 +0000)
12 files changed:
TRD/AliTRDcluster.cxx
TRD/AliTRDcluster.h
TRD/AliTRDfindTracks.C
TRD/AliTRDtimeBin.h
TRD/AliTRDtrack.cxx
TRD/AliTRDtrack.h
TRD/AliTRDtracker.cxx
TRD/AliTRDtracker.h
TRD/AliTRDtrackingSector.cxx
TRD/AliTRDtrackingSector.h
TRD/TrackDisplay.C
TRD/slowClusterCreate.C

index bd1954a..25f0008 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.2  2000/10/06 16:49:46  cblume
+Made Getters const
+
 Revision 1.1.2.1  2000/09/22 14:47:52  cblume
 Add the tracking code
 
@@ -57,8 +60,31 @@ AliTRDcluster::AliTRDcluster(AliTRDrecPoint *rp)
   fSigmaY2    = rp->GetSigmaY2();
   fSigmaZ2    = rp->GetSigmaZ2();  
 
-  fSigmaY2    = 1;
-  fSigmaZ2    = 5;  
+  fSigmaY2    = 0.2;
+  fSigmaZ2    = 5.;  
+
+}
+
+//_____________________________________________________________________________
+AliTRDcluster::AliTRDcluster(AliTRDcluster *cl)
+{
+  //
+  // Copy constructor 
+  //
+
+  fDetector   = cl->GetDetector();
+  fTimeBin    = cl->GetLocalTimeBin();
+
+  fTracks[0]  = cl->GetTrackIndex(0);
+  fTracks[1]  = cl->GetTrackIndex(1);
+  fTracks[2]  = cl->GetTrackIndex(2);
+
+  fQ          = cl->GetQ();
+
+  fY          = cl->GetY();
+  fZ          = cl->GetZ();
+  fSigmaY2    = cl->GetSigmaY2();
+  fSigmaZ2    = cl->GetSigmaZ2();  
 
 }
 
index 4756148..5951d52 100644 (file)
@@ -15,19 +15,23 @@ class AliTRDcluster : public TObject {
 
   AliTRDcluster();
   AliTRDcluster(AliTRDrecPoint *rp);
+  AliTRDcluster(AliTRDcluster *cl);
   
-  virtual Int_t   GetDetector() const           { return fDetector; };
-  virtual Int_t   GetLocalTimeBin() const       { return fTimeBin; }
-
-  virtual Float_t GetSigmaY2() const            { return fSigmaY2; }
-  virtual Float_t GetSigmaZ2() const            { return fSigmaZ2; }
-  virtual Float_t GetY() const                  { return fY; }
-  virtual Float_t GetZ() const                  { return fZ; }
-  virtual Float_t GetQ() const                  { return fQ; }
-
-  Int_t   IsUsed() const                        { return (fQ<0) ? 1 : 0; }
-  void    Use()                                 { fQ=-fQ; }
-  Int_t   GetTrackIndex(Int_t i) const          { return fTracks[i]; }
+  Int_t   GetDetector() const           { return fDetector; };
+  Int_t   GetLocalTimeBin() const       { return fTimeBin; }
+
+  Float_t GetSigmaY2() const            { return fSigmaY2; }
+  Float_t GetSigmaZ2() const            { return fSigmaZ2; }
+  Float_t GetY() const                  { return fY; }
+  Float_t GetZ() const                  { return fZ; }
+  Float_t GetQ() const                  { return fQ; }
+
+  Int_t   IsUsed() const                { return (fQ<0) ? 1 : 0; }
+  void    Use()                         { fQ=-fQ; }
+  Int_t   GetTrackIndex(Int_t i) const  { return fTracks[i]; }
+
+  void    SetSigmaY2(Float_t s)         { fSigmaY2 = s; }
+  void    SetSigmaZ2(Float_t s)         { fSigmaZ2 = s; }
 
 
  protected:
index 1153c02..e9cb377 100644 (file)
@@ -14,25 +14,18 @@ void AliTRDfindTracks() {
     cout << "Loaded shared libraries" << endl;
   }       
 
-  Char_t *alifile = "AliTRDclusters.root"; 
-
-  cerr<<"got this far"<<endl;
+  Char_t *hitfile     = "galice.root"; 
+  Char_t *clusterfile = "AliTRDclusters.root"; 
+  Char_t *trackfile   = "AliTRDtracks.root"; 
 
   AliTRDtracker *Tracker =
     new AliTRDtracker("TheOnlyTRDtrackerSoFar","UniqueVariationOfIt");
 
+  Tracker->GetEvent(hitfile,clusterfile);
 
-  Tracker->GetEvent(alifile);
-
-  Int_t inner, outer, delta=60;
-  for(Int_t i=0; i<1; i++) {
-    outer=179-i; inner=outer-delta;
-    Tracker->MakeSeeds(inner,outer);
-  }
-
-  Tracker->FindTracks();
+  Tracker->Clusters2Tracks();
 
-  Tracker->WriteTracks();
+  Tracker->WriteTracks(trackfile);
 
 
 }
index a02c3d8..f3fa41e 100644 (file)
@@ -28,7 +28,7 @@ public:
 
   Int_t Find(Double_t y) const; 
 
- protected:
+protected:
  
    unsigned fN;
    AliTRDcluster *fClusters[kMAX_CLUSTER_PER_TIME_BIN];
index f40105d..07dcc1d 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.3  2000/10/15 23:40:01  cblume
+Remove AliTRDconst
+
 Revision 1.2  2000/10/06 16:49:46  cblume
 Made Getters const
 
@@ -426,28 +429,4 @@ void AliTRDtrack::Streamer(TBuffer &R__b)
    }
 }                                                          
 
-//_____________________________________________________________________________
-void AliTRDseed::CookdEdx(Double_t low, Double_t up) {
-
-  // Calculates dE/dX within the "low" and "up" cuts.
-
-  Int_t i;
-  Int_t nc=this->GetNclusters();
-
-  Int_t swap;//stupid sorting
-  do {
-    swap=0;
-    for (i=0; i<nc-1; i++) {
-      if (fdEdx[i]<=fdEdx[i+1]) continue;
-      Float_t tmp=fdEdx[i]; fdEdx[i]=fdEdx[i+1]; fdEdx[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 += fdEdx[i];
-  dedx /= (nu-nl+1);
-  SetdEdx(dedx);
-}
 
index 834863e..e30c035 100644 (file)
@@ -12,29 +12,6 @@ class AliTRDtrack : public TObject {
 
 // Represents reconstructed TRD track
 
-   Int_t    fLab;         // track label  
-   Double_t fChi2;        // total chi2 value for the track  
-   Float_t  fdEdx;        // dE/dx 
-
-   Double_t fAlpha;       // rotation angle
-   Double_t fX;           // running local X-coordinate of the track (time bin)
-
-   Double_t fY;           // Y-coordinate of the track
-   Double_t fZ;           // Z-coordinate of the track
-   Double_t fC;           // track curvature
-   Double_t fE;           // C*x0
-   Double_t fT;           // tangent of the track dip angle   
-
-   Double_t fCyy;                         // covariance
-   Double_t fCzy, fCzz;                   // matrix
-   Double_t fCcy, fCcz, fCcc;             // of the
-   Double_t fCey, fCez, fCec, fCee;       // track
-   Double_t fCty, fCtz, fCtc, fCte, fCtt; // parameters   
-
-   Short_t fN;             // number of clusters associated with the track
-   UInt_t  fIndex[200];    // global indexes of these clusters  
-                          
-
 public:
 
    AliTRDtrack() { fN=0;}
@@ -81,24 +58,34 @@ public:
 
    void     Update(const AliTRDcluster* c, Double_t chi2, UInt_t i);
 
+
+protected:
+
+   Int_t    fLab;         // track label  
+   Double_t fChi2;        // total chi2 value for the track  
+   Float_t  fdEdx;        // dE/dx 
+
+   Double_t fAlpha;       // rotation angle
+   Double_t fX;           // running local X-coordinate of the track (time bin)
+
+   Double_t fY;           // Y-coordinate of the track
+   Double_t fZ;           // Z-coordinate of the track
+   Double_t fC;           // track curvature
+   Double_t fE;           // C*x0
+   Double_t fT;           // tangent of the track dip angle   
+
+   Double_t fCyy;                         // covariance
+   Double_t fCzy, fCzz;                   // matrix
+   Double_t fCcy, fCcz, fCcc;             // of the
+   Double_t fCey, fCez, fCec, fCee;       // track
+   Double_t fCty, fCtz, fCtc, fCte, fCtt; // parameters   
+
+   Short_t fN;             // number of clusters associated with the track
+   UInt_t  fIndex[200];    // global indexes of these clusters  
+                          
+
    ClassDef(AliTRDtrack,1)  // TRD reconstructed tracks
 };                     
 
 
-//-----------------------------------------------------------------
-class AliTRDseed : public AliTRDtrack {
-   Float_t fdEdx[200];
-public:
-   AliTRDseed():AliTRDtrack(){}
-   AliTRDseed(UInt_t index, const Double_t xx[5],
-              const Double_t cc[15], Double_t xr, Double_t alpha):
-              AliTRDtrack(index, xx, cc, xr, alpha) {}
-   void SetSampledEdx(Float_t q, Int_t i) {
-     Double_t c=GetC(), e=GetEta(), t=GetTgl(), x=GetX();
-     q *= TMath::Sqrt((1-(c*x-e)*(c*x-e))/(1+t*t));
-     fdEdx[i]=q;
-   }
-   void CookdEdx(Double_t low=0.05, Double_t up=0.70);
-};            
-
 #endif   
index 0166c6e..6d0136a 100644 (file)
@@ -15,6 +15,9 @@
                                                       
 /*
 $Log$
+Revision 1.6  2000/11/30 17:38:08  cblume
+Changes to get in line with new STEER and EVGEN
+
 Revision 1.5  2000/11/14 14:40:27  cblume
 Correction for the Sun compiler (kTRUE and kFALSE)
 
@@ -34,7 +37,7 @@ Revision 1.1.2.1  2000/09/22 14:47:52  cblume
 Add the tracking code
 
 */   
+
 #include <iostream.h>
 
 #include <TFile.h>
@@ -43,7 +46,6 @@ Add the tracking code
 #include <TTree.h>
 
 #include "AliRun.h"
-
 #include "AliTRD.h"
 #include "AliTRDgeometry.h"
 #include "AliTRDrecPoint.h" 
@@ -56,6 +58,26 @@ Add the tracking code
 
 ClassImp(AliTRDtracker) 
 
+  const  Int_t     AliTRDtracker::fSeedGap            = 35;  
+  const  Int_t     AliTRDtracker::fSeedStep           = 5;   
+
+
+  const  Float_t   AliTRDtracker::fMinClustersInTrack = 0.5;  
+  const  Float_t   AliTRDtracker::fMinClustersInSeed  = 0.5;  
+  const  Float_t   AliTRDtracker::fSeedDepth          = 0.5; 
+  const  Float_t   AliTRDtracker::fSkipDepth          = 0.2;
+  const  Float_t   AliTRDtracker::fMaxSeedDeltaZ      = 30.;  
+  const  Float_t   AliTRDtracker::fMaxSeedC           = 0.01; 
+  const  Float_t   AliTRDtracker::fMaxSeedTan         = 1.2;  
+  const  Float_t   AliTRDtracker::fMaxSeedVertexZ     = 200.; 
+  const  Float_t   AliTRDtracker::fLabelFraction      = 0.5;  
+  const  Float_t   AliTRDtracker::fWideRoad           = 30.;
+
+  const  Double_t  AliTRDtracker::fMaxChi2            = 12.; 
+  const  Double_t  AliTRDtracker::fSeedErrorSY        = 0.1;
+  const  Double_t  AliTRDtracker::fSeedErrorSY3       = 2.5;
+  const  Double_t  AliTRDtracker::fSeedErrorSZ        = 0.1;
+
 //____________________________________________________________________
 AliTRDtracker::AliTRDtracker()
 {
@@ -63,10 +85,9 @@ AliTRDtracker::AliTRDtracker()
   // Default constructor
   //   
 
-  fInputFile = NULL;
   fEvent     = 0;
-
   fGeom      = NULL;
+
   fNclusters = 0;
   fClusters  = NULL; 
   fNseeds    = 0;
@@ -80,10 +101,9 @@ AliTRDtracker::AliTRDtracker()
 AliTRDtracker::AliTRDtracker(const Text_t* name, const Text_t* title)
                   :TNamed(name, title)
 {
-  fInputFile = NULL;
   fEvent     = 0;
-
   fGeom      = NULL;
+
   fNclusters = 0;
   fClusters  = new TObjArray(2000); 
   fNseeds    = 0;
@@ -93,38 +113,44 @@ AliTRDtracker::AliTRDtracker(const Text_t* name, const Text_t* title)
 
 }   
 
-
 //___________________________________________________________________
 AliTRDtracker::~AliTRDtracker()
 {
-  if (fInputFile) {
-    fInputFile->Close();
-    delete fInputFile;
-  }
   delete fClusters;
   delete fTracks;
   delete fSeeds;
   delete fGeom;
 }   
 
+//___________________________________________________________________
+void AliTRDtracker::Clusters2Tracks()
+{
+  Int_t inner, outer;
+  Int_t fTotalNofTimeBins = fGeom->GetTimeMax() * AliTRDgeometry::Nplan();
+  Int_t nSteps = (Int_t) (fTotalNofTimeBins * fSeedDepth)/fSeedStep;
+
+  for(Int_t i=0; i<nSteps; i++) {
+    printf("step %d out of %d \n", i+1, nSteps);
+    outer=fTotalNofTimeBins-1-i*fSeedStep; inner=outer-fSeedGap;
+    MakeSeeds(inner,outer);
+    FindTracks();
+  } 
+}          
 
 //_____________________________________________________________________
-static Double_t SigmaY2trd(Double_t r, Double_t tgl, Double_t pt)
+Double_t AliTRDtracker::ExpectedSigmaY2(Double_t r, Double_t tgl, Double_t pt)
 {
   // Parametrised "expected" error of the cluster reconstruction in Y 
 
-  Double_t s = 1.;    
+  Double_t s = 0.2;    
   return s;
 }
 
 //_____________________________________________________________________
-static Double_t SigmaZ2trd(Double_t r, Double_t tgl)
+Double_t AliTRDtracker::ExpectedSigmaZ2(Double_t r, Double_t tgl)
 {
   // Parametrised "expected" error of the cluster reconstruction in Z 
 
-  AliTRD *TRD = (AliTRD*) gAlice->GetDetector("TRD");
-  AliTRDgeometry   *fGeom;   
-  fGeom = TRD->GetGeometry();
   Double_t s, pad = fGeom->GetRowPadSize();
   s = pad * pad /12.;  
   return s;
@@ -182,7 +208,7 @@ inline Double_t f3trd(Double_t x1,Double_t y1,
 
 //___________________________________________________________________
 
-static Int_t FindProlongation(AliTRDseed& t, AliTRDtrackingSector *sec,
+Int_t AliTRDtracker::FindProlongation(AliTRDtrack& t, AliTRDtrackingSector *sec,
                             Int_t s, Int_t rf=0)
 {
   // Starting from current position on track=t this function tries 
@@ -190,8 +216,7 @@ static Int_t FindProlongation(AliTRDseed& t, AliTRDtrackingSector *sec,
   // if a close cluster is found. *sec is a pointer to allocated
   // array of sectors, in which the initial sector has index=s. 
 
-  const Int_t TIME_BINS_TO_SKIP=Int_t(0.2*sec->GetNtimeBins());
-  const Double_t MAX_CHI2=12.;
+  const Int_t TIME_BINS_TO_SKIP=Int_t(fSkipDepth*sec->GetNtimeBins());
   Int_t try_again=TIME_BINS_TO_SKIP;
 
   Double_t alpha=AliTRDgeometry::GetAlpha();
@@ -208,14 +233,14 @@ static Int_t FindProlongation(AliTRDseed& t, AliTRDtrackingSector *sec,
     AliTRDcluster *cl=0;
     UInt_t index=0;
 
-    Double_t max_chi2=MAX_CHI2;
-    //    const AliTRDtimeBin& time_bin=sec[s][nr];
+    Double_t max_chi2=fMaxChi2;
+
     AliTRDtimeBin& time_bin=sec[s][nr];
-    Double_t sy2=SigmaY2trd(t.GetX(),t.GetTgl(),t.GetPt());
-    Double_t sz2=SigmaZ2trd(t.GetX(),t.GetTgl());
+    Double_t sy2=ExpectedSigmaY2(t.GetX(),t.GetTgl(),t.GetPt());
+    Double_t sz2=ExpectedSigmaZ2(t.GetX(),t.GetTgl());
     Double_t road=5.*sqrt(t.GetSigmaY2() + sy2), y=t.GetY(), z=t.GetZ();
 
-    if (road>30) {
+    if (road>fWideRoad) {
       if (t.GetNclusters() > 4) {
        cerr<<t.GetNclusters()<<" FindProlongation: Road is too wide !\n";
       }
@@ -273,37 +298,36 @@ static Int_t FindProlongation(AliTRDseed& t, AliTRDtrackingSector *sec,
 
 
 //_____________________________________________________________________________
-void AliTRDtracker::GetEvent(const Char_t *name, Int_t nEvent)
+void AliTRDtracker::GetEvent(const Char_t *hitfile, const Char_t *clusterfile)
 {
   // Opens a ROOT-file with TRD-clusters and reads in the cluster-tree
 
-  // Connect the AliRoot file containing Geometry, Kine, and Hits
-  fInputFile = (TFile*) gROOT->GetListOfFiles()->FindObject(name);
+  ReadClusters(fClusters, clusterfile);
+
+  // get geometry from the file with hits
+
+  TFile *fInputFile = (TFile*) gROOT->GetListOfFiles()->FindObject(hitfile);
   if (!fInputFile) {
     printf("AliTRDtracker::Open -- ");
-    printf("Open the ALIROOT-file %s.\n",name);
-    fInputFile = new TFile(name,"UPDATE");
+    printf("Open the ALIROOT-file %s.\n",hitfile);
+    fInputFile = new TFile(hitfile);
   }
   else {
     printf("AliTRDtracker::Open -- ");
-    printf("%s is already open.\n",name);
+    printf("%s is already open.\n",hitfile);
   }
 
   // Get AliRun object from file or create it if not on file
-  //if (!gAlice) {
-    gAlice = (AliRun*) fInputFile->Get("gAlice");
-    if (gAlice) {
-      printf("AliTRDtracker::GetEvent -- ");
-      printf("AliRun object found on file.\n");
-    }
-    else {
-      printf("AliTRDtracker::GetEvent -- ");
-      printf("Could not find AliRun object.\n");
-    }
-  //}        
 
-  fEvent = nEvent;
+  gAlice = (AliRun*) fInputFile->Get("gAlice");
+  if (gAlice) {
+    printf("AliTRDtracker::GetEvent -- ");
+    printf("AliRun object found on file.\n");
+  }
+  else {
+    printf("AliTRDtracker::GetEvent -- ");
+    printf("Could not find AliRun object.\n");
+  }
 
   // Import the Trees for the event nEvent in the file
   Int_t nparticles = gAlice->GetEvent(fEvent);
@@ -317,27 +341,6 @@ void AliTRDtracker::GetEvent(const Char_t *name, Int_t nEvent)
   AliTRD *TRD = (AliTRD*) gAlice->GetDetector("TRD");
   fGeom = TRD->GetGeometry();
 
-  Char_t treeName[14];
-  sprintf(treeName,"TRDrecPoints%d", nEvent);
-
-  TTree *tree=(TTree*)fInputFile->Get(treeName);
-  TBranch *branch=tree->GetBranch("TRDrecPoints");
-  Int_t nentr = (Int_t) tree->GetEntries();
-  printf("found %d entries in %s tree.\n",nentr,treeName);
-
-  for (Int_t i=0; i<nentr; i++) {
-    TObjArray *ioArray = new TObjArray(400);
-    branch->SetAddress(&ioArray);
-    tree->GetEvent(i);
-    Int_t npoints = ioArray->GetEntriesFast();
-    printf("Read %d rec. points from entry %d \n", npoints, i);
-    for(Int_t j=0; j<npoints; j++) {
-      AliTRDrecPoint *p=(AliTRDrecPoint*)ioArray->UncheckedAt(j);
-      AliTRDcluster  *c = new AliTRDcluster(p); 
-      fClusters->AddLast(c);
-    }
-  }
-
 }     
 
 
@@ -348,7 +351,7 @@ void AliTRDtracker::SetUpSectors(AliTRDtrackingSector *sec)
   // Note that the numbering scheme for the TRD tracking_sectors 
   // differs from that of TRD sectors
 
-  for (Int_t i=0; i<AliTRDgeometry::kNsect; i++) sec[i].SetUp();
+  for (Int_t i=0; i<AliTRDgeometry::Nsect(); i++) sec[i].SetUp();
 
   //  Sort clusters into AliTRDtimeBin's within AliTRDtrackSector's 
 
@@ -378,7 +381,7 @@ void AliTRDtracker::MakeSeeds(Int_t inner, Int_t outer)
 {
   // Creates track seeds using clusters in timeBins=i1,i2
 
-  Int_t i2 = inner, i1=outer; 
+  Int_t i2 = inner, i1 = outer; 
 
   if (!fClusters) return; 
 
@@ -438,7 +441,7 @@ void AliTRDtracker::MakeSeeds(Int_t inner, Int_t outer)
 
         Double_t zz=z1 - z1/x1*(x1-x2);
        
-        if (TMath::Abs(zz-z2)>30.) continue;   
+        if (TMath::Abs(zz-z2)>fMaxSeedDeltaZ) continue;   
 
         Double_t d=(x2-x1)*(0.-y2)-(0.-x2)*(y2-y1);
         if (d==0.) {cerr<<"TRD MakeSeeds: Straight seed !\n"; continue;}
@@ -447,7 +450,7 @@ void AliTRDtracker::MakeSeeds(Int_t inner, Int_t outer)
         x[1]=z1;
         x[2]=f1trd(x1,y1,x2,y2,x3,y3);
 
-        if (TMath::Abs(x[2]) >= 0.01) continue;
+        if (TMath::Abs(x[2]) >= fMaxSeedC) continue;
 
         x[3]=f2trd(x1,y1,x2,y2,x3,y3);
 
@@ -455,15 +458,15 @@ void AliTRDtracker::MakeSeeds(Int_t inner, Int_t outer)
 
         x[4]=f3trd(x1,y1,x2,y2,z1,z2);
 
-        if (TMath::Abs(x[4]) > 1.2) continue;
+        if (TMath::Abs(x[4]) > fMaxSeedTan) continue;
 
         Double_t a=asin(x[3]);
         Double_t zv=z1 - x[4]/x[2]*(a+asin(x[2]*x1-x[3]));
-        if (TMath::Abs(zv)>200.) continue;    
+        if (TMath::Abs(zv)>fMaxSeedVertexZ) continue;    
 
-        Double_t sy1=r1[is]->GetSigmaY2(), sz1=r1[is]->GetSigmaZ2()*12;
-        Double_t sy2=cl->GetSigmaY2(),     sz2=cl->GetSigmaZ2()*12;
-        Double_t sy3=100*0.025, sy=0.1, sz=0.1;
+        Double_t sy1=r1[is]->GetSigmaY2(), sz1=r1[is]->GetSigmaZ2();
+        Double_t sy2=cl->GetSigmaY2(),     sz2=cl->GetSigmaZ2();
+        Double_t sy3=fSeedErrorSY3, sy=fSeedErrorSY, sz=fSeedErrorSZ;
 
         Double_t f20=(f1trd(x1,y1+sy,x2,y2,x3,y3)-x[2])/sy;
         Double_t f22=(f1trd(x1,y1,x2,y2+sy,x3,y3)-x[2])/sy;
@@ -486,14 +489,12 @@ void AliTRDtracker::MakeSeeds(Int_t inner, Int_t outer)
         c[14]=f40*sy1*f40+f41*sz1*f41+f42*sy2*f42+f43*sz2*f43;   
 
         UInt_t index=r1.GetIndex(is);
-        AliTRDseed *track=new AliTRDseed(index, x, c, x1, ns*alpha+shift); 
-
-       //        Float_t l=fTrSec->GetPitch();
-       //        track->SetSampledEdx(r1[is]->fQ/l,0); 
+        AliTRDtrack *track=new AliTRDtrack(index, x, c, x1, ns*alpha+shift); 
 
         Int_t rc=FindProlongation(*track,fTrSec,ns,i2);
        
-        if ((rc < 0) || (track->GetNclusters() < (i1-i2)/2) ) delete track;
+        if ((rc < 0) || 
+            (track->GetNclusters() < (i1-i2)*fMinClustersInSeed)) delete track;
         else { 
          fSeeds->AddLast(track); fNseeds++; 
          cerr<<"found seed "<<fNseeds<<endl;
@@ -502,8 +503,6 @@ void AliTRDtracker::MakeSeeds(Int_t inner, Int_t outer)
     }
   }
 
-  //  delete[] fTrSec;
-
   fSeeds->Sort();
 }          
 
@@ -524,10 +523,10 @@ void AliTRDtracker::FindTracks()
   for (Int_t i=0; i<nseed; i++) {
     cerr<<"FindTracks: seed "<<i+1<<" out of "<<nseed<<endl;
 
-    AliTRDseed& t=*((AliTRDseed*)fSeeds->UncheckedAt(i));
+    AliTRDtrack& t=*((AliTRDtrack*)fSeeds->UncheckedAt(i));
 
     nSeedClusters = t.GetNclusters();
-    Double_t alpha=AliTRDgeometry::GetAlpha();
+    Double_t alpha=t.GetAlpha();
 
     if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
     if (alpha < 0.            ) alpha += 2.*TMath::Pi();
@@ -535,22 +534,23 @@ void AliTRDtracker::FindTracks()
 
     if (FindProlongation(t,fTrSec,ns)) {
       cerr<<"No of clusters in the track = "<<t.GetNclusters()<<endl; 
-      if ((t.GetNclusters() >= Int_t(0.3*num_of_time_bins)) && 
-         ((t.GetNclusters()-nSeedClusters)>60)) {
-       t.CookdEdx();
+      if (t.GetNclusters() >= Int_t(fMinClustersInTrack*num_of_time_bins)) {
        Int_t label = GetTrackLabel(t);
        t.SetLabel(label);
-       AliTRDtrack* pt=&t;
-        fTracks->AddLast(pt); fNtracks++;
        UseClusters(t);
+
+        AliTRDtrack *pt = new AliTRDtrack(t);
+        fTracks->AddLast(pt); fNtracks++;     
+
        cerr<<"found track "<<fNtracks<<endl;
       }                         
     }     
+    delete fSeeds->RemoveAt(i);  
   }            
 }
 
 //__________________________________________________________________
-void AliTRDtracker::UseClusters(AliTRDseed t) {
+void AliTRDtracker::UseClusters(AliTRDtrack t) {
   Int_t ncl=t.GetNclusters();
   for (Int_t i=0; i<ncl; i++) {
     Int_t index = t.GetClusterIndex(i);
@@ -560,11 +560,11 @@ void AliTRDtracker::UseClusters(AliTRDseed t) {
 }
 
 //__________________________________________________________________
-Int_t AliTRDtracker::GetTrackLabel(AliTRDseed t) {
+Int_t AliTRDtracker::GetTrackLabel(AliTRDtrack t) {
 
   Int_t label=123456789, index, i, j;
   Int_t ncl=t.GetNclusters();
-  const Int_t range=300;
+  const Int_t range = AliTRDgeometry::kNplan * fGeom->GetTimeMax();
   Bool_t label_added;
 
   Int_t s[range][2];
@@ -601,7 +601,6 @@ Int_t AliTRDtracker::GetTrackLabel(AliTRDseed t) {
     }
   }
 
-
   Int_t max=0;
   label = -123456789;
 
@@ -610,17 +609,17 @@ Int_t AliTRDtracker::GetTrackLabel(AliTRDseed t) {
       max=s[i][1]; label=s[i][0];
     }
   }
-  if(max > ncl/2) return label;
+  if(max > ncl*fLabelFraction) return label;
   else return -1;
 }
 
 //___________________________________________________________________
 
-Int_t AliTRDtracker::WriteTracks() {
+Int_t AliTRDtracker::WriteTracks(const Char_t *filename) {
 
   TDirectory *savedir=gDirectory;   
 
-  TFile *out=TFile::Open("AliTRDtracks.root","RECREATE");
+  TFile *out=TFile::Open(filename,"RECREATE");
 
   TTree tracktree("TreeT","Tree with TRD tracks");
 
@@ -645,11 +644,9 @@ Int_t AliTRDtracker::WriteTracks() {
   return 0;
 }
 
-
-
 //_____________________________________________________________________________
-void AliTRDtracker::ReadClusters(TObjArray *array, const Char_t *filename
-                               , Int_t nEvent, Int_t option)
+void AliTRDtracker::ReadClusters(TObjArray *array, const Char_t *filename, 
+Int_t option = 1) 
 {
   //
   // Reads AliTRDclusters (option >= 0) or AliTRDrecPoints (option < 0) 
@@ -662,33 +659,48 @@ void AliTRDtracker::ReadClusters(TObjArray *array, const Char_t *filename
   TFile *file = TFile::Open(filename);
   if (!file->IsOpen()) {printf("Can't open file %s !\n",filename); return;} 
 
-  Char_t treeName[14];
-  sprintf(treeName,"TRDrecPoints%d", nEvent);
-
-  TTree *tree=(TTree*)file->Get(treeName);
-  TBranch *branch=tree->GetBranch("TRDrecPoints");
+  TTree *tree = (TTree*)file->Get("ClusterTree");
   Int_t nentr = (Int_t) tree->GetEntries();
-  printf("found %d entries in %s tree.\n",nentr,treeName);
-
-  for (Int_t i=0; i<nentr; i++) {
-    TObjArray *ioArray = new TObjArray(400);
-    branch->SetAddress(&ioArray);
-    tree->GetEvent(i);
-    Int_t npoints = ioArray->GetEntriesFast();
-    printf("Read %d rec. points from entry %d \n", npoints, i);
-    for(Int_t j=0; j<npoints; j++) {
-      AliTRDrecPoint *p=(AliTRDrecPoint*)ioArray->UncheckedAt(j);
-      AliTRDcluster  *c = new AliTRDcluster(p); 
-      if( option >= 0) array->AddLast(c);
-      else array->AddLast(p);
+  printf("found %d entries in %s.\n",nentr,tree->GetName());
+
+  TBranch *branch;
+  TObjArray *ioArray = new TObjArray(400);
+
+  if( option < 0 ) {
+    branch = tree->GetBranch("RecPoints");
+
+    for (Int_t i=0; i<nentr; i++) {
+      branch->SetAddress(&ioArray);
+      tree->GetEvent(i);
+      Int_t npoints = ioArray->GetEntriesFast();
+      printf("Read %d rec. points from entry %d \n", npoints, i);
+
+      for(Int_t j=0; j<npoints; j++) {
+       AliTRDrecPoint *p=(AliTRDrecPoint*)ioArray->UncheckedAt(j);
+       array->AddLast(p);
+       ioArray->RemoveAt(j);
+      }
+    }
+  }
+  else {
+    branch = tree->GetBranch("Clusters");
+
+    for (Int_t i=0; i<nentr; i++) {
+      branch->SetAddress(&ioArray);
+      tree->GetEvent(i);
+      Int_t npoints = ioArray->GetEntriesFast();
+      printf("Read %d clusters from entry %d \n", npoints, i);
+
+      for(Int_t j=0; j<npoints; j++) {
+       AliTRDcluster *c=(AliTRDcluster*)ioArray->UncheckedAt(j);
+       array->AddLast(c);
+       ioArray->RemoveAt(j);
+      }
     }
   }
 
   file->Close();                   
   savedir->cd(); 
-
+  
 }
 
-
-
-
index 2d726ac..6caf38a 100644 (file)
@@ -7,12 +7,14 @@
 #include <TNamed.h>
 
 class TFile;
+class TParticle;
+class TParticlePDG;
 class TObjArray;
 
 class AliTRDgeometry;
 // class AliTRDtrackingSector;
 class AliTRDtrack;
-class AliTRDseed;
+class AliTRDmcTrack;
 
 
 class AliTRDtracker : public TNamed { 
@@ -23,21 +25,27 @@ class AliTRDtracker : public TNamed {
   AliTRDtracker(const Text_t* name, const Text_t* title);
   ~AliTRDtracker(); 
 
-  virtual void  GetEvent(const Char_t *name, Int_t nEvent = 0);
-  virtual void  SetUpSectors(AliTRDtrackingSector *sec);
+  virtual void  Clusters2Tracks(); 
+  Double_t      ExpectedSigmaY2(Double_t r, Double_t tgl, Double_t pt);
+  Double_t      ExpectedSigmaZ2(Double_t r, Double_t tgl);
+  Int_t         FindProlongation(AliTRDtrack& t, AliTRDtrackingSector *sec,
+                                 Int_t s, Int_t rf=0);
+  void          GetEvent(const Char_t *hitfile, const Char_t *clusterfile);
+  void          SetUpSectors(AliTRDtrackingSector *sec);
   virtual void  MakeSeeds(Int_t inner, Int_t outer);
   virtual void  FindTracks();
-  virtual void  UseClusters(AliTRDseed t);
-  virtual Int_t GetTrackLabel(AliTRDseed t);
-  virtual Int_t WriteTracks(); 
-  virtual void  ReadClusters(TObjArray *array, const Char_t *filename, Int_t nEvent = 0, Int_t option = 1);
+  virtual void  UseClusters(AliTRDtrack t);
+  virtual Int_t GetTrackLabel(AliTRDtrack t);
+  Int_t         WriteTracks(const Char_t *filename); 
+  void          ReadClusters(TObjArray *array, const Char_t *filename, 
+                             Int_t option = 1);
 
  protected:
 
-  TFile            *fInputFile;       // AliROOT input file
-  AliTRDgeometry   *fGeom;            // Pointer to TRD geometry
   Int_t            fEvent;            // Event number
 
+  AliTRDgeometry   *fGeom;            // Pointer to TRD geometry
+
   Int_t            fNclusters;        // Number of clusters in TRD 
   TObjArray        *fClusters;        // List of clusters for all sectors
 
@@ -47,6 +55,27 @@ class AliTRDtracker : public TNamed {
   Int_t            fNtracks;          // Number of reconstructed tracks 
   TObjArray        *fTracks;          // List of reconstructed tracks   
 
+  static const Int_t    fSeedGap;  // Distance between inner and outer
+                                      // time bin in seeding
+  
+  static const Int_t    fSeedStep;    // Step in iterations
+  static const Float_t         fSeedDepth;   // Fraction of TRD allocated for seeding
+  static const Float_t  fSkipDepth;   // Fraction of TRD which can be skipped
+                                      // in track prolongation            
+  static const Double_t fMaxChi2;     // max increment in track chi2 
+       
+  static const Float_t  fMinClustersInTrack; // min fraction of clusters in track
+  static const Float_t  fMinClustersInSeed;  // min fraction of clusters in seed
+  static const Float_t  fMaxSeedDeltaZ;  // max dZ in MakeSeeds
+  static const Float_t  fMaxSeedC;       // max initial curvature in MakeSeeds
+  static const Float_t  fMaxSeedTan;     // max initial Tangens(lambda) in MakeSeeds
+  static const Float_t  fMaxSeedVertexZ; // max vertex Z in MakeSeeds
+  static const Double_t fSeedErrorSY;    // sy parameter in MakeSeeds
+  static const Double_t fSeedErrorSY3;   // sy3 parameter in MakeSeeds
+  static const Double_t fSeedErrorSZ;    // sz parameter in MakeSeeds
+  static const Float_t  fLabelFraction;  // min fraction of clusters in GetTrackLabel
+  static const Float_t  fWideRoad;       // max road width in FindProlongation
   ClassDef(AliTRDtracker,1)           // manager base class  
 
 };
index a443a7e..157d00a 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.4  2000/10/16 01:16:53  cblume
+Changed timebin 0 to be the one closest to the readout
+
 Revision 1.3  2000/10/15 23:40:01  cblume
 Remove AliTRDconst
 
@@ -68,7 +71,6 @@ AliTRDtimeBin &AliTRDtrackingSector::operator[](Int_t i)
 
 void AliTRDtrackingSector::SetUp()
 { 
-
   AliTRD *TRD = (AliTRD*) gAlice->GetDetector("TRD");
   fGeom = TRD->GetGeometry();
 
@@ -97,9 +99,7 @@ Double_t AliTRDtrackingSector::GetX(Int_t l) const
                                /fTimeBinSize) + 1);
 
     Float_t t0 = fGeom->GetTime0(plane);
-    Double_t x = t0 + time_slice * fTimeBinSize;
-
-    //    cerr<<"plane, tb, x = "<<plane<<","<<time_slice<<","<<x<<endl;
+    Double_t x = t0 - time_slice * fTimeBinSize;
 
     return x;
   }
@@ -127,29 +127,23 @@ Double_t AliTRDtrackingSector::GetMaxY(Int_t l) const
 
 Int_t AliTRDtrackingSector::GetTimeBinNumber(Double_t x) const
 {
-  //Float_t r_out = fGeom->GetTime0(AliTRDgeometry::Nplan()-1) 
-  //              + AliTRDgeometry::DrThick(); 
-  // Changed to new time0 (CBL)
   Float_t r_out = fGeom->GetTime0(AliTRDgeometry::Nplan()-1); 
-  Float_t r_in = fGeom->GetTime0(0);
-  //  cerr<<"GetTimeBinNumber: r_in,r_out = "<<r_in<<","<<r_out<<endl;
+  Float_t r_in = fGeom->GetTime0(0) - AliTRDgeometry::DrThick();
 
   if(x >= r_out) return fN-1;
   if(x <= r_in) return 0;
 
   Float_t gap = fGeom->GetTime0(1) - fGeom->GetTime0(0);
-  //  cerr<<"GetTimeBinNumber: gap = "<<gap<<endl;
 
   Int_t plane = Int_t((x - r_in + fTimeBinSize/2)/gap);
-  //  cerr<<"GetTimeBinNumber: plane="<<plane<<endl;
 
-  Int_t local_tb = Int_t((x-fGeom->GetTime0(plane))/fTimeBinSize + 0.5);
-  //  cerr<<"GetTimeBinNumber: local_tb="<<local_tb<<endl;
+  Int_t local_tb = Int_t((fGeom->GetTime0(plane)-x)/fTimeBinSize + 0.5);
+
 
-  Int_t time_bin = plane * (Int_t(AliTRDgeometry::DrThick()
-                                 /fTimeBinSize) + 1) + local_tb;
-  //  cerr<<"GetTimeBinNumber: time_bin = "<<time_bin<<endl;
-  
+  Int_t tb_per_plane = fN/AliTRDgeometry::Nplan();
+
+  Int_t time_bin = plane * (Int_t(AliTRDgeometry::DrThick()/fTimeBinSize) + 1)
+                   + (tb_per_plane - 1 - local_tb);
 
   return time_bin;
 }
@@ -160,8 +154,11 @@ Int_t AliTRDtrackingSector::GetTimeBin(Int_t det, Int_t local_tb) const
 {
   Int_t plane = fGeom->GetPlane(det);
 
-  Int_t time_bin = plane * (Int_t(AliTRDgeometry::DrThick()
-                                 /fTimeBinSize) + 1) + local_tb;  
+  Int_t tb_per_plane = fN/AliTRDgeometry::Nplan();
+
+  Int_t time_bin = plane * (Int_t(AliTRDgeometry::DrThick()/fTimeBinSize) + 1)
+                   + (tb_per_plane - 1 - local_tb);
+
   return time_bin;
 }
 
index 89f1718..e79f549 100644 (file)
@@ -15,13 +15,8 @@ class AliTRDtrackingSector : public TObject {
 
 // Provides tools to address clusters which lay within one sector
 
-protected:
-  Int_t fN;
-  AliTRDtimeBin           *fTimeBin;    // Pointer to array of AliTRDtimeBin
-  AliTRDgeometry          *fGeom;       // Pointer to TRD geometry
-  Float_t                  fTimeBinSize;  // Time bin size in cm  
-
 public:
+
   AliTRDtrackingSector() {fN=0; fTimeBin=0; fGeom=0; fTimeBinSize=0;}
   virtual ~AliTRDtrackingSector();
   virtual void SetUp();
@@ -35,6 +30,15 @@ public:
   Int_t GetTimeBin(Int_t det, Int_t local_tb) const;
   Float_t GetPitch() const {return fTimeBinSize;}   
 
+
+protected:
+
+  Int_t fN;
+  AliTRDgeometry          *fGeom;       // Pointer to TRD geometry
+  AliTRDtimeBin           *fTimeBin;    // Pointer to array of AliTRDtimeBin
+  Float_t                  fTimeBinSize;  // Time bin size in cm  
+
+
   ClassDef(AliTRDtrackingSector,1)  // Provides tools to address clusters which lay within one sector
 
 }; 
index 83a031a..a5a20dc 100644 (file)
@@ -46,12 +46,13 @@ void TrackDisplay(Int_t track) {
   TObjArray rparray(2000);
   TObjArray *RecPointsArray = &rparray;
   AliTRDtracker *Tracker = new AliTRDtracker("dummy","dummy");
-  Tracker->ReadClusters(RecPointsArray,alifile,nEvent,-1); 
+  Tracker->ReadClusters(RecPointsArray,alifile,-1); 
   Int_t nRecPoints = RecPointsArray->GetEntriesFast();
   cerr<<"Found "<<nRecPoints<<" rec. points"<<endl;
 
 
   // Connect the AliRoot file containing Geometry, Kine, Hits, and Digits
+  alifile = "galice.root";
   TFile *gafl = (TFile*) gROOT->GetListOfFiles()->FindObject(alifile);
   if (!gafl) {
     cout << "Open the ALIROOT-file " << alifile << endl;
index 2d7d937..4246ffc 100644 (file)
@@ -13,29 +13,30 @@ void slowClusterCreate() {
     cout << "Loaded shared libraries" << endl;
   }
 
-  // Input (and output) file name
-  Char_t *alifile = "galice.root";
+  // Input and output file names
+  Char_t *infile  = "galice.root";
+  Char_t *outfile = "AliTRDclusters.root";
 
   // Create the clusterizer
   AliTRDclusterizerV1 *Clusterizer = 
     new AliTRDclusterizerV1("clusterizer","slow clusterizer class"); 
 
+  // Define output file name
+  Clusterizer->Init(outfile);
+
   // Open the AliRoot file 
-  Clusterizer->Open(alifile);
+  Clusterizer->Open(infile);
 
   // Load the digits
   Clusterizer->ReadDigits();
-
-  // Clean output branch
-  Clusterizer->WriteClusters(-2);
  
   // Find the cluster
   Clusterizer->MakeClusters();
 
-  // Write the cluster into the input file
+  // Write the cluster tree into file AliTRDclusters.root
   Clusterizer->WriteClusters(-1);
 
   // Save the clusterizer class in the AliROOT file
-  Clusterizer->Write();
+  // Clusterizer->Write();
 
 }