[u/mrichter/AliRoot.git] / TRD / AliTRDtracker.h

#ifndef ALITRDTRACKER_H
#define ALITRDTRACKER_H   

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */ 

/* $Id$ */

////////////////////////////////////////////////////////////////////////////
//                                                                        //
//  The TRD tracker                                                       //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#include "AliTracker.h" 
#include "TObjArray.h" 

class TFile;
class TTree;
class TH1D;
class TH2D;
class TParticle;
class TParticlePDG;

class AliTRDgeometry;
class AliTRDtrack;
class AliTRDtracklet;
class AliTRDcluster;
class AliTRDseed;
class AliESDEvent;
class TTreeSRedirector;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  The standard TRD tracker                                                 //  
//  Based on Kalman filltering approach                                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

class AliTRDtracker : public AliTracker { 

  // Histograms
  TH1D *fHBackfit;  // Histogram for back propagation
  TH1D *fHClSearch; // Cluster search
  TH1D *fHRefit;
  
  TH1D *fHX;
  TH1D *fHNCl;
  TH1D *fHNClTrack;
  TH1D *fHFindCl[4];
  TH1D *fHMinYPos;
  TH1D *fHMinYNeg; 
  TH1D *fHMinZ;

  TH2D *fHMinD;
  TH1D *fHDeltaX;

  TH1D *fHXCl;

  void InitLogHists();
  void SaveLogHists();

 public:

  enum { kMaxLayersPerSector   = 1000
	 , kMaxTimeBinIndex      = 216
	 , kMaxClusterPerTimeBin = 2300
	 , kZones                = 5
	 , kTrackingSectors      = 18   };
  
  AliTRDtracker();
  AliTRDtracker(const AliTRDtracker &t);
  AliTRDtracker(const TFile *in);
  virtual         ~AliTRDtracker(); 
  AliTRDtracker   &operator=(const AliTRDtracker &/*t*/)  { return *this;                 } 
  
  void     SetAddTRDseeds()                       { fAddTRDseeds = kTRUE;         }
  void     SetNoTilt()                            { fNoTilt      = kTRUE;         }
  
  Int_t    GetTimeBinsPerPlane() const            { return fTimeBinsPerPlane;     }   
  Double_t GetMaxChi2() const                     { return fgkMaxChi2;            }
  Float_t  GetLabelFraction() const               { return fgkLabelFraction;      }
  Float_t  GetMinClustersInTrack() const          { return fgkMinClustersInTrack; }
  Int_t    GetLastPlane(AliTRDtrack *track);
  Double_t GetTiltFactor(const AliTRDcluster *c);
  Bool_t   GetTrackPoint(Int_t index, AliTrackPoint& p) const;
  Double_t GetX(Int_t sec, Int_t plane, Int_t localTB) const;
  Double_t GetX(Int_t sec, Int_t pl) const        { return fTrSec[sec]->GetLayer(pl)->GetX();            }
  Int_t    GetGlobalTimeBin(Int_t sec, Int_t plane, Int_t localTB) const 
    { return fTrSec[sec]->CookTimeBinIndex(plane,localTB); }
  Double_t GetLayerNumber(Int_t sec, Double_t x) const 
    { return fTrSec[sec]->GetLayerNumber(x);               }
  AliCluster    *GetCluster(Int_t index) const    { if (index >= fNclusters) return NULL; 
  return (AliCluster *) fClusters->UncheckedAt(index); }
  
  static  Int_t    Freq(Int_t n, const Int_t *inlist, Int_t *outlist, Bool_t down);    
  Int_t    Clusters2Tracks(AliESDEvent *event);
  Int_t    PropagateBack(AliESDEvent *event);
  Int_t    RefitInward(AliESDEvent *event);
  
  virtual void     CookLabel(AliKalmanTrack *t, Float_t wrong) const;
  
  Int_t    LocalToGlobalID(Int_t lid);
  Int_t    GlobalToLocalID(Int_t gid);
  Bool_t   Transform(AliTRDcluster *cluster);
  
  Int_t    LoadClusters(TTree *cTree);
  void     UnloadClusters();
  virtual void     UseClusters(const AliKalmanTrack *t, Int_t from = 0) const;  
  Int_t    ReadClusters(TObjArray *array, TTree *in) const;
  AliTRDcluster *GetCluster(AliTRDtrack *track, Int_t plane, Int_t timebin, UInt_t &index);
  Int_t    FindClusters(Int_t sector, Int_t t0, Int_t t1, AliTRDtrack *track
                              , Int_t *clusters, AliTRDtracklet &tracklet);
  
 protected:
  
  class AliTRDpropagationLayer {
    
  public: 
    
    AliTRDpropagationLayer(Double_t x, Double_t dx, Double_t rho
			   , Double_t x0, Int_t tbIndex, Int_t plane); 
    AliTRDpropagationLayer(const AliTRDpropagationLayer &/*p*/);
    ~AliTRDpropagationLayer() { 
      if (fTimeBinIndex >= 0) { 
	delete[] fClusters; 
	delete[] fIndex; 
      }     
    }
    AliTRDpropagationLayer &operator=(const AliTRDpropagationLayer &/*p*/) 
      {return *this;}

    operator Int_t() const {return fN;}
    AliTRDcluster  *operator[](Int_t i) {return fClusters[i];}
    
    void SetZmax(Int_t cham, Double_t center, Double_t w) { 
      fZc[cham] = center;  
      fZmax[cham]    = w; 
    }
    void SetYmax(Double_t w, Double_t wsensitive) {
      fYmax          = w;
      fYmaxSensitive = wsensitive;
    }

    void SetZ(Double_t* center, Double_t *w, Double_t *wsensitive);
    void SetHoles(Bool_t* holes);
    void SetHole(Double_t Zmax, Double_t Ymax
		 , Double_t rho = 1.29e-3, Double_t x0 = 36.66
		 , Double_t Yc = 0.0, Double_t Zc = 0.0);
    
    Double_t GetYmax() const           { return fYmax;                  }
    Double_t GetZmax(Int_t c) const    { return fZmax[c];               }
    Double_t GetZc(Int_t c) const      { return fZc[c];                 }
    UInt_t   GetIndex(Int_t i) const   { return fIndex[i];              }  
    Double_t GetX() const              { return fX;                     }
    Double_t GetdX() const             { return fdX;                    }
    Int_t    GetTimeBinIndex() const   { return fTimeBinIndex;          }     
    Int_t    GetPlane() const          { return fPlane;                 }
    Bool_t   IsHole(Int_t zone) const  { return fIsHole[zone];          }              
    Bool_t   IsSensitive() const       { return (fTimeBinIndex >= 0)? kTRUE : kFALSE;} 
    
    void     Clear() { 
      for (Int_t i = 0; i < fN; i++) fClusters[i] = NULL;
      fN = 0;
    }
    
    void     InsertCluster(AliTRDcluster *c, UInt_t index);
    Int_t    Find(Float_t y) const; 
    Int_t    FindNearestCluster(Float_t y, Float_t z, Float_t maxroad, Float_t maxroadz) const;
 
    void SetX(Double_t x) {fX = x;}

    
  private:     
    
    Int_t                     fN;                            // This is fN
    Int_t                     fSec;                          // Sector mumber
    AliTRDcluster           **fClusters;                     // Array of pointers to clusters
    UInt_t                   *fIndex;                        // Array of cluster indexes
    Double_t                  fX;                            // X coordinate of the middle plane
    Double_t                  fdX;                           // Radial thickness of the time bin
    Double_t                  fRho;                          // Default density of the material 
    Double_t                  fX0;                           // Default radiation length 
    Int_t                     fTimeBinIndex;                 // Plane * F(local_tb)  
    Int_t                     fPlane;                        // Plane number
    Double_t                  fZc[kZones];                   // Z position of the center for 5 active areas
    Double_t                  fZmax[kZones];                 // Half of active area length in Z
    Double_t                  fZmaxSensitive[kZones];        // Sensitive area for detection Z     
    Bool_t                    fIsHole[kZones];               // Is hole in given sector       
    Double_t                  fYmax;                         // Half of active area length in Y
    Double_t                  fYmaxSensitive;                // Half of active area length in Y
    
    Bool_t                    fHole;                         // kTRUE if there is a hole in the layer
    Double_t                  fHoleZc;                       // Z of the center of the hole 
    Double_t                  fHoleZmax;                     // Half of the hole length in Z
    Double_t                  fHoleYc;                       // Y of the center of the hole 
    Double_t                  fHoleYmax;                     // Half of the hole length in Y 
    Double_t                  fHoleRho;                      // Density of the gas in the hole 
    Double_t                  fHoleX0;                       // Radiation length of the gas in the hole 
    
  };
  
  class AliTRDtrackingSector {
    
   public:
    
    AliTRDtrackingSector(AliTRDgeometry* geo, Int_t gs);
    AliTRDtrackingSector(const AliTRDtrackingSector &/*t*/);
    ~AliTRDtrackingSector() { 
      for (Int_t i = 0; i < fN; i++) delete fLayers[i];           
    }
    
    AliTRDtrackingSector &operator=(const AliTRDtrackingSector &/*t*/){ return *this;}
    
    Int_t    GetNumberOfLayers() const             { return fN;}
    Int_t    GetNumberOfTimeBins() const;
    Int_t    GetLayerNumber(Double_t x) const;
    Int_t    GetInnerTimeBin() const;
    Int_t    GetOuterTimeBin() const;
    Int_t    GetLayerNumber(Int_t tb) const        { return fTimeBinIndex[tb];}
    Double_t GetX(Int_t pl) const                  { return fLayers[pl]->GetX();}
    AliTRDpropagationLayer* GetLayer(Int_t i)      { return fLayers[i];}
    
    void     MapTimeBinLayers();
    Int_t    Find(Double_t x) const; 
    void     InsertLayer(AliTRDpropagationLayer *pl);
    Int_t    CookTimeBinIndex(Int_t plane, Int_t localTB) const;     
    
  private:
    
    Int_t                   fN;                              // Total number of layers
    AliTRDgeometry         *fGeom;                           // Geometry
    AliTRDpropagationLayer *fLayers[kMaxLayersPerSector];    // Layers   
    Int_t                   fTimeBinIndex[kMaxTimeBinIndex]; // Time bin index
    Int_t                   fGeomSector;                     // Sector# in AliTRDgeometry
    
  };
  
  AliTRDgeometry          *fGeom;                          // Pointer to TRD geometry
  AliTRDtrackingSector    *fTrSec[kTrackingSectors];       // Array of tracking sectors;    
  Int_t                    fNclusters;                     // Number of clusters in TRD 
  TObjArray               *fClusters;                      // List of clusters for all sectors
  Int_t                    fNseeds;                        // Number of track seeds  
  TObjArray               *fSeeds;                         // List of track seeds
  Int_t                    fNtracks;                       // Number of reconstructed tracks 
  TObjArray               *fTracks;                        // List of reconstructed tracks   
  Int_t                    fTimeBinsPerPlane;              // Timebins per plane in track prolongation 
  
  static const Double_t    fgkMaxChi2;                     // Max increment in track chi2 
  static const Float_t     fgkMinClustersInTrack;          // Min number of clusters in track
  static const Float_t     fgkLabelFraction;               // Min fraction of same label
  static const Double_t    fgkMaxSnp;                      // Maximal snp for tracking
  static const Double_t    fgkMaxStep;                     // Maximal step for tracking  
  
  Bool_t                   fAddTRDseeds;                   // Something else
  Bool_t                   fNoTilt;                        // No tilt, or what?
  Bool_t                   fHoles[5][18];                  // Holes
  
  Bool_t   AdjustSector(AliTRDtrack *track); 
  
 private:
  
  AliTRDtrack *RegisterSeed(AliTRDseed *seeds, Double_t *params);
  void     MakeSeedsMI(Int_t inner, Int_t outer, AliESDEvent *esd = 0);
  
  Int_t    FollowBackProlongation(AliTRDtrack &t);
  Int_t    FollowProlongation(AliTRDtrack &t);
  Int_t    PropagateToX(AliTRDtrack &t, Double_t xToGo, Double_t maxStep);
  Double_t ExpectedSigmaY2(Double_t r, Double_t tgl, Double_t pt) const;
  Double_t ExpectedSigmaZ2(Double_t r, Double_t tgl) const;
  
  TTreeSRedirector        *fDebugStreamer;                 //!Debug streamer
  
  ClassDef(AliTRDtracker,2)                                        // TRD tracker
    
 };
#endif
Commit	Line	Data
46d29e70	1	#ifndef ALITRDTRACKER_H
	2	#define ALITRDTRACKER_H
	3
	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
ad670fba	7	/* $Id$ */
	8
	9	////////////////////////////////////////////////////////////////////////////
	10	// //
	11	// The TRD tracker //
	12	// //
	13	////////////////////////////////////////////////////////////////////////////
	14
5443e65e	15	#include "AliTracker.h"
e24ea474	16	#include "TObjArray.h"
46d29e70	17
46d29e70	18	class TFile;
c630aafd	19	class TTree;
7e448bcc	20	class TH1D;
7e448bcc	21	class TH2D;
ad670fba	22	class TParticle;
ad670fba	23	class TParticlePDG;
46d29e70	24
46d29e70	25	class AliTRDgeometry;
46d29e70	26	class AliTRDtrack;
7ad19338	27	class AliTRDtracklet;
5443e65e	28	class AliTRDcluster;
75bd7f81	29	class AliTRDseed;
af885e0f	30	class AliESDEvent;
7ad19338	31	class TTreeSRedirector;
46d29e70	32
75bd7f81	33	///////////////////////////////////////////////////////////////////////////////
	34	// //
	35	// The standard TRD tracker //
	36	// Based on Kalman filltering approach //
	37	// //
	38	///////////////////////////////////////////////////////////////////////////////
7ad19338	39
c630aafd	40	class AliTRDtracker : public AliTracker {
46d29e70	41
4e009ce4	42	// Histograms
	43	TH1D *fHBackfit; // Histogram for back propagation
	44	TH1D *fHClSearch; // Cluster search
7e448bcc	45	TH1D *fHRefit;
	46
	47	TH1D *fHX;
	48	TH1D *fHNCl;
	49	TH1D *fHNClTrack;
	50	TH1D *fHFindCl[4];
	51	TH1D *fHMinYPos;
	52	TH1D *fHMinYNeg;
	53	TH1D *fHMinZ;
	54
	55	TH2D *fHMinD;
	56	TH1D *fHDeltaX;
	57
	58	TH1D *fHXCl;
	59
	60	void InitLogHists();
	61	void SaveLogHists();
	62
46d29e70	63	public:
46d29e70	64
75bd7f81	65	enum { kMaxLayersPerSector = 1000
7e448bcc	66	, kMaxTimeBinIndex = 216
	67	, kMaxClusterPerTimeBin = 2300
	68	, kZones = 5
	69	, kTrackingSectors = 18 };
	70
89f05372	71	AliTRDtracker();
ad670fba	72	AliTRDtracker(const AliTRDtracker &t);
5443e65e	73	AliTRDtracker(const TFile *in);
ad670fba	74	virtual ~AliTRDtracker();
ad670fba	75	AliTRDtracker &operator=(const AliTRDtracker &/t/) { return *this; }
7e448bcc	76
	77	void SetAddTRDseeds() { fAddTRDseeds = kTRUE; }
	78	void SetNoTilt() { fNoTilt = kTRUE; }
	79
	80	Int_t GetTimeBinsPerPlane() const { return fTimeBinsPerPlane; }
	81	Double_t GetMaxChi2() const { return fgkMaxChi2; }
	82	Float_t GetLabelFraction() const { return fgkLabelFraction; }
	83	Float_t GetMinClustersInTrack() const { return fgkMinClustersInTrack; }
	84	Int_t GetLastPlane(AliTRDtrack *track);
	85	Double_t GetTiltFactor(const AliTRDcluster *c);
	86	Bool_t GetTrackPoint(Int_t index, AliTrackPoint& p) const;
	87	Double_t GetX(Int_t sec, Int_t plane, Int_t localTB) const;
	88	Double_t GetX(Int_t sec, Int_t pl) const { return fTrSec[sec]->GetLayer(pl)->GetX(); }
	89	Int_t GetGlobalTimeBin(Int_t sec, Int_t plane, Int_t localTB) const
	90	{ return fTrSec[sec]->CookTimeBinIndex(plane,localTB); }
	91	Double_t GetLayerNumber(Int_t sec, Double_t x) const
	92	{ return fTrSec[sec]->GetLayerNumber(x); }
	93	AliCluster *GetCluster(Int_t index) const { if (index >= fNclusters) return NULL;
	94	return (AliCluster *) fClusters->UncheckedAt(index); }
	95
ad670fba	96	static Int_t Freq(Int_t n, const Int_t inlist, Int_t outlist, Bool_t down);
af885e0f	97	Int_t Clusters2Tracks(AliESDEvent *event);
	98	Int_t PropagateBack(AliESDEvent *event);
	99	Int_t RefitInward(AliESDEvent *event);
7e448bcc	100
ad670fba	101	virtual void CookLabel(AliKalmanTrack *t, Float_t wrong) const;
7e448bcc	102
	103	Int_t LocalToGlobalID(Int_t lid);
	104	Int_t GlobalToLocalID(Int_t gid);
	105	Bool_t Transform(AliTRDcluster *cluster);
5443e65e	106
7e448bcc	107	Int_t LoadClusters(TTree *cTree);
7e448bcc	108	void UnloadClusters();
ad670fba	109	virtual void UseClusters(const AliKalmanTrack *t, Int_t from = 0) const;
7e448bcc	110	Int_t ReadClusters(TObjArray array, TTree in) const;
	111	AliTRDcluster GetCluster(AliTRDtrack track, Int_t plane, Int_t timebin, UInt_t &index);
	112	Int_t FindClusters(Int_t sector, Int_t t0, Int_t t1, AliTRDtrack *track
ad670fba	113	, Int_t *clusters, AliTRDtracklet &tracklet);
7e448bcc	114
75bd7f81	115	protected:
7e448bcc	116
029cd327	117	class AliTRDpropagationLayer {
7e448bcc	118
	119	public:
	120
ad670fba	121	AliTRDpropagationLayer(Double_t x, Double_t dx, Double_t rho
7e448bcc	122	, Double_t x0, Int_t tbIndex, Int_t plane);
ad670fba	123	AliTRDpropagationLayer(const AliTRDpropagationLayer &/p/);
7e448bcc	124	~AliTRDpropagationLayer() {
	125	if (fTimeBinIndex >= 0) {
	126	delete[] fClusters;
	127	delete[] fIndex;
	128	}
	129	}
ad670fba	130	AliTRDpropagationLayer &operator=(const AliTRDpropagationLayer &/p/)
7e448bcc	131	{return *this;}
	132
	133	operator Int_t() const {return fN;}
	134	AliTRDcluster *operator[](Int_t i) {return fClusters[i];}
	135
	136	void SetZmax(Int_t cham, Double_t center, Double_t w) {
	137	fZc[cham] = center;
	138	fZmax[cham] = w;
	139	}
	140	void SetYmax(Double_t w, Double_t wsensitive) {
	141	fYmax = w;
	142	fYmaxSensitive = wsensitive;
	143	}
	144
	145	void SetZ(Double_t* center, Double_t w, Double_t wsensitive);
	146	void SetHoles(Bool_t* holes);
	147	void SetHole(Double_t Zmax, Double_t Ymax
	148	, Double_t rho = 1.29e-3, Double_t x0 = 36.66
	149	, Double_t Yc = 0.0, Double_t Zc = 0.0);
	150
	151	Double_t GetYmax() const { return fYmax; }
	152	Double_t GetZmax(Int_t c) const { return fZmax[c]; }
	153	Double_t GetZc(Int_t c) const { return fZc[c]; }
	154	UInt_t GetIndex(Int_t i) const { return fIndex[i]; }
	155	Double_t GetX() const { return fX; }
	156	Double_t GetdX() const { return fdX; }
	157	Int_t GetTimeBinIndex() const { return fTimeBinIndex; }
	158	Int_t GetPlane() const { return fPlane; }
	159	Bool_t IsHole(Int_t zone) const { return fIsHole[zone]; }
	160	Bool_t IsSensitive() const { return (fTimeBinIndex >= 0)? kTRUE : kFALSE;}
	161
	162	void Clear() {
	163	for (Int_t i = 0; i < fN; i++) fClusters[i] = NULL;
	164	fN = 0;
	165	}
	166
	167	void InsertCluster(AliTRDcluster *c, UInt_t index);
	168	Int_t Find(Float_t y) const;
	169	Int_t FindNearestCluster(Float_t y, Float_t z, Float_t maxroad, Float_t maxroadz) const;
	170
	171	void SetX(Double_t x) {fX = x;}
	172
	173
	174	private:
	175
	176	Int_t fN; // This is fN
	177	Int_t fSec; // Sector mumber
	178	AliTRDcluster **fClusters; // Array of pointers to clusters
	179	UInt_t *fIndex; // Array of cluster indexes
	180	Double_t fX; // X coordinate of the middle plane
	181	Double_t fdX; // Radial thickness of the time bin
	182	Double_t fRho; // Default density of the material
	183	Double_t fX0; // Default radiation length
	184	Int_t fTimeBinIndex; // Plane * F(local_tb)
	185	Int_t fPlane; // Plane number
	186	Double_t fZc[kZones]; // Z position of the center for 5 active areas
	187	Double_t fZmax[kZones]; // Half of active area length in Z
	188	Double_t fZmaxSensitive[kZones]; // Sensitive area for detection Z
	189	Bool_t fIsHole[kZones]; // Is hole in given sector
	190	Double_t fYmax; // Half of active area length in Y
	191	Double_t fYmaxSensitive; // Half of active area length in Y
	192
	193	Bool_t fHole; // kTRUE if there is a hole in the layer
	194	Double_t fHoleZc; // Z of the center of the hole
195	Double_t fHoleZmax; // Half of the hole length in Z
196	Double_t fHoleYc; // Y of the center of the hole
197	Double_t fHoleYmax; // Half of the hole length in Y
198	Double_t fHoleRho; // Density of the gas in the hole
199	Double_t fHoleX0; // Radiation length of the gas in the hole
200
75bd7f81	201	};
7e448bcc	202
75bd7f81	203	class AliTRDtrackingSector {
7e448bcc	204
5443e65e	205	public:
7e448bcc	206
	207	AliTRDtrackingSector(AliTRDgeometry* geo, Int_t gs);
	208	AliTRDtrackingSector(const AliTRDtrackingSector &/t/);
	209	~AliTRDtrackingSector() {
	210	for (Int_t i = 0; i < fN; i++) delete fLayers[i];
	211	}
	212
	213	AliTRDtrackingSector &operator=(const AliTRDtrackingSector &/t/){ return *this;}
	214
	215	Int_t GetNumberOfLayers() const { return fN;}
	216	Int_t GetNumberOfTimeBins() const;
	217	Int_t GetLayerNumber(Double_t x) const;
	218	Int_t GetInnerTimeBin() const;
	219	Int_t GetOuterTimeBin() const;
	220	Int_t GetLayerNumber(Int_t tb) const { return fTimeBinIndex[tb];}
	221	Double_t GetX(Int_t pl) const { return fLayers[pl]->GetX();}
	222	AliTRDpropagationLayer* GetLayer(Int_t i) { return fLayers[i];}
	223
	224	void MapTimeBinLayers();
	225	Int_t Find(Double_t x) const;
	226	void InsertLayer(AliTRDpropagationLayer *pl);
	227	Int_t CookTimeBinIndex(Int_t plane, Int_t localTB) const;
	228
	229	private:
	230
	231	Int_t fN; // Total number of layers
	232	AliTRDgeometry *fGeom; // Geometry
	233	AliTRDpropagationLayer *fLayers[kMaxLayersPerSector]; // Layers
	234	Int_t fTimeBinIndex[kMaxTimeBinIndex]; // Time bin index
	235	Int_t fGeomSector; // Sector# in AliTRDgeometry
	236
75bd7f81	237	};
9c9d2487	238
7e448bcc	239	AliTRDgeometry *fGeom; // Pointer to TRD geometry
	240	AliTRDtrackingSector *fTrSec[kTrackingSectors]; // Array of tracking sectors;
	241	Int_t fNclusters; // Number of clusters in TRD
	242	TObjArray *fClusters; // List of clusters for all sectors
	243	Int_t fNseeds; // Number of track seeds
	244	TObjArray *fSeeds; // List of track seeds
	245	Int_t fNtracks; // Number of reconstructed tracks
	246	TObjArray *fTracks; // List of reconstructed tracks
	247	Int_t fTimeBinsPerPlane; // Timebins per plane in track prolongation
	248
	249	static const Double_t fgkMaxChi2; // Max increment in track chi2
	250	static const Float_t fgkMinClustersInTrack; // Min number of clusters in track
	251	static const Float_t fgkLabelFraction; // Min fraction of same label
	252	static const Double_t fgkMaxSnp; // Maximal snp for tracking
	253	static const Double_t fgkMaxStep; // Maximal step for tracking
	254
	255	Bool_t fAddTRDseeds; // Something else
	256	Bool_t fNoTilt; // No tilt, or what?
	257	Bool_t fHoles[5][18]; // Holes
	258
	259	Bool_t AdjustSector(AliTRDtrack *track);
	260
029cd327	261	private:
7e448bcc	262
7e448bcc	263	AliTRDtrack RegisterSeed(AliTRDseed seeds, Double_t *params);
af885e0f	264	void MakeSeedsMI(Int_t inner, Int_t outer, AliESDEvent *esd = 0);
7e448bcc	265
	266	Int_t FollowBackProlongation(AliTRDtrack &t);
	267	Int_t FollowProlongation(AliTRDtrack &t);
7e448bcc	268	Int_t PropagateToX(AliTRDtrack &t, Double_t xToGo, Double_t maxStep);
	269	Double_t ExpectedSigmaY2(Double_t r, Double_t tgl, Double_t pt) const;
	270	Double_t ExpectedSigmaZ2(Double_t r, Double_t tgl) const;
	271
	272	TTreeSRedirector *fDebugStreamer; //!Debug streamer
	273
ad670fba	274	ClassDef(AliTRDtracker,2) // TRD tracker
7e448bcc	275
7e448bcc	276	};
46d29e70	277	#endif