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