]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - STEER/AliReconstruction.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
option for reconstructors added
[u/mrichter/AliRoot.git] / STEER / AliReconstruction.cxx
... / ...
CommitLineData
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
90ClassImp(AliReconstruction)
91
92
93//_____________________________________________________________________________
94const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "RICH", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "START", "VZERO", "CRT", "HLT"};
95
96//_____________________________________________________________________________
97AliReconstruction::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//_____________________________________________________________________________
128AliReconstruction::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//_____________________________________________________________________________
161AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
162{
163// assignment operator
164
165 this->~AliReconstruction();
166 new(this) AliReconstruction(rec);
167 return *this;
168}
169
170//_____________________________________________________________________________
171AliReconstruction::~AliReconstruction()
172{
173// clean up
174
175 CleanUp();
176 fOptions.Delete();
177}
178
179
180//_____________________________________________________________________________
181void AliReconstruction::SetGAliceFile(const char* fileName)
182{
183// set the name of the galice file
184
185 fGAliceFileName = fileName;
186}
187
188//_____________________________________________________________________________
189void 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//_____________________________________________________________________________
200Bool_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//_____________________________________________________________________________
362Bool_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//_____________________________________________________________________________
398Bool_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//_____________________________________________________________________________
451Bool_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//_____________________________________________________________________________
596Bool_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//_____________________________________________________________________________
631Bool_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//_____________________________________________________________________________
664AliReconstructor* 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//_____________________________________________________________________________
679Bool_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//_____________________________________________________________________________
697Bool_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//_____________________________________________________________________________
769void 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//_____________________________________________________________________________
797Bool_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//_____________________________________________________________________________
824void 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}