use dummy reconstructor only if detector exists
[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 // create reconstruction object with default parameters
121
122 }
123
124 //_____________________________________________________________________________
125 AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
126   TNamed(rec),
127
128   fRunLocalReconstruction(rec.fRunLocalReconstruction),
129   fRunVertexFinder(rec.fRunVertexFinder),
130   fRunTracking(rec.fRunTracking),
131   fFillESD(rec.fFillESD),
132   fGAliceFileName(rec.fGAliceFileName),
133   fStopOnError(rec.fStopOnError),
134   fCheckPointLevel(0),
135
136   fRunLoader(NULL),
137   fITSLoader(NULL),
138   fITSVertexer(NULL),
139   fITSTracker(NULL),
140   fTPCLoader(NULL),
141   fTPCTracker(NULL),
142   fTRDLoader(NULL),
143   fTRDTracker(NULL),
144   fTOFLoader(NULL),
145   fTOFTracker(NULL)
146 {
147 // copy constructor
148
149 }
150
151 //_____________________________________________________________________________
152 AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
153 {
154 // assignment operator
155
156   this->~AliReconstruction();
157   new(this) AliReconstruction(rec);
158   return *this;
159 }
160
161 //_____________________________________________________________________________
162 AliReconstruction::~AliReconstruction()
163 {
164 // clean up
165
166   CleanUp();
167 }
168
169
170 //_____________________________________________________________________________
171 void AliReconstruction::SetGAliceFile(const char* fileName)
172 {
173 // set the name of the galice file
174
175   fGAliceFileName = fileName;
176 }
177
178
179 //_____________________________________________________________________________
180 Bool_t AliReconstruction::Run()
181 {
182 // run the reconstruction
183
184   // open the run loader
185   fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
186   if (!fRunLoader) {
187     Error("Run", "no run loader found in file %s", 
188           fGAliceFileName.Data());
189     CleanUp();
190     return kFALSE;
191   }
192   fRunLoader->LoadgAlice();
193   AliRun* aliRun = fRunLoader->GetAliRun();
194   if (!aliRun) {
195     Error("Run", "no gAlice object found in file %s", 
196           fGAliceFileName.Data());
197     CleanUp();
198     return kFALSE;
199   }
200   gAlice = aliRun;
201
202   // load the reconstructor objects
203   TPluginManager* pluginManager = gROOT->GetPluginManager();
204   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
205     TString detName = fgkDetectorName[iDet];
206     TString recName = "Ali" + detName + "Reconstructor";
207     if (!gAlice->GetDetector(detName) && detName != "HLT") continue;
208
209     if(detName == "HLT") {
210       if (!gROOT->GetClass("AliLevel3")) {
211         gSystem->Load("libAliL3Src.so");
212         gSystem->Load("libAliL3Misc.so");
213         gSystem->Load("libAliL3Hough.so");
214         gSystem->Load("libAliL3Comp.so");
215       }
216     }
217
218     AliReconstructor* reconstructor = NULL;
219     // first check if a plugin is defined for the reconstructor
220     TPluginHandler* pluginHandler = 
221       pluginManager->FindHandler("AliReconstructor", detName);
222     // if not, but the reconstructor class is implemented, add a plugin for it
223     if (!pluginHandler && gROOT->GetClass(recName.Data())) {
224       Info("Run", "defining plugin for %s", recName.Data());
225       pluginManager->AddHandler("AliReconstructor", detName, 
226                                 recName, detName, recName + "()");
227       pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
228     }
229     if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
230       reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
231     }
232     // if there is no reconstructor class for the detector use the dummy one
233     if (!reconstructor && gAlice->GetDetector(detName)) {
234       Info("Run", "using dummy reconstructor for %s", detName.Data());
235       reconstructor = new AliDummyReconstructor(gAlice->GetDetector(detName));
236     }
237     if (reconstructor) fReconstructors.Add(reconstructor);
238   }
239
240   // local reconstruction
241   if (!fRunLocalReconstruction.IsNull()) {
242     if (!RunLocalReconstruction(fRunLocalReconstruction)) {
243       if (fStopOnError) {CleanUp(); return kFALSE;}
244     }
245   }
246   if (!fRunVertexFinder && !fRunTracking && fFillESD.IsNull()) return kTRUE;
247
248   // get vertexer
249   if (fRunVertexFinder && !CreateVertexer()) {
250     if (fStopOnError) {
251       CleanUp(); 
252       return kFALSE;
253     }
254   }
255
256   // get loaders and trackers
257   if (fRunTracking && !CreateTrackers()) {
258     if (fStopOnError) {
259       CleanUp(); 
260       return kFALSE;
261     }      
262   }
263
264   // create the ESD output file
265   TFile* file = TFile::Open("AliESDs.root", "RECREATE");
266   if (!file->IsOpen()) {
267     Error("Run", "opening AliESDs.root failed");
268     if (fStopOnError) {CleanUp(file); return kFALSE;}    
269   }
270
271   // loop over events
272   for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) {
273     Info("Run", "processing event %d", iEvent);
274     fRunLoader->GetEvent(iEvent);
275
276     char fileName[256];
277     sprintf(fileName, "ESD_%d.%d_final.root", 
278             aliRun->GetRunNumber(), aliRun->GetEvNumber());
279     if (!gSystem->AccessPathName(fileName)) continue;
280
281     AliESD* esd = new AliESD;
282     esd->SetRunNumber(aliRun->GetRunNumber());
283     esd->SetEventNumber(aliRun->GetEvNumber());
284     esd->SetMagneticField(aliRun->Field()->SolenoidField());
285
286     // vertex finder
287     if (fRunVertexFinder) {
288       if (!ReadESD(esd, "vertex")) {
289         if (!RunVertexFinder(esd)) {
290           if (fStopOnError) {CleanUp(file); return kFALSE;}
291         }
292         if (fCheckPointLevel > 0) WriteESD(esd, "vertex");
293       }
294     }
295
296     // barrel tracking
297     if (fRunTracking) {
298       if (!ReadESD(esd, "tracking")) {
299         if (!RunTracking(esd)) {
300           if (fStopOnError) {CleanUp(file); return kFALSE;}
301         }
302         if (fCheckPointLevel > 0) WriteESD(esd, "tracking");
303       }
304     }
305
306     // fill ESD
307     if (!fFillESD.IsNull()) {
308       if (!FillESD(esd, fFillESD)) {
309         if (fStopOnError) {CleanUp(file); return kFALSE;}
310       }
311     }
312
313     // combined PID
314     AliESDpid::MakePID(esd);
315     if (fCheckPointLevel > 1) WriteESD(esd, "PID");
316
317     // write ESD
318     char name[100]; 
319     sprintf(name, "ESD%d", iEvent);
320     file->cd();
321     if (!esd->Write(name)) {
322       Error("Run", "writing ESD failed");
323       if (fStopOnError) {CleanUp(file); return kFALSE;}
324     }
325     file->Flush();
326
327     if (fCheckPointLevel > 0) WriteESD(esd, "final");
328     delete esd;
329   }
330
331   CleanUp(file);
332
333   return kTRUE;
334 }
335
336
337 //_____________________________________________________________________________
338 Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors)
339 {
340 // run the local reconstruction
341
342   TStopwatch stopwatch;
343   stopwatch.Start();
344
345   TString detStr = detectors;
346   for (Int_t iDet = 0; iDet < fReconstructors.GetEntriesFast(); iDet++) {
347     AliReconstructor* reconstructor = 
348       (AliReconstructor*) fReconstructors[iDet];
349     TString detName = reconstructor->GetDetectorName();
350     if (IsSelected(detName, detStr)) {
351       Info("RunReconstruction", "running reconstruction for %s", 
352            detName.Data());
353       TStopwatch stopwatchDet;
354       stopwatchDet.Start();
355       reconstructor->Reconstruct(fRunLoader);
356       Info("RunReconstruction", "execution time for %s:", detName.Data());
357       stopwatchDet.Print();
358     }
359   }
360
361   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
362     Error("RunReconstruction", "the following detectors were not found: %s", 
363           detStr.Data());
364     if (fStopOnError) return kFALSE;
365   }
366
367   Info("RunReconstruction", "execution time:");
368   stopwatch.Print();
369
370   return kTRUE;
371 }
372
373 //_____________________________________________________________________________
374 Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd)
375 {
376 // run the barrel tracking
377
378   TStopwatch stopwatch;
379   stopwatch.Start();
380
381   AliESDVertex* vertex = NULL;
382   Double_t vtxPos[3] = {0, 0, 0};
383   Double_t vtxErr[3] = {0.07, 0.07, 0.1};
384   TArrayF mcVertex(3); 
385   if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
386     fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
387     for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
388   }
389
390   if (fITSVertexer) {
391     Info("RunVertexFinder", "running the ITS vertex finder");
392     fITSVertexer->SetDebug(1);
393     vertex = fITSVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
394     if(!vertex){
395       Warning("RunVertexFinder","Vertex not found \n");
396       vertex = new AliESDVertex();
397     }
398     else {
399       vertex->SetTruePos(vtxPos);  // store also the vertex from MC
400     }
401
402   } else {
403     Info("RunVertexFinder", "getting the primary vertex from MC");
404     vertex = new AliESDVertex(vtxPos, vtxErr);
405   }
406
407   if (vertex) {
408     vertex->GetXYZ(vtxPos);
409     vertex->GetSigmaXYZ(vtxErr);
410   } else {
411     Warning("RunVertexFinder", "no vertex reconstructed");
412     vertex = new AliESDVertex(vtxPos, vtxErr);
413   }
414   esd->SetVertex(vertex);
415   if (fITSTracker) fITSTracker->SetVertex(vtxPos, vtxErr);
416   if (fTPCTracker) fTPCTracker->SetVertex(vtxPos, vtxErr);
417   if (fTRDTracker) fTRDTracker->SetVertex(vtxPos, vtxErr);
418   delete vertex;
419
420   Info("RunVertexFinder", "execution time:");
421   stopwatch.Print();
422
423   return kTRUE;
424 }
425
426 //_____________________________________________________________________________
427 Bool_t AliReconstruction::RunTracking(AliESD*& esd)
428 {
429 // run the barrel tracking
430
431   TStopwatch stopwatch;
432   stopwatch.Start();
433
434   if (!fTPCTracker) {
435     Error("RunTracking", "no TPC tracker");
436     return kFALSE;
437   }
438
439   // TPC tracking
440   Info("RunTracking", "TPC tracking");
441   fTPCLoader->LoadRecPoints("read");
442   TTree* tpcTree = fTPCLoader->TreeR();
443   if (!tpcTree) {
444     Error("RunTracking", "Can't get the TPC cluster tree");
445     return kFALSE;
446   }
447   fTPCTracker->LoadClusters(tpcTree);
448   if (fTPCTracker->Clusters2Tracks(esd) != 0) {
449     Error("RunTracking", "TPC Clusters2Tracks failed");
450     return kFALSE;
451   }
452   if (fCheckPointLevel > 1) WriteESD(esd, "TPC.tracking");
453
454   if (!fITSTracker) {
455     Warning("RunTracking", "no ITS tracker");
456   } else {
457
458     fRunLoader->GetAliRun()->GetDetector("TPC")->FillESD(esd); // preliminary
459     AliESDpid::MakePID(esd);                  // PID for the ITS tracker
460
461     // ITS tracking
462     Info("RunTracking", "ITS tracking");
463     fITSLoader->LoadRecPoints("read");
464     TTree* itsTree = fITSLoader->TreeR();
465     if (!itsTree) {
466       Error("RunTracking", "Can't get the ITS cluster tree");
467       return kFALSE;
468     }
469     fITSTracker->LoadClusters(itsTree);
470     if (fITSTracker->Clusters2Tracks(esd) != 0) {
471       Error("RunTracking", "ITS Clusters2Tracks failed");
472       return kFALSE;
473     }
474     if (fCheckPointLevel > 1) WriteESD(esd, "ITS.tracking");
475
476     if (!fTRDTracker) {
477       Warning("RunTracking", "no TRD tracker");
478     } else {
479       // ITS back propagation
480       Info("RunTracking", "ITS back propagation");
481       if (fITSTracker->PropagateBack(esd) != 0) {
482         Error("RunTracking", "ITS backward propagation failed");
483         return kFALSE;
484       }
485       if (fCheckPointLevel > 1) WriteESD(esd, "ITS.back");
486
487       // TPC back propagation
488       Info("RunTracking", "TPC back propagation");
489       if (fTPCTracker->PropagateBack(esd) != 0) {
490         Error("RunTracking", "TPC backward propagation failed");
491         return kFALSE;
492       }
493       if (fCheckPointLevel > 1) WriteESD(esd, "TPC.back");
494
495       // TRD back propagation
496       Info("RunTracking", "TRD back propagation");
497       fTRDLoader->LoadRecPoints("read");
498       TTree* trdTree = fTRDLoader->TreeR();
499       if (!trdTree) {
500         Error("RunTracking", "Can't get the TRD cluster tree");
501         return kFALSE;
502       }
503       fTRDTracker->LoadClusters(trdTree);
504       if (fTRDTracker->PropagateBack(esd) != 0) {
505         Error("RunTracking", "TRD backward propagation failed");
506         return kFALSE;
507       }
508       if (fCheckPointLevel > 1) WriteESD(esd, "TRD.back");
509
510       if (!fTOFTracker) {
511         Warning("RunTracking", "no TOF tracker");
512       } else {
513         // TOF back propagation
514         Info("RunTracking", "TOF back propagation");
515         fTOFLoader->LoadDigits("read");
516         TTree* tofTree = fTOFLoader->TreeD();
517         if (!tofTree) {
518           Error("RunTracking", "Can't get the TOF digits tree");
519           return kFALSE;
520         }
521         fTOFTracker->LoadClusters(tofTree);
522         if (fTOFTracker->PropagateBack(esd) != 0) {
523           Error("RunTracking", "TOF backward propagation failed");
524           return kFALSE;
525         }
526         if (fCheckPointLevel > 1) WriteESD(esd, "TOF.back");
527         fTOFTracker->UnloadClusters();
528         fTOFLoader->UnloadDigits();
529       }
530
531       // TRD inward refit
532       Info("RunTracking", "TRD inward refit");
533       if (fTRDTracker->RefitInward(esd) != 0) {
534         Error("RunTracking", "TRD inward refit failed");
535         return kFALSE;
536       }
537       if (fCheckPointLevel > 1) WriteESD(esd, "TRD.refit");
538       fTRDTracker->UnloadClusters();
539       fTRDLoader->UnloadRecPoints();
540     
541       // TPC inward refit
542       Info("RunTracking", "TPC inward refit");
543       if (fTPCTracker->RefitInward(esd) != 0) {
544         Error("RunTracking", "TPC inward refit failed");
545         return kFALSE;
546       }
547       if (fCheckPointLevel > 1) WriteESD(esd, "TPC.refit");
548     
549       // ITS inward refit
550       Info("RunTracking", "ITS inward refit");
551       if (fITSTracker->RefitInward(esd) != 0) {
552         Error("RunTracking", "ITS inward refit failed");
553         return kFALSE;
554       }
555       if (fCheckPointLevel > 1) WriteESD(esd, "ITS.refit");
556
557     }  // if TRD tracker
558     fITSTracker->UnloadClusters();
559     fITSLoader->UnloadRecPoints();
560
561   }  // if ITS tracker
562   fTPCTracker->UnloadClusters();
563   fTPCLoader->UnloadRecPoints();
564
565   Info("RunTracking", "execution time:");
566   stopwatch.Print();
567
568   return kTRUE;
569 }
570
571 //_____________________________________________________________________________
572 Bool_t AliReconstruction::FillESD(AliESD*& esd, const TString& detectors)
573 {
574 // fill the event summary data
575
576   TStopwatch stopwatch;
577   stopwatch.Start();
578
579   TString detStr = detectors;
580   for (Int_t iDet = 0; iDet < fReconstructors.GetEntriesFast(); iDet++) {
581     AliReconstructor* reconstructor = 
582       (AliReconstructor*) fReconstructors[iDet];
583     TString detName = reconstructor->GetDetectorName();
584     if (IsSelected(detName, detStr)) {
585       if (!ReadESD(esd, detName.Data())) {
586         Info("FillESD", "filling ESD for %s", detName.Data());
587         reconstructor->FillESD(fRunLoader, esd);
588         if (fCheckPointLevel > 2) WriteESD(esd, detName.Data());
589       }
590     }
591   }
592
593   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
594     Error("FillESD", "the following detectors were not found: %s", 
595           detStr.Data());
596     if (fStopOnError) return kFALSE;
597   }
598
599   Info("FillESD", "execution time:");
600   stopwatch.Print();
601
602   return kTRUE;
603 }
604
605
606 //_____________________________________________________________________________
607 Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
608 {
609 // check whether detName is contained in detectors
610 // if yes, it is removed from detectors
611
612   // check if all detectors are selected
613   if ((detectors.CompareTo("ALL") == 0) ||
614       detectors.BeginsWith("ALL ") ||
615       detectors.EndsWith(" ALL") ||
616       detectors.Contains(" ALL ")) {
617     detectors = "ALL";
618     return kTRUE;
619   }
620
621   // search for the given detector
622   Bool_t result = kFALSE;
623   if ((detectors.CompareTo(detName) == 0) ||
624       detectors.BeginsWith(detName+" ") ||
625       detectors.EndsWith(" "+detName) ||
626       detectors.Contains(" "+detName+" ")) {
627     detectors.ReplaceAll(detName, "");
628     result = kTRUE;
629   }
630
631   // clean up the detectors string
632   while (detectors.Contains("  ")) detectors.ReplaceAll("  ", " ");
633   while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
634   while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
635
636   return result;
637 }
638
639 //_____________________________________________________________________________
640 AliReconstructor* AliReconstruction::GetReconstructor(const char* detName) const
641 {
642 // get the reconstructor object for a detector
643
644   for (Int_t iDet = 0; iDet < fReconstructors.GetEntriesFast(); iDet++) {
645     AliReconstructor* reconstructor = 
646       (AliReconstructor*) fReconstructors[iDet];
647     if (strcmp(reconstructor->GetDetectorName(), detName) == 0) {
648       return reconstructor;
649     }
650   }
651   return NULL;
652 }
653
654 //_____________________________________________________________________________
655 Bool_t AliReconstruction::CreateVertexer()
656 {
657 // create the vertexer
658
659   fITSVertexer = NULL;
660   AliReconstructor* itsReconstructor = GetReconstructor("ITS");
661   if (itsReconstructor) {
662     fITSVertexer = itsReconstructor->CreateVertexer(fRunLoader);
663   }
664   if (!fITSVertexer) {
665     Warning("CreateVertexer", "couldn't create a vertexer for ITS");
666     if (fStopOnError) return kFALSE;
667   }
668
669   return kTRUE;
670 }
671
672 //_____________________________________________________________________________
673 Bool_t AliReconstruction::CreateTrackers()
674 {
675 // get the loaders and create the trackers
676
677   fITSTracker = NULL;
678   fITSLoader = fRunLoader->GetLoader("ITSLoader");
679   if (!fITSLoader) {
680     Warning("CreateTrackers", "no ITS loader found");
681     if (fStopOnError) return kFALSE;
682   } else {
683     AliReconstructor* itsReconstructor = GetReconstructor("ITS");
684     if (itsReconstructor) {
685       fITSTracker = itsReconstructor->CreateTracker(fRunLoader);
686     }
687     if (!fITSTracker) {
688       Warning("CreateTrackers", "couldn't create a tracker for ITS");
689       if (fStopOnError) return kFALSE;
690     }
691   }
692     
693   fTPCTracker = NULL;
694   fTPCLoader = fRunLoader->GetLoader("TPCLoader");
695   if (!fTPCLoader) {
696     Error("CreateTrackers", "no TPC loader found");
697     if (fStopOnError) return kFALSE;
698   } else {
699     AliReconstructor* tpcReconstructor = GetReconstructor("TPC");
700     if (tpcReconstructor) {
701       fTPCTracker = tpcReconstructor->CreateTracker(fRunLoader);
702     }
703     if (!fTPCTracker) {
704       Error("CreateTrackers", "couldn't create a tracker for TPC");
705       if (fStopOnError) return kFALSE;
706     }
707   }
708     
709   fTRDTracker = NULL;
710   fTRDLoader = fRunLoader->GetLoader("TRDLoader");
711   if (!fTRDLoader) {
712     Warning("CreateTrackers", "no TRD loader found");
713     if (fStopOnError) return kFALSE;
714   } else {
715     AliReconstructor* trdReconstructor = GetReconstructor("TRD");
716     if (trdReconstructor) {
717       fTRDTracker = trdReconstructor->CreateTracker(fRunLoader);
718     }
719     if (!fTRDTracker) {
720       Warning("CreateTrackers", "couldn't create a tracker for TRD");
721       if (fStopOnError) return kFALSE;
722     }
723   }
724     
725   fTOFTracker = NULL;
726   fTOFLoader = fRunLoader->GetLoader("TOFLoader");
727   if (!fTOFLoader) {
728     Warning("CreateTrackers", "no TOF loader found");
729     if (fStopOnError) return kFALSE;
730   } else {
731     AliReconstructor* tofReconstructor = GetReconstructor("TOF");
732     if (tofReconstructor) {
733       fTOFTracker = tofReconstructor->CreateTracker(fRunLoader);
734     }
735     if (!fTOFTracker) {
736       Warning("CreateTrackers", "couldn't create a tracker for TOF");
737       if (fStopOnError) return kFALSE;
738     }
739   }
740
741   return kTRUE;
742 }
743
744 //_____________________________________________________________________________
745 void AliReconstruction::CleanUp(TFile* file)
746 {
747 // delete trackers and the run loader and close and delete the file
748
749   fReconstructors.Delete();
750
751   delete fITSVertexer;
752   fITSVertexer = NULL;
753   delete fITSTracker;
754   fITSTracker = NULL;
755   delete fTPCTracker;
756   fTPCTracker = NULL;
757   delete fTRDTracker;
758   fTRDTracker = NULL;
759   delete fTOFTracker;
760   fTOFTracker = NULL;
761
762   delete fRunLoader;
763   fRunLoader = NULL;
764
765   if (file) {
766     file->Close();
767     delete file;
768   }
769 }
770
771
772 //_____________________________________________________________________________
773 Bool_t AliReconstruction::ReadESD(AliESD*& esd, const char* recStep) const
774 {
775 // read the ESD event from a file
776
777   if (!esd) return kFALSE;
778   char fileName[256];
779   sprintf(fileName, "ESD_%d.%d_%s.root", 
780           esd->GetRunNumber(), esd->GetEventNumber(), recStep);
781   if (gSystem->AccessPathName(fileName)) return kFALSE;
782
783   Info("ReadESD", "reading ESD from file %s", fileName);
784   TFile* file = TFile::Open(fileName);
785   if (!file || !file->IsOpen()) {
786     Error("ReadESD", "opening %s failed", fileName);
787     delete file;
788     return kFALSE;
789   }
790
791   gROOT->cd();
792   delete esd;
793   esd = (AliESD*) file->Get("ESD");
794   file->Close();
795   delete file;
796   return kTRUE;
797 }
798
799 //_____________________________________________________________________________
800 void AliReconstruction::WriteESD(AliESD* esd, const char* recStep) const
801 {
802 // write the ESD event to a file
803
804   if (!esd) return;
805   char fileName[256];
806   sprintf(fileName, "ESD_%d.%d_%s.root", 
807           esd->GetRunNumber(), esd->GetEventNumber(), recStep);
808
809   Info("WriteESD", "writing ESD to file %s", fileName);
810   TFile* file = TFile::Open(fileName, "recreate");
811   if (!file || !file->IsOpen()) {
812     Error("WriteESD", "opening %s failed", fileName);
813   } else {
814     esd->Write("ESD");
815     file->Close();
816   }
817   delete file;
818 }