[u/mrichter/AliRoot.git] / HLT / TPCLib / Ref / AliHLTTPC.h

// @(#) $Id$

#ifndef ALILEVEL3_H
#define ALILEVEL3_H

#ifndef no_root
#include <TObject.h>
#include <TFile.h>
#endif

#include "AliHLTTPCDigitData.h"
#include "AliHLTTPCRootTypes.h"

class AliHLTTPCSpacePointData;
class AliHLTTPCDigitRowData;
class AliHLTTPCTrackSegmentData;
class AliHLTTPCDigitData;
class AliHLTTPCConfMapper;
class AliHLTTPCVertex;
class AliHLTTPCVertexFinder;
class AliHLTTPCTrackMerger;
class AliHLTTPCGlobalMerger;
#ifndef no_root
class TDirectory;
#endif
class AliHLTTPCClustFinderNew;
class AliHLTTPCMerger;
class AliHLTTPCInterMerger;
class AliHLTTPCFileHandler;
class AliHLTTPCMemHandler;
class AliHLTTPCBenchmark;

#ifdef no_root
class AliHLTTPC {
#else
class AliHLTTPC : public TObject {
#endif

 private:
  UInt_t fNTrackData;
  AliHLTTPCTrackSegmentData* fTrackData; //!
  AliHLTTPCConfMapper *fTracker; //!
  AliHLTTPCVertex *fVertex; //! 
  AliHLTTPCVertexFinder *fVertexFinder; //!
  AliHLTTPCTrackMerger *fTrackMerger; //!
  AliHLTTPCGlobalMerger *fGlobalMerger; //!
  AliHLTTPCInterMerger *fInterMerger; //!
  AliHLTTPCClustFinderNew *fClusterFinder; //! 
  AliHLTTPCMemHandler *fFileHandler; //!
  AliHLTTPCBenchmark *fBenchmark;//!

  Int_t fEvent;
  Int_t fNPatch;
  Int_t fRow[6][2];
  Float_t fEta[2];
  
  Char_t *fInputFile;//!

  Char_t fPath[256];
  Char_t fWriteOutPath[256];
  
  Bool_t fDoRoi;
  Bool_t fFindVertex;
  Bool_t fDoNonVertex;
  Bool_t fPileUp;
  Bool_t fNoCF;
  
  Bool_t fUseBinary;
  Bool_t fWriteOut;
  
  //Define whether track parameters should be given at first point on track (default)
  //If not, the parameters will be given at the vertex.
  static Bool_t fSetTracks2FirstPoint; 

  Bool_t fClusterDeconv;
  Float_t fXYClusterError;
  Float_t fZClusterError;


  void WriteSpacePoints(UInt_t npoints,AliHLTTPCSpacePointData *points,
                                          Int_t slice,Int_t patch);
  Int_t WriteTracks(char *filename,AliHLTTPCMerger *merger,char opt='o');  
  void WriteResults();
  void FitGlobalTracks();
  void SetPath(char *p){sprintf(fPath,"%s",p);}

 public:
  AliHLTTPC ();
  AliHLTTPC(Char_t *infile);
  virtual ~AliHLTTPC();
  enum EFileType {kBinary, kBinary8, kRoot, kRaw, kDate};
  void Init(Char_t *path,EFileType filetype=kBinary,Int_t npatches=6);
  void SetMergerParameters(Double_t maxy=1.2,Double_t maxz=1.6,Double_t maxkappa=0.003,
			   Double_t maxpsi=0.02,Double_t maxtgl=0.03);
  void SetTrackerParam(Int_t phi_segments=50,Int_t eta_segments=100,
		       Int_t trackletlength=3,Int_t tracklength=5,
		       Int_t rowscopetracklet=2,Int_t rowscopetrack=3,
		       Double_t min_pt_fit=0,Double_t maxangle=1.31,
		       Double_t goodDist=5,Double_t hitChi2Cut=10,
		       Double_t goodHitChi2=20,Double_t trackChi2Cut=50,
		       Int_t maxdist=50,Double_t maxphi=0.1,Double_t maxeta=0.1,
                       Bool_t vertexconstraint=kTRUE);
  void SetClusterFinderParam(Float_t fXYError=0.2,Float_t fZError=0.3,Bool_t deconv=kTRUE);

  void ProcessEvent(Int_t first,Int_t last,Int_t event=0);
  void ProcessSlice(Int_t slice);

  void DoMc(char* file="point_mc.dat");
  void DoNonVertexTracking() {fDoNonVertex=kTRUE;}
  void FindVertex() {fFindVertex=kTRUE;}
  void DoBench(char* name="benchmark");
  void DoPileup() {fPileUp = kTRUE;}
  void NoCF() {fNoCF=kTRUE;}
  void DoRoi(Float_t e0=0.4,Float_t e1=0.5){fEta[0]=e0;fEta[1]=e1;fDoRoi=kTRUE;}
  void WriteFiles(Char_t *path="./"){fWriteOut = kTRUE; sprintf(fWriteOutPath,"%s",path);}
  
  static void SetTracks2FirstPoint()   {fSetTracks2FirstPoint = kTRUE;}
  static void SetTracks2Vertex()       {fSetTracks2FirstPoint = kFALSE;}
  static Bool_t IsTracksAtFirstPoint() {return fSetTracks2FirstPoint;}
  
  ClassDef(AliHLTTPC,1) //Interface class for Level3-tracking
};

#endif
Commit	Line	Data
78001a73	1	// @(#) $Id$
	2
	3	#ifndef ALILEVEL3_H
	4	#define ALILEVEL3_H
	5
	6	#ifndef no_root
	7	#include <TObject.h>
	8	#include <TFile.h>
	9	#endif
	10
	11	#include "AliHLTTPCDigitData.h"
	12	#include "AliHLTTPCRootTypes.h"
	13
	14	class AliHLTTPCSpacePointData;
	15	class AliHLTTPCDigitRowData;
	16	class AliHLTTPCTrackSegmentData;
	17	class AliHLTTPCDigitData;
	18	class AliHLTTPCConfMapper;
	19	class AliHLTTPCVertex;
	20	class AliHLTTPCVertexFinder;
	21	class AliHLTTPCTrackMerger;
	22	class AliHLTTPCGlobalMerger;
	23	#ifndef no_root
	24	class TDirectory;
	25	#endif
	26	class AliHLTTPCClustFinderNew;
	27	class AliHLTTPCMerger;
	28	class AliHLTTPCInterMerger;
	29	class AliHLTTPCFileHandler;
	30	class AliHLTTPCMemHandler;
	31	class AliHLTTPCBenchmark;
	32
	33	#ifdef no_root
	34	class AliHLTTPC {
	35	#else
	36	class AliHLTTPC : public TObject {
	37	#endif
	38
	39	private:
	40	UInt_t fNTrackData;
	41	AliHLTTPCTrackSegmentData* fTrackData; //!
	42	AliHLTTPCConfMapper *fTracker; //!
	43	AliHLTTPCVertex *fVertex; //!
	44	AliHLTTPCVertexFinder *fVertexFinder; //!
	45	AliHLTTPCTrackMerger *fTrackMerger; //!
	46	AliHLTTPCGlobalMerger *fGlobalMerger; //!
	47	AliHLTTPCInterMerger *fInterMerger; //!
	48	AliHLTTPCClustFinderNew *fClusterFinder; //!
	49	AliHLTTPCMemHandler *fFileHandler; //!
	50	AliHLTTPCBenchmark *fBenchmark;//!
	51
	52	Int_t fEvent;
	53	Int_t fNPatch;
	54	Int_t fRow[6][2];
	55	Float_t fEta[2];
	56
	57	Char_t *fInputFile;//!
	58
	59	Char_t fPath[256];
	60	Char_t fWriteOutPath[256];
	61
	62	Bool_t fDoRoi;
	63	Bool_t fFindVertex;
	64	Bool_t fDoNonVertex;
65	Bool_t fPileUp;
66	Bool_t fNoCF;
67
68	Bool_t fUseBinary;
69	Bool_t fWriteOut;
70
71	//Define whether track parameters should be given at first point on track (default)
72	//If not, the parameters will be given at the vertex.
73	static Bool_t fSetTracks2FirstPoint;
74
75	Bool_t fClusterDeconv;
76	Float_t fXYClusterError;
77	Float_t fZClusterError;
78
79
80	void WriteSpacePoints(UInt_t npoints,AliHLTTPCSpacePointData *points,
81	Int_t slice,Int_t patch);
82	Int_t WriteTracks(char filename,AliHLTTPCMerger merger,char opt='o');
83	void WriteResults();
84	void FitGlobalTracks();
85	void SetPath(char *p){sprintf(fPath,"%s",p);}
86
87	public:
88	AliHLTTPC ();
89	AliHLTTPC(Char_t *infile);
90	virtual ~AliHLTTPC();
91	enum EFileType {kBinary, kBinary8, kRoot, kRaw, kDate};
92	void Init(Char_t *path,EFileType filetype=kBinary,Int_t npatches=6);
93	void SetMergerParameters(Double_t maxy=1.2,Double_t maxz=1.6,Double_t maxkappa=0.003,
94	Double_t maxpsi=0.02,Double_t maxtgl=0.03);
95	void SetTrackerParam(Int_t phi_segments=50,Int_t eta_segments=100,
96	Int_t trackletlength=3,Int_t tracklength=5,
97	Int_t rowscopetracklet=2,Int_t rowscopetrack=3,
98	Double_t min_pt_fit=0,Double_t maxangle=1.31,
99	Double_t goodDist=5,Double_t hitChi2Cut=10,
100	Double_t goodHitChi2=20,Double_t trackChi2Cut=50,
101	Int_t maxdist=50,Double_t maxphi=0.1,Double_t maxeta=0.1,
102	Bool_t vertexconstraint=kTRUE);
103	void SetClusterFinderParam(Float_t fXYError=0.2,Float_t fZError=0.3,Bool_t deconv=kTRUE);
104
105	void ProcessEvent(Int_t first,Int_t last,Int_t event=0);
106	void ProcessSlice(Int_t slice);
107
108	void DoMc(char* file="point_mc.dat");
109	void DoNonVertexTracking() {fDoNonVertex=kTRUE;}
110	void FindVertex() {fFindVertex=kTRUE;}
111	void DoBench(char* name="benchmark");
112	void DoPileup() {fPileUp = kTRUE;}
113	void NoCF() {fNoCF=kTRUE;}
114	void DoRoi(Float_t e0=0.4,Float_t e1=0.5){fEta[0]=e0;fEta[1]=e1;fDoRoi=kTRUE;}
115	void WriteFiles(Char_t *path="./"){fWriteOut = kTRUE; sprintf(fWriteOutPath,"%s",path);}
116
117	static void SetTracks2FirstPoint() {fSetTracks2FirstPoint = kTRUE;}
118	static void SetTracks2Vertex() {fSetTracks2FirstPoint = kFALSE;}
119	static Bool_t IsTracksAtFirstPoint() {return fSetTracks2FirstPoint;}
120
121	ClassDef(AliHLTTPC,1) //Interface class for Level3-tracking
122	};
123
124	#endif
125
126
127
128
129