1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 ///////////////////////////////////////////////////////////////////////////////
20 // class for running the reconstruction //
22 // Clusters and tracks are created for all detectors and all events by //
25 // AliReconstruction rec; //
28 // The Run method returns kTRUE in case of successful execution. //
30 // If the input to the reconstruction are not simulated digits but raw data, //
31 // this can be specified by an argument of the Run method or by the method //
33 // rec.SetInput("..."); //
35 // The input formats and the corresponding argument are: //
36 // - DDL raw data files: directory name, ends with "/" //
37 // - raw data root file: root file name, extension ".root" //
38 // - raw data DATE file: DATE file name, any other non-empty string //
39 // - MC root files : empty string, default //
41 // By default all events are reconstructed. The reconstruction can be //
42 // limited to a range of events by giving the index of the first and the //
43 // last event as an argument to the Run method or by calling //
45 // rec.SetEventRange(..., ...); //
47 // The index -1 (default) can be used for the last event to indicate no //
48 // upper limit of the event range. //
50 // The name of the galice file can be changed from the default //
51 // "galice.root" by passing it as argument to the AliReconstruction //
52 // constructor or by //
54 // rec.SetGAliceFile("..."); //
56 // The local reconstruction can be switched on or off for individual //
59 // rec.SetRunLocalReconstruction("..."); //
61 // The argument is a (case sensitive) string with the names of the //
62 // detectors separated by a space. The special string "ALL" selects all //
63 // available detectors. This is the default. //
65 // The reconstruction of the primary vertex position can be switched off by //
67 // rec.SetRunVertexFinder(kFALSE); //
69 // The tracking and the creation of ESD tracks can be switched on for //
70 // selected detectors by //
72 // rec.SetRunTracking("..."); //
74 // The filling of additional ESD information can be steered by //
76 // rec.SetFillESD("..."); //
78 // Again, for both methods the string specifies the list of detectors. //
79 // The default is "ALL". //
81 // The call of the shortcut method //
83 // rec.SetRunReconstruction("..."); //
85 // is equivalent to calling SetRunLocalReconstruction, SetRunTracking and //
86 // SetFillESD with the same detector selecting string as argument. //
88 // The reconstruction requires digits or raw data as input. For the creation //
89 // of digits and raw data have a look at the class AliSimulation. //
91 // For debug purposes the method SetCheckPointLevel can be used. If the //
92 // argument is greater than 0, files with ESD events will be written after //
93 // selected steps of the reconstruction for each event: //
94 // level 1: after tracking and after filling of ESD (final) //
95 // level 2: in addition after each tracking step //
96 // level 3: in addition after the filling of ESD for each detector //
97 // If a final check point file exists for an event, this event will be //
98 // skipped in the reconstruction. The tracking and the filling of ESD for //
99 // a detector will be skipped as well, if the corresponding check point //
100 // file exists. The ESD event will then be loaded from the file instead. //
102 ///////////////////////////////////////////////////////////////////////////////
108 #include <TPluginManager.h>
109 #include <TStopwatch.h>
111 #include "AliReconstruction.h"
112 #include "AliReconstructor.h"
114 #include "AliRunLoader.h"
116 #include "AliRawReaderFile.h"
117 #include "AliRawReaderDate.h"
118 #include "AliRawReaderRoot.h"
119 #include "AliTracker.h"
121 #include "AliESDVertex.h"
122 #include "AliVertexer.h"
123 #include "AliHeader.h"
124 #include "AliGenEventHeader.h"
126 #include "AliESDpid.h"
129 ClassImp(AliReconstruction)
132 //_____________________________________________________________________________
133 const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "RICH", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "START", "VZERO", "CRT", "HLT"};
135 //_____________________________________________________________________________
136 AliReconstruction::AliReconstruction(const char* gAliceFilename,
137 const char* name, const char* title) :
140 fRunLocalReconstruction("ALL"),
141 fRunVertexFinder(kTRUE),
142 fRunHLTTracking(kFALSE),
145 fGAliceFileName(gAliceFilename),
149 fStopOnError(kFALSE),
158 // create reconstruction object with default parameters
160 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
161 fReconstructor[iDet] = NULL;
162 fLoader[iDet] = NULL;
163 fTracker[iDet] = NULL;
168 //_____________________________________________________________________________
169 AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
172 fRunLocalReconstruction(rec.fRunLocalReconstruction),
173 fRunVertexFinder(rec.fRunVertexFinder),
174 fRunHLTTracking(rec.fRunHLTTracking),
175 fRunTracking(rec.fRunTracking),
176 fFillESD(rec.fFillESD),
177 fGAliceFileName(rec.fGAliceFileName),
179 fFirstEvent(rec.fFirstEvent),
180 fLastEvent(rec.fLastEvent),
181 fStopOnError(rec.fStopOnError),
192 for (Int_t i = 0; i < fOptions.GetEntriesFast(); i++) {
193 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
195 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
196 fReconstructor[iDet] = NULL;
197 fLoader[iDet] = NULL;
198 fTracker[iDet] = NULL;
202 //_____________________________________________________________________________
203 AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
205 // assignment operator
207 this->~AliReconstruction();
208 new(this) AliReconstruction(rec);
212 //_____________________________________________________________________________
213 AliReconstruction::~AliReconstruction()
222 //_____________________________________________________________________________
223 void AliReconstruction::SetGAliceFile(const char* fileName)
225 // set the name of the galice file
227 fGAliceFileName = fileName;
230 //_____________________________________________________________________________
231 void AliReconstruction::SetOption(const char* detector, const char* option)
233 // set options for the reconstruction of a detector
235 TObject* obj = fOptions.FindObject(detector);
236 if (obj) fOptions.Remove(obj);
237 fOptions.Add(new TNamed(detector, option));
241 //_____________________________________________________________________________
242 Bool_t AliReconstruction::Run(const char* input,
243 Int_t firstEvent, Int_t lastEvent)
245 // run the reconstruction
248 if (!input) input = fInput.Data();
249 TString fileName(input);
250 if (fileName.EndsWith("/")) {
251 fRawReader = new AliRawReaderFile(fileName);
252 } else if (fileName.EndsWith(".root")) {
253 fRawReader = new AliRawReaderRoot(fileName);
254 } else if (!fileName.IsNull()) {
255 fRawReader = new AliRawReaderDate(fileName);
256 fRawReader->SelectEvents(7);
259 // get the run loader
260 if (!InitRunLoader()) return kFALSE;
262 // local reconstruction
263 if (!fRunLocalReconstruction.IsNull()) {
264 if (!RunLocalReconstruction(fRunLocalReconstruction)) {
265 if (fStopOnError) {CleanUp(); return kFALSE;}
268 // if (!fRunVertexFinder && fRunTracking.IsNull() &&
269 // fFillESD.IsNull()) return kTRUE;
272 if (fRunVertexFinder && !CreateVertexer()) {
280 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
287 // get the possibly already existing ESD file and tree
288 AliESD* esd = new AliESD; AliESD* hltesd = new AliESD;
289 TFile* fileOld = NULL;
290 TTree* treeOld = NULL; TTree *hlttreeOld = NULL;
291 if (!gSystem->AccessPathName("AliESDs.root")){
292 gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE);
293 fileOld = TFile::Open("AliESDs.old.root");
294 if (fileOld && fileOld->IsOpen()) {
295 treeOld = (TTree*) fileOld->Get("esdTree");
296 if (treeOld) treeOld->SetBranchAddress("ESD", &esd);
297 hlttreeOld = (TTree*) fileOld->Get("HLTesdTree");
298 if (hlttreeOld) hlttreeOld->SetBranchAddress("ESD", &hltesd);
302 // create the ESD output file and tree
303 TFile* file = TFile::Open("AliESDs.root", "RECREATE");
304 if (!file->IsOpen()) {
305 AliError("opening AliESDs.root failed");
306 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
308 TTree* tree = new TTree("esdTree", "Tree with ESD objects");
309 tree->Branch("ESD", "AliESD", &esd);
310 TTree* hlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
311 hlttree->Branch("ESD", "AliESD", &hltesd);
312 delete esd; delete hltesd;
313 esd = NULL; hltesd = NULL;
317 if (fRawReader) fRawReader->RewindEvents();
319 for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) {
320 if (fRawReader) fRawReader->NextEvent();
321 if ((iEvent < firstEvent) || ((lastEvent >= 0) && (iEvent > lastEvent))) {
322 // copy old ESD to the new one
324 treeOld->SetBranchAddress("ESD", &esd);
325 treeOld->GetEntry(iEvent);
329 hlttreeOld->SetBranchAddress("ESD", &hltesd);
330 hlttreeOld->GetEntry(iEvent);
336 AliInfo(Form("processing event %d", iEvent));
337 fRunLoader->GetEvent(iEvent);
340 sprintf(fileName, "ESD_%d.%d_final.root",
341 fRunLoader->GetHeader()->GetRun(),
342 fRunLoader->GetHeader()->GetEventNrInRun());
343 if (!gSystem->AccessPathName(fileName)) continue;
345 // local reconstruction
346 if (!fRunLocalReconstruction.IsNull()) {
347 if (!RunLocalEventReconstruction(fRunLocalReconstruction)) {
348 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
352 esd = new AliESD; hltesd = new AliESD;
353 esd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
354 hltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
355 esd->SetEventNumber(fRunLoader->GetHeader()->GetEventNrInRun());
356 hltesd->SetEventNumber(fRunLoader->GetHeader()->GetEventNrInRun());
358 esd->SetMagneticField(gAlice->Field()->SolenoidField());
359 hltesd->SetMagneticField(gAlice->Field()->SolenoidField());
365 if (fRunVertexFinder) {
366 if (!ReadESD(esd, "vertex")) {
367 if (!RunVertexFinder(esd)) {
368 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
370 if (fCheckPointLevel > 0) WriteESD(esd, "vertex");
375 if (!fRunTracking.IsNull()) {
376 if (fRunHLTTracking) {
377 hltesd->SetVertex(esd->GetVertex());
378 if (!RunHLTTracking(hltesd)) {
379 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
385 if (!fRunTracking.IsNull()) {
386 if (!ReadESD(esd, "tracking")) {
387 if (!RunTracking(esd)) {
388 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
390 if (fCheckPointLevel > 0) WriteESD(esd, "tracking");
395 if (!fFillESD.IsNull()) {
396 if (!FillESD(esd, fFillESD)) {
397 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
402 AliESDpid::MakePID(esd);
403 if (fCheckPointLevel > 1) WriteESD(esd, "PID");
410 if (fCheckPointLevel > 0) WriteESD(esd, "final");
411 delete esd; delete hltesd;
412 esd = NULL; hltesd = NULL;
418 CleanUp(file, fileOld);
424 //_____________________________________________________________________________
425 Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors)
427 // run the local reconstruction
429 TStopwatch stopwatch;
432 TString detStr = detectors;
433 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
434 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
435 AliReconstructor* reconstructor = GetReconstructor(iDet);
436 if (!reconstructor) continue;
437 if (reconstructor->HasLocalReconstruction()) continue;
439 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
440 TStopwatch stopwatchDet;
441 stopwatchDet.Start();
443 fRawReader->RewindEvents();
444 reconstructor->Reconstruct(fRunLoader, fRawReader);
446 reconstructor->Reconstruct(fRunLoader);
448 AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs",
449 fgkDetectorName[iDet],
450 stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
453 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
454 AliError(Form("the following detectors were not found: %s",
456 if (fStopOnError) return kFALSE;
459 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
460 stopwatch.RealTime(),stopwatch.CpuTime()));
465 //_____________________________________________________________________________
466 Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
468 // run the local reconstruction
470 TStopwatch stopwatch;
473 TString detStr = detectors;
474 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
475 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
476 AliReconstructor* reconstructor = GetReconstructor(iDet);
477 if (!reconstructor) continue;
478 AliLoader* loader = fLoader[iDet];
480 // conversion of digits
481 if (fRawReader && reconstructor->HasDigitConversion()) {
482 AliInfo(Form("converting raw data digits into root objects for %s",
483 fgkDetectorName[iDet]));
484 TStopwatch stopwatchDet;
485 stopwatchDet.Start();
486 loader->LoadDigits("update");
487 loader->CleanDigits();
488 loader->MakeDigitsContainer();
489 TTree* digitsTree = loader->TreeD();
490 reconstructor->ConvertDigits(fRawReader, digitsTree);
491 loader->WriteDigits("OVERWRITE");
492 loader->UnloadDigits();
493 AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs",
494 fgkDetectorName[iDet],
495 stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
498 // local reconstruction
499 if (!reconstructor->HasLocalReconstruction()) continue;
500 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
501 TStopwatch stopwatchDet;
502 stopwatchDet.Start();
503 loader->LoadRecPoints("update");
504 loader->CleanRecPoints();
505 loader->MakeRecPointsContainer();
506 TTree* clustersTree = loader->TreeR();
507 if (fRawReader && !reconstructor->HasDigitConversion()) {
508 reconstructor->Reconstruct(fRawReader, clustersTree);
510 loader->LoadDigits("read");
511 TTree* digitsTree = loader->TreeD();
513 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
514 if (fStopOnError) return kFALSE;
516 reconstructor->Reconstruct(digitsTree, clustersTree);
518 loader->UnloadDigits();
520 loader->WriteRecPoints("OVERWRITE");
521 loader->UnloadRecPoints();
522 AliDebug(1,Form("Execution time for %s: R:%.2fs C:%.2fs",
523 fgkDetectorName[iDet],
524 stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
527 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
528 AliError(Form("the following detectors were not found: %s",
530 if (fStopOnError) return kFALSE;
533 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
534 stopwatch.RealTime(),stopwatch.CpuTime()));
539 //_____________________________________________________________________________
540 Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd)
542 // run the barrel tracking
544 TStopwatch stopwatch;
547 AliESDVertex* vertex = NULL;
548 Double_t vtxPos[3] = {0, 0, 0};
549 Double_t vtxErr[3] = {0.07, 0.07, 0.1};
551 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
552 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
553 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
557 AliInfo("running the ITS vertex finder");
558 if (fLoader[0]) fLoader[0]->LoadRecPoints();
559 vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
560 if (fLoader[0]) fLoader[0]->UnloadRecPoints();
562 AliWarning("Vertex not found");
563 vertex = new AliESDVertex();
566 vertex->SetTruePos(vtxPos); // store also the vertex from MC
570 AliInfo("getting the primary vertex from MC");
571 vertex = new AliESDVertex(vtxPos, vtxErr);
575 vertex->GetXYZ(vtxPos);
576 vertex->GetSigmaXYZ(vtxErr);
578 AliWarning("no vertex reconstructed");
579 vertex = new AliESDVertex(vtxPos, vtxErr);
581 esd->SetVertex(vertex);
582 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
583 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
587 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
588 stopwatch.RealTime(),stopwatch.CpuTime()));
593 //_____________________________________________________________________________
594 Bool_t AliReconstruction::RunHLTTracking(AliESD*& esd)
596 // run the HLT barrel tracking
598 TStopwatch stopwatch;
602 AliError("Missing runLoader!");
606 AliInfo("running HLT tracking");
608 // Get a pointer to the HLT reconstructor
609 AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
610 if (!reconstructor) return kFALSE;
613 for (Int_t iDet = 1; iDet >= 0; iDet--) {
614 TString detName = fgkDetectorName[iDet];
615 AliDebug(1, Form("%s HLT tracking", detName.Data()));
616 reconstructor->SetOption(detName.Data());
617 AliTracker *tracker = reconstructor->CreateTracker(fRunLoader);
619 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
620 if (fStopOnError) return kFALSE;
624 Double_t vtxErr[3]={0.005,0.005,0.010};
625 const AliESDVertex *vertex = esd->GetVertex();
626 vertex->GetXYZ(vtxPos);
627 tracker->SetVertex(vtxPos,vtxErr);
629 fLoader[iDet]->LoadRecPoints("read");
630 TTree* tree = fLoader[iDet]->TreeR();
632 AliError(Form("Can't get the %s cluster tree", detName.Data()));
635 tracker->LoadClusters(tree);
637 if (tracker->Clusters2Tracks(esd) != 0) {
638 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
642 tracker->UnloadClusters();
647 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
648 stopwatch.RealTime(),stopwatch.CpuTime()));
653 //_____________________________________________________________________________
654 Bool_t AliReconstruction::RunTracking(AliESD*& esd)
656 // run the barrel tracking
658 TStopwatch stopwatch;
661 AliInfo("running tracking");
663 // pass 1: TPC + ITS inwards
664 for (Int_t iDet = 1; iDet >= 0; iDet--) {
665 if (!fTracker[iDet]) continue;
666 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
669 fLoader[iDet]->LoadRecPoints("read");
670 TTree* tree = fLoader[iDet]->TreeR();
672 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
675 fTracker[iDet]->LoadClusters(tree);
678 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
679 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
682 if (fCheckPointLevel > 1) {
683 WriteESD(esd, Form("%s.tracking", fgkDetectorName[iDet]));
685 // preliminary PID in TPC needed by the ITS tracker
687 GetReconstructor(1)->FillESD(fRunLoader, esd);
688 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
689 AliESDpid::MakePID(esd);
693 // pass 2: ALL backwards
694 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
695 if (!fTracker[iDet]) continue;
696 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
699 if (iDet > 1) { // all except ITS, TPC
701 if (iDet == 3) { // TOF
702 fLoader[iDet]->LoadDigits("read");
703 tree = fLoader[iDet]->TreeD();
705 fLoader[iDet]->LoadRecPoints("read");
706 tree = fLoader[iDet]->TreeR();
709 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
712 fTracker[iDet]->LoadClusters(tree);
716 if (fTracker[iDet]->PropagateBack(esd) != 0) {
717 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
720 if (fCheckPointLevel > 1) {
721 WriteESD(esd, Form("%s.back", fgkDetectorName[iDet]));
725 if (iDet > 2) { // all except ITS, TPC, TRD
726 fTracker[iDet]->UnloadClusters();
727 if (iDet == 3) { // TOF
728 fLoader[iDet]->UnloadDigits();
730 fLoader[iDet]->UnloadRecPoints();
735 // pass 3: TRD + TPC + ITS refit inwards
736 for (Int_t iDet = 2; iDet >= 0; iDet--) {
737 if (!fTracker[iDet]) continue;
738 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
741 if (fTracker[iDet]->RefitInward(esd) != 0) {
742 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
745 if (fCheckPointLevel > 1) {
746 WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet]));
750 fTracker[iDet]->UnloadClusters();
751 fLoader[iDet]->UnloadRecPoints();
754 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
755 stopwatch.RealTime(),stopwatch.CpuTime()));
760 //_____________________________________________________________________________
761 Bool_t AliReconstruction::FillESD(AliESD*& esd, const TString& detectors)
763 // fill the event summary data
765 TStopwatch stopwatch;
767 AliInfo("filling ESD");
769 TString detStr = detectors;
770 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
771 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
772 AliReconstructor* reconstructor = GetReconstructor(iDet);
773 if (!reconstructor) continue;
775 if (!ReadESD(esd, fgkDetectorName[iDet])) {
776 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
777 TTree* clustersTree = NULL;
778 if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) {
779 fLoader[iDet]->LoadRecPoints("read");
780 clustersTree = fLoader[iDet]->TreeR();
782 AliError(Form("Can't get the %s clusters tree",
783 fgkDetectorName[iDet]));
784 if (fStopOnError) return kFALSE;
787 if (fRawReader && !reconstructor->HasDigitConversion()) {
788 reconstructor->FillESD(fRawReader, clustersTree, esd);
790 TTree* digitsTree = NULL;
792 fLoader[iDet]->LoadDigits("read");
793 digitsTree = fLoader[iDet]->TreeD();
795 AliError(Form("Can't get the %s digits tree",
796 fgkDetectorName[iDet]));
797 if (fStopOnError) return kFALSE;
800 reconstructor->FillESD(digitsTree, clustersTree, esd);
801 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
803 if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) {
804 fLoader[iDet]->UnloadRecPoints();
808 reconstructor->FillESD(fRunLoader, fRawReader, esd);
810 reconstructor->FillESD(fRunLoader, esd);
812 if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
816 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
817 AliError(Form("the following detectors were not found: %s",
819 if (fStopOnError) return kFALSE;
822 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
823 stopwatch.RealTime(),stopwatch.CpuTime()));
829 //_____________________________________________________________________________
830 Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
832 // check whether detName is contained in detectors
833 // if yes, it is removed from detectors
835 // check if all detectors are selected
836 if ((detectors.CompareTo("ALL") == 0) ||
837 detectors.BeginsWith("ALL ") ||
838 detectors.EndsWith(" ALL") ||
839 detectors.Contains(" ALL ")) {
844 // search for the given detector
845 Bool_t result = kFALSE;
846 if ((detectors.CompareTo(detName) == 0) ||
847 detectors.BeginsWith(detName+" ") ||
848 detectors.EndsWith(" "+detName) ||
849 detectors.Contains(" "+detName+" ")) {
850 detectors.ReplaceAll(detName, "");
854 // clean up the detectors string
855 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
856 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
857 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
862 //_____________________________________________________________________________
863 Bool_t AliReconstruction::InitRunLoader()
865 // get or create the run loader
867 if (gAlice) delete gAlice;
870 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
871 // load all base libraries to get the loader classes
872 TString libs = gSystem->GetLibraries();
873 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
874 TString detName = fgkDetectorName[iDet];
875 if (detName == "HLT") continue;
876 if (libs.Contains("lib" + detName + "base.so")) continue;
877 gSystem->Load("lib" + detName + "base.so");
879 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
881 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
885 fRunLoader->CdGAFile();
886 if (gFile->GetKey(AliRunLoader::GetGAliceName())) {
887 if (fRunLoader->LoadgAlice() == 0) {
888 gAlice = fRunLoader->GetAliRun();
889 AliTracker::SetFieldMap(gAlice->Field());
892 if (!gAlice && !fRawReader) {
893 AliError(Form("no gAlice object found in file %s",
894 fGAliceFileName.Data()));
899 } else { // galice.root does not exist
901 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
905 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
906 AliConfig::GetDefaultEventFolderName(),
909 AliError(Form("could not create run loader in file %s",
910 fGAliceFileName.Data()));
914 fRunLoader->MakeTree("E");
916 while (fRawReader->NextEvent()) {
917 fRunLoader->SetEventNumber(iEvent);
918 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
920 fRunLoader->MakeTree("H");
921 fRunLoader->TreeE()->Fill();
924 fRawReader->RewindEvents();
925 fRunLoader->WriteHeader("OVERWRITE");
926 fRunLoader->CdGAFile();
927 fRunLoader->Write(0, TObject::kOverwrite);
928 // AliTracker::SetFieldMap(???);
934 //_____________________________________________________________________________
935 AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
937 // get the reconstructor object and the loader for a detector
939 if (fReconstructor[iDet]) return fReconstructor[iDet];
941 // load the reconstructor object
942 TPluginManager* pluginManager = gROOT->GetPluginManager();
943 TString detName = fgkDetectorName[iDet];
944 TString recName = "Ali" + detName + "Reconstructor";
945 if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) return NULL;
947 if (detName == "HLT") {
948 if (!gROOT->GetClass("AliLevel3")) {
949 gSystem->Load("libAliL3Src.so");
950 gSystem->Load("libAliL3Misc.so");
951 gSystem->Load("libAliL3Hough.so");
952 gSystem->Load("libAliL3Comp.so");
956 AliReconstructor* reconstructor = NULL;
957 // first check if a plugin is defined for the reconstructor
958 TPluginHandler* pluginHandler =
959 pluginManager->FindHandler("AliReconstructor", detName);
960 // if not, add a plugin for it
961 if (!pluginHandler) {
962 AliDebug(1, Form("defining plugin for %s", recName.Data()));
963 TString libs = gSystem->GetLibraries();
964 if (libs.Contains("lib" + detName + "base.so") ||
965 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
966 pluginManager->AddHandler("AliReconstructor", detName,
967 recName, detName + "rec", recName + "()");
969 pluginManager->AddHandler("AliReconstructor", detName,
970 recName, detName, recName + "()");
972 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
974 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
975 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
978 TObject* obj = fOptions.FindObject(detName.Data());
979 if (obj) reconstructor->SetOption(obj->GetTitle());
980 reconstructor->Init(fRunLoader);
981 fReconstructor[iDet] = reconstructor;
984 // get or create the loader
985 if (detName != "HLT") {
986 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
987 if (!fLoader[iDet]) {
988 AliConfig::Instance()
989 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
991 // first check if a plugin is defined for the loader
992 TPluginHandler* pluginHandler =
993 pluginManager->FindHandler("AliLoader", detName);
994 // if not, add a plugin for it
995 if (!pluginHandler) {
996 TString loaderName = "Ali" + detName + "Loader";
997 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
998 pluginManager->AddHandler("AliLoader", detName,
999 loaderName, detName + "base",
1000 loaderName + "(const char*, TFolder*)");
1001 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
1003 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
1005 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
1006 fRunLoader->GetEventFolder());
1008 if (!fLoader[iDet]) { // use default loader
1009 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
1011 if (!fLoader[iDet]) {
1012 AliWarning(Form("couldn't get loader for %s", detName.Data()));
1013 if (fStopOnError) return NULL;
1015 fRunLoader->AddLoader(fLoader[iDet]);
1016 fRunLoader->CdGAFile();
1017 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
1018 fRunLoader->Write(0, TObject::kOverwrite);
1023 return reconstructor;
1026 //_____________________________________________________________________________
1027 Bool_t AliReconstruction::CreateVertexer()
1029 // create the vertexer
1032 AliReconstructor* itsReconstructor = GetReconstructor(0);
1033 if (itsReconstructor) {
1034 fVertexer = itsReconstructor->CreateVertexer(fRunLoader);
1037 AliWarning("couldn't create a vertexer for ITS");
1038 if (fStopOnError) return kFALSE;
1044 //_____________________________________________________________________________
1045 Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
1047 // create the trackers
1049 TString detStr = detectors;
1050 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1051 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1052 AliReconstructor* reconstructor = GetReconstructor(iDet);
1053 if (!reconstructor) continue;
1054 TString detName = fgkDetectorName[iDet];
1055 if (detName == "HLT") {
1056 fRunHLTTracking = kTRUE;
1060 fTracker[iDet] = reconstructor->CreateTracker(fRunLoader);
1061 if (!fTracker[iDet] && (iDet < 7)) {
1062 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
1063 if (fStopOnError) return kFALSE;
1070 //_____________________________________________________________________________
1071 void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
1073 // delete trackers and the run loader and close and delete the file
1075 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1076 delete fReconstructor[iDet];
1077 fReconstructor[iDet] = NULL;
1078 fLoader[iDet] = NULL;
1079 delete fTracker[iDet];
1080 fTracker[iDet] = NULL;
1098 gSystem->Unlink("AliESDs.old.root");
1103 //_____________________________________________________________________________
1104 Bool_t AliReconstruction::ReadESD(AliESD*& esd, const char* recStep) const
1106 // read the ESD event from a file
1108 if (!esd) return kFALSE;
1110 sprintf(fileName, "ESD_%d.%d_%s.root",
1111 esd->GetRunNumber(), esd->GetEventNumber(), recStep);
1112 if (gSystem->AccessPathName(fileName)) return kFALSE;
1114 AliDebug(1, Form("reading ESD from file %s", fileName));
1115 TFile* file = TFile::Open(fileName);
1116 if (!file || !file->IsOpen()) {
1117 AliError(Form("opening %s failed", fileName));
1124 esd = (AliESD*) file->Get("ESD");
1130 //_____________________________________________________________________________
1131 void AliReconstruction::WriteESD(AliESD* esd, const char* recStep) const
1133 // write the ESD event to a file
1137 sprintf(fileName, "ESD_%d.%d_%s.root",
1138 esd->GetRunNumber(), esd->GetEventNumber(), recStep);
1140 AliDebug(1, Form("writing ESD to file %s", fileName));
1141 TFile* file = TFile::Open(fileName, "recreate");
1142 if (!file || !file->IsOpen()) {
1143 AliError(Form("opening %s failed", fileName));