[u/mrichter/AliRoot.git] / STEER / AliTPCComparisonMI.h



////////////////////////////////////////////////////////////////////////
//
// Start of implementation of the class digitRow
//
////////////////////////////////////////////////////////////////////////
const Int_t kgRowBytes = 32;

class digitRow: public TObject {

public:
  digitRow();
  virtual ~digitRow(){;}
  void SetRow(Int_t row);
  Bool_t TestRow(Int_t row);
  digitRow & operator=(const digitRow &digOld);
  Int_t RowsOn(Int_t upto=8*kgRowBytes);
  Int_t Last();
  Int_t First();
  void Reset();

//private:
  UChar_t fDig[kgRowBytes];

  ClassDef(digitRow,1)  // container for digit pattern
};
ClassImp(digitRow)


////////////////////////////////////////////////////////////////////////
//
// Start of implementation of the class AliTPCGenInfo
//
////////////////////////////////////////////////////////////////////////

class AliTPCGenInfo: public TObject {

public:
  AliTPCGenInfo();
  ~AliTPCGenInfo();

  AliTrackReference fTrackRef;      // track reference saved in the output tree
  AliTrackReference fTrackRefOut;   // decay track reference saved in the output tree
  TParticle fParticle;           // generated particle 
  Int_t fLabel;                   // track label
  Int_t fEventNr;                 // event number

  Float_t fDecayCoord[3];         // position of particle decay
  Double_t fVDist[4];             //distance of the particle vertex from primary vertex
  
  Int_t fRowsWithDigitsInn;    // number of rows with digits in the inner sectors
  Int_t fRowsWithDigits;       // number of rows with digits in the outer sectors
  Int_t fRowsTrackLength;      // last - first row with digit
  Int_t fDigitsInSeed;         // digits in the default seed rows
  Float_t fPrim;               // theoretical dedx in tpc according particle momenta and mass
  digitRow fRow;               // information about digits row pattern
  TClonesArray * fReferences;  //containner with all track references
  ClassDef(AliTPCGenInfo,1)  // container for 
};
ClassImp(AliTPCGenInfo)


class AliTPCGenV0Info: public TObject {
public:
  AliTPCGenInfo fMCd;      //info about daughter particle
  AliTPCGenInfo fMCm;      //info about mother particle
  void Update();        // put some derived info to special field 
  Double_t    fDist1;    //info about closest distance according closest MC - linear DCA
  Double_t    fDist2;    //info about closest distance parabolic DCA
  //
  Double_t     fPdr[3];    //momentum at vertex daughter  - according approx at DCA
  Double_t     fPd[4];     //exact momentum from MC info
  Double_t     fX[3];      //exact position of the vertex
  Double_t     fXr[3];     //rec. position according helix
  //
  Double_t     fPm[3];    //momentum at the vertex mother
  Double_t     fAngle[3]; //three angels
  Double_t     fRr;       // rec position of the vertex 
  Double_t     fR;        //exact r position of the vertex
  Int_t        fPdg[2];   //pdg code of mother and daugter particles
  Int_t        fLab[2];   //MC label of the partecle
  ClassDef(AliTPCGenV0Info,1)  // container for  
};
ClassImp(AliTPCGenV0Info)


void AliTPCGenV0Info::Update()
{
  fPd[0] = fMCd.fParticle.Px();
  fPd[1] = fMCd.fParticle.Py();
  fPd[2] = fMCd.fParticle.Pz();
  fPd[3] = fMCd.fParticle.P();
  fX[0]  = fMCd.fParticle.Vx();
  fX[1]  = fMCd.fParticle.Vy();
  fX[2]  = fMCd.fParticle.Vz();
  fR     = TMath::Sqrt( fX[0]*fX[0]+
				 fX[1]*fX[1]);
  fPdg[0]    = fMCd.fParticle.GetPdgCode();
  fPdg[1]    = fMCm.fParticle.GetPdgCode();
  //
  fLab[0]    = fMCd.fParticle.GetUniqueID();
  fLab[1]    = fMCm.fParticle.GetUniqueID();

}


     /////////////////////////////////////////////////////////////////////////
class AliTPCRecInfo: public TObject {

public:
  AliTPCRecInfo(){fTP = new TClonesArray("AliTPCTrackPoint2",0);}
  ~AliTPCRecInfo(){if (fTP) {fTP->Delete();delete fTP;}}
  //
  AliTPCtrack fTPCTrack;          // tpc track
  Float_t fTRLocalCoord[3];       //local coordinates of the track ref.
  Int_t   fReconstructed;         //flag if track was reconstructed
  Double_t fRecPhi;         // reconstructed phi angle (0;2*kPI)
  Double_t fLambda;         // reconstructed 
  Double_t fRecPt_1;        // reconstructed 
  Float_t fdEdx;           // reconstructed  dEdx      
  Int_t fFake;             // fake track
  Int_t fMultiple;         // number of reconstructions
  TClonesArray *fTP;        //container with track  points 
  void Reset();
  //
  ClassDef(AliTPCRecInfo,1)  // container for 
};
ClassImp(AliTPCRecInfo)

void AliTPCRecInfo::Reset()
{
  fMultiple =0; 
  fFake     =0;
  fReconstructed=0;
  fRecPhi =0;
  fLambda =0;
}


/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////


class AliTPCRecV0Info: public TObject {
public:
  AliTPCRecInfo  fT1;      //track1
  AliTPCRecInfo  fT2;      //track2  
  Double_t    fDist1;    //info about closest distance according closest MC - linear DCA
  Double_t    fDist2;    //info about closest distance parabolic DCA
  //
  Double_t     fPdr[3];    //momentum at vertex daughter  - according approx at DCA
  Double_t     fXr[3];     //rec. position according helix
  //
  Double_t     fPm[3];    //momentum at the vertex mother
  Double_t     fAngle[3]; //three angles
  Double_t     fRr;       // rec position of the vertex 
  Int_t        fLab[2];   //MC label of the partecle
  ClassDef(AliTPCRecV0Info,1)  // container for  
};

ClassImp(AliTPCRecV0Info)


////////////////////////////////////////////////////////////////////////
// 
// Start of implementation of the class TPCFindGenTracks
//
////////////////////////////////////////////////////////////////////////

class TPCFindGenTracks {

public:
  TPCFindGenTracks();
  TPCFindGenTracks(char* fnHits,
		   char* fnDigits ="tpc.digits.root",
		   char* fnRes    ="genTracks.root",
		   Int_t nEvents=1, Int_t firstEvent=0);
  virtual ~TPCFindGenTracks();
  void Reset();
  Int_t Exec();
  Int_t Exec(Int_t nEvents, Int_t firstEventNr);
  void CreateTreeGenTracks();
  void CloseOutputFile();
  Int_t TreeKLoop();
  Int_t TreeTRLoop();
  Int_t TreeDLoop();
  //void  FillInfo(Int_t iParticle);
  void SetFirstEventNr(Int_t i) {fFirstEventNr = i;}
  void SetNEvents(Int_t i) {fNEvents = i;}
  void SetDebug(Int_t level) {fDebug = level;}
  Int_t SetIO(Int_t eventNr);
  Int_t SetIO();
  Float_t TR2LocalX(AliTrackReference *trackRef,
		    AliTPCParam *paramTPC);

public:
  AliTPCGenInfo*  fMCInfo;           //! information writen per particle
  Int_t fDebug;                   //! debug flag  
  Int_t fEventNr;                 //! current event number
  Int_t fLabel;                   //! track label
  Int_t fNEvents;                 //! number of events to process
  Int_t fFirstEventNr;            //! first event to process
  Int_t fNParticles;              //! number of particles in TreeK
  TTree *fTreeGenTracks;          //! output tree with generated tracks
  char *fFnRes;                   //! output file name with stored tracks
  char *fFnHits;                  //! input file name with hits
  char *fFnDigits;                //! input file name with digits
  TFile *fFileGenTracks;          //! output file with stored fTreeGenTracks
  TFile *fFileHits;               //! input file with hits
  TFile *fFileTreeD;              //! input file with digits
  //
  TTree * fTreeD;                 //! current tree with digits
  TTree * fTreeTR;                //! current tree with TR
  AliStack *fStack;               //! current stack
  //
  digitRow *fContainerDigitRow;   //! big container for partial information
  //
  AliTrackReference *fReferences; //! container with track references
  Int_t *fReferenceIndex0;        //! first index for given track
  Int_t *fReferenceIndex1;        //! last  index for given track
  //
  AliTPCParam* fParamTPC;         //! AliTPCParam
  Double_t fVPrim[3];             //! primary vertex position
                                  // the fVDist[3] contains size of the 3-vector

private:

// some constants for the original non-pareller tracking (by Y.Belikov)
  static const Int_t seedRow11 = 158;  // nRowUp - 1
  static const Int_t seedRow12 = 139;  // nRowUp - 1 - (Int_t) 0.125*nRowUp
  static const Int_t seedRow21 = 149;  // seedRow11 - shift
  static const Int_t seedRow22 = 130;  // seedRow12 - shift
  static const Double_t kRaddeg = 180./kPI;

  static const Int_t fgMaxIndexTR = 50000; // maximum number of tracks with a track ref
  static const Int_t fgMaxTR = 1000000; // maximum number of  track refs

  static const Int_t fgMaxParticles = 2000000; // maximum number of generated particles
  static const Double_t fgPtCut = .1; // do not store particles with generated pT less than this
  static const Float_t fgTrackRefLocalXMax = 82.95;
  static const Float_t fgTrackRefLocalXMaxDelta = 5.;

  ClassDef(TPCFindGenTracks,1)    // class which creates and fills tree with TPCGenTrack objects
};
ClassImp(TPCFindGenTracks)


////////////////////////////////////////////////////////////////////////
// 
// Start of implementation of the class TPCCmpTr
//
////////////////////////////////////////////////////////////////////////

class TPCCmpTr {

public:
  TPCCmpTr();
  TPCCmpTr(char* fnRecTracks,
	   char* fnGenTracks   ="genTracks.root",
	   char* fnCmpRes      ="cmpTracks.root", 
	   char* fnGalice      ="galice.root",
	   Int_t nEvents=1, Int_t firstEvent=0);
  virtual ~TPCCmpTr();
  void Reset();
  Int_t Exec();
  Int_t Exec(Int_t nEvents, Int_t firstEventNr);
  void CreateTreeCmp();
  void CloseOutputFile();
  Bool_t ConnectGenTree();
  Int_t TreeGenLoop(Int_t eventNr);
  Int_t TreeTLoop(Int_t eventNr);
  void SetFirstEventNr(Int_t i) {fFirstEventNr = i;}
  void SetNEvents(Int_t i) {fNEvents = i;}
  void SetDebug(Int_t level) {fDebug = level;}

// tmp method, should go to TrackReferenceTPC
  TVector3 TR2Local(AliTrackReference *trackRef,
		    AliTPCParam *paramTPC);

private:

  Int_t fEventNr;                 //! current event number
  Int_t fNEvents;                 //! number of events to process
  Int_t fFirstEventNr;            //! first event to process
  //
  char *fFnCmp;                   //! output file name with cmp tracks
  TFile *fFileCmp;                //! output file with cmp tracks
  TTree *fTreeCmp;                //! output tree with cmp tracks
  //
  char *fFnGenTracks;             //! input file name with gen tracks
  TFile *fFileGenTracks;
  TTree *fTreeGenTracks;
  //
  char *fFnHits;                  //! input file name with gAlice object (needed for B)
  TFile *fFileHits;               //! input file with gAlice
  //
  char *fFnRecTracks;             //! input file name with tpc rec. tracks
  TFile *fFileRecTracks;          //! input file with reconstructed tracks
  TTree *fTreeRecTracks;          //! tree with reconstructed tracks
  TTree *fTreePoints;             //! tree with reconstructed points
  //
  Int_t *fIndexRecTracks;         //! index of particle label in the TreeT_TPC
  Int_t *fFakeRecTracks;          //! number of fake tracks
  Int_t *fMultiRecTracks;         //! number of multiple reconstructions
  //
  TObjArray * fTracks;            //!container with tracks 
  TObjArray * fTrackPoints;       //! container with track points
  //
  AliTPCParam* fParamTPC;         //! AliTPCParam
  Int_t fNParticles;              //! number of particles in the input tree genTracks
  Int_t fDebug;                   //! debug flag  
  Int_t fNextTreeGenEntryToRead;    //! last entry already read from genTracks tree
  //
  AliTPCGenInfo*  fMCInfo;           //! MC information writen per particle
  AliTPCRecInfo*  fRecInfo;          //! Rec. information writen per particle
  //
  AliTPCtrack *fTPCTrack;         //! pointer to TPC track to connect branch

  ClassDef(TPCCmpTr,1)    // class which creates and fills tree with TPCGenTrack objects
};
ClassImp(TPCCmpTr)
Commit	Line	Data
ae7d73d2	1
	2
	3	////////////////////////////////////////////////////////////////////////
	4	//
	5	// Start of implementation of the class digitRow
	6	//
	7	////////////////////////////////////////////////////////////////////////
	8	const Int_t kgRowBytes = 32;
	9
	10	class digitRow: public TObject {
	11
	12	public:
	13	digitRow();
	14	virtual ~digitRow(){;}
	15	void SetRow(Int_t row);
	16	Bool_t TestRow(Int_t row);
	17	digitRow & operator=(const digitRow &digOld);
	18	Int_t RowsOn(Int_t upto=8*kgRowBytes);
	19	Int_t Last();
	20	Int_t First();
	21	void Reset();
	22
	23	//private:
	24	UChar_t fDig[kgRowBytes];
	25
	26	ClassDef(digitRow,1) // container for digit pattern
	27	};
	28	ClassImp(digitRow)
	29
	30
	31	////////////////////////////////////////////////////////////////////////
	32	//
	33	// Start of implementation of the class AliTPCGenInfo
	34	//
	35	////////////////////////////////////////////////////////////////////////
	36
	37	class AliTPCGenInfo: public TObject {
	38
	39	public:
	40	AliTPCGenInfo();
	41	~AliTPCGenInfo();
	42
	43	AliTrackReference fTrackRef; // track reference saved in the output tree
	44	AliTrackReference fTrackRefOut; // decay track reference saved in the output tree
	45	TParticle fParticle; // generated particle
	46	Int_t fLabel; // track label
	47	Int_t fEventNr; // event number
	48
	49	Float_t fDecayCoord[3]; // position of particle decay
	50	Double_t fVDist[4]; //distance of the particle vertex from primary vertex
	51
	52	Int_t fRowsWithDigitsInn; // number of rows with digits in the inner sectors
	53	Int_t fRowsWithDigits; // number of rows with digits in the outer sectors
	54	Int_t fRowsTrackLength; // last - first row with digit
	55	Int_t fDigitsInSeed; // digits in the default seed rows
	56	Float_t fPrim; // theoretical dedx in tpc according particle momenta and mass
	57	digitRow fRow; // information about digits row pattern
	58	TClonesArray * fReferences; //containner with all track references
	59	ClassDef(AliTPCGenInfo,1) // container for
	60	};
	61	ClassImp(AliTPCGenInfo)
	62
	63
	64
65	class AliTPCGenV0Info: public TObject {
66	public:
67	AliTPCGenInfo fMCd; //info about daughter particle
68	AliTPCGenInfo fMCm; //info about mother particle
69	void Update(); // put some derived info to special field
70	Double_t fDist1; //info about closest distance according closest MC - linear DCA
71	Double_t fDist2; //info about closest distance parabolic DCA
72	//
73	Double_t fPdr[3]; //momentum at vertex daughter - according approx at DCA
74	Double_t fPd[4]; //exact momentum from MC info
75	Double_t fX[3]; //exact position of the vertex
76	Double_t fXr[3]; //rec. position according helix
77	//
78	Double_t fPm[3]; //momentum at the vertex mother
79	Double_t fAngle[3]; //three angels
80	Double_t fRr; // rec position of the vertex
81	Double_t fR; //exact r position of the vertex
82	Int_t fPdg[2]; //pdg code of mother and daugter particles
83	Int_t fLab[2]; //MC label of the partecle
84	ClassDef(AliTPCGenV0Info,1) // container for
85	};
86	ClassImp(AliTPCGenV0Info)
87
88
89
90	void AliTPCGenV0Info::Update()
91	{
92	fPd[0] = fMCd.fParticle.Px();
93	fPd[1] = fMCd.fParticle.Py();
94	fPd[2] = fMCd.fParticle.Pz();
95	fPd[3] = fMCd.fParticle.P();
96	fX[0] = fMCd.fParticle.Vx();
97	fX[1] = fMCd.fParticle.Vy();
98	fX[2] = fMCd.fParticle.Vz();
99	fR = TMath::Sqrt( fX[0]*fX[0]+
100	fX[1]*fX[1]);
101	fPdg[0] = fMCd.fParticle.GetPdgCode();
102	fPdg[1] = fMCm.fParticle.GetPdgCode();
103	//
104	fLab[0] = fMCd.fParticle.GetUniqueID();
105	fLab[1] = fMCm.fParticle.GetUniqueID();
106
107	}
108
109
110
111
112	/////////////////////////////////////////////////////////////////////////
113	class AliTPCRecInfo: public TObject {
114
115	public:
116	AliTPCRecInfo(){fTP = new TClonesArray("AliTPCTrackPoint2",0);}
117	~AliTPCRecInfo(){if (fTP) {fTP->Delete();delete fTP;}}
118	//
119	AliTPCtrack fTPCTrack; // tpc track
120	Float_t fTRLocalCoord[3]; //local coordinates of the track ref.
121	Int_t fReconstructed; //flag if track was reconstructed
122	Double_t fRecPhi; // reconstructed phi angle (0;2*kPI)
123	Double_t fLambda; // reconstructed
124	Double_t fRecPt_1; // reconstructed
125	Float_t fdEdx; // reconstructed dEdx
126	Int_t fFake; // fake track
127	Int_t fMultiple; // number of reconstructions
128	TClonesArray *fTP; //container with track points
129	void Reset();
130	//
131	ClassDef(AliTPCRecInfo,1) // container for
132	};
133	ClassImp(AliTPCRecInfo)
134
135	void AliTPCRecInfo::Reset()
136	{
137	fMultiple =0;
138	fFake =0;
139	fReconstructed=0;
140	fRecPhi =0;
141	fLambda =0;
142	}
143
144
145	/////////////////////////////////////////////////////////
146	/////////////////////////////////////////////////////////
147	/////////////////////////////////////////////////////////
148
149
150	class AliTPCRecV0Info: public TObject {
151	public:
152	AliTPCRecInfo fT1; //track1
153	AliTPCRecInfo fT2; //track2
154	Double_t fDist1; //info about closest distance according closest MC - linear DCA
155	Double_t fDist2; //info about closest distance parabolic DCA
156	//
157	Double_t fPdr[3]; //momentum at vertex daughter - according approx at DCA
158	Double_t fXr[3]; //rec. position according helix
159	//
160	Double_t fPm[3]; //momentum at the vertex mother
161	Double_t fAngle[3]; //three angles
162	Double_t fRr; // rec position of the vertex
163	Int_t fLab[2]; //MC label of the partecle
164	ClassDef(AliTPCRecV0Info,1) // container for
165	};
166
167	ClassImp(AliTPCRecV0Info)
168
169
170
171
172
173
174	////////////////////////////////////////////////////////////////////////
175	//
176	// Start of implementation of the class TPCFindGenTracks
177	//
178	////////////////////////////////////////////////////////////////////////
179
180	class TPCFindGenTracks {
181
182	public:
183	TPCFindGenTracks();
184	TPCFindGenTracks(char* fnHits,
185	char* fnDigits ="tpc.digits.root",
186	char* fnRes ="genTracks.root",
187	Int_t nEvents=1, Int_t firstEvent=0);
188	virtual ~TPCFindGenTracks();
189	void Reset();
190	Int_t Exec();
191	Int_t Exec(Int_t nEvents, Int_t firstEventNr);
192	void CreateTreeGenTracks();
193	void CloseOutputFile();
194	Int_t TreeKLoop();
195	Int_t TreeTRLoop();
196	Int_t TreeDLoop();
197	//void FillInfo(Int_t iParticle);
198	void SetFirstEventNr(Int_t i) {fFirstEventNr = i;}
199	void SetNEvents(Int_t i) {fNEvents = i;}
200	void SetDebug(Int_t level) {fDebug = level;}
201	Int_t SetIO(Int_t eventNr);
202	Int_t SetIO();
203	Float_t TR2LocalX(AliTrackReference *trackRef,
204	AliTPCParam *paramTPC);
205
206	public:
207	AliTPCGenInfo* fMCInfo; //! information writen per particle
208	Int_t fDebug; //! debug flag
209	Int_t fEventNr; //! current event number
210	Int_t fLabel; //! track label
211	Int_t fNEvents; //! number of events to process
212	Int_t fFirstEventNr; //! first event to process
213	Int_t fNParticles; //! number of particles in TreeK
214	TTree *fTreeGenTracks; //! output tree with generated tracks
215	char *fFnRes; //! output file name with stored tracks
216	char *fFnHits; //! input file name with hits
217	char *fFnDigits; //! input file name with digits
218	TFile *fFileGenTracks; //! output file with stored fTreeGenTracks
219	TFile *fFileHits; //! input file with hits
220	TFile *fFileTreeD; //! input file with digits
221	//
222	TTree * fTreeD; //! current tree with digits
223	TTree * fTreeTR; //! current tree with TR
224	AliStack *fStack; //! current stack
225	//
226	digitRow *fContainerDigitRow; //! big container for partial information
227	//
228	AliTrackReference *fReferences; //! container with track references
229	Int_t *fReferenceIndex0; //! first index for given track
230	Int_t *fReferenceIndex1; //! last index for given track
231	//
232	AliTPCParam* fParamTPC; //! AliTPCParam
233	Double_t fVPrim[3]; //! primary vertex position
234	// the fVDist[3] contains size of the 3-vector
235
236	private:
237
238	// some constants for the original non-pareller tracking (by Y.Belikov)
239	static const Int_t seedRow11 = 158; // nRowUp - 1
240	static const Int_t seedRow12 = 139; // nRowUp - 1 - (Int_t) 0.125*nRowUp
241	static const Int_t seedRow21 = 149; // seedRow11 - shift
242	static const Int_t seedRow22 = 130; // seedRow12 - shift
243	static const Double_t kRaddeg = 180./kPI;
244
245	static const Int_t fgMaxIndexTR = 50000; // maximum number of tracks with a track ref
246	static const Int_t fgMaxTR = 1000000; // maximum number of track refs
247
248	static const Int_t fgMaxParticles = 2000000; // maximum number of generated particles
249	static const Double_t fgPtCut = .1; // do not store particles with generated pT less than this
250	static const Float_t fgTrackRefLocalXMax = 82.95;
251	static const Float_t fgTrackRefLocalXMaxDelta = 5.;
252
253	ClassDef(TPCFindGenTracks,1) // class which creates and fills tree with TPCGenTrack objects
254	};
255	ClassImp(TPCFindGenTracks)
256
257
258
259	////////////////////////////////////////////////////////////////////////
260	//
261	// Start of implementation of the class TPCCmpTr
262	//
263	////////////////////////////////////////////////////////////////////////
264
265	class TPCCmpTr {
266
267	public:
268	TPCCmpTr();
269	TPCCmpTr(char* fnRecTracks,
270	char* fnGenTracks ="genTracks.root",
271	char* fnCmpRes ="cmpTracks.root",
272	char* fnGalice ="galice.root",
273	Int_t nEvents=1, Int_t firstEvent=0);
274	virtual ~TPCCmpTr();
275	void Reset();
276	Int_t Exec();
277	Int_t Exec(Int_t nEvents, Int_t firstEventNr);
278	void CreateTreeCmp();
279	void CloseOutputFile();
280	Bool_t ConnectGenTree();
281	Int_t TreeGenLoop(Int_t eventNr);
282	Int_t TreeTLoop(Int_t eventNr);
283	void SetFirstEventNr(Int_t i) {fFirstEventNr = i;}
284	void SetNEvents(Int_t i) {fNEvents = i;}
285	void SetDebug(Int_t level) {fDebug = level;}
286
287	// tmp method, should go to TrackReferenceTPC
288	TVector3 TR2Local(AliTrackReference *trackRef,
289	AliTPCParam *paramTPC);
290
291	private:
292
293	Int_t fEventNr; //! current event number
294	Int_t fNEvents; //! number of events to process
295	Int_t fFirstEventNr; //! first event to process
296	//
297	char *fFnCmp; //! output file name with cmp tracks
298	TFile *fFileCmp; //! output file with cmp tracks
299	TTree *fTreeCmp; //! output tree with cmp tracks
300	//
301	char *fFnGenTracks; //! input file name with gen tracks
302	TFile *fFileGenTracks;
303	TTree *fTreeGenTracks;
304	//
305	char *fFnHits; //! input file name with gAlice object (needed for B)
306	TFile *fFileHits; //! input file with gAlice
307	//
308	char *fFnRecTracks; //! input file name with tpc rec. tracks
309	TFile *fFileRecTracks; //! input file with reconstructed tracks
310	TTree *fTreeRecTracks; //! tree with reconstructed tracks
311	TTree *fTreePoints; //! tree with reconstructed points
312	//
313	Int_t *fIndexRecTracks; //! index of particle label in the TreeT_TPC
314	Int_t *fFakeRecTracks; //! number of fake tracks
315	Int_t *fMultiRecTracks; //! number of multiple reconstructions
316	//
317	TObjArray * fTracks; //!container with tracks
318	TObjArray * fTrackPoints; //! container with track points
319	//
320	AliTPCParam* fParamTPC; //! AliTPCParam
321	Int_t fNParticles; //! number of particles in the input tree genTracks
322	Int_t fDebug; //! debug flag
323	Int_t fNextTreeGenEntryToRead; //! last entry already read from genTracks tree
324	//
325	AliTPCGenInfo* fMCInfo; //! MC information writen per particle
326	AliTPCRecInfo* fRecInfo; //! Rec. information writen per particle
327	//
328	AliTPCtrack *fTPCTrack; //! pointer to TPC track to connect branch
329
330	ClassDef(TPCCmpTr,1) // class which creates and fills tree with TPCGenTrack objects
331	};
332	ClassImp(TPCCmpTr)
333