]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/AliReconstruction.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Removal of the run-loaders from the algorithmic part of the vertexers code. Some...
[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// //
b26c3770 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 //
44// //
45// rec.SetEventRange(..., ...); //
46// //
47// The index -1 (default) can be used for the last event to indicate no //
48// upper limit of the event range. //
49// //
973388c2 50// In case of raw-data reconstruction the user can modify the default //
51// number of events per digits/clusters/tracks file. In case the option //
52// is not used the number is set 1. In case the user provides 0, than //
53// the number of events is equal to the number of events inside the //
54// raw-data file (i.e. one digits/clusters/tracks file): //
55// //
56// rec.SetNumberOfEventsPerFile(...); //
57// //
58// //
596a855f 59// The name of the galice file can be changed from the default //
e583c30d 60// "galice.root" by passing it as argument to the AliReconstruction //
61// constructor or by //
596a855f 62// //
63// rec.SetGAliceFile("..."); //
64// //
59697224 65// The local reconstruction can be switched on or off for individual //
66// detectors by //
596a855f 67// //
59697224 68// rec.SetRunLocalReconstruction("..."); //
596a855f 69// //
70// The argument is a (case sensitive) string with the names of the //
71// detectors separated by a space. The special string "ALL" selects all //
72// available detectors. This is the default. //
73// //
c71de921 74// The reconstruction of the primary vertex position can be switched off by //
75// //
76// rec.SetRunVertexFinder(kFALSE); //
77// //
b8cd5251 78// The tracking and the creation of ESD tracks can be switched on for //
79// selected detectors by //
596a855f 80// //
b8cd5251 81// rec.SetRunTracking("..."); //
596a855f 82// //
c84a5e9e 83// Uniform/nonuniform field tracking switches (default: uniform field) //
84// //
1d99986f 85// rec.SetUniformFieldTracking(); ( rec.SetUniformFieldTracking(kFALSE); ) //
c84a5e9e 86// //
596a855f 87// The filling of additional ESD information can be steered by //
88// //
89// rec.SetFillESD("..."); //
90// //
b8cd5251 91// Again, for both methods the string specifies the list of detectors. //
92// The default is "ALL". //
93// //
94// The call of the shortcut method //
95// //
96// rec.SetRunReconstruction("..."); //
97// //
98// is equivalent to calling SetRunLocalReconstruction, SetRunTracking and //
99// SetFillESD with the same detector selecting string as argument. //
596a855f 100// //
c71de921 101// The reconstruction requires digits or raw data as input. For the creation //
102// of digits and raw data have a look at the class AliSimulation. //
596a855f 103// //
cd0b062e 104// The input data of a detector can be replaced by the corresponding HLT //
105// data by calling (usual detector string) //
106// SetUseHLTData("..."); //
107// //
24f7a148 108// For debug purposes the method SetCheckPointLevel can be used. If the //
109// argument is greater than 0, files with ESD events will be written after //
110// selected steps of the reconstruction for each event: //
111// level 1: after tracking and after filling of ESD (final) //
112// level 2: in addition after each tracking step //
113// level 3: in addition after the filling of ESD for each detector //
114// If a final check point file exists for an event, this event will be //
115// skipped in the reconstruction. The tracking and the filling of ESD for //
116// a detector will be skipped as well, if the corresponding check point //
117// file exists. The ESD event will then be loaded from the file instead. //
118// //
596a855f 119///////////////////////////////////////////////////////////////////////////////
120
024a7e64 121#include <TArrayF.h>
122#include <TFile.h>
444753c6 123#include <TList.h>
024a7e64 124#include <TSystem.h>
125#include <TROOT.h>
126#include <TPluginManager.h>
3103d196 127#include <TGeoManager.h>
2bdb9d38 128#include <TLorentzVector.h>
3dd9f9e3 129#include <TArrayS.h>
130#include <TArrayD.h>
3c3709c4 131#include <TObjArray.h>
325aa76f 132#include <TMap.h>
596a855f 133
134#include "AliReconstruction.h"
87932dab 135#include "AliCodeTimer.h"
b8cd5251 136#include "AliReconstructor.h"
815c2b38 137#include "AliLog.h"
596a855f 138#include "AliRunLoader.h"
139#include "AliRun.h"
b649205a 140#include "AliRawReaderFile.h"
141#include "AliRawReaderDate.h"
142#include "AliRawReaderRoot.h"
001397cd 143#include "AliRawEventHeaderBase.h"
af885e0f 144#include "AliESDEvent.h"
faffd83e 145#include "AliESDMuonTrack.h"
1d99986f 146#include "AliESDfriend.h"
2257f27e 147#include "AliESDVertex.h"
faffd83e 148#include "AliESDcascade.h"
149#include "AliESDkink.h"
150#include "AliESDtrack.h"
151#include "AliESDCaloCluster.h"
e649177a 152#include "AliESDCaloCells.h"
32e449be 153#include "AliMultiplicity.h"
c84a5e9e 154#include "AliTracker.h"
2257f27e 155#include "AliVertexer.h"
c5e3e5d1 156#include "AliVertexerTracks.h"
5e4ff34d 157#include "AliV0vertexer.h"
158#include "AliCascadeVertexer.h"
596a855f 159#include "AliHeader.h"
160#include "AliGenEventHeader.h"
b26c3770 161#include "AliPID.h"
596a855f 162#include "AliESDpid.h"
ff8bb5ae 163#include "AliESDtrack.h"
3dd9f9e3 164#include "AliESDPmdTrack.h"
f3a97c86 165
08e1a23e 166#include "AliESDTagCreator.h"
a1069ee1 167#include "AliAODTagCreator.h"
f3a97c86 168
25be1e5c 169#include "AliGeomManager.h"
98937d93 170#include "AliTrackPointArray.h"
b0314964 171#include "AliCDBManager.h"
795e4a22 172#include "AliCDBStorage.h"
6bae477a 173#include "AliCDBEntry.h"
174#include "AliAlignObj.h"
f3a97c86 175
b647652d 176#include "AliCentralTrigger.h"
b024fd7f 177#include "AliTriggerConfiguration.h"
178#include "AliTriggerClass.h"
b647652d 179#include "AliCTPRawStream.h"
180
04236e67 181#include "AliQADataMakerRec.h"
aa3c69a9 182#include "AliGlobalQADataMaker.h"
c65c502a 183#include "AliQA.h"
184#include "AliQADataMakerSteer.h"
f29f1726 185
7167ae53 186#include "AliPlaneEff.h"
187
0f88822a 188#include "AliSysInfo.h" // memory snapshots
cd0b062e 189#include "AliRawHLTManager.h"
0f88822a 190
325aa76f 191#include "AliMagWrapCheb.h"
6efecea1 192
596a855f 193ClassImp(AliReconstruction)
194
195
c757bafd 196//_____________________________________________________________________________
b384f8a4 197const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
c757bafd 198
596a855f 199//_____________________________________________________________________________
795e4a22 200AliReconstruction::AliReconstruction(const char* gAliceFilename,
e583c30d 201 const char* name, const char* title) :
202 TNamed(name, title),
203
f8b507e0 204 fUniformField(kFALSE),
2257f27e 205 fRunVertexFinder(kTRUE),
a84e2607 206 fRunVertexFinderTracks(kTRUE),
1f46a9ae 207 fRunHLTTracking(kFALSE),
e66fbafb 208 fRunMuonTracking(kFALSE),
d1683eef 209 fRunV0Finder(kTRUE),
210 fRunCascadeFinder(kTRUE),
1d99986f 211 fStopOnError(kFALSE),
212 fWriteAlignmentData(kFALSE),
213 fWriteESDfriend(kFALSE),
a7807689 214 fWriteAOD(kFALSE),
b647652d 215 fFillTriggerESD(kTRUE),
1d99986f 216
7f68891d 217 fCleanESD(kTRUE),
a023d8d8 218 fV0DCAmax(3.),
219 fV0CsPmin(0.),
7f68891d 220 fDmax(50.),
221 fZmax(50.),
222
1d99986f 223 fRunLocalReconstruction("ALL"),
b8cd5251 224 fRunTracking("ALL"),
e583c30d 225 fFillESD("ALL"),
48ce48d1 226 fUseTrackingErrorsForAlignment(""),
e583c30d 227 fGAliceFileName(gAliceFilename),
b649205a 228 fInput(""),
35042093 229 fEquipIdMap(""),
b26c3770 230 fFirstEvent(0),
231 fLastEvent(-1),
973388c2 232 fNumberOfEventsPerFile(1),
24f7a148 233 fCheckPointLevel(0),
b8cd5251 234 fOptions(),
6bae477a 235 fLoadAlignFromCDB(kTRUE),
236 fLoadAlignData("ALL"),
46698ae4 237 fESDPar(""),
cd0b062e 238 fUseHLTData(),
e583c30d 239
240 fRunLoader(NULL),
b649205a 241 fRawReader(NULL),
cd0b062e 242 fParentRawReader(NULL),
b8cd5251 243
98937d93 244 fVertexer(NULL),
9178838a 245 fDiamondProfile(NULL),
43c9dae1 246 fDiamondProfileTPC(NULL),
87317a47 247 fMeanVertexConstraint(kTRUE),
98937d93 248
6b6e4472 249 fGRPData(NULL),
444753c6 250
6bae477a 251 fAlignObjArray(NULL),
795e4a22 252 fCDBUri(),
759c1df1 253 fSpecCDBUri(),
795e4a22 254 fInitCDBCalled(kFALSE),
255 fSetRunNumberFromDataCalled(kFALSE),
7e963665 256 fRunQA(kTRUE),
6b150027 257 fRunGlobalQA(kTRUE),
7167ae53 258 fInLoopQA(kFALSE),
e4a998ed 259 fSameQACycle(kFALSE),
7167ae53 260
21a3aa09 261 fRunPlaneEff(kFALSE),
262
263 fesd(NULL),
264 fhltesd(NULL),
265 fesdf(NULL),
266 ffile(NULL),
267 ftree(NULL),
268 fhlttree(NULL),
269 ffileOld(NULL),
270 ftreeOld(NULL),
271 fhlttreeOld(NULL),
272 ftVertexer(NULL),
14dd053c 273 fIsNewRunLoader(kFALSE),
274 fRunAliEVE(kFALSE)
596a855f 275{
276// create reconstruction object with default parameters
b8cd5251 277
278 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
279 fReconstructor[iDet] = NULL;
280 fLoader[iDet] = NULL;
281 fTracker[iDet] = NULL;
7e963665 282 fQADataMaker[iDet] = NULL;
283 fQACycles[iDet] = 999999;
b8cd5251 284 }
aa3c69a9 285 fQADataMaker[fgkNDetectors]=NULL; //Global QA
e47c4c2e 286 AliPID pid;
596a855f 287}
288
289//_____________________________________________________________________________
290AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
e583c30d 291 TNamed(rec),
292
c84a5e9e 293 fUniformField(rec.fUniformField),
2257f27e 294 fRunVertexFinder(rec.fRunVertexFinder),
a84e2607 295 fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
1f46a9ae 296 fRunHLTTracking(rec.fRunHLTTracking),
e66fbafb 297 fRunMuonTracking(rec.fRunMuonTracking),
d1683eef 298 fRunV0Finder(rec.fRunV0Finder),
299 fRunCascadeFinder(rec.fRunCascadeFinder),
1d99986f 300 fStopOnError(rec.fStopOnError),
301 fWriteAlignmentData(rec.fWriteAlignmentData),
302 fWriteESDfriend(rec.fWriteESDfriend),
a7807689 303 fWriteAOD(rec.fWriteAOD),
b647652d 304 fFillTriggerESD(rec.fFillTriggerESD),
1d99986f 305
7f68891d 306 fCleanESD(rec.fCleanESD),
a023d8d8 307 fV0DCAmax(rec.fV0DCAmax),
5e5c1aa9 308 fV0CsPmin(rec.fV0CsPmin),
7f68891d 309 fDmax(rec.fDmax),
310 fZmax(rec.fZmax),
311
1d99986f 312 fRunLocalReconstruction(rec.fRunLocalReconstruction),
e583c30d 313 fRunTracking(rec.fRunTracking),
314 fFillESD(rec.fFillESD),
48ce48d1 315 fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
e583c30d 316 fGAliceFileName(rec.fGAliceFileName),
b649205a 317 fInput(rec.fInput),
35042093 318 fEquipIdMap(rec.fEquipIdMap),
b26c3770 319 fFirstEvent(rec.fFirstEvent),
320 fLastEvent(rec.fLastEvent),
973388c2 321 fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
24f7a148 322 fCheckPointLevel(0),
b8cd5251 323 fOptions(),
6bae477a 324 fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
325 fLoadAlignData(rec.fLoadAlignData),
46698ae4 326 fESDPar(rec.fESDPar),
2972d4eb 327 fUseHLTData(rec.fUseHLTData),
e583c30d 328
329 fRunLoader(NULL),
b649205a 330 fRawReader(NULL),
2972d4eb 331 fParentRawReader(NULL),
b8cd5251 332
98937d93 333 fVertexer(NULL),
9178838a 334 fDiamondProfile(NULL),
43c9dae1 335 fDiamondProfileTPC(NULL),
87317a47 336 fMeanVertexConstraint(rec.fMeanVertexConstraint),
98937d93 337
6b6e4472 338 fGRPData(NULL),
444753c6 339
6bae477a 340 fAlignObjArray(rec.fAlignObjArray),
ec92bee0 341 fCDBUri(rec.fCDBUri),
7e963665 342 fSpecCDBUri(),
795e4a22 343 fInitCDBCalled(rec.fInitCDBCalled),
344 fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
aa3c69a9 345 fRunQA(rec.fRunQA),
346 fRunGlobalQA(rec.fRunGlobalQA),
7167ae53 347 fInLoopQA(rec.fInLoopQA),
e4a998ed 348 fSameQACycle(rec.fSameQACycle),
21a3aa09 349 fRunPlaneEff(rec.fRunPlaneEff),
350
351 fesd(NULL),
352 fhltesd(NULL),
353 fesdf(NULL),
354 ffile(NULL),
355 ftree(NULL),
356 fhlttree(NULL),
357 ffileOld(NULL),
358 ftreeOld(NULL),
359 fhlttreeOld(NULL),
360 ftVertexer(NULL),
14dd053c 361 fIsNewRunLoader(rec.fIsNewRunLoader),
362 fRunAliEVE(kFALSE)
596a855f 363{
364// copy constructor
365
ec92bee0 366 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
efd2085e 367 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
368 }
b8cd5251 369 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
370 fReconstructor[iDet] = NULL;
371 fLoader[iDet] = NULL;
372 fTracker[iDet] = NULL;
7e963665 373 fQADataMaker[iDet] = NULL;
374 fQACycles[iDet] = rec.fQACycles[iDet];
b8cd5251 375 }
aa3c69a9 376 fQADataMaker[fgkNDetectors]=NULL; //Global QA
ec92bee0 377 for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
378 if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
379 }
596a855f 380}
381
382//_____________________________________________________________________________
383AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
384{
385// assignment operator
386
387 this->~AliReconstruction();
388 new(this) AliReconstruction(rec);
389 return *this;
390}
391
392//_____________________________________________________________________________
393AliReconstruction::~AliReconstruction()
394{
395// clean up
396
e583c30d 397 CleanUp();
efd2085e 398 fOptions.Delete();
ec92bee0 399 fSpecCDBUri.Delete();
87932dab 400
401 AliCodeTimer::Instance()->Print();
596a855f 402}
403
024cf675 404//_____________________________________________________________________________
795e4a22 405void AliReconstruction::InitCDB()
024cf675 406{
407// activate a default CDB storage
408// First check if we have any CDB storage set, because it is used
409// to retrieve the calibration and alignment constants
410
795e4a22 411 if (fInitCDBCalled) return;
412 fInitCDBCalled = kTRUE;
413
024cf675 414 AliCDBManager* man = AliCDBManager::Instance();
ec92bee0 415 if (man->IsDefaultStorageSet())
024cf675 416 {
417 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
ec92bee0 418 AliWarning("Default CDB storage has been already set !");
419 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
024cf675 420 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
795e4a22 421 fCDBUri = man->GetDefaultStorage()->GetURI();
ec92bee0 422 }
423 else {
795e4a22 424 if (fCDBUri.Length() > 0)
425 {
426 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
427 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
428 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
429 } else {
430 fCDBUri="local://$ALICE_ROOT";
431 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
432 AliWarning("Default CDB storage not yet set !!!!");
433 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
434 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
435
436 }
ec92bee0 437 man->SetDefaultStorage(fCDBUri);
438 }
439
440 // Now activate the detector specific CDB storage locations
c3a7b59a 441 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
442 TObject* obj = fSpecCDBUri[i];
443 if (!obj) continue;
b8ec52f6 444 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
445 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
446 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
c3a7b59a 447 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
ec92bee0 448 }
795e4a22 449
024cf675 450}
451
452//_____________________________________________________________________________
453void AliReconstruction::SetDefaultStorage(const char* uri) {
ec92bee0 454// Store the desired default CDB storage location
455// Activate it later within the Run() method
024cf675 456
ec92bee0 457 fCDBUri = uri;
024cf675 458
459}
460
00aa02d5 461//_____________________________________________________________________________
c3a7b59a 462void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
ec92bee0 463// Store a detector-specific CDB storage location
464// Activate it later within the Run() method
024cf675 465
c3a7b59a 466 AliCDBPath aPath(calibType);
467 if(!aPath.IsValid()){
468 // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
469 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
470 if(!strcmp(calibType, fgkDetectorName[iDet])) {
471 aPath.SetPath(Form("%s/*", calibType));
472 AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
473 break;
474 }
475 }
476 if(!aPath.IsValid()){
477 AliError(Form("Not a valid path or detector: %s", calibType));
478 return;
479 }
480 }
481
53dd3c3d 482// // check that calibType refers to a "valid" detector name
483// Bool_t isDetector = kFALSE;
484// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
485// TString detName = fgkDetectorName[iDet];
486// if(aPath.GetLevel0() == detName) {
487// isDetector = kTRUE;
488// break;
489// }
490// }
491//
492// if(!isDetector) {
493// AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
494// return;
495// }
c3a7b59a 496
497 TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
ec92bee0 498 if (obj) fSpecCDBUri.Remove(obj);
c3a7b59a 499 fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
024cf675 500
501}
502
6bae477a 503//_____________________________________________________________________________
795e4a22 504Bool_t AliReconstruction::SetRunNumberFromData()
6bae477a 505{
506 // The method is called in Run() in order
507 // to set a correct run number.
508 // In case of raw data reconstruction the
509 // run number is taken from the raw data header
510
795e4a22 511 if (fSetRunNumberFromDataCalled) return kTRUE;
512 fSetRunNumberFromDataCalled = kTRUE;
513
514 AliCDBManager* man = AliCDBManager::Instance();
515
516 if(man->GetRun() > 0) {
21a3aa09 517 AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
795e4a22 518 }
519
520 if (!fRunLoader) {
6bae477a 521 AliError("No run loader is found !");
522 return kFALSE;
523 }
524 // read run number from gAlice
ec92bee0 525 if(fRunLoader->GetAliRun())
f2ee4290 526 AliCDBManager::Instance()->SetRun(fRunLoader->GetHeader()->GetRun());
ec92bee0 527 else {
528 if(fRawReader) {
529 if(fRawReader->NextEvent()) {
530 AliCDBManager::Instance()->SetRun(fRawReader->GetRunNumber());
531 fRawReader->RewindEvents();
532 }
533 else {
21a3aa09 534 if(man->GetRun() > 0) {
535 AliWarning("No raw events is found ! Using settings in AliCDBManager !");
536 man->Print();
537 return kTRUE;
538 }
539 else {
540 AliWarning("Neither raw events nor settings in AliCDBManager are found !");
541 return kFALSE;
542 }
ec92bee0 543 }
544 }
545 else {
546 AliError("Neither gAlice nor RawReader objects are found !");
547 return kFALSE;
548 }
6bae477a 549 }
795e4a22 550
551 man->Print();
552
6bae477a 553 return kTRUE;
554}
555
795e4a22 556//_____________________________________________________________________________
557void AliReconstruction::SetCDBLock() {
558 // Set CDB lock: from now on it is forbidden to reset the run number
559 // or the default storage or to activate any further storage!
560
561 AliCDBManager::Instance()->SetLock(1);
562}
563
6bae477a 564//_____________________________________________________________________________
565Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
566{
567 // Read the alignment objects from CDB.
568 // Each detector is supposed to have the
569 // alignment objects in DET/Align/Data CDB path.
570 // All the detector objects are then collected,
571 // sorted by geometry level (starting from ALIC) and
572 // then applied to the TGeo geometry.
573 // Finally an overlaps check is performed.
574
575 // Load alignment data from CDB and fill fAlignObjArray
576 if(fLoadAlignFromCDB){
6bae477a 577
25be1e5c 578 TString detStr = detectors;
579 TString loadAlObjsListOfDets = "";
580
581 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
582 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
583 loadAlObjsListOfDets += fgkDetectorName[iDet];
584 loadAlObjsListOfDets += " ";
585 } // end loop over detectors
53dd3c3d 586 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
98e303d9 587 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
25be1e5c 588 }else{
589 // Check if the array with alignment objects was
590 // provided by the user. If yes, apply the objects
591 // to the present TGeo geometry
592 if (fAlignObjArray) {
593 if (gGeoManager && gGeoManager->IsClosed()) {
98e303d9 594 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
25be1e5c 595 AliError("The misalignment of one or more volumes failed!"
596 "Compare the list of simulated detectors and the list of detector alignment data!");
597 return kFALSE;
598 }
599 }
600 else {
601 AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
6bae477a 602 return kFALSE;
603 }
604 }
6bae477a 605 }
25be1e5c 606
8e245d15 607 delete fAlignObjArray; fAlignObjArray=0;
a03b0371 608
6bae477a 609 return kTRUE;
610}
596a855f 611
612//_____________________________________________________________________________
613void AliReconstruction::SetGAliceFile(const char* fileName)
614{
615// set the name of the galice file
616
617 fGAliceFileName = fileName;
618}
619
21a3aa09 620//_____________________________________________________________________________
b58710ef 621void AliReconstruction::SetInput(const char* input)
21a3aa09 622{
b58710ef 623 // In case the input string starts with 'mem://', we run in an online mode
624 // and AliRawReaderDateOnline object is created. In all other cases a raw-data
625 // file is assumed. One can give as an input:
626 // mem://: - events taken from DAQ monitoring libs online
627 // or
628 // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
629 fInput = input;
21a3aa09 630}
631
efd2085e 632//_____________________________________________________________________________
633void AliReconstruction::SetOption(const char* detector, const char* option)
634{
635// set options for the reconstruction of a detector
636
637 TObject* obj = fOptions.FindObject(detector);
638 if (obj) fOptions.Remove(obj);
639 fOptions.Add(new TNamed(detector, option));
640}
641
596a855f 642//_____________________________________________________________________________
21a3aa09 643Bool_t AliReconstruction::Run(const char* input)
596a855f 644{
21a3aa09 645 // Run Run Run
646 AliCodeTimerAuto("");
596a855f 647
21a3aa09 648 if (!InitRun(input)) return kFALSE;
319f3084 649
21a3aa09 650 //******* The loop over events
651 Int_t iEvent = 0;
652 while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
653 (fRawReader && fRawReader->NextEvent())) {
654 if (!RunEvent(iEvent)) return kFALSE;
655 iEvent++;
656 }
657
658 if (!FinishRun()) return kFALSE;
659
660 return kTRUE;
661}
662
663//_____________________________________________________________________________
b58710ef 664Bool_t AliReconstruction::InitRun(const char* input)
21a3aa09 665{
666 // Initialize all the stuff before
667 // going into the event loop
668 // If the second argument is given, the first one is ignored and
669 // the reconstruction works in an online mode
670 AliCodeTimerAuto("");
671
b58710ef 672 // Overwrite the previous setting
21a3aa09 673 if (input) fInput = input;
674
675 // set the input in case of raw data
b58710ef 676 fRawReader = AliRawReader::Create(fInput.Data());
677 if (!fRawReader)
21a3aa09 678 AliInfo("Reconstruction will run over digits");
e0027792 679
35042093 680 if (!fEquipIdMap.IsNull() && fRawReader)
681 fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
682
cd0b062e 683 if (!fUseHLTData.IsNull()) {
684 // create the RawReaderHLT which performs redirection of HLT input data for
685 // the specified detectors
686 AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
687 if (pRawReader) {
688 fParentRawReader=fRawReader;
689 fRawReader=pRawReader;
690 } else {
691 AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
692 }
693 }
694
0f88822a 695 AliSysInfo::AddStamp("Start");
f08fc9f5 696 // get the run loader
697 if (!InitRunLoader()) return kFALSE;
0f88822a 698 AliSysInfo::AddStamp("LoadLoader");
596a855f 699
ec92bee0 700 // Initialize the CDB storage
795e4a22 701 InitCDB();
702
703 AliSysInfo::AddStamp("LoadCDB");
ec92bee0 704
6bae477a 705 // Set run number in CDBManager (if it is not already set by the user)
795e4a22 706 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
707
708 // Set CDB lock: from now on it is forbidden to reset the run number
709 // or the default storage or to activate any further storage!
710 SetCDBLock();
711
6bae477a 712 // Import ideal TGeo geometry and apply misalignment
713 if (!gGeoManager) {
714 TString geom(gSystem->DirName(fGAliceFileName));
715 geom += "/geometry.root";
98e303d9 716 AliGeomManager::LoadGeometry(geom.Data());
ff5970a3 717
718 TString detsToCheck=fRunLocalReconstruction;
719 if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data()))
0bf7aade 720 AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
6bae477a 721 if (!gGeoManager) if (fStopOnError) return kFALSE;
722 }
8e245d15 723
6bae477a 724 if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
0f88822a 725 AliSysInfo::AddStamp("LoadGeom");
6bae477a 726
325aa76f 727
728 // Get the GRP CDB entry
729 AliCDBEntry* entryGRP = AliCDBManager::Instance()->Get("GRP/GRP/Data");
730
325aa76f 731 if (entryGRP)
ff5b314b 732 fGRPData = dynamic_cast<TMap*>(entryGRP->GetObject());
325aa76f 733
734 if (!fGRPData) {
735 AliError("No GRP entry found in OCDB!");
736 return kFALSE;
f6806ad3 737 }
325aa76f 738
739
740 // Magnetic field map
741 if (!AliTracker::GetFieldMap()) {
742 // Construct the field map out of the information retrieved from GRP.
743 //
744 // For the moment, this is a dummy piece of code.
745 // The actual map is expected to be already created in rec.C !
746 //
747
748 Float_t factor=1.;
749 Int_t map=AliMagWrapCheb::k5kG;
750 Bool_t dipoleON=kTRUE;
751
752 // L3
753 TObjString *l3Current=
754 dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Current"));
755 if (!l3Current) {
756 AliError("GRP/GRP/Data entry: missing value for the L3 current !");
757 return kFALSE;
758 }
759 TObjString *l3Polarity=
760 dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Polarity"));
761 if (!l3Polarity) {
762 AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
763 return kFALSE;
596a855f 764 }
325aa76f 765
766 // Dipole
767 TObjString *diCurrent=
768 dynamic_cast<TObjString*>(fGRPData->GetValue("fDipoleCurrent"));
769 if (!diCurrent) {
770 AliError("GRP/GRP/Data entry: missing value for the dipole current !");
771 return kFALSE;
772 }
773 TObjString *diPolarity=
774 dynamic_cast<TObjString*>(fGRPData->GetValue("fDipolePolarity"));
775 if (!diPolarity) {
776 AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
777 return kFALSE;
778 }
779
780
781 AliMagF *field=
782 new AliMagWrapCheb("Maps","Maps",2,factor,10.,map,dipoleON);
783 AliTracker::SetFieldMap(field,fUniformField);
784
785 //Temporary measure
786 AliFatal("Please, provide the field map ! Crashing deliberately...");
787
788 }
789
790
791 // Get the diamond profile from OCDB
792 AliCDBEntry* entry = AliCDBManager::Instance()
793 ->Get("GRP/Calib/MeanVertex");
794
795 if(entry) {
796 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
797 } else {
798 AliError("No diamond profile found in OCDB!");
799 }
800
801 entry = 0;
802 entry = AliCDBManager::Instance()
803 ->Get("GRP/Calib/MeanVertexTPC");
804
805 if(entry) {
806 fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
807 } else {
808 AliError("No diamond profile found in OCDB!");
596a855f 809 }
325aa76f 810
811 ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
812 if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile);
2257f27e 813
814 // get vertexer
815 if (fRunVertexFinder && !CreateVertexer()) {
816 if (fStopOnError) {
817 CleanUp();
818 return kFALSE;
819 }
820 }
0f88822a 821 AliSysInfo::AddStamp("Vertexer");
596a855f 822
f08fc9f5 823 // get trackers
b8cd5251 824 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
24f7a148 825 if (fStopOnError) {
826 CleanUp();
827 return kFALSE;
828 }
596a855f 829 }
0f88822a 830 AliSysInfo::AddStamp("LoadTrackers");
24f7a148 831
b26c3770 832 // get the possibly already existing ESD file and tree
21a3aa09 833 fesd = new AliESDEvent(); fhltesd = new AliESDEvent();
b26c3770 834 if (!gSystem->AccessPathName("AliESDs.root")){
835 gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE);
21a3aa09 836 ffileOld = TFile::Open("AliESDs.old.root");
837 if (ffileOld && ffileOld->IsOpen()) {
838 ftreeOld = (TTree*) ffileOld->Get("esdTree");
839 if (ftreeOld)fesd->ReadFromTree(ftreeOld);
840 fhlttreeOld = (TTree*) ffileOld->Get("HLTesdTree");
841 if (fhlttreeOld) fhltesd->ReadFromTree(fhlttreeOld);
b26c3770 842 }
843 }
844
36711aa4 845 // create the ESD output file and tree
21a3aa09 846 ffile = TFile::Open("AliESDs.root", "RECREATE");
847 ffile->SetCompressionLevel(2);
848 if (!ffile->IsOpen()) {
815c2b38 849 AliError("opening AliESDs.root failed");
21a3aa09 850 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
596a855f 851 }
46698ae4 852
21a3aa09 853 ftree = new TTree("esdTree", "Tree with ESD objects");
854 fesd = new AliESDEvent();
855 fesd->CreateStdContent();
856 fesd->WriteToTree(ftree);
46698ae4 857
21a3aa09 858 fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
859 fhltesd = new AliESDEvent();
860 fhltesd->CreateStdContent();
861 fhltesd->WriteToTree(fhlttree);
46698ae4 862
5728d3d5 863
1d99986f 864 if (fWriteESDfriend) {
21a3aa09 865 fesdf = new AliESDfriend();
866 TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
46698ae4 867 br->SetFile("AliESDfriends.root");
21a3aa09 868 fesd->AddObject(fesdf);
1d99986f 869 }
5728d3d5 870
444753c6 871
c5e3e5d1 872
b649205a 873 if (fRawReader) fRawReader->RewindEvents();
a5fa6165 874
95cee32f 875 ProcInfo_t ProcInfo;
876 gSystem->GetProcInfo(&ProcInfo);
877 AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
8661738e 878
aa3c69a9 879
325aa76f 880 //QA
881 AliQADataMakerSteer qas ;
882 if (fRunQA && fRawReader) {
883 qas.Run(fRunLocalReconstruction, fRawReader) ;
884 fSameQACycle = kTRUE ;
885 }
aa3c69a9 886 //Initialize the QA and start of cycle for out-of-cycle QA
f6806ad3 887 if (fRunQA) {
459fdee0 888// TString detStr(fFillESD);
889// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
890// if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
891// AliQADataMakerRec *qadm = GetQADataMaker(iDet);
892// if (!qadm) continue;
893// AliInfo(Form("Initializing the QA data maker for %s",
894// fgkDetectorName[iDet]));
895// qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
896// qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
897// if (!fInLoopQA) {
898// qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
899// qadm->StartOfCycle(AliQA::kESDS,"same");
900// }
901// }
e4a998ed 902 if (fRunGlobalQA) {
903 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
904 AliInfo(Form("Initializing the global QA data maker"));
905 TObjArray *arr=
906 qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
907 AliTracker::SetResidualsArray(arr);
908 qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
909 if (!fInLoopQA) {
910 qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
911 qadm->StartOfCycle(AliQA::kESDS, "same");
912 }
913 }
914 if (!fInLoopQA)
915 fSameQACycle = kTRUE;
aa3c69a9 916 }
917
7167ae53 918 //Initialize the Plane Efficiency framework
919 if (fRunPlaneEff && !InitPlaneEff()) {
21a3aa09 920 if(fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
7167ae53 921 }
aa3c69a9 922
14dd053c 923 if (strcmp(gProgName,"alieve") == 0)
924 fRunAliEVE = InitAliEVE();
925
21a3aa09 926 return kTRUE;
927}
928
929//_____________________________________________________________________________
930Bool_t AliReconstruction::RunEvent(Int_t iEvent)
931{
932 // run the reconstruction over a single event
933 // The event loop is steered in Run method
934
935 AliCodeTimerAuto("");
936
937 if (iEvent >= fRunLoader->GetNumberOfEvents()) {
938 fRunLoader->SetEventNumber(iEvent);
939 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
940 iEvent, iEvent);
941 //?? fRunLoader->MakeTree("H");
942 fRunLoader->TreeE()->Fill();
943 }
944
945 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
946 // copy old ESD to the new one
947 if (ftreeOld) {
948 fesd->ReadFromTree(ftreeOld);
949 ftreeOld->GetEntry(iEvent);
950 ftree->Fill();
b26c3770 951 }
21a3aa09 952 if (fhlttreeOld) {
f6806ad3 953 fhltesd->ReadFromTree(fhlttreeOld);
21a3aa09 954 fhlttreeOld->GetEntry(iEvent);
955 fhlttree->Fill();
956 }
957 return kTRUE;
958 }
959
960 AliInfo(Form("processing event %d", iEvent));
aa3c69a9 961
962 //Start of cycle for the in-loop QA
3b378a42 963 if (fInLoopQA) {
964 if (fRunQA) {
965 TString detStr(fFillESD);
966 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
e4a998ed 967 if (!IsSelected(fgkDetectorName[iDet], detStr))
968 continue;
3b378a42 969 AliQADataMakerRec *qadm = GetQADataMaker(iDet);
e4a998ed 970 if (!qadm)
971 continue;
972 qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
3b378a42 973 qadm->StartOfCycle(AliQA::kESDS, "same") ;
974 }
e4a998ed 975 if (fRunGlobalQA) {
976 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
977 qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
978 qadm->StartOfCycle(AliQA::kESDS, "same");
979 }
980 }
aa3c69a9 981 }
982
596a855f 983 fRunLoader->GetEvent(iEvent);
24f7a148 984
bb0901a4 985 char aFileName[256];
986 sprintf(aFileName, "ESD_%d.%d_final.root",
f08fc9f5 987 fRunLoader->GetHeader()->GetRun(),
988 fRunLoader->GetHeader()->GetEventNrInRun());
21a3aa09 989 if (!gSystem->AccessPathName(aFileName)) return kTRUE;
24f7a148 990
d506c543 991 // local single event reconstruction
b26c3770 992 if (!fRunLocalReconstruction.IsNull()) {
d506c543 993 TString detectors=fRunLocalReconstruction;
a441bf51 994 // run HLT event reconstruction first
d506c543 995 // ;-( IsSelected changes the string
996 if (IsSelected("HLT", detectors) &&
997 !RunLocalEventReconstruction("HLT")) {
a441bf51 998 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
999 }
1000 detectors=fRunLocalReconstruction;
1001 detectors.ReplaceAll("HLT", "");
1002 if (!RunLocalEventReconstruction(detectors)) {
21a3aa09 1003 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
b26c3770 1004 }
1005 }
1006
21a3aa09 1007 fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1008 fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1009 fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1010 fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
46698ae4 1011
d6ee376f 1012 // Set magnetic field from the tracker
21a3aa09 1013 fesd->SetMagneticField(AliTracker::GetBz());
1014 fhltesd->SetMagneticField(AliTracker::GetBz());
596a855f 1015
46698ae4 1016
1017
2e3550da 1018 // Fill raw-data error log into the ESD
21a3aa09 1019 if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
2e3550da 1020
2257f27e 1021 // vertex finder
1022 if (fRunVertexFinder) {
21a3aa09 1023 if (!ReadESD(fesd, "vertex")) {
1024 if (!RunVertexFinder(fesd)) {
1025 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
2257f27e 1026 }
21a3aa09 1027 if (fCheckPointLevel > 0) WriteESD(fesd, "vertex");
2257f27e 1028 }
1029 }
1030
e66fbafb 1031 // Muon tracking
b8cd5251 1032 if (!fRunTracking.IsNull()) {
e66fbafb 1033 if (fRunMuonTracking) {
21a3aa09 1034 if (!RunMuonTracking(fesd)) {
1035 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
24f7a148 1036 }
596a855f 1037 }
1038 }
1039
e66fbafb 1040 // barrel tracking
1041 if (!fRunTracking.IsNull()) {
21a3aa09 1042 if (!ReadESD(fesd, "tracking")) {
1043 if (!RunTracking(fesd)) {
1044 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
e66fbafb 1045 }
21a3aa09 1046 if (fCheckPointLevel > 0) WriteESD(fesd, "tracking");
e66fbafb 1047 }
1048 }
21c573b7 1049
596a855f 1050 // fill ESD
1051 if (!fFillESD.IsNull()) {
d506c543 1052 TString detectors=fFillESD;
f6806ad3 1053 // run HLT first and on hltesd
d506c543 1054 // ;-( IsSelected changes the string
1055 if (IsSelected("HLT", detectors) &&
1056 !FillESD(fhltesd, "HLT")) {
f6806ad3 1057 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1058 }
1059 detectors=fFillESD;
d5105682 1060 // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
1061 if (detectors.Contains("ALL")) {
1062 detectors="";
1063 for (Int_t idet=0; idet<fgkNDetectors; ++idet){
1064 detectors += fgkDetectorName[idet];
1065 detectors += " ";
1066 }
1067 }
f6806ad3 1068 detectors.ReplaceAll("HLT", "");
1069 if (!FillESD(fesd, detectors)) {
21a3aa09 1070 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
596a855f 1071 }
1072 }
a5fa6165 1073
001397cd 1074 // fill Event header information from the RawEventHeader
21a3aa09 1075 if (fRawReader){FillRawEventHeaderESD(fesd);}
596a855f 1076
1077 // combined PID
21a3aa09 1078 AliESDpid::MakePID(fesd);
1079 if (fCheckPointLevel > 1) WriteESD(fesd, "PID");
596a855f 1080
b647652d 1081 if (fFillTriggerESD) {
21a3aa09 1082 if (!ReadESD(fesd, "trigger")) {
1083 if (!FillTriggerESD(fesd)) {
1084 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
b647652d 1085 }
21a3aa09 1086 if (fCheckPointLevel > 1) WriteESD(fesd, "trigger");
b647652d 1087 }
1088 }
1089
21a3aa09 1090 ffile->cd();
a6ee503a 1091
3c3709c4 1092 //
67be5c77 1093 // Propagate track to the beam pipe (if not already done by ITS)
3c3709c4 1094 //
21a3aa09 1095 const Int_t ntracks = fesd->GetNumberOfTracks();
1096 const Double_t kBz = fesd->GetMagneticField();
3c3709c4 1097 const Double_t kRadius = 2.8; //something less than the beam pipe radius
1098
1099 TObjArray trkArray;
1100 UShort_t *selectedIdx=new UShort_t[ntracks];
1101
1102 for (Int_t itrack=0; itrack<ntracks; itrack++){
1103 const Double_t kMaxStep = 5; //max step over the material
1104 Bool_t ok;
1105
21a3aa09 1106 AliESDtrack *track = fesd->GetTrack(itrack);
3c3709c4 1107 if (!track) continue;
1108
1109 AliExternalTrackParam *tpcTrack =
1110 (AliExternalTrackParam *)track->GetTPCInnerParam();
bcabd6af 1111 ok = kFALSE;
1112 if (tpcTrack)
1113 ok = AliTracker::
1114 PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE);
43c9dae1 1115
1116
1117
3c3709c4 1118 if (ok) {
1119 Int_t n=trkArray.GetEntriesFast();
1120 selectedIdx[n]=track->GetID();
1121 trkArray.AddLast(tpcTrack);
1122 }
1123
f6806ad3 1124 if (track->GetX() < kRadius) continue;
3c3709c4 1125
f6806ad3 1126 ok = AliTracker::
3c3709c4 1127 PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
f6806ad3 1128 if (ok) {
1129 track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kRadius);
1130 }
3c3709c4 1131 }
1132
1133 //
1134 // Improve the reconstructed primary vertex position using the tracks
1135 //
1136 TObject *obj = fOptions.FindObject("ITS");
c060d7fe 1137 if (obj) {
1138 TString optITS = obj->GetTitle();
1139 if (optITS.Contains("cosmics") || optITS.Contains("COSMICS"))
a84e2607 1140 fRunVertexFinderTracks=kFALSE;
c060d7fe 1141 }
3c3709c4 1142 if (fRunVertexFinderTracks) {
1143 // TPC + ITS primary vertex
21a3aa09 1144 ftVertexer->SetITSrefitRequired();
43c9dae1 1145 if(fDiamondProfile && fMeanVertexConstraint) {
21a3aa09 1146 ftVertexer->SetVtxStart(fDiamondProfile);
43c9dae1 1147 } else {
21a3aa09 1148 ftVertexer->SetConstraintOff();
43c9dae1 1149 }
21a3aa09 1150 AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
3c3709c4 1151 if (pvtx) {
1152 if (pvtx->GetStatus()) {
21a3aa09 1153 fesd->SetPrimaryVertex(pvtx);
3c3709c4 1154 for (Int_t i=0; i<ntracks; i++) {
21a3aa09 1155 AliESDtrack *t = fesd->GetTrack(i);
f6806ad3 1156 t->RelateToVertex(pvtx, kBz, kRadius);
3c3709c4 1157 }
1158 }
1159 }
1160
1161 // TPC-only primary vertex
21a3aa09 1162 ftVertexer->SetITSrefitNotRequired();
43c9dae1 1163 if(fDiamondProfileTPC && fMeanVertexConstraint) {
21a3aa09 1164 ftVertexer->SetVtxStart(fDiamondProfileTPC);
43c9dae1 1165 } else {
21a3aa09 1166 ftVertexer->SetConstraintOff();
43c9dae1 1167 }
21a3aa09 1168 pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
3c3709c4 1169 if (pvtx) {
1170 if (pvtx->GetStatus()) {
21a3aa09 1171 fesd->SetPrimaryVertexTPC(pvtx);
3c3709c4 1172 Int_t nsel=trkArray.GetEntriesFast();
1173 for (Int_t i=0; i<nsel; i++) {
1174 AliExternalTrackParam *t =
1175 (AliExternalTrackParam *)trkArray.UncheckedAt(i);
1176 t->PropagateToDCA(pvtx, kBz, kRadius);
1177 }
1178 }
1179 }
1180
1181 }
1182 delete[] selectedIdx;
1183
21a3aa09 1184 if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
17c86e90 1185
c5e3e5d1 1186
d1683eef 1187 if (fRunV0Finder) {
1188 // V0 finding
1189 AliV0vertexer vtxer;
21a3aa09 1190 vtxer.Tracks2V0vertices(fesd);
5e4ff34d 1191
d1683eef 1192 if (fRunCascadeFinder) {
1193 // Cascade finding
1194 AliCascadeVertexer cvtxer;
21a3aa09 1195 cvtxer.V0sTracks2CascadeVertices(fesd);
d1683eef 1196 }
5e4ff34d 1197 }
1198
596a855f 1199 // write ESD
21a3aa09 1200 if (fCleanESD) CleanESD(fesd);
854c6476 1201
79740dfc 1202 if (fRunQA) {
1203 if (fRunGlobalQA) {
1204 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
1205 if (qadm) qadm->Exec(AliQA::kESDS, fesd);
1206 }
1207 }
854c6476 1208
1d99986f 1209 if (fWriteESDfriend) {
21a3aa09 1210 fesdf->~AliESDfriend();
1211 new (fesdf) AliESDfriend(); // Reset...
1212 fesd->GetESDfriend(fesdf);
1d99986f 1213 }
21a3aa09 1214 ftree->Fill();
500d54ab 1215
1216 // write HLT ESD
21a3aa09 1217 fhlttree->Fill();
1d99986f 1218
14dd053c 1219 // call AliEVE
1220 if (fRunAliEVE) RunAliEVE();
1221
21a3aa09 1222 if (fCheckPointLevel > 0) WriteESD(fesd, "final");
1223 fesd->Reset();
1224 fhltesd->Reset();
5728d3d5 1225 if (fWriteESDfriend) {
21a3aa09 1226 fesdf->~AliESDfriend();
1227 new (fesdf) AliESDfriend(); // Reset...
5728d3d5 1228 }
a5fa6165 1229
21a3aa09 1230 ProcInfo_t ProcInfo;
95cee32f 1231 gSystem->GetProcInfo(&ProcInfo);
1232 AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
a5fa6165 1233
7e963665 1234
aa3c69a9 1235 // End of cycle for the in-loop QA
3b378a42 1236 if (fInLoopQA) {
1237 if (fRunQA) {
21a3aa09 1238 RunQA(fFillESD.Data(), fesd);
3b378a42 1239 TString detStr(fFillESD);
1240 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
7c002d48 1241 if (!IsSelected(fgkDetectorName[iDet], detStr))
1242 continue;
1243 AliQADataMakerRec * qadm = GetQADataMaker(iDet);
1244 if (!qadm)
1245 continue;
1246 qadm->EndOfCycle(AliQA::kRECPOINTS);
1247 qadm->EndOfCycle(AliQA::kESDS);
1248 qadm->Finish();
1249 }
aa3c69a9 1250 }
1251 if (fRunGlobalQA) {
7c002d48 1252 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
aa3c69a9 1253 if (qadm) {
1254 qadm->EndOfCycle(AliQA::kRECPOINTS);
d7259b2e 1255 qadm->EndOfCycle(AliQA::kESDS);
aa3c69a9 1256 qadm->Finish();
1257 }
1258 }
1259 }
aa3c69a9 1260
21a3aa09 1261 return kTRUE;
1262}
1263
21a3aa09 1264//_____________________________________________________________________________
1265Bool_t AliReconstruction::FinishRun()
1266{
1267 // Finalize the run
1268 // Called after the exit
1269 // from the event loop
1270 AliCodeTimerAuto("");
1271
1272 if (fIsNewRunLoader) { // galice.root didn't exist
1273 fRunLoader->WriteHeader("OVERWRITE");
1274 fRunLoader->CdGAFile();
1275 fRunLoader->Write(0, TObject::kOverwrite);
1276 }
1277
1278 ftree->GetUserInfo()->Add(fesd);
1279 fhlttree->GetUserInfo()->Add(fhltesd);
f747912b 1280
1281 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
1282 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
1283
1284 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
1285 cdbMapCopy->SetOwner(1);
1286 cdbMapCopy->SetName("cdbMap");
1287 TIter iter(cdbMap->GetTable());
1288
1289 TPair* pair = 0;
1290 while((pair = dynamic_cast<TPair*> (iter.Next()))){
1291 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
1292 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
1293 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
1294 }
1295
1296 TList *cdbListCopy = new TList();
1297 cdbListCopy->SetOwner(1);
1298 cdbListCopy->SetName("cdbList");
1299
1300 TIter iter2(cdbList);
1301
1302 AliCDBId* id=0;
1303 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
a4970db9 1304 cdbListCopy->Add(new TObjString(id->ToString().Data()));
f747912b 1305 }
1306
21a3aa09 1307 ftree->GetUserInfo()->Add(cdbMapCopy);
1308 ftree->GetUserInfo()->Add(cdbListCopy);
abe0c04e 1309
46698ae4 1310
1311 if(fESDPar.Contains("ESD.par")){
1312 AliInfo("Attaching ESD.par to Tree");
1313 TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
21a3aa09 1314 ftree->GetUserInfo()->Add(fn);
596a855f 1315 }
1316
46698ae4 1317
21a3aa09 1318 ffile->cd();
aa3c69a9 1319
a9c0e6db 1320 if (fWriteESDfriend)
21a3aa09 1321 ftree->SetBranchStatus("ESDfriend*",0);
562dd0b4 1322 // we want to have only one tree version number
21a3aa09 1323 ftree->Write(ftree->GetName(),TObject::kOverwrite);
1324 fhlttree->Write();
f3a97c86 1325
a7a1e1c7 1326// Finish with Plane Efficiency evaluation: before of CleanUp !!!
1327 if (fRunPlaneEff && !FinishPlaneEff()) {
1328 AliWarning("Finish PlaneEff evaluation failed");
1329 }
1330
eae191bc 1331 gROOT->cd();
21a3aa09 1332 CleanUp(ffile, ffileOld);
eae191bc 1333
a7807689 1334 if (fWriteAOD) {
7a3b2050 1335 AliWarning("AOD creation not supported anymore during reconstruction. See ANALYSIS/AliAnalysisTaskESDfilter.cxx instead.");
a7807689 1336 }
1337
f3a97c86 1338 // Create tags for the events in the ESD tree (the ESD tree is always present)
1339 // In case of empty events the tags will contain dummy values
08e1a23e 1340 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
6b6e4472 1341 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData);
a1069ee1 1342 if (fWriteAOD) {
7a3b2050 1343 AliWarning("AOD tag creation not supported anymore during reconstruction.");
a1069ee1 1344 }
596a855f 1345
aa3c69a9 1346 //Finish QA and end of cycle for out-of-loop QA
3b378a42 1347 if (!fInLoopQA) {
79740dfc 1348 if (fRunQA) {
1349 AliQADataMakerSteer qas;
1350 qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS, fSameQACycle);
1351 //qas.Reset() ;
459fdee0 1352 qas.Run(fRunLocalReconstruction.Data(), AliQA::kESDS, fSameQACycle);
79740dfc 1353 if (fRunGlobalQA) {
1354 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
1355 if (qadm) {
1356 qadm->EndOfCycle(AliQA::kRECPOINTS);
1357 qadm->EndOfCycle(AliQA::kESDS);
1358 qadm->Finish();
1359 }
1360 }
1361 }
759c1df1 1362 }
795e4a22 1363
1364 // Cleanup of CDB manager: cache and active storages!
1365 AliCDBManager::Instance()->ClearCache();
1366
596a855f 1367 return kTRUE;
1368}
1369
1370
1371//_____________________________________________________________________________
c4aa7a4c 1372Bool_t AliReconstruction::RunLocalReconstruction(const TString& /*detectors*/)
596a855f 1373{
59697224 1374// run the local reconstruction
0f88822a 1375 static Int_t eventNr=0;
87932dab 1376 AliCodeTimerAuto("")
030b532d 1377
d76c31f4 1378 // AliCDBManager* man = AliCDBManager::Instance();
1379// Bool_t origCache = man->GetCacheFlag();
8e245d15 1380
d76c31f4 1381// TString detStr = detectors;
1382// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1383// if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1384// AliReconstructor* reconstructor = GetReconstructor(iDet);
1385// if (!reconstructor) continue;
1386// if (reconstructor->HasLocalReconstruction()) continue;
b8cd5251 1387
d76c31f4 1388// AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1389// AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
87932dab 1390
d76c31f4 1391// AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
1392// AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
8e245d15 1393
d76c31f4 1394// man->SetCacheFlag(kTRUE);
1395// TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]);
1396// man->GetAll(calibPath); // entries are cached!
8e245d15 1397
d76c31f4 1398// AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
87932dab 1399
d76c31f4 1400// if (fRawReader) {
1401// fRawReader->RewindEvents();
1402// reconstructor->Reconstruct(fRunLoader, fRawReader);
1403// } else {
1404// reconstructor->Reconstruct(fRunLoader);
1405// }
87932dab 1406
d76c31f4 1407// AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
0f88822a 1408 // AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr));
8e245d15 1409
d76c31f4 1410// // unload calibration data
1411// man->UnloadFromCache(calibPath);
1412// //man->ClearCache();
1413// }
596a855f 1414
d76c31f4 1415// man->SetCacheFlag(origCache);
8e245d15 1416
d76c31f4 1417// if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1418// AliError(Form("the following detectors were not found: %s",
1419// detStr.Data()));
1420// if (fStopOnError) return kFALSE;
1421// }
596a855f 1422
0f88822a 1423 eventNr++;
596a855f 1424 return kTRUE;
1425}
1426
b26c3770 1427//_____________________________________________________________________________
1428Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
1429{
1430// run the local reconstruction
aa3c69a9 1431
0f88822a 1432 static Int_t eventNr=0;
87932dab 1433 AliCodeTimerAuto("")
b26c3770 1434
1435 TString detStr = detectors;
1436 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1437 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1438 AliReconstructor* reconstructor = GetReconstructor(iDet);
1439 if (!reconstructor) continue;
1440 AliLoader* loader = fLoader[iDet];
f6806ad3 1441 // Matthias April 2008: temporary fix to run HLT reconstruction
1442 // although the HLT loader is missing
1443 if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
1444 if (fRawReader) {
1445 reconstructor->Reconstruct(fRawReader, NULL);
1446 } else {
1447 TTree* dummy=NULL;
1448 reconstructor->Reconstruct(dummy, NULL);
1449 }
1450 continue;
1451 }
d76c31f4 1452 if (!loader) {
1453 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
1454 continue;
1455 }
b26c3770 1456 // conversion of digits
1457 if (fRawReader && reconstructor->HasDigitConversion()) {
1458 AliInfo(Form("converting raw data digits into root objects for %s",
1459 fgkDetectorName[iDet]));
87932dab 1460 AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
1461 fgkDetectorName[iDet]));
b26c3770 1462 loader->LoadDigits("update");
1463 loader->CleanDigits();
1464 loader->MakeDigitsContainer();
1465 TTree* digitsTree = loader->TreeD();
1466 reconstructor->ConvertDigits(fRawReader, digitsTree);
1467 loader->WriteDigits("OVERWRITE");
1468 loader->UnloadDigits();
b26c3770 1469 }
b26c3770 1470 // local reconstruction
b26c3770 1471 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
87932dab 1472 AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
b26c3770 1473 loader->LoadRecPoints("update");
1474 loader->CleanRecPoints();
1475 loader->MakeRecPointsContainer();
1476 TTree* clustersTree = loader->TreeR();
1477 if (fRawReader && !reconstructor->HasDigitConversion()) {
1478 reconstructor->Reconstruct(fRawReader, clustersTree);
1479 } else {
1480 loader->LoadDigits("read");
1481 TTree* digitsTree = loader->TreeD();
1482 if (!digitsTree) {
1483 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
1484 if (fStopOnError) return kFALSE;
1485 } else {
1486 reconstructor->Reconstruct(digitsTree, clustersTree);
1487 }
1488 loader->UnloadDigits();
1489 }
d76c31f4 1490
aa3c69a9 1491 // In-loop QA for local reconstrucion
1492 if (fRunQA && fInLoopQA) {
04236e67 1493 AliQADataMakerRec * qadm = GetQADataMaker(iDet);
aa3c69a9 1494 if (qadm) {
1495 //AliCodeTimerStart
1496 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1497 //AliInfo
1498 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1499
1500 qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
1501
1502 //AliCodeTimerStop
1503 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1504 }
1505 }
d76c31f4 1506
aa3c69a9 1507 loader->WriteRecPoints("OVERWRITE");
b26c3770 1508 loader->UnloadRecPoints();
6efecea1 1509 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
b26c3770 1510 }
1511
1512 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1513 AliError(Form("the following detectors were not found: %s",
1514 detStr.Data()));
1515 if (fStopOnError) return kFALSE;
1516 }
0f88822a 1517 eventNr++;
b26c3770 1518 return kTRUE;
1519}
1520
596a855f 1521//_____________________________________________________________________________
af885e0f 1522Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
596a855f 1523{
1524// run the barrel tracking
1525
87932dab 1526 AliCodeTimerAuto("")
030b532d 1527
2257f27e 1528 AliESDVertex* vertex = NULL;
1529 Double_t vtxPos[3] = {0, 0, 0};
1530 Double_t vtxErr[3] = {0.07, 0.07, 0.1};
1531 TArrayF mcVertex(3);
a6b0b91b 1532 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
1533 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
1534 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
1535 }
2257f27e 1536
b8cd5251 1537 if (fVertexer) {
815c2b38 1538 AliInfo("running the ITS vertex finder");
308c2f7c 1539 if (fLoader[0]) {
1540 fLoader[0]->LoadRecPoints();
1541 TTree* cltree = fLoader[0]->TreeR();
1542 if (cltree) {
1543 if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
1544 vertex = fVertexer->FindVertexForCurrentEvent(cltree);
1545 }
1546 else {
1547 AliError("Can't get the ITS cluster tree");
1548 }
1549 fLoader[0]->UnloadRecPoints();
1550 }
1551 else {
1552 AliError("Can't get the ITS loader");
1553 }
2257f27e 1554 if(!vertex){
815c2b38 1555 AliWarning("Vertex not found");
c710f220 1556 vertex = new AliESDVertex();
d1a50cb5 1557 vertex->SetName("default");
2257f27e 1558 }
1559 else {
d1a50cb5 1560 vertex->SetName("reconstructed");
2257f27e 1561 }
1562
1563 } else {
815c2b38 1564 AliInfo("getting the primary vertex from MC");
2257f27e 1565 vertex = new AliESDVertex(vtxPos, vtxErr);
1566 }
1567
1568 if (vertex) {
1569 vertex->GetXYZ(vtxPos);
1570 vertex->GetSigmaXYZ(vtxErr);
1571 } else {
815c2b38 1572 AliWarning("no vertex reconstructed");
2257f27e 1573 vertex = new AliESDVertex(vtxPos, vtxErr);
1574 }
06cc9d95 1575 esd->SetPrimaryVertexSPD(vertex);
32e449be 1576 // if SPD multiplicity has been determined, it is stored in the ESD
25be1e5c 1577 AliMultiplicity *mult = fVertexer->GetMultiplicity();
32e449be 1578 if(mult)esd->SetMultiplicity(mult);
1579
b8cd5251 1580 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1581 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
1582 }
2257f27e 1583 delete vertex;
1584
2257f27e 1585 return kTRUE;
1586}
1587
1f46a9ae 1588//_____________________________________________________________________________
af885e0f 1589Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
1f46a9ae 1590{
1591// run the HLT barrel tracking
1592
87932dab 1593 AliCodeTimerAuto("")
1f46a9ae 1594
1595 if (!fRunLoader) {
1596 AliError("Missing runLoader!");
1597 return kFALSE;
1598 }
1599
1600 AliInfo("running HLT tracking");
1601
1602 // Get a pointer to the HLT reconstructor
1603 AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
1604 if (!reconstructor) return kFALSE;
1605
1606 // TPC + ITS
1607 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1608 TString detName = fgkDetectorName[iDet];
1609 AliDebug(1, Form("%s HLT tracking", detName.Data()));
1610 reconstructor->SetOption(detName.Data());
d76c31f4 1611 AliTracker *tracker = reconstructor->CreateTracker();
1f46a9ae 1612 if (!tracker) {
1613 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
1614 if (fStopOnError) return kFALSE;
9dcc06e1 1615 continue;
1f46a9ae 1616 }
1617 Double_t vtxPos[3];
1618 Double_t vtxErr[3]={0.005,0.005,0.010};
1619 const AliESDVertex *vertex = esd->GetVertex();
1620 vertex->GetXYZ(vtxPos);
1621 tracker->SetVertex(vtxPos,vtxErr);
1622 if(iDet != 1) {
1623 fLoader[iDet]->LoadRecPoints("read");
1624 TTree* tree = fLoader[iDet]->TreeR();
1625 if (!tree) {
1626 AliError(Form("Can't get the %s cluster tree", detName.Data()));
1627 return kFALSE;
1628 }
1629 tracker->LoadClusters(tree);
1630 }
1631 if (tracker->Clusters2Tracks(esd) != 0) {
1632 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
1633 return kFALSE;
1634 }
1635 if(iDet != 1) {
1636 tracker->UnloadClusters();
1637 }
1638 delete tracker;
1639 }
1640
1f46a9ae 1641 return kTRUE;
1642}
1643
e66fbafb 1644//_____________________________________________________________________________
af885e0f 1645Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
e66fbafb 1646{
1647// run the muon spectrometer tracking
1648
87932dab 1649 AliCodeTimerAuto("")
e66fbafb 1650
1651 if (!fRunLoader) {
1652 AliError("Missing runLoader!");
1653 return kFALSE;
1654 }
1655 Int_t iDet = 7; // for MUON
1656
1657 AliInfo("is running...");
1658
1659 // Get a pointer to the MUON reconstructor
1660 AliReconstructor *reconstructor = GetReconstructor(iDet);
1661 if (!reconstructor) return kFALSE;
1662
1663
1664 TString detName = fgkDetectorName[iDet];
1665 AliDebug(1, Form("%s tracking", detName.Data()));
d76c31f4 1666 AliTracker *tracker = reconstructor->CreateTracker();
e66fbafb 1667 if (!tracker) {
1668 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
1669 return kFALSE;
1670 }
1671
e66fbafb 1672 // read RecPoints
761350a6 1673 fLoader[iDet]->LoadRecPoints("read");
c1954ee5 1674
761350a6 1675 tracker->LoadClusters(fLoader[iDet]->TreeR());
1676
1677 Int_t rv = tracker->Clusters2Tracks(esd);
1678
761350a6 1679 if ( rv )
1680 {
e66fbafb 1681 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
1682 return kFALSE;
1683 }
761350a6 1684
e66fbafb 1685 fLoader[iDet]->UnloadRecPoints();
1686
c1954ee5 1687 tracker->UnloadClusters();
1688
e66fbafb 1689 delete tracker;
1690
e66fbafb 1691 return kTRUE;
1692}
1693
1694
2257f27e 1695//_____________________________________________________________________________
af885e0f 1696Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
2257f27e 1697{
1698// run the barrel tracking
0f88822a 1699 static Int_t eventNr=0;
87932dab 1700 AliCodeTimerAuto("")
24f7a148 1701
815c2b38 1702 AliInfo("running tracking");
596a855f 1703
91b876d1 1704 //Fill the ESD with the T0 info (will be used by the TOF)
d76c31f4 1705 if (fReconstructor[11] && fLoader[11]) {
1706 fLoader[11]->LoadRecPoints("READ");
1707 TTree *treeR = fLoader[11]->TreeR();
1708 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
1709 }
91b876d1 1710
b8cd5251 1711 // pass 1: TPC + ITS inwards
1712 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1713 if (!fTracker[iDet]) continue;
1714 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
24f7a148 1715
b8cd5251 1716 // load clusters
1717 fLoader[iDet]->LoadRecPoints("read");
6efecea1 1718 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
b8cd5251 1719 TTree* tree = fLoader[iDet]->TreeR();
1720 if (!tree) {
1721 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
24f7a148 1722 return kFALSE;
1723 }
b8cd5251 1724 fTracker[iDet]->LoadClusters(tree);
6efecea1 1725 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 1726 // run tracking
1727 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
1728 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
24f7a148 1729 return kFALSE;
1730 }
b8cd5251 1731 if (fCheckPointLevel > 1) {
1732 WriteESD(esd, Form("%s.tracking", fgkDetectorName[iDet]));
1733 }
878e1fe1 1734 // preliminary PID in TPC needed by the ITS tracker
1735 if (iDet == 1) {
b26c3770 1736 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
878e1fe1 1737 AliESDpid::MakePID(esd);
0f88822a 1738 }
6efecea1 1739 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
b8cd5251 1740 }
596a855f 1741
b8cd5251 1742 // pass 2: ALL backwards
aa3c69a9 1743
b8cd5251 1744 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1745 if (!fTracker[iDet]) continue;
1746 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
1747
1748 // load clusters
1749 if (iDet > 1) { // all except ITS, TPC
1750 TTree* tree = NULL;
7b61cd9c 1751 fLoader[iDet]->LoadRecPoints("read");
6efecea1 1752 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
7b61cd9c 1753 tree = fLoader[iDet]->TreeR();
b8cd5251 1754 if (!tree) {
1755 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
24f7a148 1756 return kFALSE;
1757 }
0f88822a 1758 fTracker[iDet]->LoadClusters(tree);
6efecea1 1759 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 1760 }
24f7a148 1761
b8cd5251 1762 // run tracking
283f39c6 1763 if (iDet>1) // start filling residuals for the "outer" detectors
1764 if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
1765
b8cd5251 1766 if (fTracker[iDet]->PropagateBack(esd) != 0) {
1767 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
49dfd67a 1768 // return kFALSE;
b8cd5251 1769 }
1770 if (fCheckPointLevel > 1) {
1771 WriteESD(esd, Form("%s.back", fgkDetectorName[iDet]));
1772 }
24f7a148 1773
b8cd5251 1774 // unload clusters
1775 if (iDet > 2) { // all except ITS, TPC, TRD
1776 fTracker[iDet]->UnloadClusters();
7b61cd9c 1777 fLoader[iDet]->UnloadRecPoints();
b8cd5251 1778 }
8f37df88 1779 // updated PID in TPC needed by the ITS tracker -MI
1780 if (iDet == 1) {
8f37df88 1781 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
1782 AliESDpid::MakePID(esd);
1783 }
6efecea1 1784 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
b8cd5251 1785 }
283f39c6 1786 //stop filling residuals for the "outer" detectors
1787 if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
596a855f 1788
98937d93 1789 // write space-points to the ESD in case alignment data output
1790 // is switched on
1791 if (fWriteAlignmentData)
1792 WriteAlignmentData(esd);
1793
b8cd5251 1794 // pass 3: TRD + TPC + ITS refit inwards
aa3c69a9 1795
b8cd5251 1796 for (Int_t iDet = 2; iDet >= 0; iDet--) {
1797 if (!fTracker[iDet]) continue;
1798 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
596a855f 1799
b8cd5251 1800 // run tracking
283f39c6 1801 if (iDet<2) // start filling residuals for TPC and ITS
1802 if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
1803
b8cd5251 1804 if (fTracker[iDet]->RefitInward(esd) != 0) {
1805 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
49dfd67a 1806 // return kFALSE;
b8cd5251 1807 }
db2368d0 1808 // run postprocessing
1809 if (fTracker[iDet]->PostProcess(esd) != 0) {
1810 AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
1811 // return kFALSE;
1812 }
b8cd5251 1813 if (fCheckPointLevel > 1) {
1814 WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet]));
1815 }
6efecea1 1816 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
b8cd5251 1817 // unload clusters
1818 fTracker[iDet]->UnloadClusters();
6efecea1 1819 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
b8cd5251 1820 fLoader[iDet]->UnloadRecPoints();
6efecea1 1821 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
b8cd5251 1822 }
283f39c6 1823 // stop filling residuals for TPC and ITS
3b378a42 1824 if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
854c6476 1825
0f88822a 1826 eventNr++;
596a855f 1827 return kTRUE;
1828}
1829
d64bd07d 1830//_____________________________________________________________________________
1831Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
1832 //
1833 // Remove the data which are not needed for the physics analysis.
1834 //
1835
d64bd07d 1836 Int_t nTracks=esd->GetNumberOfTracks();
18571674 1837 Int_t nV0s=esd->GetNumberOfV0s();
cf37fd88 1838 AliInfo
1839 (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
d64bd07d 1840
18571674 1841 Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
7f68891d 1842 Bool_t rc=esd->Clean(cleanPars);
d64bd07d 1843
7f68891d 1844 nTracks=esd->GetNumberOfTracks();
18571674 1845 nV0s=esd->GetNumberOfV0s();
cf37fd88 1846 AliInfo
ae5d5566 1847 (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
d64bd07d 1848
7f68891d 1849 return rc;
d64bd07d 1850}
1851
596a855f 1852//_____________________________________________________________________________
af885e0f 1853Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
596a855f 1854{
1855// fill the event summary data
1856
87932dab 1857 AliCodeTimerAuto("")
0f88822a 1858 static Int_t eventNr=0;
596a855f 1859 TString detStr = detectors;
abe0c04e 1860
b8cd5251 1861 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
abe0c04e 1862 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
b8cd5251 1863 AliReconstructor* reconstructor = GetReconstructor(iDet);
1864 if (!reconstructor) continue;
b8cd5251 1865 if (!ReadESD(esd, fgkDetectorName[iDet])) {
1866 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
b26c3770 1867 TTree* clustersTree = NULL;
d76c31f4 1868 if (fLoader[iDet]) {
b26c3770 1869 fLoader[iDet]->LoadRecPoints("read");
1870 clustersTree = fLoader[iDet]->TreeR();
1871 if (!clustersTree) {
1872 AliError(Form("Can't get the %s clusters tree",
1873 fgkDetectorName[iDet]));
1874 if (fStopOnError) return kFALSE;
1875 }
1876 }
1877 if (fRawReader && !reconstructor->HasDigitConversion()) {
1878 reconstructor->FillESD(fRawReader, clustersTree, esd);
1879 } else {
1880 TTree* digitsTree = NULL;
1881 if (fLoader[iDet]) {
1882 fLoader[iDet]->LoadDigits("read");
1883 digitsTree = fLoader[iDet]->TreeD();
1884 if (!digitsTree) {
1885 AliError(Form("Can't get the %s digits tree",
1886 fgkDetectorName[iDet]));
1887 if (fStopOnError) return kFALSE;
1888 }
1889 }
1890 reconstructor->FillESD(digitsTree, clustersTree, esd);
1891 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
1892 }
d76c31f4 1893 if (fLoader[iDet]) {
b26c3770 1894 fLoader[iDet]->UnloadRecPoints();
1895 }
1896
b8cd5251 1897 if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
596a855f 1898 }
1899 }
1900
1901 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
815c2b38 1902 AliError(Form("the following detectors were not found: %s",
1903 detStr.Data()));
596a855f 1904 if (fStopOnError) return kFALSE;
1905 }
6efecea1 1906 AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
0f88822a 1907 eventNr++;
596a855f 1908 return kTRUE;
1909}
1910
b647652d 1911//_____________________________________________________________________________
af885e0f 1912Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
b647652d 1913{
1914 // Reads the trigger decision which is
1915 // stored in Trigger.root file and fills
1916 // the corresponding esd entries
1917
87932dab 1918 AliCodeTimerAuto("")
1919
b647652d 1920 AliInfo("Filling trigger information into the ESD");
1921
b024fd7f 1922 AliCentralTrigger *aCTP = NULL;
1923
b647652d 1924 if (fRawReader) {
1925 AliCTPRawStream input(fRawReader);
1926 if (!input.Next()) {
1927 AliError("No valid CTP (trigger) DDL raw data is found ! The trigger information is not stored in the ESD !");
1928 return kFALSE;
1929 }
1930 esd->SetTriggerMask(input.GetClassMask());
1931 esd->SetTriggerCluster(input.GetClusterMask());
b024fd7f 1932
1933 aCTP = new AliCentralTrigger();
1934 TString configstr("");
1935 if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
1936 AliError("No trigger configuration found in OCDB! The trigger classes information will no be stored in ESD!");
259e35c9 1937 delete aCTP;
b024fd7f 1938 return kFALSE;
1939 }
b647652d 1940 }
1941 else {
1942 AliRunLoader *runloader = AliRunLoader::GetRunLoader();
1943 if (runloader) {
1944 if (!runloader->LoadTrigger()) {
1ea86aa2 1945 aCTP = runloader->GetTrigger();
b647652d 1946 esd->SetTriggerMask(aCTP->GetClassMask());
1947 esd->SetTriggerCluster(aCTP->GetClusterMask());
1948 }
1949 else {
1950 AliWarning("No trigger can be loaded! The trigger information is not stored in the ESD !");
1951 return kFALSE;
1952 }
1953 }
1954 else {
1955 AliError("No run loader is available! The trigger information is not stored in the ESD !");
1956 return kFALSE;
1957 }
1958 }
1959
b024fd7f 1960 // Now fill the trigger class names into AliESDRun object
1961 AliTriggerConfiguration *config = aCTP->GetConfiguration();
1962 if (!config) {
1963 AliError("No trigger configuration has been found! The trigger classes information will no be stored in ESD!");
d74294be 1964 if (fRawReader) delete aCTP;
b024fd7f 1965 return kFALSE;
1966 }
1967
1968 const TObjArray& classesArray = config->GetClasses();
1969 Int_t nclasses = classesArray.GetEntriesFast();
1970 for( Int_t j=0; j<nclasses; j++ ) {
1971 AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At( j );
1972 Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask());
1973 esd->SetTriggerClass(trclass->GetName(),trindex);
1974 }
1975
d74294be 1976 if (fRawReader) delete aCTP;
b647652d 1977 return kTRUE;
1978}
596a855f 1979
001397cd 1980
1981
1982
1983
1984//_____________________________________________________________________________
af885e0f 1985Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
001397cd 1986{
1987 //
1988 // Filling information from RawReader Header
1989 //
1990
1991 AliInfo("Filling information from RawReader Header");
31fd97b2 1992 esd->SetBunchCrossNumber(0);
1993 esd->SetOrbitNumber(0);
9bcc1e45 1994 esd->SetPeriodNumber(0);
001397cd 1995 esd->SetTimeStamp(0);
1996 esd->SetEventType(0);
1997 const AliRawEventHeaderBase * eventHeader = fRawReader->GetEventHeader();
1998 if (eventHeader){
9bcc1e45 1999
2000 const UInt_t *id = eventHeader->GetP("Id");
2001 esd->SetBunchCrossNumber((id)[1]&0x00000fff);
2002 esd->SetOrbitNumber((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff));
2003 esd->SetPeriodNumber(((id)[0]>>4)&0x0fffffff);
2004
001397cd 2005 esd->SetTimeStamp((eventHeader->Get("Timestamp")));
31fd97b2 2006 esd->SetEventType((eventHeader->Get("Type")));
001397cd 2007 }
2008
2009 return kTRUE;
2010}
2011
2012
596a855f 2013//_____________________________________________________________________________
2014Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
2015{
2016// check whether detName is contained in detectors
2017// if yes, it is removed from detectors
2018
2019 // check if all detectors are selected
2020 if ((detectors.CompareTo("ALL") == 0) ||
2021 detectors.BeginsWith("ALL ") ||
2022 detectors.EndsWith(" ALL") ||
2023 detectors.Contains(" ALL ")) {
2024 detectors = "ALL";
2025 return kTRUE;
2026 }
2027
2028 // search for the given detector
2029 Bool_t result = kFALSE;
2030 if ((detectors.CompareTo(detName) == 0) ||
2031 detectors.BeginsWith(detName+" ") ||
2032 detectors.EndsWith(" "+detName) ||
2033 detectors.Contains(" "+detName+" ")) {
2034 detectors.ReplaceAll(detName, "");
2035 result = kTRUE;
2036 }
2037
2038 // clean up the detectors string
2039 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
2040 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
2041 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
2042
2043 return result;
2044}
e583c30d 2045
f08fc9f5 2046//_____________________________________________________________________________
2047Bool_t AliReconstruction::InitRunLoader()
2048{
2049// get or create the run loader
2050
2051 if (gAlice) delete gAlice;
2052 gAlice = NULL;
2053
b26c3770 2054 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
2055 // load all base libraries to get the loader classes
2056 TString libs = gSystem->GetLibraries();
2057 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2058 TString detName = fgkDetectorName[iDet];
2059 if (detName == "HLT") continue;
2060 if (libs.Contains("lib" + detName + "base.so")) continue;
2061 gSystem->Load("lib" + detName + "base.so");
2062 }
f08fc9f5 2063 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
2064 if (!fRunLoader) {
2065 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
2066 CleanUp();
2067 return kFALSE;
2068 }
325aa76f 2069
b26c3770 2070 fRunLoader->CdGAFile();
325aa76f 2071 fRunLoader->LoadgAlice();
f08fc9f5 2072
6cae184e 2073 //PH This is a temporary fix to give access to the kinematics
2074 //PH that is needed for the labels of ITS clusters
f2ee4290 2075 fRunLoader->LoadHeader();
6cae184e 2076 fRunLoader->LoadKinematics();
2077
f08fc9f5 2078 } else { // galice.root does not exist
2079 if (!fRawReader) {
2080 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
2081 CleanUp();
2082 return kFALSE;
2083 }
2084 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
2085 AliConfig::GetDefaultEventFolderName(),
2086 "recreate");
2087 if (!fRunLoader) {
2088 AliError(Form("could not create run loader in file %s",
2089 fGAliceFileName.Data()));
2090 CleanUp();
2091 return kFALSE;
2092 }
21a3aa09 2093 fIsNewRunLoader = kTRUE;
f08fc9f5 2094 fRunLoader->MakeTree("E");
21a3aa09 2095
973388c2 2096 if (fNumberOfEventsPerFile > 0)
2097 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
2098 else
21a3aa09 2099 fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
f08fc9f5 2100 }
2101
2102 return kTRUE;
2103}
2104
c757bafd 2105//_____________________________________________________________________________
b8cd5251 2106AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
c757bafd 2107{
f08fc9f5 2108// get the reconstructor object and the loader for a detector
c757bafd 2109
b8cd5251 2110 if (fReconstructor[iDet]) return fReconstructor[iDet];
2111
2112 // load the reconstructor object
2113 TPluginManager* pluginManager = gROOT->GetPluginManager();
2114 TString detName = fgkDetectorName[iDet];
2115 TString recName = "Ali" + detName + "Reconstructor";
f0999a9a 2116
2117 if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
b8cd5251 2118
b8cd5251 2119 AliReconstructor* reconstructor = NULL;
2120 // first check if a plugin is defined for the reconstructor
2121 TPluginHandler* pluginHandler =
2122 pluginManager->FindHandler("AliReconstructor", detName);
f08fc9f5 2123 // if not, add a plugin for it
2124 if (!pluginHandler) {
b8cd5251 2125 AliDebug(1, Form("defining plugin for %s", recName.Data()));
b26c3770 2126 TString libs = gSystem->GetLibraries();
2127 if (libs.Contains("lib" + detName + "base.so") ||
2128 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
b8cd5251 2129 pluginManager->AddHandler("AliReconstructor", detName,
2130 recName, detName + "rec", recName + "()");
2131 } else {
2132 pluginManager->AddHandler("AliReconstructor", detName,
2133 recName, detName, recName + "()");
c757bafd 2134 }
b8cd5251 2135 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
2136 }
2137 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2138 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
c757bafd 2139 }
b8cd5251 2140 if (reconstructor) {
2141 TObject* obj = fOptions.FindObject(detName.Data());
2142 if (obj) reconstructor->SetOption(obj->GetTitle());
d76c31f4 2143 reconstructor->Init();
b8cd5251 2144 fReconstructor[iDet] = reconstructor;
2145 }
2146
f08fc9f5 2147 // get or create the loader
2148 if (detName != "HLT") {
2149 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
2150 if (!fLoader[iDet]) {
2151 AliConfig::Instance()
2152 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
2153 detName, detName);
2154 // first check if a plugin is defined for the loader
bb0901a4 2155 pluginHandler =
f08fc9f5 2156 pluginManager->FindHandler("AliLoader", detName);
2157 // if not, add a plugin for it
2158 if (!pluginHandler) {
2159 TString loaderName = "Ali" + detName + "Loader";
2160 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
2161 pluginManager->AddHandler("AliLoader", detName,
2162 loaderName, detName + "base",
2163 loaderName + "(const char*, TFolder*)");
2164 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
2165 }
2166 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2167 fLoader[iDet] =
2168 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
2169 fRunLoader->GetEventFolder());
2170 }
2171 if (!fLoader[iDet]) { // use default loader
2172 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
2173 }
2174 if (!fLoader[iDet]) {
2175 AliWarning(Form("couldn't get loader for %s", detName.Data()));
6667b602 2176 if (fStopOnError) return NULL;
f08fc9f5 2177 } else {
2178 fRunLoader->AddLoader(fLoader[iDet]);
2179 fRunLoader->CdGAFile();
2180 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
2181 fRunLoader->Write(0, TObject::kOverwrite);
2182 }
2183 }
2184 }
2185
b8cd5251 2186 return reconstructor;
c757bafd 2187}
2188
2257f27e 2189//_____________________________________________________________________________
2190Bool_t AliReconstruction::CreateVertexer()
2191{
2192// create the vertexer
2193
b8cd5251 2194 fVertexer = NULL;
2195 AliReconstructor* itsReconstructor = GetReconstructor(0);
59697224 2196 if (itsReconstructor) {
d76c31f4 2197 fVertexer = itsReconstructor->CreateVertexer();
2257f27e 2198 }
b8cd5251 2199 if (!fVertexer) {
815c2b38 2200 AliWarning("couldn't create a vertexer for ITS");
2257f27e 2201 if (fStopOnError) return kFALSE;
2202 }
2203
2204 return kTRUE;
2205}
2206
24f7a148 2207//_____________________________________________________________________________
b8cd5251 2208Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
24f7a148 2209{
f08fc9f5 2210// create the trackers
24f7a148 2211
b8cd5251 2212 TString detStr = detectors;
2213 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2214 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2215 AliReconstructor* reconstructor = GetReconstructor(iDet);
2216 if (!reconstructor) continue;
2217 TString detName = fgkDetectorName[iDet];
1f46a9ae 2218 if (detName == "HLT") {
2219 fRunHLTTracking = kTRUE;
2220 continue;
2221 }
e66fbafb 2222 if (detName == "MUON") {
2223 fRunMuonTracking = kTRUE;
2224 continue;
2225 }
2226
f08fc9f5 2227
d76c31f4 2228 fTracker[iDet] = reconstructor->CreateTracker();
f08fc9f5 2229 if (!fTracker[iDet] && (iDet < 7)) {
2230 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
8250d5f5 2231 if (fStopOnError) return kFALSE;
2232 }
6efecea1 2233 AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
8250d5f5 2234 }
2235
24f7a148 2236 return kTRUE;
2237}
2238
e583c30d 2239//_____________________________________________________________________________
b26c3770 2240void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
e583c30d 2241{
2242// delete trackers and the run loader and close and delete the file
2243
b8cd5251 2244 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2245 delete fReconstructor[iDet];
2246 fReconstructor[iDet] = NULL;
2247 fLoader[iDet] = NULL;
2248 delete fTracker[iDet];
2249 fTracker[iDet] = NULL;
c65c502a 2250// delete fQADataMaker[iDet];
2251// fQADataMaker[iDet] = NULL;
b8cd5251 2252 }
2253 delete fVertexer;
2254 fVertexer = NULL;
21a3aa09 2255
2256 if (ftVertexer) delete ftVertexer;
2257 ftVertexer = NULL;
795e4a22 2258
2259 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
2260 delete fDiamondProfile;
2261 fDiamondProfile = NULL;
43c9dae1 2262 delete fDiamondProfileTPC;
2263 fDiamondProfileTPC = NULL;
6b6e4472 2264 delete fGRPData;
2265 fGRPData = NULL;
795e4a22 2266 }
e583c30d 2267
444753c6 2268
e583c30d 2269 delete fRunLoader;
2270 fRunLoader = NULL;
b649205a 2271 delete fRawReader;
2272 fRawReader = NULL;
cd0b062e 2273 if (fParentRawReader) delete fParentRawReader;
2274 fParentRawReader=NULL;
e583c30d 2275
2276 if (file) {
2277 file->Close();
2278 delete file;
2279 }
b26c3770 2280
2281 if (fileOld) {
2282 fileOld->Close();
2283 delete fileOld;
2284 gSystem->Unlink("AliESDs.old.root");
2285 }
21a3aa09 2286
e583c30d 2287}
24f7a148 2288
24f7a148 2289//_____________________________________________________________________________
af885e0f 2290
2291Bool_t AliReconstruction::ReadESD(AliESDEvent*& esd, const char* recStep) const
24f7a148 2292{
2293// read the ESD event from a file
2294
2295 if (!esd) return kFALSE;
2296 char fileName[256];
2297 sprintf(fileName, "ESD_%d.%d_%s.root",
31fd97b2 2298 esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
24f7a148 2299 if (gSystem->AccessPathName(fileName)) return kFALSE;
2300
f3a97c86 2301 AliInfo(Form("reading ESD from file %s", fileName));
815c2b38 2302 AliDebug(1, Form("reading ESD from file %s", fileName));
24f7a148 2303 TFile* file = TFile::Open(fileName);
2304 if (!file || !file->IsOpen()) {
815c2b38 2305 AliError(Form("opening %s failed", fileName));
24f7a148 2306 delete file;
2307 return kFALSE;
2308 }
2309
2310 gROOT->cd();
2311 delete esd;
af885e0f 2312 esd = (AliESDEvent*) file->Get("ESD");
24f7a148 2313 file->Close();
2314 delete file;
2315 return kTRUE;
af885e0f 2316
24f7a148 2317}
2318
af885e0f 2319
2320
24f7a148 2321//_____________________________________________________________________________
af885e0f 2322void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const
24f7a148 2323{
2324// write the ESD event to a file
2325
2326 if (!esd) return;
2327 char fileName[256];
2328 sprintf(fileName, "ESD_%d.%d_%s.root",
31fd97b2 2329 esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
24f7a148 2330
815c2b38 2331 AliDebug(1, Form("writing ESD to file %s", fileName));
24f7a148 2332 TFile* file = TFile::Open(fileName, "recreate");
2333 if (!file || !file->IsOpen()) {
815c2b38 2334 AliError(Form("opening %s failed", fileName));
24f7a148 2335 } else {
2336 esd->Write("ESD");
2337 file->Close();
2338 }
2339 delete file;
2340}
f3a97c86 2341
2342
af885e0f 2343void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
98937d93 2344{
2345 // Write space-points which are then used in the alignment procedures
2346 // For the moment only ITS, TRD and TPC
2347
2348 // Load TOF clusters
d528ee75 2349 if (fTracker[3]){
2350 fLoader[3]->LoadRecPoints("read");
2351 TTree* tree = fLoader[3]->TreeR();
2352 if (!tree) {
2353 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[3]));
2354 return;
2355 }
2356 fTracker[3]->LoadClusters(tree);
98937d93 2357 }
98937d93 2358 Int_t ntracks = esd->GetNumberOfTracks();
2359 for (Int_t itrack = 0; itrack < ntracks; itrack++)
2360 {
2361 AliESDtrack *track = esd->GetTrack(itrack);
2362 Int_t nsp = 0;
ef7253ac 2363 Int_t idx[200];
98937d93 2364 for (Int_t iDet = 3; iDet >= 0; iDet--)
2365 nsp += track->GetNcls(iDet);
2366 if (nsp) {
2367 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
2368 track->SetTrackPointArray(sp);
2369 Int_t isptrack = 0;
2370 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2371 AliTracker *tracker = fTracker[iDet];
2372 if (!tracker) continue;
2373 Int_t nspdet = track->GetNcls(iDet);
98937d93 2374 if (nspdet <= 0) continue;
2375 track->GetClusters(iDet,idx);
2376 AliTrackPoint p;
2377 Int_t isp = 0;
2378 Int_t isp2 = 0;
4ed6fb1c 2379 while (isp2 < nspdet) {
48ce48d1 2380 Bool_t isvalid;
c12b6e44 2381 TString dets = fgkDetectorName[iDet];
2382 if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
2383 fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
2384 fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
2385 fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
2386 isvalid = tracker->GetTrackPointTrackingError(idx[isp2],p,track);
48ce48d1 2387 } else {
2388 isvalid = tracker->GetTrackPoint(idx[isp2],p);
2389 }
2390 isp2++;
160db090 2391 const Int_t kNTPCmax = 159;
2392 if (iDet==1 && isp2>kNTPCmax) break; // to be fixed
98937d93 2393 if (!isvalid) continue;
2394 sp->AddPoint(isptrack,&p); isptrack++; isp++;
2395 }
98937d93 2396 }
2397 }
2398 }
d528ee75 2399 if (fTracker[3]){
2400 fTracker[3]->UnloadClusters();
2401 fLoader[3]->UnloadRecPoints();
2402 }
98937d93 2403}
2e3550da 2404
2405//_____________________________________________________________________________
af885e0f 2406void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
2e3550da 2407{
2408 // The method reads the raw-data error log
2409 // accumulated within the rawReader.
2410 // It extracts the raw-data errors related to
2411 // the current event and stores them into
2412 // a TClonesArray inside the esd object.
2413
2414 if (!fRawReader) return;
2415
2416 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
2417
2418 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
2419 if (!log) continue;
2420 if (iEvent != log->GetEventNumber()) continue;
2421
2422 esd->AddRawDataErrorLog(log);
2423 }
2424
2425}
46698ae4 2426
605cb8bb 2427TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString pName){
b545009a 2428 // Dump a file content into a char in TNamed
46698ae4 2429 ifstream in;
2430 in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
2431 Int_t kBytes = (Int_t)in.tellg();
2432 printf("Size: %d \n",kBytes);
2433 TNamed *fn = 0;
2434 if(in.good()){
2435 char* memblock = new char [kBytes];
2436 in.seekg (0, ios::beg);
2437 in.read (memblock, kBytes);
2438 in.close();
2439 TString fData(memblock,kBytes);
605cb8bb 2440 fn = new TNamed(pName,fData);
46698ae4 2441 printf("fData Size: %d \n",fData.Sizeof());
605cb8bb 2442 printf("pName Size: %d \n",pName.Sizeof());
46698ae4 2443 printf("fn Size: %d \n",fn->Sizeof());
2444 delete[] memblock;
2445 }
2446 else{
2447 AliInfo(Form("Could not Open %s\n",fPath.Data()));
2448 }
2449
2450 return fn;
2451}
2452
605cb8bb 2453void AliReconstruction::TNamedToFile(TTree* fTree, TString pName){
46698ae4 2454 // This is not really needed in AliReconstruction at the moment
2455 // but can serve as a template
2456
2457 TList *fList = fTree->GetUserInfo();
605cb8bb 2458 TNamed *fn = (TNamed*)fList->FindObject(pName.Data());
46698ae4 2459 printf("fn Size: %d \n",fn->Sizeof());
2460
605cb8bb 2461 TString fTmp(fn->GetName()); // to be 100% sure in principle pName also works
46698ae4 2462 const char* cdata = fn->GetTitle();
2463 printf("fTmp Size %d\n",fTmp.Sizeof());
2464
2465 int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
2466 printf("calculated size %d\n",size);
605cb8bb 2467 ofstream out(pName.Data(),ios::out | ios::binary);
46698ae4 2468 out.write(cdata,size);
2469 out.close();
2470
2471}
6efecea1 2472
7e963665 2473//_____________________________________________________________________________
04236e67 2474AliQADataMakerRec * AliReconstruction::GetQADataMaker(Int_t iDet)
7e963665 2475{
2476 // get the quality assurance data maker object and the loader for a detector
6efecea1 2477
7e963665 2478 if (fQADataMaker[iDet])
2479 return fQADataMaker[iDet];
2480
04236e67 2481 AliQADataMakerRec * qadm = NULL;
2482 if (iDet == fgkNDetectors) { //Global QA
2483 qadm = new AliGlobalQADataMaker();
aa3c69a9 2484 fQADataMaker[iDet] = qadm;
2485 return qadm;
2486 }
2487
7e963665 2488 // load the QA data maker object
2489 TPluginManager* pluginManager = gROOT->GetPluginManager();
2490 TString detName = fgkDetectorName[iDet];
04236e67 2491 TString qadmName = "Ali" + detName + "QADataMakerRec";
f0999a9a 2492 if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT"))
7e963665 2493 return NULL;
2494
7e963665 2495 // first check if a plugin is defined for the quality assurance data maker
04236e67 2496 TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
7e963665 2497 // if not, add a plugin for it
2498 if (!pluginHandler) {
2499 AliDebug(1, Form("defining plugin for %s", qadmName.Data()));
2500 TString libs = gSystem->GetLibraries();
2501 if (libs.Contains("lib" + detName + "base.so") ||
2502 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
04236e67 2503 pluginManager->AddHandler("AliQADataMakerRec", detName,
7e963665 2504 qadmName, detName + "qadm", qadmName + "()");
2505 } else {
04236e67 2506 pluginManager->AddHandler("AliQADataMakerRec", detName,
7e963665 2507 qadmName, detName, qadmName + "()");
2508 }
04236e67 2509 pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
7e963665 2510 }
2511 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
04236e67 2512 qadm = (AliQADataMakerRec *) pluginHandler->ExecPlugin(0);
7e963665 2513 }
aa3c69a9 2514
2515 fQADataMaker[iDet] = qadm;
7e963665 2516
2517 return qadm;
2518}
46698ae4 2519
a5fa6165 2520//_____________________________________________________________________________
7e963665 2521Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd)
2522{
2523 // run the Quality Assurance data producer
2524
2525 AliCodeTimerAuto("")
2526 TString detStr = detectors;
2527 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2528 if (!IsSelected(fgkDetectorName[iDet], detStr))
2529 continue;
04236e67 2530 AliQADataMakerRec * qadm = GetQADataMaker(iDet);
7e963665 2531 if (!qadm)
2532 continue;
2533 AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2534 AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2535
2536 qadm->Exec(AliQA::kESDS, esd) ;
2537 qadm->Increment() ;
2538
2539 AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2540 }
2541 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2542 AliError(Form("the following detectors were not found: %s",
2543 detStr.Data()));
2544 if (fStopOnError)
2545 return kFALSE;
2546 }
2547
2548 return kTRUE;
2549
2550}
8661738e 2551
2552//_____________________________________________________________________________
2553void AliReconstruction::CheckQA()
2554{
2555// check the QA of SIM for this run and remove the detectors
2556// with status Fatal
2557
abe0c04e 2558 TString newRunLocalReconstruction ;
2559 TString newRunTracking ;
2560 TString newFillESD ;
2561
8661738e 2562 for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
2563 TString detName(AliQA::GetDetName(iDet)) ;
96d67a8d 2564 AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ;
2565 if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, AliQA::kFATAL)) {
8661738e 2566 AliInfo(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed", detName.Data())) ;
abe0c04e 2567 } else {
2568 if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) ||
2569 fRunLocalReconstruction.Contains("ALL") ) {
2570 newRunLocalReconstruction += detName ;
2571 newRunLocalReconstruction += " " ;
2572 }
2573 if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) ||
2574 fRunTracking.Contains("ALL") ) {
2575 newRunTracking += detName ;
2576 newRunTracking += " " ;
2577 }
2578 if ( fFillESD.Contains(AliQA::GetDetName(iDet)) ||
2579 fFillESD.Contains("ALL") ) {
2580 newFillESD += detName ;
2581 newFillESD += " " ;
8661738e 2582 }
2583 }
2584 }
abe0c04e 2585 fRunLocalReconstruction = newRunLocalReconstruction ;
2586 fRunTracking = newRunTracking ;
2587 fFillESD = newFillESD ;
a5fa6165 2588}
5b188f2f 2589
2590//_____________________________________________________________________________
2591Int_t AliReconstruction::GetDetIndex(const char* detector)
2592{
2593 // return the detector index corresponding to detector
2594 Int_t index = -1 ;
2595 for (index = 0; index < fgkNDetectors ; index++) {
2596 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
2597 break ;
2598 }
2599 return index ;
2600}
7167ae53 2601//_____________________________________________________________________________
2602Bool_t AliReconstruction::FinishPlaneEff() {
2603 //
2604 // Here execute all the necessary operationis, at the end of the tracking phase,
2605 // in case that evaluation of PlaneEfficiencies was required for some detector.
2606 // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
2607 //
2608 // This Preliminary version works only FOR ITS !!!!!
2609 // other detectors (TOF,TRD, etc. have to develop their specific codes)
2610 //
2611 // Input: none
2612 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
2613 //
2614 Bool_t ret=kFALSE;
2615 //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2616 for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
2617 //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
5fbd4fd6 2618 if(fTracker[iDet]) {
2619 AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
2620 ret=planeeff->WriteIntoCDB();
2621 if(planeeff->GetCreateHistos()) {
2622 TString name="PlaneEffHisto";
2623 name+=fgkDetectorName[iDet];
2624 name+=".root";
2625 ret*=planeeff->WriteHistosToFile(name,"RECREATE");
2626 }
2627 }
7167ae53 2628 }
2629 return ret;
2630}
2631//_____________________________________________________________________________
2632Bool_t AliReconstruction::InitPlaneEff() {
2633//
2634 // Here execute all the necessary operations, before of the tracking phase,
2635 // for the evaluation of PlaneEfficiencies, in case required for some detectors.
2636 // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
2637 // which should be updated/recalculated.
2638 //
2639 // This Preliminary version will work only FOR ITS !!!!!
2640 // other detectors (TOF,TRD, etc. have to develop their specific codes)
2641 //
2642 // Input: none
2643 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
2644 //
2645 AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE"));
2646 return kTRUE;
7520312d 2647}
14dd053c 2648
2649//_____________________________________________________________________________
2650Bool_t AliReconstruction::InitAliEVE()
2651{
2652 // This method should be called only in case
2653 // AliReconstruction is run
2654 // within the alieve environment.
2655 // It will initialize AliEVE in a way
2656 // so that it can visualize event processed
2657 // by AliReconstruction.
2658 // The return flag shows whenever the
2659 // AliEVE initialization was successful or not.
2660
2661 TString macroStr;
2662 macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
2663 AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
2664 if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
2665
de33999e 2666 gROOT->ProcessLine("if (!gAliEveEvent) {gAliEveEvent = new AliEveEventManager();gAliEveEvent->SetAutoLoad(kTRUE);gAliEveEvent->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(gAliEveEvent);};");
2667 gROOT->ProcessLine("alieve_online_init()");
14dd053c 2668
2669 return kTRUE;
2670}
2671
2672//_____________________________________________________________________________
2673void AliReconstruction::RunAliEVE()
2674{
2675 // Runs AliEVE visualisation of
2676 // the current event.
2677 // Should be executed only after
2678 // successful initialization of AliEVE.
2679
2680 AliInfo("Running AliEVE...");
2681 gROOT->ProcessLine(Form("gAliEveEvent->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p);",fRunLoader,fRawReader,fesd));
2682 gROOT->ProcessLine("gAliEveEvent->StartStopAutoLoadTimer();");
2683 gSystem->Run();
2684}