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

// @(#) $Id$
// Original: AliLevel3.h,v 1.24 2004/06/11 16:06:33 loizides 

#ifndef ALIHLTTPC_H
#define ALIHLTTPC_H

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

class AliRunLoader;

#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 AliHLTTPCClusterFinder;
class AliHLTTPCDigitReaderUnpacked;
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; //count data
  AliHLTTPCTrackSegmentData* fTrackData; //!
  AliHLTTPCConfMapper *fTracker; //!
  AliHLTTPCVertex *fVertex; //! 
  AliHLTTPCVertexFinder *fVertexFinder; //!
  AliHLTTPCTrackMerger *fTrackMerger; //!
  AliHLTTPCGlobalMerger *fGlobalMerger; //!
  AliHLTTPCInterMerger *fInterMerger; //!
  AliHLTTPCClusterFinder *fClusterFinder; //! 
  AliHLTTPCDigitReaderUnpacked* fDigitReader; //!
  AliHLTTPCMemHandler *fFileHandler; //!
  AliHLTTPCBenchmark *fBenchmark;//!

  Int_t fEvent;    //event number
  Int_t fNPatch;   //number of patches
  Int_t fRow[6][2];//rows
  Float_t fEta[2]; //eta
  
  Char_t *fInputFile;//!
  AliRunLoader *fRunLoader; //runloader
  Char_t fPath[256]; //path to aliroot
  Char_t fWriteOutPath[256]; //path to store
  
  Bool_t fDoRoi; //do region of interest
  Bool_t fFindVertex; //find vertex
  Bool_t fDoNonVertex;//do non vertex pass
  Bool_t fPileUp; //do pileup
  Bool_t fNoCF; //dont do cluster finder
  
  Bool_t fUseBinary; //use binary input
  Bool_t fWriteOut; //write tracks
  
  static Bool_t fgDoVertexFit; //do vertex fix

  Bool_t fClusterDeconv; //do cluster deconv
  Float_t fXYClusterError; //Cluster error
  Float_t fZClusterError; //Cluster error

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

 public:
  AliHLTTPC ();
  AliHLTTPC(Char_t *infile);
  AliHLTTPC(AliRunLoader *rl);
  virtual ~AliHLTTPC();
  enum EFileType {kBinary, kBinary8, kRoot, kRaw, kDate, kRunLoader};
  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 SetVertexFit(Bool_t f)   {fgDoVertexFit=f;}
  static Bool_t DoVertexFit()          {return fgDoVertexFit;}

  ClassDef(AliHLTTPC,1) //Interface class for HLTTPC-tracking
};

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