[u/mrichter/AliRoot.git] / TPC / 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 * fnGalice, 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
  TFile *fFileGenTracks;          //! output file with stored fTreeGenTracks
  //
  AliRunLoader * fLoader;         //! pointer to the run loader
  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* fnGenTracks,
	   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);
  Int_t SetIO();
  Int_t SetIO(Int_t eventNr );
  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;
  //
  // 
  AliRunLoader * fLoader;         //! pointer to the run loader
  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
7699f61f	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 * fnGalice, char* fnRes ="genTracks.root",
185	Int_t nEvents=1, Int_t firstEvent=0);
186	virtual ~TPCFindGenTracks();
187	void Reset();
188	Int_t Exec();
189	Int_t Exec(Int_t nEvents, Int_t firstEventNr);
190	void CreateTreeGenTracks();
191	void CloseOutputFile();
192	Int_t TreeKLoop();
193	Int_t TreeTRLoop();
194	Int_t TreeDLoop();
195	//void FillInfo(Int_t iParticle);
196	void SetFirstEventNr(Int_t i) {fFirstEventNr = i;}
197	void SetNEvents(Int_t i) {fNEvents = i;}
198	void SetDebug(Int_t level) {fDebug = level;}
199	Int_t SetIO(Int_t eventNr);
200	Int_t SetIO();
201	Float_t TR2LocalX(AliTrackReference *trackRef,
202	AliTPCParam *paramTPC);
203
204	public:
205	AliTPCGenInfo* fMCInfo; //! information writen per particle
206	Int_t fDebug; //! debug flag
207	Int_t fEventNr; //! current event number
208	Int_t fLabel; //! track label
209	Int_t fNEvents; //! number of events to process
210	Int_t fFirstEventNr; //! first event to process
211	Int_t fNParticles; //! number of particles in TreeK
212	TTree *fTreeGenTracks; //! output tree with generated tracks
213	char *fFnRes; //! output file name with stored tracks
214	TFile *fFileGenTracks; //! output file with stored fTreeGenTracks
215	//
216	AliRunLoader * fLoader; //! pointer to the run loader
217	TTree * fTreeD; //! current tree with digits
218	TTree * fTreeTR; //! current tree with TR
219	AliStack *fStack; //! current stack
220	//
221	digitRow *fContainerDigitRow; //! big container for partial information
222	//
223	AliTrackReference *fReferences; //! container with track references
224	Int_t *fReferenceIndex0; //! first index for given track
225	Int_t *fReferenceIndex1; //! last index for given track
226	//
227	AliTPCParam* fParamTPC; //! AliTPCParam
228	Double_t fVPrim[3]; //! primary vertex position
229	// the fVDist[3] contains size of the 3-vector
230
231	private:
232
233	// some constants for the original non-pareller tracking (by Y.Belikov)
234	static const Int_t seedRow11 = 158; // nRowUp - 1
235	static const Int_t seedRow12 = 139; // nRowUp - 1 - (Int_t) 0.125*nRowUp
236	static const Int_t seedRow21 = 149; // seedRow11 - shift
237	static const Int_t seedRow22 = 130; // seedRow12 - shift
238	static const Double_t kRaddeg = 180./kPI;
239
240	static const Int_t fgMaxIndexTR = 50000; // maximum number of tracks with a track ref
241	static const Int_t fgMaxTR = 1000000; // maximum number of track refs
242
243	static const Int_t fgMaxParticles = 2000000; // maximum number of generated particles
244	static const Double_t fgPtCut = .1; // do not store particles with generated pT less than this
245	static const Float_t fgTrackRefLocalXMax = 82.95;
246	static const Float_t fgTrackRefLocalXMaxDelta = 5.;
247
248	ClassDef(TPCFindGenTracks,1) // class which creates and fills tree with TPCGenTrack objects
249	};
250	ClassImp(TPCFindGenTracks)
251
252
253
254	////////////////////////////////////////////////////////////////////////
255	//
256	// Start of implementation of the class TPCCmpTr
257	//
258	////////////////////////////////////////////////////////////////////////
259
260	class TPCCmpTr {
261
262	public:
263	TPCCmpTr();
264	TPCCmpTr(char* fnGenTracks,
265	char* fnCmpRes ="cmpTracks.root",
266	char* fnGalice ="galice.root",
267	Int_t nEvents=1, Int_t firstEvent=0);
268	virtual ~TPCCmpTr();
269	void Reset();
270	Int_t Exec();
271	Int_t Exec(Int_t nEvents, Int_t firstEventNr);
272	Int_t SetIO();
273	Int_t SetIO(Int_t eventNr );
274	void CreateTreeCmp();
275	void CloseOutputFile();
276	Bool_t ConnectGenTree();
277	Int_t TreeGenLoop(Int_t eventNr);
278	Int_t TreeTLoop(Int_t eventNr);
279	void SetFirstEventNr(Int_t i) {fFirstEventNr = i;}
280	void SetNEvents(Int_t i) {fNEvents = i;}
281	void SetDebug(Int_t level) {fDebug = level;}
282
283	// tmp method, should go to TrackReferenceTPC
284	TVector3 TR2Local(AliTrackReference *trackRef,
285	AliTPCParam *paramTPC);
286
287	private:
288
289	Int_t fEventNr; //! current event number
290	Int_t fNEvents; //! number of events to process
291	Int_t fFirstEventNr; //! first event to process
292	//
293	char *fFnCmp; //! output file name with cmp tracks
294	TFile *fFileCmp; //! output file with cmp tracks
295	TTree *fTreeCmp; //! output tree with cmp tracks
296	//
297	char *fFnGenTracks; //! input file name with gen tracks
298	TFile *fFileGenTracks;
299	TTree *fTreeGenTracks;
300	//
301	//
302	AliRunLoader * fLoader; //! pointer to the run loader
303	TTree *fTreeRecTracks; //! tree with reconstructed tracks
304	TTree *fTreePoints; //! tree with reconstructed points
305	//
306	Int_t *fIndexRecTracks; //! index of particle label in the TreeT_TPC
307	Int_t *fFakeRecTracks; //! number of fake tracks
308	Int_t *fMultiRecTracks; //! number of multiple reconstructions
309	//
310	TObjArray * fTracks; //!container with tracks
311	TObjArray * fTrackPoints; //! container with track points
312	//
313	AliTPCParam* fParamTPC; //! AliTPCParam
314	Int_t fNParticles; //! number of particles in the input tree genTracks
315	Int_t fDebug; //! debug flag
316	Int_t fNextTreeGenEntryToRead; //! last entry already read from genTracks tree
317	//
318	AliTPCGenInfo* fMCInfo; //! MC information writen per particle
319	AliTPCRecInfo* fRecInfo; //! Rec. information writen per particle
320	//
321	AliTPCtrack *fTPCTrack; //! pointer to TPC track to connect branch
322
323	ClassDef(TPCCmpTr,1) // class which creates and fills tree with TPCGenTrack objects
324	};
325	ClassImp(TPCCmpTr)
326