option for reconstructors added
[u/mrichter/AliRoot.git] / STEER / AliReconstruction.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////////////////
19 //                                                                           //
20 // class for running the reconstruction                                      //
21 //                                                                           //
22 // Clusters and tracks are created for all detectors and all events by       //
23 // typing:                                                                   //
24 //                                                                           //
25 //   AliReconstruction rec;                                                  //
26 //   rec.Run();                                                              //
27 //                                                                           //
28 // The Run method returns kTRUE in case of successful execution.             //
29 // The name of the galice file can be changed from the default               //
30 // "galice.root" by passing it as argument to the AliReconstruction          //
31 // constructor or by                                                         //
32 //                                                                           //
33 //   rec.SetGAliceFile("...");                                               //
34 //                                                                           //
35 // The local reconstruction can be switched on or off for individual         //
36 // detectors by                                                              //
37 //                                                                           //
38 //   rec.SetRunLocalReconstruction("...");                                   //
39 //                                                                           //
40 // The argument is a (case sensitive) string with the names of the           //
41 // detectors separated by a space. The special string "ALL" selects all      //
42 // available detectors. This is the default.                                 //
43 //                                                                           //
44 // The tracking in ITS, TPC and TRD and the creation of ESD tracks can be    //
45 // switched off by                                                           //
46 //                                                                           //
47 //   rec.SetRunTracking(kFALSE);                                             //
48 //                                                                           //
49 // The filling of additional ESD information can be steered by               //
50 //                                                                           //
51 //   rec.SetFillESD("...");                                                  //
52 //                                                                           //
53 // Again, the string specifies the list of detectors. The default is "ALL".  //
54 //                                                                           //
55 // The reconstruction requires digits as input. For the creation of digits   //
56 // have a look at the class AliSimulation.                                   //
57 //                                                                           //
58 // For debug purposes the method SetCheckPointLevel can be used. If the      //
59 // argument is greater than 0, files with ESD events will be written after   //
60 // selected steps of the reconstruction for each event:                      //
61 //   level 1: after tracking and after filling of ESD (final)                //
62 //   level 2: in addition after each tracking step                           //
63 //   level 3: in addition after the filling of ESD for each detector         //
64 // If a final check point file exists for an event, this event will be       //
65 // skipped in the reconstruction. The tracking and the filling of ESD for    //
66 // a detector will be skipped as well, if the corresponding check point      //
67 // file exists. The ESD event will then be loaded from the file instead.     //
68 //                                                                           //
69 ///////////////////////////////////////////////////////////////////////////////
70
71 #include <TArrayF.h>
72 #include <TFile.h>
73 #include <TSystem.h>
74 #include <TROOT.h>
75 #include <TPluginManager.h>
76 #include <TStopwatch.h>
77
78 #include "AliReconstruction.h"
79 #include "AliRunLoader.h"
80 #include "AliRun.h"
81 #include "AliTracker.h"
82 #include "AliESD.h"
83 #include "AliESDVertex.h"
84 #include "AliVertexer.h"
85 #include "AliHeader.h"
86 #include "AliGenEventHeader.h"
87 #include "AliESDpid.h"
88 #include "AliMagF.h"
89
90 ClassImp(AliReconstruction)
91
92
93 //_____________________________________________________________________________
94 const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "RICH", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "START", "VZERO", "CRT", "HLT"};
95
96 //_____________________________________________________________________________
97 AliReconstruction::AliReconstruction(const char* gAliceFilename,
98                                      const char* name, const char* title) :
99   TNamed(name, title),
100
101   fRunLocalReconstruction("ALL"),
102   fRunVertexFinder(kTRUE),
103   fRunTracking(kTRUE),
104   fFillESD("ALL"),
105   fGAliceFileName(gAliceFilename),
106   fStopOnError(kFALSE),
107   fCheckPointLevel(0),
108
109   fRunLoader(NULL),
110   fITSLoader(NULL),
111   fITSVertexer(NULL),
112   fITSTracker(NULL),
113   fTPCLoader(NULL),
114   fTPCTracker(NULL),
115   fTRDLoader(NULL),
116   fTRDTracker(NULL),
117   fTOFLoader(NULL),
118   fTOFTracker(NULL),
119
120   fReconstructors(),
121   fOptions()
122 {
123 // create reconstruction object with default parameters
124
125 }
126
127 //_____________________________________________________________________________
128 AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
129   TNamed(rec),
130
131   fRunLocalReconstruction(rec.fRunLocalReconstruction),
132   fRunVertexFinder(rec.fRunVertexFinder),
133   fRunTracking(rec.fRunTracking),
134   fFillESD(rec.fFillESD),
135   fGAliceFileName(rec.fGAliceFileName),
136   fStopOnError(rec.fStopOnError),
137   fCheckPointLevel(0),
138
139   fRunLoader(NULL),
140   fITSLoader(NULL),
141   fITSVertexer(NULL),
142   fITSTracker(NULL),
143   fTPCLoader(NULL),
144   fTPCTracker(NULL),
145   fTRDLoader(NULL),
146   fTRDTracker(NULL),
147   fTOFLoader(NULL),
148   fTOFTracker(NULL),
149
150   fReconstructors(),
151   fOptions()
152 {
153 // copy constructor
154
155   for (Int_t i = 0; i < fOptions.GetEntriesFast(); i++) {
156     if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
157   }
158 }
159
160 //_____________________________________________________________________________
161 AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
162 {
163 // assignment operator
164
165   this->~AliReconstruction();
166   new(this) AliReconstruction(rec);
167   return *this;
168 }
169
170 //_____________________________________________________________________________
171 AliReconstruction::~AliReconstruction()
172 {
173 // clean up
174
175   CleanUp();
176   fOptions.Delete();
177 }
178
179
180 //_____________________________________________________________________________
181 void AliReconstruction::SetGAliceFile(const char* fileName)
182 {
183 // set the name of the galice file
184
185   fGAliceFileName = fileName;
186 }
187
188 //_____________________________________________________________________________
189 void AliReconstruction::SetOption(const char* detector, const char* option)
190 {
191 // set options for the reconstruction of a detector
192
193   TObject* obj = fOptions.FindObject(detector);
194   if (obj) fOptions.Remove(obj);
195   fOptions.Add(new TNamed(detector, option));
196 }
197
198
199 //_____________________________________________________________________________
200 Bool_t AliReconstruction::Run()
201 {
202 // run the reconstruction
203
204   // open the run loader
205   fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
206   if (!fRunLoader) {
207     Error("Run", "no run loader found in file %s", 
208           fGAliceFileName.Data());
209     CleanUp();
210     return kFALSE;
211   }
212   fRunLoader->LoadgAlice();
213   AliRun* aliRun = fRunLoader->GetAliRun();
214   if (!aliRun) {
215     Error("Run", "no gAlice object found in file %s", 
216           fGAliceFileName.Data());
217     CleanUp();
218     return kFALSE;
219   }
220   gAlice = aliRun;
221
222   // load the reconstructor objects
223   TPluginManager* pluginManager = gROOT->GetPluginManager();
224   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
225     TString detName = fgkDetectorName[iDet];
226     TString recName = "Ali" + detName + "Reconstructor";
227     if (!gAlice->GetDetector(detName) && detName != "HLT") continue;
228
229     if(detName == "HLT") {
230       if (!gROOT->GetClass("AliLevel3")) {
231         gSystem->Load("libAliL3Src.so");
232         gSystem->Load("libAliL3Misc.so");
233         gSystem->Load("libAliL3Hough.so");
234         gSystem->Load("libAliL3Comp.so");
235       }
236     }
237
238     AliReconstructor* reconstructor = NULL;
239     // first check if a plugin is defined for the reconstructor
240     TPluginHandler* pluginHandler = 
241       pluginManager->FindHandler("AliReconstructor", detName);
242     // if not, but the reconstructor class is implemented, add a plugin for it
243     if (!pluginHandler && gROOT->GetClass(recName.Data())) {
244       Info("Run", "defining plugin for %s", recName.Data());
245       pluginManager->AddHandler("AliReconstructor", detName, 
246                                 recName, detName, recName + "()");
247       pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
248     }
249     if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
250       reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
251     }
252     // if there is no reconstructor class for the detector use the dummy one
253     if (!reconstructor && gAlice->GetDetector(detName)) {
254       Info("Run", "using dummy reconstructor for %s", detName.Data());
255       reconstructor = new AliDummyReconstructor(gAlice->GetDetector(detName));
256     }
257     if (reconstructor) {
258       TObject* obj = fOptions.FindObject(detName.Data());
259       if (obj) reconstructor->SetOption(obj->GetTitle());
260       fReconstructors.Add(reconstructor);
261     }
262   }
263
264   // local reconstruction
265   if (!fRunLocalReconstruction.IsNull()) {
266     if (!RunLocalReconstruction(fRunLocalReconstruction)) {
267       if (fStopOnError) {CleanUp(); return kFALSE;}
268     }
269   }
270   if (!fRunVertexFinder && !fRunTracking && fFillESD.IsNull()) return kTRUE;
271
272   // get vertexer
273   if (fRunVertexFinder && !CreateVertexer()) {
274     if (fStopOnError) {
275       CleanUp(); 
276       return kFALSE;
277     }
278   }
279
280   // get loaders and trackers
281   if (fRunTracking && !CreateTrackers()) {
282     if (fStopOnError) {
283       CleanUp(); 
284       return kFALSE;
285     }      
286   }
287
288   // create the ESD output file and tree
289   TFile* file = TFile::Open("AliESDs.root", "RECREATE");
290   if (!file->IsOpen()) {
291     Error("Run", "opening AliESDs.root failed");
292     if (fStopOnError) {CleanUp(file); return kFALSE;}    
293   }
294   AliESD* esd = new AliESD;
295   TTree* tree = new TTree("esdTree", "Tree with ESD objects");
296   tree->Branch("ESD", "AliESD", &esd);
297   delete esd;
298   gROOT->cd();
299
300   // loop over events
301   for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) {
302     Info("Run", "processing event %d", iEvent);
303     fRunLoader->GetEvent(iEvent);
304
305     char fileName[256];
306     sprintf(fileName, "ESD_%d.%d_final.root", 
307             aliRun->GetRunNumber(), aliRun->GetEvNumber());
308     if (!gSystem->AccessPathName(fileName)) continue;
309
310     esd = new AliESD;
311     esd->SetRunNumber(aliRun->GetRunNumber());
312     esd->SetEventNumber(aliRun->GetEvNumber());
313     esd->SetMagneticField(aliRun->Field()->SolenoidField());
314
315     // vertex finder
316     if (fRunVertexFinder) {
317       if (!ReadESD(esd, "vertex")) {
318         if (!RunVertexFinder(esd)) {
319           if (fStopOnError) {CleanUp(file); return kFALSE;}
320         }
321         if (fCheckPointLevel > 0) WriteESD(esd, "vertex");
322       }
323     }
324
325     // barrel tracking
326     if (fRunTracking) {
327       if (!ReadESD(esd, "tracking")) {
328         if (!RunTracking(esd)) {
329           if (fStopOnError) {CleanUp(file); return kFALSE;}
330         }
331         if (fCheckPointLevel > 0) WriteESD(esd, "tracking");
332       }
333     }
334
335     // fill ESD
336     if (!fFillESD.IsNull()) {
337       if (!FillESD(esd, fFillESD)) {
338         if (fStopOnError) {CleanUp(file); return kFALSE;}
339       }
340     }
341
342     // combined PID
343     AliESDpid::MakePID(esd);
344     if (fCheckPointLevel > 1) WriteESD(esd, "PID");
345
346     // write ESD
347     tree->Fill();
348
349     if (fCheckPointLevel > 0) WriteESD(esd, "final");
350     delete esd;
351   }
352
353   file->cd();
354   tree->Write();
355   CleanUp(file);
356
357   return kTRUE;
358 }
359
360
361 //_____________________________________________________________________________
362 Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors)
363 {
364 // run the local reconstruction
365
366   TStopwatch stopwatch;
367   stopwatch.Start();
368
369   TString detStr = detectors;
370   for (Int_t iDet = 0; iDet < fReconstructors.GetEntriesFast(); iDet++) {
371     AliReconstructor* reconstructor = 
372       (AliReconstructor*) fReconstructors[iDet];
373     TString detName = reconstructor->GetDetectorName();
374     if (IsSelected(detName, detStr)) {
375       Info("RunReconstruction", "running reconstruction for %s", 
376            detName.Data());
377       TStopwatch stopwatchDet;
378       stopwatchDet.Start();
379       reconstructor->Reconstruct(fRunLoader);
380       Info("RunReconstruction", "execution time for %s:", detName.Data());
381       stopwatchDet.Print();
382     }
383   }
384
385   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
386     Error("RunReconstruction", "the following detectors were not found: %s", 
387           detStr.Data());
388     if (fStopOnError) return kFALSE;
389   }
390
391   Info("RunReconstruction", "execution time:");
392   stopwatch.Print();
393
394   return kTRUE;
395 }
396
397 //_____________________________________________________________________________
398 Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd)
399 {
400 // run the barrel tracking
401
402   TStopwatch stopwatch;
403   stopwatch.Start();
404
405   AliESDVertex* vertex = NULL;
406   Double_t vtxPos[3] = {0, 0, 0};
407   Double_t vtxErr[3] = {0.07, 0.07, 0.1};
408   TArrayF mcVertex(3); 
409   if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
410     fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
411     for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
412   }
413
414   if (fITSVertexer) {
415     Info("RunVertexFinder", "running the ITS vertex finder");
416     fITSVertexer->SetDebug(1);
417     vertex = fITSVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
418     if(!vertex){
419       Warning("RunVertexFinder","Vertex not found \n");
420       vertex = new AliESDVertex();
421     }
422     else {
423       vertex->SetTruePos(vtxPos);  // store also the vertex from MC
424     }
425
426   } else {
427     Info("RunVertexFinder", "getting the primary vertex from MC");
428     vertex = new AliESDVertex(vtxPos, vtxErr);
429   }
430
431   if (vertex) {
432     vertex->GetXYZ(vtxPos);
433     vertex->GetSigmaXYZ(vtxErr);
434   } else {
435     Warning("RunVertexFinder", "no vertex reconstructed");
436     vertex = new AliESDVertex(vtxPos, vtxErr);
437   }
438   esd->SetVertex(vertex);
439   if (fITSTracker) fITSTracker->SetVertex(vtxPos, vtxErr);
440   if (fTPCTracker) fTPCTracker->SetVertex(vtxPos, vtxErr);
441   if (fTRDTracker) fTRDTracker->SetVertex(vtxPos, vtxErr);
442   delete vertex;
443
444   Info("RunVertexFinder", "execution time:");
445   stopwatch.Print();
446
447   return kTRUE;
448 }
449
450 //_____________________________________________________________________________
451 Bool_t AliReconstruction::RunTracking(AliESD*& esd)
452 {
453 // run the barrel tracking
454
455   TStopwatch stopwatch;
456   stopwatch.Start();
457
458   if (!fTPCTracker) {
459     Error("RunTracking", "no TPC tracker");
460     return kFALSE;
461   }
462
463   // TPC tracking
464   Info("RunTracking", "TPC tracking");
465   fTPCLoader->LoadRecPoints("read");
466   TTree* tpcTree = fTPCLoader->TreeR();
467   if (!tpcTree) {
468     Error("RunTracking", "Can't get the TPC cluster tree");
469     return kFALSE;
470   }
471   fTPCTracker->LoadClusters(tpcTree);
472   if (fTPCTracker->Clusters2Tracks(esd) != 0) {
473     Error("RunTracking", "TPC Clusters2Tracks failed");
474     return kFALSE;
475   }
476   if (fCheckPointLevel > 1) WriteESD(esd, "TPC.tracking");
477
478   if (!fITSTracker) {
479     Warning("RunTracking", "no ITS tracker");
480   } else {
481
482     GetReconstructor("TPC")->FillESD(fRunLoader, esd); // preliminary
483     AliESDpid::MakePID(esd);                  // PID for the ITS tracker
484
485     // ITS tracking
486     Info("RunTracking", "ITS tracking");
487     fITSLoader->LoadRecPoints("read");
488     TTree* itsTree = fITSLoader->TreeR();
489     if (!itsTree) {
490       Error("RunTracking", "Can't get the ITS cluster tree");
491       return kFALSE;
492     }
493     fITSTracker->LoadClusters(itsTree);
494     if (fITSTracker->Clusters2Tracks(esd) != 0) {
495       Error("RunTracking", "ITS Clusters2Tracks failed");
496       return kFALSE;
497     }
498     if (fCheckPointLevel > 1) WriteESD(esd, "ITS.tracking");
499
500     if (!fTRDTracker) {
501       Warning("RunTracking", "no TRD tracker");
502     } else {
503       // ITS back propagation
504       Info("RunTracking", "ITS back propagation");
505       if (fITSTracker->PropagateBack(esd) != 0) {
506         Error("RunTracking", "ITS backward propagation failed");
507         return kFALSE;
508       }
509       if (fCheckPointLevel > 1) WriteESD(esd, "ITS.back");
510
511       // TPC back propagation
512       Info("RunTracking", "TPC back propagation");
513       if (fTPCTracker->PropagateBack(esd) != 0) {
514         Error("RunTracking", "TPC backward propagation failed");
515         return kFALSE;
516       }
517       if (fCheckPointLevel > 1) WriteESD(esd, "TPC.back");
518
519       // TRD back propagation
520       Info("RunTracking", "TRD back propagation");
521       fTRDLoader->LoadRecPoints("read");
522       TTree* trdTree = fTRDLoader->TreeR();
523       if (!trdTree) {
524         Error("RunTracking", "Can't get the TRD cluster tree");
525         return kFALSE;
526       }
527       fTRDTracker->LoadClusters(trdTree);
528       if (fTRDTracker->PropagateBack(esd) != 0) {
529         Error("RunTracking", "TRD backward propagation failed");
530         return kFALSE;
531       }
532       if (fCheckPointLevel > 1) WriteESD(esd, "TRD.back");
533
534       if (!fTOFTracker) {
535         Warning("RunTracking", "no TOF tracker");
536       } else {
537         // TOF back propagation
538         Info("RunTracking", "TOF back propagation");
539         fTOFLoader->LoadDigits("read");
540         TTree* tofTree = fTOFLoader->TreeD();
541         if (!tofTree) {
542           Error("RunTracking", "Can't get the TOF digits tree");
543           return kFALSE;
544         }
545         fTOFTracker->LoadClusters(tofTree);
546         if (fTOFTracker->PropagateBack(esd) != 0) {
547           Error("RunTracking", "TOF backward propagation failed");
548           return kFALSE;
549         }
550         if (fCheckPointLevel > 1) WriteESD(esd, "TOF.back");
551         fTOFTracker->UnloadClusters();
552         fTOFLoader->UnloadDigits();
553       }
554
555       // TRD inward refit
556       Info("RunTracking", "TRD inward refit");
557       if (fTRDTracker->RefitInward(esd) != 0) {
558         Error("RunTracking", "TRD inward refit failed");
559         return kFALSE;
560       }
561       if (fCheckPointLevel > 1) WriteESD(esd, "TRD.refit");
562       fTRDTracker->UnloadClusters();
563       fTRDLoader->UnloadRecPoints();
564     
565       // TPC inward refit
566       Info("RunTracking", "TPC inward refit");
567       if (fTPCTracker->RefitInward(esd) != 0) {
568         Error("RunTracking", "TPC inward refit failed");
569         return kFALSE;
570       }
571       if (fCheckPointLevel > 1) WriteESD(esd, "TPC.refit");
572     
573       // ITS inward refit
574       Info("RunTracking", "ITS inward refit");
575       if (fITSTracker->RefitInward(esd) != 0) {
576         Error("RunTracking", "ITS inward refit failed");
577         return kFALSE;
578       }
579       if (fCheckPointLevel > 1) WriteESD(esd, "ITS.refit");
580
581     }  // if TRD tracker
582     fITSTracker->UnloadClusters();
583     fITSLoader->UnloadRecPoints();
584
585   }  // if ITS tracker
586   fTPCTracker->UnloadClusters();
587   fTPCLoader->UnloadRecPoints();
588
589   Info("RunTracking", "execution time:");
590   stopwatch.Print();
591
592   return kTRUE;
593 }
594
595 //_____________________________________________________________________________
596 Bool_t AliReconstruction::FillESD(AliESD*& esd, const TString& detectors)
597 {
598 // fill the event summary data
599
600   TStopwatch stopwatch;
601   stopwatch.Start();
602
603   TString detStr = detectors;
604   for (Int_t iDet = 0; iDet < fReconstructors.GetEntriesFast(); iDet++) {
605     AliReconstructor* reconstructor = 
606       (AliReconstructor*) fReconstructors[iDet];
607     TString detName = reconstructor->GetDetectorName();
608     if (IsSelected(detName, detStr)) {
609       if (!ReadESD(esd, detName.Data())) {
610         Info("FillESD", "filling ESD for %s", detName.Data());
611         reconstructor->FillESD(fRunLoader, esd);
612         if (fCheckPointLevel > 2) WriteESD(esd, detName.Data());
613       }
614     }
615   }
616
617   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
618     Error("FillESD", "the following detectors were not found: %s", 
619           detStr.Data());
620     if (fStopOnError) return kFALSE;
621   }
622
623   Info("FillESD", "execution time:");
624   stopwatch.Print();
625
626   return kTRUE;
627 }
628
629
630 //_____________________________________________________________________________
631 Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
632 {
633 // check whether detName is contained in detectors
634 // if yes, it is removed from detectors
635
636   // check if all detectors are selected
637   if ((detectors.CompareTo("ALL") == 0) ||
638       detectors.BeginsWith("ALL ") ||
639       detectors.EndsWith(" ALL") ||
640       detectors.Contains(" ALL ")) {
641     detectors = "ALL";
642     return kTRUE;
643   }
644
645   // search for the given detector
646   Bool_t result = kFALSE;
647   if ((detectors.CompareTo(detName) == 0) ||
648       detectors.BeginsWith(detName+" ") ||
649       detectors.EndsWith(" "+detName) ||
650       detectors.Contains(" "+detName+" ")) {
651     detectors.ReplaceAll(detName, "");
652     result = kTRUE;
653   }
654
655   // clean up the detectors string
656   while (detectors.Contains("  ")) detectors.ReplaceAll("  ", " ");
657   while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
658   while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
659
660   return result;
661 }
662
663 //_____________________________________________________________________________
664 AliReconstructor* AliReconstruction::GetReconstructor(const char* detName) const
665 {
666 // get the reconstructor object for a detector
667
668   for (Int_t iDet = 0; iDet < fReconstructors.GetEntriesFast(); iDet++) {
669     AliReconstructor* reconstructor = 
670       (AliReconstructor*) fReconstructors[iDet];
671     if (strcmp(reconstructor->GetDetectorName(), detName) == 0) {
672       return reconstructor;
673     }
674   }
675   return NULL;
676 }
677
678 //_____________________________________________________________________________
679 Bool_t AliReconstruction::CreateVertexer()
680 {
681 // create the vertexer
682
683   fITSVertexer = NULL;
684   AliReconstructor* itsReconstructor = GetReconstructor("ITS");
685   if (itsReconstructor) {
686     fITSVertexer = itsReconstructor->CreateVertexer(fRunLoader);
687   }
688   if (!fITSVertexer) {
689     Warning("CreateVertexer", "couldn't create a vertexer for ITS");
690     if (fStopOnError) return kFALSE;
691   }
692
693   return kTRUE;
694 }
695
696 //_____________________________________________________________________________
697 Bool_t AliReconstruction::CreateTrackers()
698 {
699 // get the loaders and create the trackers
700
701   fITSTracker = NULL;
702   fITSLoader = fRunLoader->GetLoader("ITSLoader");
703   if (!fITSLoader) {
704     Warning("CreateTrackers", "no ITS loader found");
705     if (fStopOnError) return kFALSE;
706   } else {
707     AliReconstructor* itsReconstructor = GetReconstructor("ITS");
708     if (itsReconstructor) {
709       fITSTracker = itsReconstructor->CreateTracker(fRunLoader);
710     }
711     if (!fITSTracker) {
712       Warning("CreateTrackers", "couldn't create a tracker for ITS");
713       if (fStopOnError) return kFALSE;
714     }
715   }
716     
717   fTPCTracker = NULL;
718   fTPCLoader = fRunLoader->GetLoader("TPCLoader");
719   if (!fTPCLoader) {
720     Error("CreateTrackers", "no TPC loader found");
721     if (fStopOnError) return kFALSE;
722   } else {
723     AliReconstructor* tpcReconstructor = GetReconstructor("TPC");
724     if (tpcReconstructor) {
725       fTPCTracker = tpcReconstructor->CreateTracker(fRunLoader);
726     }
727     if (!fTPCTracker) {
728       Error("CreateTrackers", "couldn't create a tracker for TPC");
729       if (fStopOnError) return kFALSE;
730     }
731   }
732     
733   fTRDTracker = NULL;
734   fTRDLoader = fRunLoader->GetLoader("TRDLoader");
735   if (!fTRDLoader) {
736     Warning("CreateTrackers", "no TRD loader found");
737     if (fStopOnError) return kFALSE;
738   } else {
739     AliReconstructor* trdReconstructor = GetReconstructor("TRD");
740     if (trdReconstructor) {
741       fTRDTracker = trdReconstructor->CreateTracker(fRunLoader);
742     }
743     if (!fTRDTracker) {
744       Warning("CreateTrackers", "couldn't create a tracker for TRD");
745       if (fStopOnError) return kFALSE;
746     }
747   }
748     
749   fTOFTracker = NULL;
750   fTOFLoader = fRunLoader->GetLoader("TOFLoader");
751   if (!fTOFLoader) {
752     Warning("CreateTrackers", "no TOF loader found");
753     if (fStopOnError) return kFALSE;
754   } else {
755     AliReconstructor* tofReconstructor = GetReconstructor("TOF");
756     if (tofReconstructor) {
757       fTOFTracker = tofReconstructor->CreateTracker(fRunLoader);
758     }
759     if (!fTOFTracker) {
760       Warning("CreateTrackers", "couldn't create a tracker for TOF");
761       if (fStopOnError) return kFALSE;
762     }
763   }
764
765   return kTRUE;
766 }
767
768 //_____________________________________________________________________________
769 void AliReconstruction::CleanUp(TFile* file)
770 {
771 // delete trackers and the run loader and close and delete the file
772
773   fReconstructors.Delete();
774
775   delete fITSVertexer;
776   fITSVertexer = NULL;
777   delete fITSTracker;
778   fITSTracker = NULL;
779   delete fTPCTracker;
780   fTPCTracker = NULL;
781   delete fTRDTracker;
782   fTRDTracker = NULL;
783   delete fTOFTracker;
784   fTOFTracker = NULL;
785
786   delete fRunLoader;
787   fRunLoader = NULL;
788
789   if (file) {
790     file->Close();
791     delete file;
792   }
793 }
794
795
796 //_____________________________________________________________________________
797 Bool_t AliReconstruction::ReadESD(AliESD*& esd, const char* recStep) const
798 {
799 // read the ESD event from a file
800
801   if (!esd) return kFALSE;
802   char fileName[256];
803   sprintf(fileName, "ESD_%d.%d_%s.root", 
804           esd->GetRunNumber(), esd->GetEventNumber(), recStep);
805   if (gSystem->AccessPathName(fileName)) return kFALSE;
806
807   Info("ReadESD", "reading ESD from file %s", fileName);
808   TFile* file = TFile::Open(fileName);
809   if (!file || !file->IsOpen()) {
810     Error("ReadESD", "opening %s failed", fileName);
811     delete file;
812     return kFALSE;
813   }
814
815   gROOT->cd();
816   delete esd;
817   esd = (AliESD*) file->Get("ESD");
818   file->Close();
819   delete file;
820   return kTRUE;
821 }
822
823 //_____________________________________________________________________________
824 void AliReconstruction::WriteESD(AliESD* esd, const char* recStep) const
825 {
826 // write the ESD event to a file
827
828   if (!esd) return;
829   char fileName[256];
830   sprintf(fileName, "ESD_%d.%d_%s.root", 
831           esd->GetRunNumber(), esd->GetEventNumber(), recStep);
832
833   Info("WriteESD", "writing ESD to file %s", fileName);
834   TFile* file = TFile::Open(fileName, "recreate");
835   if (!file || !file->IsOpen()) {
836     Error("WriteESD", "opening %s failed", fileName);
837   } else {
838     esd->Write("ESD");
839     file->Close();
840   }
841   delete file;
842 }