Code for unified TPC/TRD tracking (S.Radomski)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 10 Apr 2003 10:36:54 +0000 (10:36 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 10 Apr 2003 10:36:54 +0000 (10:36 +0000)
15 files changed:
STEER/AliBarrelTrack.cxx [new file with mode: 0644]
STEER/AliBarrelTrack.h [new file with mode: 0644]
STEER/AliKalmanTrack.h
STEER/AliTrackReference.h
STEER/AliTracker.h
STEER/STEERLinkDef.h
STEER/libSTEER.pkg
TPC/AliTPCtrack.cxx
TPC/AliTPCtrack.h
TPC/AliTPCtracker.cxx
TPC/AliTPCtracker.h
TRD/AliTRDtrack.cxx
TRD/AliTRDtrack.h
TRD/AliTRDtracker.cxx
TRD/AliTRDtracker.h

diff --git a/STEER/AliBarrelTrack.cxx b/STEER/AliBarrelTrack.cxx
new file mode 100644 (file)
index 0000000..f83c2e5
--- /dev/null
@@ -0,0 +1,123 @@
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// AliBarrelTrack is a snapshot of the TPC or TRD track.
+// The barrel track is stored by tracker every time a track is crossing 
+// reference plane.
+//  
+// Barrel track have
+// - state vactor in "external represenantion"
+// - diagonal elements of covariance matric
+// - auxiliary paramrters: 
+//   chi2, number of clusters, number of sector srossed
+// - methods to compare with track references
+//
+// Barrel track can be directly compared with AliTrackReferences,
+// TPC and TRD tracks can be compared using the same macro.
+//
+// S. Radomski, [GSI] mail: S.Radomski@gsi.de
+// 07.04.2003
+// 
+////////////////////////////////////////////////////////////////////////////////
+
+#include "AliBarrelTrack.h"
+
+ClassImp(AliBarrelTrack)
+
+////////////////////////////////////////////////////////////////////////////////
+
+AliBarrelTrack:: AliBarrelTrack() : TObject() {
+  //
+  // Standard constructor 
+  // reset all data-members
+  //
+
+  fLabel = fRefPlane = fIsIn = 0;
+  fX =  fAlpha = 0.0;
+  fZ = fY = fTgLambda = fSnPhi = f1Pt = 0.0;
+
+  for(Int_t i=0; i<5; i++)  fTimeHypothesis[i] = 0;
+  fLength = 0.0;
+  fNClusters = fNWrong = fNRotate = 0;
+  fChi2 = 0.0; 
+  fMass = fdEdX = 0;
+
+  fCy = fCz = fCtg = fCpt = fCphi = 0.0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AliBarrelTrack::SetLabel(Int_t label) {
+  //
+  // Sets the label
+  //
+
+  fLabel = label;  
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AliBarrelTrack::SetX(Double_t x, Double_t alpha) {
+  //
+  
+  fX = x;
+  fAlpha = alpha;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AliBarrelTrack::SetRefPlane(Int_t nRefPlane, Int_t isIn) {
+  
+  fRefPlane = nRefPlane;
+  fIsIn = isIn;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AliBarrelTrack::SetNClusters(Int_t nClusters, Double_t chi2) {
+
+  fNClusters = nClusters;
+  fChi2 = chi2;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AliBarrelTrack::SetTime(Float_t time[5], Double_t length) {
+
+  for(Int_t i=0; i<5; i++)
+    fTimeHypothesis[i] = time[i];
+
+  fLength = length;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AliBarrelTrack::SetStateVector(Double_t vec[5]) {
+  //
+  // Set State Vector from external representation
+  //
+
+
+  fY = vec[0];
+  fZ = vec[1];
+  fTgLambda = vec[3];
+  fSnPhi = vec[2]; 
+  f1Pt = vec[4];
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AliBarrelTrack::SetCovarianceMatrix(Double_t vec[15]) {
+  //
+  // Set Covariance Matrix from external represenatation
+  // 
+
+  fCy   = vec[0];
+  fCz   = vec[2];
+  fCtg  = vec[9];
+  fCphi = vec[5];
+  fCpt  = vec[14];
+}
+
+////////////////////////////////////////////////////////////////////////////////
diff --git a/STEER/AliBarrelTrack.h b/STEER/AliBarrelTrack.h
new file mode 100644 (file)
index 0000000..67257d1
--- /dev/null
@@ -0,0 +1,113 @@
+
+#ifndef AliBarrelTrack_H
+#define AliBarrelTrack_H
+
+#include "TObject.h"
+#include "TMath.h"
+
+class AliBarrelTrack : public TObject {
+  
+ protected:
+
+  Int_t fLabel;          // kine tree index
+
+  Int_t fRefPlane;       // id of the reference plane
+  Int_t fIsIn;           // direction
+
+  Double_t fX;           // Kalman Time
+  Double_t fAlpha;       // sector angle
+
+  // state vector
+  Double_t fZ;          // Z in global cs
+  Double_t fY;          // Y in local cs corresponds to r-phi
+  Double_t fTgLambda;   // Tangent of the dip angle
+  Double_t fSnPhi;      // Sin 
+  Double_t f1Pt;        // inverse of momentum
+
+
+  // covariance matrix
+  Double_t fCz;
+  Double_t fCy;
+  Double_t fCtg;
+  Double_t fCphi;
+  Double_t fCpt;
+
+    
+  // track time/length  
+  Double_t fTimeHypothesis[5];    // time for all hypoptheses
+  Double_t fLength;               // track length
+
+  // performance info
+  Int_t fNClusters;         // Number of clusters 
+  Int_t fNWrong;            // Number of wrong clusters
+  Double_t fChi2;           // Chi 2
+  Int_t fNRotate;           // number of rotations / sector crossing
+  Double_t fMass;           // mass hypothesis
+  Double_t fdEdX;           // dE/dX
+
+ public:
+  
+  AliBarrelTrack();
+  ~AliBarrelTrack() {}
+  
+  // Setters
+
+  void SetLabel(Int_t label); 
+  void SetX(Double_t x, Double_t alpha);
+  void SetRefPlane(Int_t nRefPlane, Int_t isIn);
+  void SetNClusters(Int_t nClusters, Double_t chi2);
+  void SetTime(Float_t time[5], Double_t length);
+  void SetStateVector(Double_t vec[5]);             // external parameters
+  void SetCovarianceMatrix(Double_t vec[15]);       // external parameters
+  void SetNWrongClusters(Int_t n) {fNWrong = n;}
+  void SetNRotate(Int_t n) {fNRotate = n;}
+
+  void SetMass(Double_t mass) {fMass = mass;}
+  void SetdEdX(Double_t dEdX) {fdEdX = dEdX;}
+
+  // Getters
+
+  // standard
+  Int_t GetLabel() const {return fLabel;}
+  Int_t GetNClusters() const {return fNClusters;}
+  Int_t GetNWrongClusters() const {return fNWrong;}
+  Int_t GetNRotate() const {return fNRotate;}
+  
+  Int_t GetRefPlane() const {return fRefPlane;}
+
+  Double_t GetX() const {return fX;}
+  Double_t Y() const {return fY;}
+  Double_t Z() const {return fZ;}
+
+  Double_t GetMass() const {return fMass;}
+
+  // track oriented variables
+  Double_t Pt() const {return (f1Pt==0)? 0 : 1./f1Pt;}
+  Double_t TgLambda() const {return fTgLambda;}
+  Double_t Eta() const {return -TMath::Log(TMath::Tan(0.25 *TMath::Pi()-0.5*Lambda()));}
+  Double_t Phi() const {return TMath::ASin(fSnPhi);}
+  
+
+  // uncertainties
+  Double_t DeltaY() const {return TMath::Sqrt(fCy);}
+  Double_t DeltaZ() const {return TMath::Sqrt(fCz);}
+  Double_t DeltaTgLambda() const {return TMath::Sqrt(fCtg);}
+  Double_t DeltaSnPhi() const {return TMath::Sqrt(fCphi);}
+  Double_t DeltaPt() const {return Pt() - 1./(Pt() + TMath::Sqrt(fCpt));}
+
+
+  // reference oriented variables
+  Double_t Px() const {return TMath::Cos(Phi()+fAlpha) * Pt();}
+  Double_t Py() const {return TMath::Sin(Phi()+fAlpha) * Pt();}
+  Double_t Pz() const {return fTgLambda*Pt();}
+  Double_t P()  const {return Pt()*(fTgLambda+1);}
+
+  Double_t Lambda() const {return TMath::ATan(fTgLambda);}
+
+  ClassDef(AliBarrelTrack,1)
+};
+
+
+#endif
index 87a33ad..7cbacf2 100644 (file)
@@ -100,11 +100,11 @@ public:
   
 
 protected:
+
   void SetChi2(Double_t chi2) {fChi2=chi2;} 
   void SetMass(Double_t mass) {fMass=mass;}
   void SetNumberOfClusters(Int_t n) {fN=n;} 
 
-private: 
   Int_t fLab;             // track label
   Double_t fChi2;         // total chi2 value for this track
   Double_t fMass;         // mass hypothesis
@@ -117,6 +117,8 @@ private:
   Bool_t  fStartTimeIntegral;       // indicator wether integrate time
   Float_t fIntegratedTime[5];       // intgrated time
   Float_t fIntegratedLength;        // integrated length
+
+ public:
   
   ClassDef(AliKalmanTrack,2)    // Reconstructed track
 };
index 04ebf7b..fc8117b 100644 (file)
@@ -38,6 +38,15 @@ public:
   virtual void SetPosition(Float_t x, Float_t y, Float_t z){fX=x; fY=y; fZ=z;}
   virtual void SetMomentum(Float_t px, Float_t py, Float_t pz){fPx=px; fPy=py; fPz=pz;}
 
+  // Methods to get position of the track reference in 
+  // in the TPC/TRD/TOF Tracking coordinate system
+
+  virtual Float_t PhiPos() const {return TMath::Pi()+TMath::ATan2(-fY, -fX);}
+  virtual Float_t Alpha() const 
+    {return TMath::Pi()*(20*((((Int_t)(PhiPos()*180/TMath::Pi()))/20))+10)/180.;}
+  virtual Float_t LocalX() const {return fX*TMath::Cos(-Alpha()) - fY*TMath::Sin(-Alpha());}
+  virtual Float_t LocalY() const {return fX*TMath::Sin(-Alpha()) + fY*TMath::Cos(-Alpha());}
+
 
 protected:
   Int_t     fTrack;  // Track number
index b522c3d..d3edf15 100644 (file)
@@ -17,8 +17,13 @@ class AliCluster;
 class TFile;
 
 class AliTracker : public TObject {
+
+
 public:
-  AliTracker() { fX=fY=fZ=0.; fSigmaX=fSigmaY=fSigmaZ=0.; fEventN=0; }
+
+  enum {kTrackInward, kTrackBack, kTrackRefit} Propagation_t;
+  
+  AliTracker() { fX=fY=fZ=0.; fSigmaX=fSigmaY=fSigmaZ=0.; fEventN=0; fStoreBarrel = 1;}
   virtual ~AliTracker(){}
   virtual Int_t Clusters2Tracks(const TFile *in, TFile *out)=0;
   virtual Int_t PropagateBack(const TFile *in, TFile *out)=0;
@@ -28,6 +33,8 @@ public:
   }
   void SetEventNumber(Int_t ev) { fEventN=ev; }
 
+  
+
 //protected:
   virtual Int_t LoadClusters()=0;
   virtual void UnloadClusters()=0;
@@ -46,9 +53,14 @@ public:
   static Int_t SetFieldFactor(TFile* file, Bool_t deletegAlice = kTRUE);
   static Int_t SetFieldFactor();
   
+  Int_t IsStoringBarrel() const {return fStoreBarrel;}
+  void  SetStoreBarrel(Int_t s) {fStoreBarrel = s;}
+
 private:
   Int_t fEventN;//event number
 
+  Int_t fStoreBarrel;
+
   Double_t fX;  //X-coordinate of the primary vertex
   Double_t fY;  //Y-coordinate of the primary vertex
   Double_t fZ;  //Z-coordinate of the primary vertex
index 8f5e33b..62e68e7 100644 (file)
@@ -63,6 +63,7 @@
 #pragma link C++ class  AliTrackMapper+;
 #pragma link C++ class  AliCollisionGeometry+;
 #pragma link C++ class  AliMemoryWatcher+;
+#pragma link C++ class  AliBarrelTrack+;
 #endif
 
 
index dc2db5b..99894f3 100644 (file)
@@ -15,7 +15,7 @@ AliRunDigitizer.cxx AliDigitizer.cxx AliStream.cxx \
 AliMergeCombi.cxx AliMagFMaps.cxx AliFieldMap.cxx \
 AliGausCorr.cxx AliTrackReference.cxx AliESD.cxx \
 AliTrackMap.cxx AliTrackMapper.cxx AliCollisionGeometry.cxx \
-AliMemoryWatcher.cxx
+AliMemoryWatcher.cxx AliBarrelTrack.cxx
 
 HDRS:= $(SRCS:.cxx=.h) 
 
index 8801d9b..dc292eb 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.19  2003/03/03 16:56:53  hristov
+Corrections to obey coding conventions
+
 Revision 1.18  2003/02/19 08:57:04  hristov
 Control^M removed
 
@@ -55,6 +58,7 @@ Logs added
 
 #include "AliTPCtrack.h"
 #include "AliCluster.h"
+#include "AliBarrelTrack.h"
 
 ClassImp(AliTPCtrack)
 
@@ -63,6 +67,7 @@ AliTPCtrack::AliTPCtrack(): AliKalmanTrack()
 {
   fX = fP0 = fP1 = fP2 = fP3 = fP3 = fP4 = 0.0;
   fAlpha = fdEdx = 0.0;
+  fNWrong = fNRotation = fNumber = 0;  // [SR, 01.04.2003]
 }
 
 //_________________________________________________________________________
@@ -149,7 +154,37 @@ AliTPCtrack::AliTPCtrack(const AliTPCtrack& t) : AliKalmanTrack(t) {
   Int_t n=GetNumberOfClusters();
   for (Int_t i=0; i<n; i++) fIndex[i]=t.fIndex[i];
 }
+//_____________________________________________________________________________
+
+void  AliTPCtrack::GetBarrelTrack(AliBarrelTrack *track) {
+  //
+  // Create a Barrel Track out of this track
+  // Current track is propagated to the reference plane
+  // by the tracker
+  //
+  // [SR, 01.04.2003]
+  
+  if (!track) return;
+  Double_t xr, vec[5], cov[15];
+
+  track->SetLabel(GetLabel());
+  track->SetX(fX, fAlpha);
+  track->SetNClusters(GetNumberOfClusters(), GetChi2());
+  track->SetTime(fIntegratedTime, fIntegratedLength);
+
+  track->SetMass(fMass);
+  track->SetdEdX(fdEdx);
+
+  track->SetNWrongClusters(fNWrong);
+  track->SetNRotate(fNRotation);
 
+  GetExternalParameters(xr, vec);
+  track->SetStateVector(vec);
+  
+  GetExternalCovariance(cov);
+  track->SetCovarianceMatrix(cov);
+
+}
 //_____________________________________________________________________________
 Int_t AliTPCtrack::Compare(const TObject *o) const {
   //-----------------------------------------------------------------
@@ -315,6 +350,14 @@ Int_t AliTPCtrack::Update(const AliCluster *c, Double_t chisq, UInt_t index) {
   //-----------------------------------------------------------------
   // This function associates a cluster with this track.
   //-----------------------------------------------------------------
+
+  // update the number of wrong SR[20.03.2003]
+  Int_t absLabel = TMath::Abs(GetLabel());
+  if ( (c->GetLabel(0) != absLabel) && 
+       (c->GetLabel(0) != absLabel) &&
+       (c->GetLabel(0) != absLabel)) fNWrong++;
+  //
+
   Double_t r00=c->GetSigmaY2(), r01=0., r11=c->GetSigmaZ2();
   r00+=fC00; r01+=fC10; r11+=fC11;
   Double_t det=r00*r11 - r01*r01;
@@ -373,6 +416,9 @@ Int_t AliTPCtrack::Rotate(Double_t alpha)
   //-----------------------------------------------------------------
   // This function rotates this track.
   //-----------------------------------------------------------------
+
+  if (alpha != 0) fNRotation++;  // [SR, 01.04.2003]
+
   fAlpha += alpha;
   if (fAlpha<-TMath::Pi()) fAlpha += 2*TMath::Pi();
   if (fAlpha>=TMath::Pi()) fAlpha -= 2*TMath::Pi();
index 3d0cfbc..203dd37 100644 (file)
@@ -32,6 +32,8 @@
 
 #include "AliTPCreco.h"
 
+class AliBarrelTrack;
+
 //_____________________________________________________________________________
 class AliTPCtrack : public AliKalmanTrack {
 public:
@@ -74,6 +76,20 @@ public:
   void GetExternalParameters(Double_t& xr, Double_t x[5]) const ;
   void GetExternalCovariance(Double_t cov[15]) const ;
 
+  // [SR, 01.04.2003]
+
+  void GetBarrelTrack(AliBarrelTrack *track);
+
+  void ResetNWrong() {fNWrong = 0;}
+  void ResetNRotation() {fNRotation = 0;}
+  
+  Int_t GetNWrong() const {return fNWrong;}
+  Int_t GetNRotation() const {return fNRotation;}
+
+  Int_t GetNumber() const {return fNumber;}
+  void  SetNumber(Int_t n) {fNumber = n;} 
+  //
+
   Int_t GetClusterIndex(Int_t i) const {return fIndex[i];}
 
 //******** To be removed next release !!! **************
@@ -114,6 +130,11 @@ protected:
  
   UInt_t fIndex[kMaxRow];       // indices of associated clusters 
 
+  //[SR, 01.04.2003]
+  Int_t fNWrong;         // number of wrong clusters
+  Int_t fNRotation;      // number of rotations
+  Int_t fNumber;         // magic number used for number of clusters
+
   ClassDef(AliTPCtrack,1)   // Time Projection Chamber reconstructed tracks
 };
 
index 7cda215..2bbf4f2 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.31  2003/03/19 17:14:11  hristov
+Load/UnloadClusters added to the base class and the derived classes changed correspondingly. Possibility to give 2 input files for ITS and TPC tracks in PropagateBack. TRD tracker uses fEventN from the base class (T.Kuhr)
+
 Revision 1.30  2003/02/28 16:13:32  hristov
 Typos corrected
 
@@ -125,6 +128,14 @@ AliTracker(), fkNIS(par->GetNInnerSector()/2), fkNOS(par->GetNOuterSector()/2)
 
   fParam = (AliTPCParam*) par;
   fSeeds=0;
+
+  // [SR 17.03.2003]
+  
+  fBarrelFile = 0;
+  fBarrelTree = 0;
+  fBarrelArray = 0;
+  fBarrelTrack = 0;
+  
 }
 
 //_____________________________________________________________________________
@@ -138,6 +149,96 @@ AliTPCtracker::~AliTPCtracker() {
     fSeeds->Delete(); 
     delete fSeeds;
   }
+
+  // [SR, 01.04.2003]
+  if (fBarrelFile) {
+    fBarrelFile->Close();
+    delete fBarrelFile;
+  }
+}
+
+//_____________________________________________________________________________
+void AliTPCtracker::SetBarrelTree(const char *mode) {
+  //
+  // Creates a tree for BarrelTracks
+  // mode = "back" or "refit"
+  //
+  // [SR, 01.04.2003]
+  //
+  
+  if (!IsStoringBarrel()) return;
+  
+  TDirectory *sav = gDirectory;
+  if (!fBarrelFile) fBarrelFile = new TFile("AliBarrelTracks.root", "UPDATE");
+
+  char buff[40];
+  sprintf(buff, "BarrelTPC_%d_%s", GetEventNumber(), mode);
+
+  fBarrelFile->cd();
+  fBarrelTree = new TTree(buff, "Barrel TPC tracks");
+  
+  if (!fBarrelArray) fBarrelArray = new TClonesArray("AliBarrelTrack", 4);
+  for(Int_t i=0; i<4; i++) new((*fBarrelArray)[i]) AliBarrelTrack();
+  
+  fBarrelTree->Branch("tracks", &fBarrelArray);
+  
+  sav->cd();
+}
+//_____________________________________________________________________________
+
+void AliTPCtracker::StoreBarrelTrack(AliTPCtrack *ps, Int_t refPlane, Int_t isIn) {
+  //
+  // Stores Track at a given reference plane
+  // 
+  // refPlane: 1-4
+  // isIn: 1 - backward, 2 - refit
+  //
+  
+  if (!IsStoringBarrel()) return;
+  if (refPlane < 0 || refPlane > 4) return;
+  if (isIn > 2) return;
+
+  static Int_t nClusters;
+  static Int_t nWrong;
+  static Double_t chi2;
+  static Int_t index;
+
+  Int_t newClusters, newWrong;
+  Double_t newChi2;
+
+  if ( (refPlane == 1 && isIn == kTrackBack) || 
+       (refPlane == 4 && isIn == kTrackRefit) ) {
+    
+    fBarrelArray->Clear();
+    nClusters = nWrong = 0;
+    chi2 = 0.0;
+    index = 0;
+  }
+
+  // propagate
+  Double_t refX = 0;
+  if (refPlane == 1) refX = fParam->GetInnerRadiusLow();
+  if (refPlane == 2) refX = fParam->GetInnerRadiusUp();
+  if (refPlane == 3) refX = fParam->GetOuterRadiusLow();
+  if (refPlane == 4) refX = fParam->GetOuterRadiusUp();
+
+  ps->PropagateTo(refX);
+
+  fBarrelTrack = (AliBarrelTrack*)(*fBarrelArray)[index++];
+  ps->GetBarrelTrack(fBarrelTrack);
+  
+  newClusters = ps->GetNumberOfClusters() - nClusters; 
+  newWrong = ps->GetNWrong() - nWrong;
+  newChi2 = ps->GetChi2() - chi2;
+
+  nClusters =  ps->GetNumberOfClusters();
+  nWrong = ps->GetNWrong();
+  chi2 = ps->GetChi2();
+
+  fBarrelTrack->SetNClusters(newClusters, newChi2);
+  fBarrelTrack->SetNWrongClusters(newWrong);
+  fBarrelTrack->SetRefPlane(refPlane, isIn);
 }
 
 //_____________________________________________________________________________
@@ -358,6 +459,10 @@ Int_t AliTPCtracker::FollowProlongation(AliTPCseed& t, Int_t rf) {
       return 0;
     }
 
+    //if (fSectors == fInnerSec && (nr == 63 || nr == 0)) {
+    //  cout << nr << "\t" << krow << endl;
+    //}
+    
     if (krow) {
       for (Int_t i=krow.Find(y-road); i<krow; i++) {
        AliTPCcluster *c=(AliTPCcluster*)(krow[i]);
@@ -398,7 +503,7 @@ Int_t AliTPCtracker::FollowProlongation(AliTPCseed& t, Int_t rf) {
 Int_t AliTPCtracker::FollowRefitInward(AliTPCseed *seed, AliTPCtrack *track) {
   //
   // This function propagates seed inward TPC using old clusters
-  // from track.
+  // from the track.
   // 
   // Sylwester Radomski, GSI
   // 26.02.2003
@@ -409,7 +514,7 @@ Int_t AliTPCtracker::FollowRefitInward(AliTPCseed *seed, AliTPCtrack *track) {
   Int_t s=Int_t(alpha/fSectors->GetAlpha())%fN;
 
   Int_t idx=-1, sec=-1, row=-1;
-  Int_t nc = seed->GetLabel(); // index to start with
+  Int_t nc = seed->GetNumber();
 
   idx=track->GetClusterIndex(nc);
   sec=(idx&0xff000000)>>24; 
@@ -419,7 +524,10 @@ Int_t AliTPCtracker::FollowRefitInward(AliTPCseed *seed, AliTPCtrack *track) {
   else { if (sec <  fkNIS) row=-1; }   
 
   Int_t nr=fSectors->GetNRows();
-  for (Int_t i=0; i<nr; i++) {
+  for (Int_t i=nr-1; i>=0; i--) {
+
+    //cout << endl;
+    //cout << i << "\t" << nc << "\t"<< row << "\t" << seed->Pt() << "\t" << track->Pt() << "\t\t";
 
     Double_t x=fSectors->GetX(i); 
     if (!seed->PropagateTo(x)) return 0;
@@ -443,10 +551,9 @@ Int_t AliTPCtracker::FollowRefitInward(AliTPCseed *seed, AliTPCtrack *track) {
     Int_t index = 0;
     Double_t maxchi2 = kMaxCHI2;
     
-    //cout << i << " " << row << " " << nc << endl;
-
     if (row==i) {
 
+      //cout << row << endl;
       // accept already found cluster
       AliTPCcluster *c=(AliTPCcluster*)GetCluster(idx);
       Double_t chi2 = seed->GetPredictedChi2(c);
@@ -455,7 +562,9 @@ Int_t AliTPCtracker::FollowRefitInward(AliTPCseed *seed, AliTPCtrack *track) {
       cl=c; 
       maxchi2=chi2;
       
-      if (++nc < track->GetNumberOfClusters() ) {
+      //cout << c->GetY() << "\t" << seed->GetY() << "\t" << track->GetY();
+      
+      if (--nc >= 0 /* track->GetNumberOfClusters()*/ ) {
         idx=track->GetClusterIndex(nc); 
         sec=(idx&0xff000000)>>24; 
         row=(idx&0x00ff0000)>>16;
@@ -467,8 +576,6 @@ Int_t AliTPCtracker::FollowRefitInward(AliTPCseed *seed, AliTPCtrack *track) {
     }
     
     if (cl) {
-      
-      //cout << "Assigned" << endl;
       Float_t l=fSectors->GetPadPitchWidth();
       Float_t corr=1.; if (i>63) corr=0.67; // new (third) pad response !
       seed->SetSampledEdx(cl->GetQ()/l*corr,seed->GetNumberOfClusters());
@@ -476,7 +583,7 @@ Int_t AliTPCtracker::FollowRefitInward(AliTPCseed *seed, AliTPCtrack *track) {
     }
   }
 
-  seed->SetLabel(nc);
+  seed->SetNumber(nc);
   return 1;
 }
 
@@ -492,7 +599,9 @@ Int_t AliTPCtracker::FollowBackProlongation
   Int_t s=Int_t(alpha/fSectors->GetAlpha())%fN;
 
   Int_t idx=-1, sec=-1, row=-1;
-  Int_t nc=seed.GetLabel(); //index of the cluster to start with
+  //Int_t nc=seed.GetLabel(); //index of the cluster to start with
+  Int_t nc=seed.GetNumber();
+
   if (nc--) {
      idx=track.GetClusterIndex(nc);
      sec=(idx&0xff000000)>>24; row=(idx&0x00ff0000)>>16;
@@ -504,6 +613,8 @@ Int_t AliTPCtracker::FollowBackProlongation
   for (Int_t i=0; i<nr; i++) {
     Double_t x=fSectors->GetX(i), ymax=fSectors->GetMaxY(i);
 
+    //cout << i << "\t" << nc << "\t" << row << "\t" << track.GetNumberOfClusters() << endl;
+
     if (!seed.PropagateTo(x)) return 0;
 
     Double_t y=seed.GetY();
@@ -528,9 +639,12 @@ Int_t AliTPCtracker::FollowBackProlongation
       return 0;
     }
 
-
     Int_t accepted=seed.GetNumberOfClusters();
     if (row==i) {
+      
+      //if (fSectors == fInnerSec && row == 0)
+      //cout << "row == " << row << endl;
+
        //try to accept already found cluster
        AliTPCcluster *c=(AliTPCcluster*)GetCluster(idx);
        Double_t chi2;
@@ -574,7 +688,8 @@ Int_t AliTPCtracker::FollowBackProlongation
 
   }
 
-  seed.SetLabel(nc);
+  //seed.SetLabel(nc);
+  seed.SetNumber(nc);
 
   return 1;
 }
@@ -763,6 +878,9 @@ Int_t AliTPCtracker::Clusters2Tracks(const TFile *inp, TFile *out) {
 
   Int_t found=0;
   Int_t nseed=fSeeds->GetEntriesFast();
+
+  cout << fInnerSec->GetNRows() << " " << fOuterSec->GetNRows() << endl;
+
   for (Int_t i=0; i<nseed; i++) {
     //tracking in the outer sectors
     fSectors=fOuterSec; fN=fkNOS;
@@ -825,7 +943,6 @@ Int_t AliTPCtracker::RefitInward(TFile *in, TFile *out) {
   // 26.02.2003
   //
 
-
   if (!in->IsOpen()) {
     cout << "Input File not open !\n" << endl;
     return 1;
@@ -854,6 +971,9 @@ Int_t AliTPCtracker::RefitInward(TFile *in, TFile *out) {
   TTree *outputTree = new TTree("tracksTPC_0","Refited TPC tracks");
   outputTree->Branch("tracks", "AliTPCtrack", &outTrack, 32000, 3);
 
+  // [SR, 01.04.2003] - Barrel tracks
+  if (IsStoringBarrel()) SetBarrelTree("refit");
+
   Int_t nRefited = 0;
 
   for(Int_t t=0; t < nTracks; t++) {
@@ -861,20 +981,39 @@ Int_t AliTPCtracker::RefitInward(TFile *in, TFile *out) {
     cout << t << "\r";
 
     inputTree->GetEvent(t);
+    inTrack->ResetCovariance();
     AliTPCseed *seed = new AliTPCseed(*inTrack, inTrack->GetAlpha());
 
-    seed->ResetCovariance();
+    /*
+    //cout << inTrack->GetNumberOfClusters() << endl;
+    if (inTrack->GetNumberOfClusters() == 158) {
+      cout << inTrack->GetNumberOfClusters() << endl;
+      cout << endl;
+      for(Int_t c=0; c<inTrack->GetNumberOfClusters(); c++) {
+        Int_t idx = inTrack->GetClusterIndex(c);
+        Int_t row=(idx&0x00ff0000)>>16;
+        cout << c << " " << row << endl;
+      }
+    }
+    */
 
-    seed->SetLabel(0);    
-    fSectors = fInnerSec;
+    if (IsStoringBarrel()) StoreBarrelTrack(seed, 4, 2);
+
+    seed->SetNumber(inTrack->GetNumberOfClusters()-1);    
+    fSectors = fOuterSec;
     Int_t res = FollowRefitInward(seed, inTrack);
     UseClusters(seed);
     Int_t nc = seed->GetNumberOfClusters();
 
-    fSectors = fOuterSec;
+    if (IsStoringBarrel()) StoreBarrelTrack(seed, 3, 2);
+    if (IsStoringBarrel()) StoreBarrelTrack(seed, 2, 2);
+
+    fSectors = fInnerSec;
     res = FollowRefitInward(seed, inTrack);
     UseClusters(seed, nc);
 
+    if (IsStoringBarrel()) StoreBarrelTrack(seed, 1, 2);
+
     if (res) {
       seed->PropagateTo(fParam->GetInnerRadiusLow());
       outTrack = (AliTPCtrack*)seed;
@@ -883,13 +1022,25 @@ Int_t AliTPCtracker::RefitInward(TFile *in, TFile *out) {
       nRefited++;
     }
 
+    if (IsStoringBarrel()) fBarrelTree->Fill();
     delete seed;
   }
 
   cout << "Refitted " << nRefited << " tracks." << endl;
 
+  out->cd();
   outputTree->Write();
   
+  // [SR, 01.04.2003]
+  if (IsStoringBarrel()) {
+    fBarrelFile->cd();
+    fBarrelTree->Write();
+    fBarrelFile->Flush();  
+    
+    delete fBarrelArray;
+    delete fBarrelTree;
+  }
+  
   if (inputTree) delete inputTree;
   if (outputTree) delete outputTree;
 
@@ -955,6 +1106,9 @@ Int_t AliTPCtracker::PropagateBack(const TFile *inp, const TFile *inp2, TFile *o
   AliTPCtrack *tpcTrack=new AliTPCtrack; 
   tpcTree->SetBranchAddress("tracks",&tpcTrack);
 
+  // [SR, 01.04.2003] - Barrel tracks
+  if (IsStoringBarrel()) SetBarrelTree("back");
+  
   //*** Prepare an array of tracks to be back propagated
   Int_t nup=fOuterSec->GetNRows(), nlow=fInnerSec->GetNRows();
   Int_t nrows=nlow+nup;
@@ -996,8 +1150,9 @@ Int_t AliTPCtracker::PropagateBack(const TFile *inp, const TFile *inp2, TFile *o
 
       // No ITS - use TPC track only
       
+      tpcTrack->ResetCovariance();
       AliTPCseed * seed = new AliTPCseed(*tpcTrack, tpcTrack->GetAlpha());
-      seed->ResetCovariance();
+
       fSeeds->AddLast(seed);
       tracks.AddLast(new AliTPCtrack(*tpcTrack));
     
@@ -1053,31 +1208,48 @@ Int_t AliTPCtracker::PropagateBack(const TFile *inp, const TFile *inp2, TFile *o
   AliTPCtrack *otrack=0;
   backTree.Branch("tracks","AliTPCtrack",&otrack,32000,0);
 
-  //*** Back propagation through inner sectors
-  fSectors=fInnerSec; fN=fkNIS;
+  //
+  Int_t nRefPlane;
+  Int_t found=0;
   Int_t nseed=fSeeds->GetEntriesFast();
+      
+  // loop changed [SR, 01.04.2003]
+
   for (i=0; i<nseed; i++) {
+
+    nRefPlane = 1;
+    if (IsStoringBarrel()) fBarrelArray->Clear();
+
      AliTPCseed *ps=(AliTPCseed*)fSeeds->UncheckedAt(i), &s=*ps;
      const AliTPCtrack *pt=(AliTPCtrack*)tracks.UncheckedAt(i), &t=*pt;
 
+    ps->ResetNWrong();
+    ps->ResetNRotation();
+    
+    if (IsStoringBarrel()) StoreBarrelTrack(ps, 1, 1);
+
+    // Load outer sectors
+    fSectors=fInnerSec;
+    fN=fkNIS;
+       
      Int_t nc=t.GetNumberOfClusters();
-     s.SetLabel(nc-1); //set number of the cluster to start with
+    //s.SetLabel(nc-1); //set number of the cluster to start with
+    s.SetNumber(nc);
 
-     if (FollowBackProlongation(s,t)) {
-       UseClusters(&s);
+    if (FollowBackProlongation(s,t)) UseClusters(&s);    
+    else {
+      fSeeds->RemoveAt(i);
         continue;
      }
-     delete fSeeds->RemoveAt(i);
-  }  
 
-//*** Back propagation through outer sectors
-  fSectors=fOuterSec; fN=fkNOS;
-  Int_t found=0;
-  for (i=0; i<nseed; i++) {
-     AliTPCseed *ps=(AliTPCseed*)fSeeds->UncheckedAt(i), &s=*ps;
-     if (!ps) continue;
-     Int_t nc=s.GetNumberOfClusters();
-     const AliTPCtrack *pt=(AliTPCtrack*)tracks.UncheckedAt(i), &t=*pt;
+    if (IsStoringBarrel()) StoreBarrelTrack(ps, 2, 1);
+    if (IsStoringBarrel()) StoreBarrelTrack(ps, 3, 1);
+
+    // Load outer sectors
+    fSectors=fOuterSec; 
+    fN=fkNOS;
+    
+    nc=s.GetNumberOfClusters();
 
      Double_t alpha=s.GetAlpha() - fSectors->GetAlphaShift();
      if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
@@ -1100,16 +1272,31 @@ Int_t AliTPCtracker::PropagateBack(const TFile *inp, const TFile *inp2, TFile *o
            ps->PropagateTo(fParam->GetOuterRadiusUp()); 
            otrack=ps;
            backTree.Fill();
-          found++;
-//           cerr<<found<<'\r';
-           continue;
+
+          if (IsStoringBarrel()) StoreBarrelTrack(ps, 4, 1);
+          cerr<<found++<<'\r';
          }
        }
      }
+    
+    if (IsStoringBarrel()) fBarrelTree->Fill();
      delete fSeeds->RemoveAt(i);
   }  
 
+
+  out->cd();
   backTree.Write();
+
+  // [SR, 01.04.2003]
+  if (IsStoringBarrel()) {
+    fBarrelFile->cd();
+    fBarrelTree->Write();
+    fBarrelFile->Flush();  
+
+    delete fBarrelArray;
+    delete fBarrelTree;
+  }
+
   savedir->cd();
   cerr<<"Number of seeds: "<<nseed<<endl;
   cerr<<"Number of back propagated ITS tracks: "<<bckN<<endl;
index ebe7647..36df374 100644 (file)
@@ -14,6 +14,7 @@
 #include "AliTPCtrack.h"
 #include "AliTPCreco.h"
 #include "AliTPCcluster.h"
+#include "AliBarrelTrack.h"
 
 class TFile;
 class AliTPCParam;
@@ -166,6 +167,18 @@ private:
    
    AliTPCParam *fParam;      //! TPC parameters for outer reference plane [SR, GSI, 18.02.2003]
    TObjArray *fSeeds;        //array of track seeds
+
+   // [SR, 01.04.2003]
+   void SetBarrelTree(const char *mode);
+   void StoreBarrelTrack(AliTPCtrack *ps, Int_t refPlane, Int_t isIn);
+
+   // [SR, 01.04.2003]
+   TFile *fBarrelFile;             // file with "barrel" tracks
+   TTree *fBarrelTree;             // tree with "barrel" tracks
+   TBranch *fBarrelBranch;
+   TClonesArray *fBarrelArray;
+   AliBarrelTrack *fBarrelTrack;
+
 };
 
 #endif
index 24e9c32..b734db1 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.17  2003/02/19 09:02:28  hristov
+Track time measurement (S.Radomski)
+
 Revision 1.16  2003/02/10 14:06:10  cblume
 Add tracking without tilted pads as option
 
@@ -102,6 +105,8 @@ AliTRDtrack::AliTRDtrack(const AliTRDcluster *c, UInt_t index,
   fdEdx=0.;
 
   fLhElectron = 0.0;
+  fNWrong = 0;
+  fNRotate = 0;
 
   Double_t q = TMath::Abs(c->GetQ());
   Double_t s = fX*fC - fE, t=fT;
@@ -129,6 +134,8 @@ AliTRDtrack::AliTRDtrack(const AliTRDtrack& t) : AliKalmanTrack(t) {
   fdEdx=t.fdEdx;
 
   fLhElectron = 0.0;
+  fNWrong = t.fNWrong;
+  fNRotate = t.fNRotate;
 
   fAlpha=t.fAlpha;
   fX=t.fX;
@@ -170,6 +177,8 @@ AliTRDtrack::AliTRDtrack(const AliKalmanTrack& t, Double_t alpha)
   fdEdx=0;
 
   fLhElectron = 0.0;
+  fNWrong = 0;
+  fNRotate = 0;
 
   fAlpha = alpha;
   if      (fAlpha < -TMath::Pi()) fAlpha += 2*TMath::Pi();
@@ -208,7 +217,32 @@ AliTRDtrack::AliTRDtrack(const AliKalmanTrack& t, Double_t alpha)
     fIndex[i] = 0;
   }
 }              
+//_____________________________________________________________________________
+
+void  AliTRDtrack::GetBarrelTrack(AliBarrelTrack *track) {
+  //
+  //
+  //
+  
+  if (!track) return;
+  Double_t xr, vec[5], cov[15];
+
+  track->SetLabel(GetLabel());
+  track->SetX(fX, fAlpha);
+  track->SetNClusters(GetNumberOfClusters(), GetChi2());
+  track->SetNWrongClusters(fNWrong);
+  track->SetNRotate(fNRotate);
+  track->SetTime(fIntegratedTime, fIntegratedLength);
+
+  track->SetMass(fMass);
+  track->SetdEdX(fdEdx);
 
+  GetExternalParameters(xr, vec);
+  track->SetStateVector(vec);
+
+  GetExternalCovariance(cov);
+  track->SetCovarianceMatrix(cov);
+}
 //____________________________________________________________________________
 void AliTRDtrack::GetExternalParameters(Double_t& xr, Double_t x[5]) const {
   //
@@ -311,9 +345,12 @@ Int_t AliTRDtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
   // Propagates a track of particle with mass=pm to a reference plane 
   // defined by x=xk through media of density=rho and radiationLength=x0
 
+  if (xk == fX) return 1;
+
   if (TMath::Abs(fC*xk - fE) >= 0.99999) {
     Int_t n=GetNumberOfClusters();
-    if (n>4) cerr<<n<<" AliTRDtrack warning: Propagation failed !\n";
+    if (n>4) cerr << n << " AliTRDtrack: Propagation failed, \tPt = " 
+                  << GetPt() << "\t" << GetLabel() << "\t" << GetMass() << endl;
     return 0;
   }
 
@@ -432,7 +469,7 @@ Int_t AliTRDtrack::Update(const AliTRDcluster *c, Double_t chisq, UInt_t index,
     fY += k00*dy + k01*dz;
     fZ += k10*dy + k11*dz;
     fE  = eta;
-    fT += k30*dy + k31*dz;
+    //fT += k30*dy + k31*dz;
     fC  = cur;
   }
   else {
@@ -462,7 +499,7 @@ Int_t AliTRDtrack::Update(const AliTRDcluster *c, Double_t chisq, UInt_t index,
     fY += k00*dy + k01*dz;
     fZ += k10*dy + k11*dz;
     fE  = eta;
-    fT += k30*dy + k31*dz;
+    //fT += k30*dy + k31*dz;
     fC  = cur;
     
     k01+=h01*k00;
@@ -503,6 +540,8 @@ Int_t AliTRDtrack::Update(const AliTRDcluster *c, Double_t chisq, UInt_t index,
 Int_t AliTRDtrack::Rotate(Double_t alpha)
 {
   // Rotates track parameters in R*phi plane
+  
+  fNRotate++;
 
   fAlpha += alpha;
   if (fAlpha<-TMath::Pi()) fAlpha += 2*TMath::Pi();
index 31eeafe..6a92c39 100644 (file)
@@ -7,6 +7,10 @@
 #include <AliKalmanTrack.h>
 #include <TMath.h>
 
+#include "AliBarrelTrack.h"
+#include "AliTRDgeometry.h"
+#include "TVector2.h"
+
 class AliTRDcluster;
 class AliTPCtrack;
 
@@ -28,6 +32,10 @@ public:
    void     CookdEdx(Double_t low=0.05, Double_t up=0.70);   
 
    Double_t GetAlpha() const {return fAlpha;}
+   Int_t    GetSector() const {
+     //if (fabs(fAlpha) < AliTRDgeometry::GetAlpha()/2) return 0;
+     return Int_t(TVector2::Phi_0_2pi(fAlpha)/AliTRDgeometry::GetAlpha())%AliTRDgeometry::kNsect;}
+
    Double_t GetC()     const {return fC;}
    Int_t    GetClusterIndex(Int_t i) const {return fIndex[i];}    
    Float_t  GetClusterdQdl(Int_t i) const {return fdQdl[i];}    
@@ -78,6 +86,15 @@ public:
    Int_t    Update(const AliTRDcluster* c, Double_t chi2, UInt_t i, 
                    Double_t h01);
 
+  //
+  void GetBarrelTrack(AliBarrelTrack *track);
+  void AddNWrong() {fNWrong++;}
+  
+  Int_t GetNWrong() const {return fNWrong;}
+  Int_t GetNRotate() const {return fNRotate;}
+  //
+
+
 protected:
 
    Int_t    fSeedLab;     // track label taken from seeding  
@@ -104,6 +121,8 @@ protected:
                                              // for track angles    
                            
    Float_t fLhElectron;    // Likelihood to be an electron    
+   Int_t fNWrong;    // number of wrong clusters
+   Int_t fNRotate;
 
    ClassDef(AliTRDtrack,2) // TRD reconstructed tracks
 
index 0287f06..4b66644 100644 (file)
@@ -15,6 +15,9 @@
                                                       
 /*
 $Log$
+Revision 1.25  2003/03/19 17:14:11  hristov
+Load/UnloadClusters added to the base class and the derived classes changed correspondingly. Possibility to give 2 input files for ITS and TPC tracks in PropagateBack. TRD tracker uses fEventN from the base class (T.Kuhr)
+
 Revision 1.24  2003/02/19 09:02:28  hristov
 Track time measurement (S.Radomski)
 
@@ -126,9 +129,12 @@ ClassImp(AliTRDtracker)
 
   const  Double_t    AliTRDtracker::fMaxChi2            = 12.; 
 
+const Int_t AliTRDtracker::kFirstPlane = 5;
+const Int_t AliTRDtracker::kLastPlane = 17;
+
 
 //____________________________________________________________________
-AliTRDtracker::AliTRDtracker(const TFile *geomfile)
+AliTRDtracker::AliTRDtracker(const TFile *geomfile):AliTracker()
 {
   // 
   //  Main constructor
@@ -213,6 +219,15 @@ AliTRDtracker::AliTRDtracker(const TFile *geomfile)
 
   fVocal = kFALSE;
 
+
+  // Barrel Tracks [SR, 03.04.2003]
+
+  fBarrelFile = 0;
+  fBarrelTree = 0;
+  fBarrelArray = 0;
+  fBarrelTrack = 0;
+
+  savedir->cd();
 }   
 
 //___________________________________________________________________
@@ -230,6 +245,106 @@ AliTRDtracker::~AliTRDtracker()
 }   
 
 //_____________________________________________________________________
+
+void AliTRDtracker::SetBarrelTree(const char *mode) {
+  //
+  //
+  //
+
+  if (!IsStoringBarrel()) return;
+
+  TDirectory *sav = gDirectory;
+  if (!fBarrelFile) fBarrelFile = new TFile("AliBarrelTracks.root", "UPDATE");
+
+  char buff[40];
+  sprintf(buff,  "BarrelTRD_%d_%s", GetEventNumber(), mode);
+
+  fBarrelFile->cd();
+  fBarrelTree = new TTree(buff, "Barrel TPC tracks");
+  
+  Int_t nRefs = kLastPlane - kFirstPlane + 1;
+
+  if (!fBarrelArray) fBarrelArray = new TClonesArray("AliBarrelTrack", nRefs);
+  for(Int_t i=0; i<nRefs; i++) new((*fBarrelArray)[i]) AliBarrelTrack();
+  
+  fBarrelTree->Branch("tracks", &fBarrelArray);
+  sav->cd();
+}
+  
+//_____________________________________________________________________
+
+void AliTRDtracker::StoreBarrelTrack(AliTRDtrack *ps, Int_t refPlane, Int_t isIn) {
+  //
+  //
+  //
+  
+  if (!IsStoringBarrel()) return;
+  
+  static Int_t nClusters;
+  static Int_t nWrong;
+  static Double_t chi2;
+  static Int_t index;
+  static Bool_t wasLast = kTRUE;
+  
+  Int_t newClusters, newWrong;
+  Double_t newChi2;
+  
+  if (wasLast) {   
+    fBarrelArray->Clear();
+    nClusters = nWrong = 0;
+    chi2 = 0.0;
+    index = 0;
+    wasLast = kFALSE;
+  }
+  
+  fBarrelTrack = (AliBarrelTrack*)(*fBarrelArray)[index++];
+  ps->GetBarrelTrack(fBarrelTrack);
+  
+  newClusters = ps->GetNumberOfClusters() - nClusters; 
+  newWrong = ps->GetNWrong() - nWrong;
+  newChi2 = ps->GetChi2() - chi2;
+  
+  nClusters =  ps->GetNumberOfClusters();
+  nWrong = ps->GetNWrong();
+  chi2 = ps->GetChi2();  
+
+  if (refPlane != kLastPlane) {
+    fBarrelTrack->SetNClusters(newClusters, newChi2);
+    fBarrelTrack->SetNWrongClusters(newWrong);
+  } else {
+    wasLast = kTRUE;
+  } 
+
+  fBarrelTrack->SetRefPlane(refPlane, isIn);
+}
+
+//_____________________________________________________________________
+
+Bool_t AliTRDtracker::AdjustSector(AliTRDtrack *track) {
+  //
+  // Rotates the track when necessary
+  //
+
+  Double_t alpha = AliTRDgeometry::GetAlpha(); 
+  Double_t y = track->GetY();
+  Double_t ymax = track->GetX()*TMath::Tan(0.5*alpha);
+
+  Int_t ns = AliTRDgeometry::kNsect;
+  //Int_t s=Int_t(track->GetAlpha()/alpha)%ns; 
+
+  if (y > ymax) {
+    //s = (s+1) % ns;
+    if (!track->Rotate(alpha)) return kFALSE;
+  } else if (y <-ymax) {
+    //s = (s-1+ns) % ns;                           
+    if (!track->Rotate(-alpha)) return kFALSE;   
+  } 
+
+  return kTRUE;
+}
+
+//_____________________________________________________________________
 inline Double_t f1trd(Double_t x1,Double_t y1,
                       Double_t x2,Double_t y2,
                       Double_t x3,Double_t y3)
@@ -530,12 +645,14 @@ Int_t AliTRDtracker::PropagateBack(const TFile *inp, TFile *out) {
   AliTRDtrack *otrack_trd=0;
   trdTree.Branch("tracks","AliTRDtrack",&otrack_trd,32000,0);   
      
-  Int_t found=0;  
+  if (IsStoringBarrel()) SetBarrelTree("back");
+  out->cd();
 
+  Int_t found=0;  
   Int_t nseed=fSeeds->GetEntriesFast();
 
   //  Float_t foundMin = fMinClustersInTrack * fTimeBinsPerPlane * fGeom->Nplan(); 
-  Float_t foundMin = 0;
+  Float_t foundMin = 40;
 
   Int_t outermost_tb  = fTrSec[0]->GetOuterTimeBin();
 
@@ -543,6 +660,12 @@ Int_t AliTRDtracker::PropagateBack(const TFile *inp, TFile *out) {
 
     AliTRDtrack *ps=(AliTRDtrack*)fSeeds->UncheckedAt(i), &s=*ps;
     Int_t expectedClr = FollowBackProlongation(s);
+
+    if (IsStoringBarrel()) {
+      StoreBarrelTrack(ps, kLastPlane, kTrackBack);
+      fBarrelTree->Fill();        
+    }
+
     Int_t foundClr = s.GetNumberOfClusters();
     Int_t last_tb = fTrSec[0]->GetLayerNumber(s.GetX());
 
@@ -607,12 +730,20 @@ Int_t AliTRDtracker::PropagateBack(const TFile *inp, TFile *out) {
     }
   }
   
+  
+  out->cd();
   tofTree1.Write(); 
   tofTree2.Write(); 
   phosTree.Write(); 
   richTree.Write(); 
   trdTree.Write(); 
 
+  if (IsStoringBarrel()) { // [SR, 03.04.2003]
+    fBarrelFile->cd();
+    fBarrelTree->Write();
+    fBarrelFile->Flush();
+  }
+
   savedir->cd();  
   cerr<<"Number of seeds: "<<nseed<<endl;  
   cerr<<"Number of back propagated TRD tracks: "<<found<<endl;
@@ -646,12 +777,9 @@ Int_t AliTRDtracker::FollowProlongation(AliTRDtrack& t, Int_t rf)
   Int_t try_again=fMaxGap;
 
   Double_t alpha=t.GetAlpha();
-
-  if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
-  if (alpha < 0.            ) alpha += 2.*TMath::Pi();
+  TVector2::Phi_0_2pi(alpha);
 
   Int_t s=Int_t(alpha/AliTRDgeometry::GetAlpha())%AliTRDgeometry::kNsect;  
-
   Double_t rad_length, rho, x, dx, y, ymax, z;
 
   Int_t expectedNumberOfClusters = 0;
@@ -869,22 +997,15 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t)
   Float_t  wSigmaC2, wSigmaTgl2, wSigmaY2, wSigmaZ2;
 
   Int_t trackIndex = t.GetLabel();  
-
-  Int_t ns=Int_t(2*TMath::Pi()/AliTRDgeometry::GetAlpha()+0.5);     
-
   Int_t try_again=fMaxGap;
 
   Double_t alpha=t.GetAlpha();
+  TVector2::Phi_0_2pi(alpha);
 
-  if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
-  if (alpha < 0.            ) alpha += 2.*TMath::Pi();
-
-  Int_t s=Int_t(alpha/AliTRDgeometry::GetAlpha())%AliTRDgeometry::kNsect;  
+  Int_t s;
 
   Int_t outerTB = fTrSec[0]->GetOuterTimeBin();
-
-  Double_t rad_length, rho, x, dx, y, ymax, z;
-
+  Double_t rad_length, rho, x, dx, y, ymax = 0, z;
   Bool_t lookForCluster;
 
   Int_t expectedNumberOfClusters = 0;
@@ -892,55 +1013,63 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t)
 
   alpha=AliTRDgeometry::GetAlpha();  // note: change in meaning
 
+  Int_t nRefPlane = kFirstPlane;
+  Bool_t isNewLayer = kFALSE; 
 
-  for (Int_t nr=fTrSec[0]->GetLayerNumber(t.GetX()); nr<outerTB; nr++) { 
+  Double_t chi2;
+  Double_t minDY;
 
-    y = t.GetY(); z = t.GetZ();
+  for (Int_t nr=fTrSec[0]->GetLayerNumber(t.GetX()); nr<outerTB+1; nr++) { 
+    
+    y = t.GetY(); 
+    z = t.GetZ();
 
     // first propagate to the outer surface of the current time bin 
 
+    s = t.GetSector();
     fTrSec[s]->GetLayer(nr)->GetPropagationParameters(y,z,dx,rho,rad_length,lookForCluster);
-    x = fTrSec[s]->GetLayer(nr)->GetX()+dx/2; y = t.GetY(); z = t.GetZ();
+    x = fTrSec[s]->GetLayer(nr)->GetX()+dx/2; 
+    y = t.GetY(); 
+    z = t.GetZ();
 
     if(!t.PropagateTo(x,rad_length,rho)) break;
+    if (!AdjustSector(&t)) break;
+    s = t.GetSector();
+    if (!t.PropagateTo(x,rad_length,rho)) break;
 
     y = t.GetY();
-    ymax = x*TMath::Tan(0.5*alpha);
+    z = t.GetZ();
 
-    if (y > ymax) {
-      s = (s+1) % ns;
-      if (!t.Rotate(alpha)) break;
-      if(!t.PropagateTo(x,rad_length,rho)) break;
-    } else if (y <-ymax) {
-      s = (s-1+ns) % ns;                           
-      if (!t.Rotate(-alpha)) break;   
-      if(!t.PropagateTo(x,rad_length,rho)) break;
-    } 
-    y = t.GetY(); z = t.GetZ();
+    // Barrel Tracks [SR, 04.04.2003]
 
-    // now propagate to the middle plane of the next time bin 
-    fTrSec[s]->GetLayer(nr+1)->GetPropagationParameters(y,z,dx,rho,rad_length,lookForCluster);
+    s = t.GetSector();
+    if (fTrSec[s]->GetLayer(nr)->IsSensitive() != 
+        fTrSec[s]->GetLayer(nr+1)->IsSensitive() ) {
 
-    x = fTrSec[s]->GetLayer(nr+1)->GetX(); y = t.GetY(); z = t.GetZ();
+      if (IsStoringBarrel()) StoreBarrelTrack(&t, nRefPlane++, kTrackBack);
+    }
 
-    if(!t.PropagateTo(x,rad_length,rho)) break;
+    if (fTrSec[s]->GetLayer(nr-1)->IsSensitive() && 
+          ! fTrSec[s]->GetLayer(nr)->IsSensitive()) {
+      isNewLayer = kTRUE;
+    } else {isNewLayer = kFALSE;}
 
     y = t.GetY();
+    z = t.GetZ();
 
-    ymax = x*TMath::Tan(0.5*alpha);
-
-    if(fVocal) printf("nr+1=%d, x %f, z %f, y %f, ymax %f\n",nr+1,x,z,y,ymax);
+    // now propagate to the middle plane of the next time bin 
+    fTrSec[s]->GetLayer(nr+1)->GetPropagationParameters(y,z,dx,rho,rad_length,lookForCluster);
 
-    if (y > ymax) {
-      s = (s+1) % ns;
-      if (!t.Rotate(alpha)) break;
+    x = fTrSec[s]->GetLayer(nr+1)->GetX(); 
       if(!t.PropagateTo(x,rad_length,rho)) break;
-    } else if (y <-ymax) {
-      s = (s-1+ns) % ns;              
-      if (!t.Rotate(-alpha)) break;   
+    if (!AdjustSector(&t)) break;
+    s = t.GetSector();
       if(!t.PropagateTo(x,rad_length,rho)) break;
-    } 
 
+    y = t.GetY();
+    z = t.GetZ();
+
+    if(fVocal) printf("nr+1=%d, x %f, z %f, y %f, ymax %f\n",nr+1,x,z,y,ymax);
     //    printf("label %d, pl %d, lookForCluster %d \n",
     //     trackIndex, nr+1, lookForCluster);
 
@@ -983,6 +1112,17 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t)
 
       Double_t max_chi2=fMaxChi2;
 
+      if (isNewLayer) { 
+        road = 3 * road;
+        //sz2 = 3 * sz2;
+        max_chi2 = 10 * fMaxChi2;
+      }
+      
+      if (nRefPlane == kFirstPlane) max_chi2 = 20 * fMaxChi2; 
+      if (nRefPlane == kFirstPlane+2) max_chi2 = 15 * fMaxChi2;
+      if (t.GetNRotate() > 0) max_chi2 = 3 * max_chi2;
+      
+
       wYclosest = 12345678;
       wYcorrect = 12345678;
       wZclosest = 12345678;
@@ -991,14 +1131,15 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t)
 
       // Find the closest correct cluster for debugging purposes
       if (time_bin) {
-        Float_t minDY = 1000000;
+        minDY = 1000000;
         for (Int_t i=0; i<time_bin; i++) {
           AliTRDcluster* c=(AliTRDcluster*)(time_bin[i]);
           if((c->GetLabel(0) != trackIndex) &&
              (c->GetLabel(1) != trackIndex) &&
              (c->GetLabel(2) != trackIndex)) continue;
           if(TMath::Abs(c->GetY() - y) > minDY) continue;
-          minDY = TMath::Abs(c->GetY() - y);
+          //minDY = TMath::Abs(c->GetY() - y);
+          minDY = c->GetY() - y;
           wYcorrect = c->GetY();
           wZcorrect = c->GetZ();
 
@@ -1014,16 +1155,21 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t)
         for (Int_t i=time_bin.Find(y-road); i<time_bin; i++) {
           AliTRDcluster* c=(AliTRDcluster*)(time_bin[i]);
           if (c->GetY() > y+road) break;
-         //          if (c->IsUsed() > 0) continue;
+          if (c->IsUsed() > 0) continue;
           if((c->GetZ()-z)*(c->GetZ()-z) > 3 * sz2) continue;
 
           Double_t h01 = GetTiltFactor(c);
-          Double_t chi2=t.GetPredictedChi2(c,h01);
+          chi2=t.GetPredictedChi2(c,h01);
           
           if (chi2 > max_chi2) continue;
           max_chi2=chi2;
           cl=c;
           index=time_bin.GetIndex(i);
+
+          //check is correct
+          if((c->GetLabel(0) != trackIndex) &&
+             (c->GetLabel(1) != trackIndex) &&
+             (c->GetLabel(2) != trackIndex)) t.AddNWrong();
         }               
        
         if(!cl) {
@@ -1032,11 +1178,11 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t)
             AliTRDcluster* c=(AliTRDcluster*)(time_bin[i]);
             
             if (c->GetY() > y+road) break;
-           //            if (c->IsUsed() > 0) continue;
+            if (c->IsUsed() > 0) continue;
             if((c->GetZ()-z)*(c->GetZ()-z) > 2.25 * 12 * sz2) continue;
             
             Double_t h01 = GetTiltFactor(c);
-            Double_t chi2=t.GetPredictedChi2(c,h01);
+            chi2=t.GetPredictedChi2(c,h01);
             
             if (chi2 > max_chi2) continue;
             max_chi2=chi2;
@@ -1059,8 +1205,15 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t)
         else {
           if (try_again==0) break; 
           try_again--;
+          
+          //if (minDY < 1000000 && isNewLayer) 
+            //cout << "\t" << nRefPlane << "\t" << "\t" << t.GetNRotate() <<  "\t" << 
+            //  road << "\t" << minDY << "\t" << chi2 << "\t" << wChi2 << "\t" << max_chi2 << endl;
+                                                                     
         }
 
+        isNewLayer = kFALSE;
+
         /*
         if((((Int_t) wTB)%15 == 0) || (((Int_t) wTB)%15 == 14)) {
           
@@ -1090,6 +1243,8 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t)
     }  
   }
   return expectedNumberOfClusters;
+
+
 }         
 
 //___________________________________________________________________
@@ -1169,9 +1324,7 @@ Int_t AliTRDtracker::PropagateToTPC(AliTRDtrack& t)
   Int_t ns=Int_t(2*TMath::Pi()/AliTRDgeometry::GetAlpha()+0.5);     
 
   Double_t alpha=t.GetAlpha();
-
-  if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
-  if (alpha < 0.            ) alpha += 2.*TMath::Pi();
+  TVector2::Phi_0_2pi(alpha);
 
   Int_t s=Int_t(alpha/AliTRDgeometry::GetAlpha())%AliTRDgeometry::kNsect;  
 
@@ -1181,49 +1334,35 @@ Int_t AliTRDtracker::PropagateToTPC(AliTRDtrack& t)
   x = t.GetX();
 
   alpha=AliTRDgeometry::GetAlpha();  // note: change in meaning
-
   Int_t plTPC = fTrSec[0]->GetLayerNumber(246.055);
 
   for (Int_t nr=fTrSec[0]->GetLayerNumber(x); nr>plTPC; nr--) { 
 
-    y = t.GetY(); z = t.GetZ();
+    y = t.GetY(); 
+    z = t.GetZ();
 
     // first propagate to the outer surface of the current time bin 
     fTrSec[s]->GetLayer(nr)->GetPropagationParameters(y,z,dx,rho,rad_length,lookForCluster);
-    x = fTrSec[s]->GetLayer(nr)->GetX()-dx/2; y = t.GetY(); z = t.GetZ();
+    x = fTrSec[s]->GetLayer(nr)->GetX()-dx/2; 
+    
     if(!t.PropagateTo(x,rad_length,rho)) return 0;
-    y = t.GetY();
-    ymax = x*TMath::Tan(0.5*alpha);
-    if (y > ymax) {
-      s = (s+1) % ns;
-      if (!t.Rotate(alpha)) return 0;
-    } else if (y <-ymax) {
-      s = (s-1+ns) % ns;                           
-      if (!t.Rotate(-alpha)) return 0;   
-    } 
+    AdjustSector(&t);
     if(!t.PropagateTo(x,rad_length,rho)) return 0;
 
-    y = t.GetY(); z = t.GetZ();
+    y = t.GetY(); 
+    z = t.GetZ();
 
     // now propagate to the middle plane of the next time bin 
     fTrSec[s]->GetLayer(nr-1)->GetPropagationParameters(y,z,dx,rho,rad_length,lookForCluster);
-    x = fTrSec[s]->GetLayer(nr-1)->GetX(); y = t.GetY(); z = t.GetZ();
+    x = fTrSec[s]->GetLayer(nr-1)->GetX(); 
+    
     if(!t.PropagateTo(x,rad_length,rho)) return 0;
-    y = t.GetY();
-    ymax = x*TMath::Tan(0.5*alpha);
-    if (y > ymax) {
-      s = (s+1) % ns;
-      if (!t.Rotate(alpha)) return 0;
-    } else if (y <-ymax) {
-      s = (s-1+ns) % ns;                           
-      if (!t.Rotate(-alpha)) return 0;   
-    } 
+    AdjustSector(&t);
     if(!t.PropagateTo(x,rad_length,rho)) return 0;
   }
   return 1;
 }         
 
-
 //_____________________________________________________________________________
 void AliTRDtracker::LoadEvent()
 {
index 3b49c50..0bcc07d 100644 (file)
@@ -6,6 +6,7 @@
 
 #include "AliTracker.h" 
 #include "TObjArray.h" 
+#include "AliBarrelTrack.h"
 
 class TFile;
 class TParticle;
@@ -33,6 +34,8 @@ class AliTRDtracker : public AliTracker {
 
   Int_t         Clusters2Tracks(const TFile *in, TFile *out);
   Int_t         PropagateBack(const TFile *in, TFile *out);
+  //Int_t         Refit(const TFile *in, TFile *out);
+
   Int_t         LoadClusters() {LoadEvent(); return 0;};
   void          UnloadClusters() {UnloadEvent();};
   AliCluster   *GetCluster(Int_t index) const { return (AliCluster*) fClusters->UncheckedAt(index); };
@@ -111,6 +114,8 @@ class AliTRDtracker : public AliTracker {
                             Double_t rho = 1.29e-3, Double_t x0 = 36.66,
                             Double_t Yc = 0, Double_t Zc = 0);
                             
+     Bool_t         IsSensitive() {return (fTimeBinIndex>=0)? kTRUE: kFALSE;}
+                       
      void    Clear() {for(Int_t i=0; i<fN; i++) fClusters[i] = NULL; fN = 0;}
                    
    private:     
@@ -174,6 +179,7 @@ class AliTRDtracker : public AliTracker {
 
   Int_t         FollowProlongation(AliTRDtrack& t, Int_t rf);
   Int_t         FollowBackProlongation(AliTRDtrack& t);
+  //Int_t         FolowRefitInward(AliTRDtrack *seed, AliTPCtrack *track);
 
   Int_t         PropagateToTPC(AliTRDtrack& t);
   Int_t         PropagateToOuterPlane(AliTRDtrack& t, Double_t x);
@@ -247,6 +253,24 @@ class AliTRDtracker : public AliTracker {
 
   Bool_t                fNoTilt;
  
+  
+  Bool_t AdjustSector(AliTRDtrack *track); 
+  
+  // Barrel tracks [SR, 03.04.2003]
+
+  static const Int_t kFirstPlane;   // Id of the first (innermost) reference plane 
+  static const Int_t kLastPlane;    // Id of the last (outermost) reference plane
+  
+  void SetBarrelTree(const char *mode);
+  void StoreBarrelTrack(AliTRDtrack *ps, Int_t refPlane, Int_t isIn);
+  
+  TFile *fBarrelFile;
+  TTree *fBarrelTree;
+  TClonesArray *fBarrelArray;
+  AliBarrelTrack *fBarrelTrack;
+
+
   ClassDef(AliTRDtracker,1)           // manager base class  
 
 };