[u/mrichter/AliRoot.git] / TRD / AliTRDTracking.C

////////////////////////////////////////////////////////////////////////
//
// AliTRDTracking.C 
//
// date: 06.02.2003
// author: Thomas Kuhr based on AliTPCTracking.C
// version: 1.0
// description: 
//      reconstructs of tracks in TRD in the following steps:
//         TRD cluster finding
//         TRD track finding
// input parameters: 
//        Int_t nEvents      ... nr of events to process
//        Int_t firstEventNr ... first event number (starts from 0)
//        const char* fileNameParam ... name of file with TPC parameters
//        const char* fileNameHits ... name of file with hits
//        const char* fileNameDigits .. name of file with TRD digits
//        const char* fileNameSeeds .. name of file with TPC track seeds
//        const char* fileNameClusters .. name of file with TRD clusters (output)
//        const char* fileNameTracks .. name of file with TRD tracks (output)
//
//        default file names correspond to pp production (2002-04)
//
////////////////////////////////////////////////////////////////////////

#if !defined(__CINT__) || defined(__MAKECINT__)
#include "Riostream.h"
#include "TFile.h"
#include "TBenchmark.h"
#include "AliTRD.h"
#include "AliTRDparameter.h"
#include "AliTRDtracker.h"
#include "AliTRDclusterizerV1.h"
#include "AliTPC.h"
#include "AliTPCParamSR.h"
#include "AliTPCtracker.h"
#include "AliITS.h"
#include "AliITSgeom.h"
#include "AliITStrackerV2.h"
#include "AliRun.h"
#endif

Int_t gDEBUG = 2;

Int_t AliTRDTracking(Int_t nEvents=1, Int_t firstEvent=0,
		     const char* fileNameParam="trd.sdigits.root",
		     const char* fileNameDigits="trd.digits.root",
		     const char* fileNameSeed="tpc.tracks.root",
		     const char* fileNameClusters="trd.clusters.root",
		     const char* fileNameTracks="trd.tracks.root");

Bool_t ITSPropagateBack(Int_t nEvents=1, Int_t firstEvent=0,
			const char* fileNameClusters="its.clusters.root",
			const char* fileNameTracks="its.tracks.root",
			const char* fileNameBackTracks="its.back.tracks.root");
Bool_t TPCPropagateBack(Int_t nEvents=1, Int_t firstEvent=0,
			const char* fileNameClusters="tpc.clusters.root",
			const char* fileNameTracks="tpc.tracks.root",
			const char* fileNameITSBackTracks="its.back.tracks.root",
			const char* fileNameBackTracks="tpc.back.tracks.root");
Bool_t TRDFindClusters(Int_t nEvents=1, Int_t firstEvent=0,
		      const char* fileNameParam="trd.sdigits.root", 
		      const char* fileNameDigits="trd.digits.root", 
		      const char* fileNameClusters="trd.clusters.root");
Bool_t TRDFindTracks(Int_t nEvents=1, Int_t firstEvent=0,
		    const char* fileNameSeeds="tpc.tracks.root",
		    const char* fileNameClusters="trd.clusters.root",
		    const char* fileNameTracks="trd.tracks.root",
		     Bool_t inwards = kTRUE, Bool_t addSeeds = kTRUE);


////////////////////////////////////////////////////////////////////////
Int_t AliTRDTracking( Int_t nEvents, Int_t firstEvent,
		      const char* fileNameParam,
		      const char* fileNameDigits,
		      const char* fileNameSeeds,
		      const char* fileNameClusters,
		      const char* fileNameTracks) {

  AliTracker::SetFieldFactor(fileNameParam,kFALSE);

// ********** Find TRD clusters *********** //
  if (fileNameParam && fileNameDigits && fileNameClusters){
    if (!TRDFindClusters(nEvents,firstEvent,fileNameParam,fileNameDigits,fileNameClusters)) {
      cerr<<"Failed to get TRD clusters: !\n";
      return 1;
    }
  }      

// ********** Find TRD tracks *********** //
  if (fileNameSeeds && fileNameClusters && fileNameTracks) {
    if (!TRDFindTracks(nEvents,firstEvent,fileNameSeeds,fileNameClusters,fileNameTracks)) {
      cerr<<"Failed to get TRD tracks !\n";
      return 2;
    }
  }

  return 0;
}

////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
Bool_t ITSPropagateBack(Int_t nEvents, Int_t firstEvent,
			const char* fileNameClusters,
			const char* fileNameTracks,
			const char* fileNameBackTracks)
{
  const char *name="ITSPropagateBack";
  if (gDEBUG>1) cout<<name<<" starts...\n";
  if (gDEBUG>1) gBenchmark->Start(name);

  TFile* clustersFile = TFile::Open(fileNameClusters);
  if (!clustersFile->IsOpen()) {
    cerr<<"Cannot open "<<fileNameClusters<<" !\n"; 
    return kFALSE;
  }
  TFile* tracksFile = NULL;
  TFile* backTracksFile = NULL;
  if (strcmp(fileNameTracks, fileNameBackTracks) == 0) {
    tracksFile = backTracksFile = TFile::Open(fileNameTracks, "UPDATE");
  } else {
    backTracksFile = TFile::Open(fileNameBackTracks, "RECREATE");
    tracksFile = TFile::Open(fileNameTracks);
  }
  if (!tracksFile->IsOpen()) {
    cerr<<"Cannot open "<<fileNameTracks<<" !\n"; 
    return kFALSE;
  }

  gROOT->cd();
  AliITSgeom* geom = (AliITSgeom*) clustersFile->Get("AliITSgeom");
  AliITStrackerV2 tracker(geom);
  clustersFile->cd();

  for (Int_t iEvent = firstEvent; iEvent < firstEvent+nEvents; iEvent++) {
    tracker.SetEventNumber(iEvent);
    tracker.PropagateBack(tracksFile, backTracksFile);
  }

  if (tracksFile != backTracksFile) {
    backTracksFile->Close();
    delete backTracksFile;
  }
  tracksFile->Close();
  delete tracksFile;
  clustersFile->Close();
  delete clustersFile;

  if (gDEBUG>1) gBenchmark->Show(name);
  return kTRUE;
}
////////////////////////////////////////////////////////////////////////
Bool_t TPCPropagateBack(Int_t nEvents, Int_t firstEvent,
			const char* fileNameClusters,
			const char* fileNameTracks,
			const char* fileNameITSBackTracks,
			const char* fileNameBackTracks)
{
  const char *name="TPCPropagateBack";
  if (gDEBUG>1) cout<<name<<" starts...\n";
  if (gDEBUG>1) gBenchmark->Start(name);

  TFile* clustersFile = TFile::Open(fileNameClusters);
  if (!clustersFile->IsOpen()) {
    cerr<<"Cannot open "<<fileNameClusters<<" !\n"; 
    return kFALSE;
  }
  TFile* itsBackFile = NULL;
  if (fileNameITSBackTracks) {
    itsBackFile = TFile::Open(fileNameITSBackTracks);
    if (!itsBackFile->IsOpen()) {
      cerr<<"Cannot open "<<fileNameITSBackTracks<<" !\n"; 
      return kFALSE;
    }
  }
  TFile* tracksFile = NULL;
  TFile* backTracksFile = NULL;
  if (strcmp(fileNameTracks, fileNameBackTracks) == 0) {
    tracksFile = backTracksFile = TFile::Open(fileNameTracks, "UPDATE");
  } else {
    backTracksFile = TFile::Open(fileNameBackTracks, "RECREATE");
    tracksFile = TFile::Open(fileNameTracks);
  }
  if (!tracksFile->IsOpen()) {
    cerr<<"Cannot open "<<fileNameTracks<<" !\n"; 
    return kFALSE;
  }

  gROOT->cd();
  AliTPCParam* tpcParam = (AliTPCParam*) 
    clustersFile->Get("75x40_100x60_150x60");
  if (!tpcParam) tpcParam = new AliTPCParamSR;
  AliTPCtracker tracker(tpcParam);
  clustersFile->cd();

  for (Int_t iEvent = firstEvent; iEvent < firstEvent+nEvents; iEvent++) {
    tracker.SetEventNumber(iEvent);
    tracker.PropagateBack(tracksFile, itsBackFile, backTracksFile);
  }

  if (tracksFile != backTracksFile) {
    backTracksFile->Close();
    delete backTracksFile;
  }
  tracksFile->Close();
  delete tracksFile;
  clustersFile->Close();
  delete clustersFile;

  if (gDEBUG>1) gBenchmark->Show(name);
  return kTRUE;
}
////////////////////////////////////////////////////////////////////////
Bool_t TRDFindClusters(Int_t nEvents, Int_t firstEvent,
		      const char* fileNameParam, 
		      const char* fileNameDigits, const char* fileNameClusters) {
  
  const char *name="TRDFindClusters";
  if (gDEBUG>1) cout<<name<<" starts...\n";
  if (gDEBUG>1) gBenchmark->Start(name);

  TFile* paramFile = TFile::Open(fileNameParam);
  if (!paramFile->IsOpen()) {
    cerr<<"Cannot open "<<fileNameParam<<" !\n"; 
    return kFALSE;
  }
  AliTRDparameter* trdParam = 
    (AliTRDparameter*) paramFile->Get("TRDparameter"); 
  if (!trdParam) {
    cerr << "TRD parameters have not been found !\n"; 
    return kFALSE;
  }
  trdParam->ReInit();
  AliTRDclusterizerV1 clusterizer("clusterizer", "Clusterizer class"); 
  clusterizer.SetParameter(trdParam);

  for (Int_t iEvent = firstEvent; iEvent < firstEvent+nEvents; iEvent++) {
    clusterizer.Open(fileNameDigits, fileNameClusters, iEvent);
    clusterizer.ReadDigits();
    clusterizer.MakeClusters();
    clusterizer.WriteClusters(-1);
  }

  paramFile->Close();
  delete paramFile;

  if (gDEBUG>1) gBenchmark->Show(name);
  return kTRUE;
}
////////////////////////////////////////////////////////////////////////
Bool_t TRDFindTracks(Int_t nEvents, Int_t firstEvent,
		    const char* fileNameSeeds,
		     const char* fileNameClusters, const char* fileNameTracks,
		     Bool_t inwards, Bool_t addSeeds) {

  const char *name="TRDFindTracks";
  if (gDEBUG>1) cout<<name<<" starts...\n";
  if (gDEBUG>1) gBenchmark->Start(name);

  TFile* seedsFile = TFile::Open(fileNameSeeds);
  if (!seedsFile->IsOpen()) {
    cerr<<"Cannot open "<<fileNameSeeds<<" !\n"; 
    return kFALSE;
  }
  TFile* clustersFile = TFile::Open(fileNameClusters);
  if (!clustersFile->IsOpen()) {
    cerr<<"Cannot open "<<fileNameClusters<<" !\n"; 
    return kFALSE;
  }
  TFile* tracksFile = TFile::Open(fileNameTracks, "recreate");
  if (!tracksFile->IsOpen()) {
    cerr<<"Cannot open "<<fileNameTracks<<" !\n"; 
    return kFALSE;
  }

  AliTRDtracker tracker(clustersFile);
  if (addSeeds) tracker.SetAddTRDseeds();
  clustersFile->cd();  
  for (Int_t iEvent = firstEvent; iEvent < firstEvent+nEvents; iEvent++) {
    printf("Processing event %d\n", iEvent);
    tracker.SetEventNumber(iEvent);
    tracker.PropagateBack(seedsFile, tracksFile);
    if (inwards) tracker.Clusters2Tracks(tracksFile, tracksFile);
  }

  seedsFile->Close();
  delete seedsFile;
  clustersFile->Close();
  delete clustersFile;
  tracksFile->Close();
  delete tracksFile;

  if (gDEBUG>1) gBenchmark->Show(name);
  return kTRUE;
}
Commit	Line	Data
4b9aeba1	1	////////////////////////////////////////////////////////////////////////
	2	//
	3	// AliTRDTracking.C
	4	//
	5	// date: 06.02.2003
	6	// author: Thomas Kuhr based on AliTPCTracking.C
	7	// version: 1.0
	8	// description:
	9	// reconstructs of tracks in TRD in the following steps:
	10	// TRD cluster finding
	11	// TRD track finding
	12	// input parameters:
	13	// Int_t nEvents ... nr of events to process
	14	// Int_t firstEventNr ... first event number (starts from 0)
	15	// const char* fileNameParam ... name of file with TPC parameters
	16	// const char* fileNameHits ... name of file with hits
	17	// const char* fileNameDigits .. name of file with TRD digits
	18	// const char* fileNameSeeds .. name of file with TPC track seeds
	19	// const char* fileNameClusters .. name of file with TRD clusters (output)
	20	// const char* fileNameTracks .. name of file with TRD tracks (output)
	21	//
	22	// default file names correspond to pp production (2002-04)
	23	//
	24	////////////////////////////////////////////////////////////////////////
	25
	26	#if !defined(__CINT__) \|\| defined(__MAKECINT__)
	27	#include "Riostream.h"
	28	#include "TFile.h"
	29	#include "TBenchmark.h"
	30	#include "AliTRD.h"
	31	#include "AliTRDparameter.h"
	32	#include "AliTRDtracker.h"
	33	#include "AliTRDclusterizerV1.h"
	34	#include "AliTPC.h"
	35	#include "AliTPCParamSR.h"
	36	#include "AliTPCtracker.h"
	37	#include "AliITS.h"
	38	#include "AliITSgeom.h"
	39	#include "AliITStrackerV2.h"
	40	#include "AliRun.h"
	41	#endif
	42
	43	Int_t gDEBUG = 2;
	44
	45	Int_t AliTRDTracking(Int_t nEvents=1, Int_t firstEvent=0,
	46	const char* fileNameParam="trd.sdigits.root",
	47	const char* fileNameDigits="trd.digits.root",
	48	const char* fileNameSeed="tpc.tracks.root",
	49	const char* fileNameClusters="trd.clusters.root",
	50	const char* fileNameTracks="trd.tracks.root");
	51
	52	Bool_t ITSPropagateBack(Int_t nEvents=1, Int_t firstEvent=0,
	53	const char* fileNameClusters="its.clusters.root",
	54	const char* fileNameTracks="its.tracks.root",
	55	const char* fileNameBackTracks="its.back.tracks.root");
	56	Bool_t TPCPropagateBack(Int_t nEvents=1, Int_t firstEvent=0,
	57	const char* fileNameClusters="tpc.clusters.root",
	58	const char* fileNameTracks="tpc.tracks.root",
	59	const char* fileNameITSBackTracks="its.back.tracks.root",
	60	const char* fileNameBackTracks="tpc.back.tracks.root");
	61	Bool_t TRDFindClusters(Int_t nEvents=1, Int_t firstEvent=0,
	62	const char* fileNameParam="trd.sdigits.root",
	63	const char* fileNameDigits="trd.digits.root",
	64	const char* fileNameClusters="trd.clusters.root");
65	Bool_t TRDFindTracks(Int_t nEvents=1, Int_t firstEvent=0,
66	const char* fileNameSeeds="tpc.tracks.root",
67	const char* fileNameClusters="trd.clusters.root",
68	const char* fileNameTracks="trd.tracks.root",
69	Bool_t inwards = kTRUE, Bool_t addSeeds = kTRUE);
70
71
72	////////////////////////////////////////////////////////////////////////
73	Int_t AliTRDTracking( Int_t nEvents, Int_t firstEvent,
74	const char* fileNameParam,
75	const char* fileNameDigits,
76	const char* fileNameSeeds,
77	const char* fileNameClusters,
78	const char* fileNameTracks) {
79
80	AliTracker::SetFieldFactor(fileNameParam,kFALSE);
81
82	// ******** Find TRD clusters ********* //
83	if (fileNameParam && fileNameDigits && fileNameClusters){
84	if (!TRDFindClusters(nEvents,firstEvent,fileNameParam,fileNameDigits,fileNameClusters)) {
85	cerr<<"Failed to get TRD clusters: !\n";
86	return 1;
87	}
88	}
89
90	// ******** Find TRD tracks ********* //
91	if (fileNameSeeds && fileNameClusters && fileNameTracks) {
92	if (!TRDFindTracks(nEvents,firstEvent,fileNameSeeds,fileNameClusters,fileNameTracks)) {
93	cerr<<"Failed to get TRD tracks !\n";
94	return 2;
95	}
96	}
97
98	return 0;
99	}
100
101	////////////////////////////////////////////////////////////////////////
102	////////////////////////////////////////////////////////////////////////
103	Bool_t ITSPropagateBack(Int_t nEvents, Int_t firstEvent,
104	const char* fileNameClusters,
105	const char* fileNameTracks,
106	const char* fileNameBackTracks)
107	{
108	const char *name="ITSPropagateBack";
109	if (gDEBUG>1) cout<<name<<" starts...\n";
110	if (gDEBUG>1) gBenchmark->Start(name);
111
112	TFile* clustersFile = TFile::Open(fileNameClusters);
113	if (!clustersFile->IsOpen()) {
114	cerr<<"Cannot open "<<fileNameClusters<<" !\n";
115	return kFALSE;
116	}
117	TFile* tracksFile = NULL;
118	TFile* backTracksFile = NULL;
119	if (strcmp(fileNameTracks, fileNameBackTracks) == 0) {
120	tracksFile = backTracksFile = TFile::Open(fileNameTracks, "UPDATE");
121	} else {
122	backTracksFile = TFile::Open(fileNameBackTracks, "RECREATE");
123	tracksFile = TFile::Open(fileNameTracks);
124	}
125	if (!tracksFile->IsOpen()) {
126	cerr<<"Cannot open "<<fileNameTracks<<" !\n";
127	return kFALSE;
128	}
129
130	gROOT->cd();
131	AliITSgeom* geom = (AliITSgeom*) clustersFile->Get("AliITSgeom");
132	AliITStrackerV2 tracker(geom);
133	clustersFile->cd();
134
135	for (Int_t iEvent = firstEvent; iEvent < firstEvent+nEvents; iEvent++) {
136	tracker.SetEventNumber(iEvent);
137	tracker.PropagateBack(tracksFile, backTracksFile);
138	}
139
140	if (tracksFile != backTracksFile) {
141	backTracksFile->Close();
142	delete backTracksFile;
143	}
144	tracksFile->Close();
145	delete tracksFile;
146	clustersFile->Close();
147	delete clustersFile;
148
149	if (gDEBUG>1) gBenchmark->Show(name);
150	return kTRUE;
151	}
152	////////////////////////////////////////////////////////////////////////
153	Bool_t TPCPropagateBack(Int_t nEvents, Int_t firstEvent,
154	const char* fileNameClusters,
155	const char* fileNameTracks,
156	const char* fileNameITSBackTracks,
157	const char* fileNameBackTracks)
158	{
159	const char *name="TPCPropagateBack";
160	if (gDEBUG>1) cout<<name<<" starts...\n";
161	if (gDEBUG>1) gBenchmark->Start(name);
162
163	TFile* clustersFile = TFile::Open(fileNameClusters);
164	if (!clustersFile->IsOpen()) {
165	cerr<<"Cannot open "<<fileNameClusters<<" !\n";
166	return kFALSE;
167	}
168	TFile* itsBackFile = NULL;
169	if (fileNameITSBackTracks) {
170	itsBackFile = TFile::Open(fileNameITSBackTracks);
171	if (!itsBackFile->IsOpen()) {
172	cerr<<"Cannot open "<<fileNameITSBackTracks<<" !\n";
173	return kFALSE;
174	}
175	}
176	TFile* tracksFile = NULL;
177	TFile* backTracksFile = NULL;
178	if (strcmp(fileNameTracks, fileNameBackTracks) == 0) {
179	tracksFile = backTracksFile = TFile::Open(fileNameTracks, "UPDATE");
180	} else {
181	backTracksFile = TFile::Open(fileNameBackTracks, "RECREATE");
182	tracksFile = TFile::Open(fileNameTracks);
183	}
184	if (!tracksFile->IsOpen()) {
185	cerr<<"Cannot open "<<fileNameTracks<<" !\n";
186	return kFALSE;
187	}
188
189	gROOT->cd();
190	AliTPCParam* tpcParam = (AliTPCParam*)
191	clustersFile->Get("75x40_100x60_150x60");
192	if (!tpcParam) tpcParam = new AliTPCParamSR;
193	AliTPCtracker tracker(tpcParam);
194	clustersFile->cd();
195
196	for (Int_t iEvent = firstEvent; iEvent < firstEvent+nEvents; iEvent++) {
197	tracker.SetEventNumber(iEvent);
198	tracker.PropagateBack(tracksFile, itsBackFile, backTracksFile);
199	}
200
201	if (tracksFile != backTracksFile) {
202	backTracksFile->Close();
203	delete backTracksFile;
204	}
205	tracksFile->Close();
206	delete tracksFile;
207	clustersFile->Close();
208	delete clustersFile;
209
210	if (gDEBUG>1) gBenchmark->Show(name);
211	return kTRUE;
212	}
213	////////////////////////////////////////////////////////////////////////
214	Bool_t TRDFindClusters(Int_t nEvents, Int_t firstEvent,
215	const char* fileNameParam,
216	const char* fileNameDigits, const char* fileNameClusters) {
217
218	const char *name="TRDFindClusters";
219	if (gDEBUG>1) cout<<name<<" starts...\n";
220	if (gDEBUG>1) gBenchmark->Start(name);
221
222	TFile* paramFile = TFile::Open(fileNameParam);
223	if (!paramFile->IsOpen()) {
224	cerr<<"Cannot open "<<fileNameParam<<" !\n";
225	return kFALSE;
226	}
227	AliTRDparameter* trdParam =
228	(AliTRDparameter*) paramFile->Get("TRDparameter");
229	if (!trdParam) {
230	cerr << "TRD parameters have not been found !\n";
231	return kFALSE;
232	}
233	trdParam->ReInit();
234	AliTRDclusterizerV1 clusterizer("clusterizer", "Clusterizer class");
235	clusterizer.SetParameter(trdParam);
236
237	for (Int_t iEvent = firstEvent; iEvent < firstEvent+nEvents; iEvent++) {
238	clusterizer.Open(fileNameDigits, fileNameClusters, iEvent);
239	clusterizer.ReadDigits();
240	clusterizer.MakeClusters();
241	clusterizer.WriteClusters(-1);
242	}
243
244	paramFile->Close();
245	delete paramFile;
246
247	if (gDEBUG>1) gBenchmark->Show(name);
248	return kTRUE;
249	}
250	////////////////////////////////////////////////////////////////////////
251	Bool_t TRDFindTracks(Int_t nEvents, Int_t firstEvent,
252	const char* fileNameSeeds,
253	const char* fileNameClusters, const char* fileNameTracks,
254	Bool_t inwards, Bool_t addSeeds) {
255
256	const char *name="TRDFindTracks";
257	if (gDEBUG>1) cout<<name<<" starts...\n";
258	if (gDEBUG>1) gBenchmark->Start(name);
259
260	TFile* seedsFile = TFile::Open(fileNameSeeds);
261	if (!seedsFile->IsOpen()) {
262	cerr<<"Cannot open "<<fileNameSeeds<<" !\n";
263	return kFALSE;
264	}
265	TFile* clustersFile = TFile::Open(fileNameClusters);
266	if (!clustersFile->IsOpen()) {
267	cerr<<"Cannot open "<<fileNameClusters<<" !\n";
268	return kFALSE;
269	}
270	TFile* tracksFile = TFile::Open(fileNameTracks, "recreate");
271	if (!tracksFile->IsOpen()) {
272	cerr<<"Cannot open "<<fileNameTracks<<" !\n";
273	return kFALSE;
274	}
275
276	AliTRDtracker tracker(clustersFile);
277	if (addSeeds) tracker.SetAddTRDseeds();
278	clustersFile->cd();
279	for (Int_t iEvent = firstEvent; iEvent < firstEvent+nEvents; iEvent++) {
280	printf("Processing event %d\n", iEvent);
281	tracker.SetEventNumber(iEvent);
282	tracker.PropagateBack(seedsFile, tracksFile);
283	if (inwards) tracker.Clusters2Tracks(tracksFile, tracksFile);
284	}
285
286	seedsFile->Close();
287	delete seedsFile;
288	clustersFile->Close();
289	delete clustersFile;
290	tracksFile->Close();
291	delete tracksFile;
292
293	if (gDEBUG>1) gBenchmark->Show(name);
294	return kTRUE;
295	}
296