]> 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
The GRP CDB entry is not any more a TList, but a TMap
[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());
6bae477a 717 if (!gGeoManager) if (fStopOnError) return kFALSE;
718 }
8e245d15 719
6bae477a 720 if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
0f88822a 721 AliSysInfo::AddStamp("LoadGeom");
6bae477a 722
325aa76f 723
724 // Get the GRP CDB entry
725 AliCDBEntry* entryGRP = AliCDBManager::Instance()->Get("GRP/GRP/Data");
726
325aa76f 727 if (entryGRP)
ff5b314b 728 fGRPData = dynamic_cast<TMap*>(entryGRP->GetObject());
325aa76f 729
730 if (!fGRPData) {
731 AliError("No GRP entry found in OCDB!");
732 return kFALSE;
f6806ad3 733 }
325aa76f 734
735
736 // Magnetic field map
737 if (!AliTracker::GetFieldMap()) {
738 // Construct the field map out of the information retrieved from GRP.
739 //
740 // For the moment, this is a dummy piece of code.
741 // The actual map is expected to be already created in rec.C !
742 //
743
744 Float_t factor=1.;
745 Int_t map=AliMagWrapCheb::k5kG;
746 Bool_t dipoleON=kTRUE;
747
748 // L3
749 TObjString *l3Current=
750 dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Current"));
751 if (!l3Current) {
752 AliError("GRP/GRP/Data entry: missing value for the L3 current !");
753 return kFALSE;
754 }
755 TObjString *l3Polarity=
756 dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Polarity"));
757 if (!l3Polarity) {
758 AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
759 return kFALSE;
596a855f 760 }
325aa76f 761
762 // Dipole
763 TObjString *diCurrent=
764 dynamic_cast<TObjString*>(fGRPData->GetValue("fDipoleCurrent"));
765 if (!diCurrent) {
766 AliError("GRP/GRP/Data entry: missing value for the dipole current !");
767 return kFALSE;
768 }
769 TObjString *diPolarity=
770 dynamic_cast<TObjString*>(fGRPData->GetValue("fDipolePolarity"));
771 if (!diPolarity) {
772 AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
773 return kFALSE;
774 }
775
776
777 AliMagF *field=
778 new AliMagWrapCheb("Maps","Maps",2,factor,10.,map,dipoleON);
779 AliTracker::SetFieldMap(field,fUniformField);
780
781 //Temporary measure
782 AliFatal("Please, provide the field map ! Crashing deliberately...");
783
784 }
785
786
787 // Get the diamond profile from OCDB
788 AliCDBEntry* entry = AliCDBManager::Instance()
789 ->Get("GRP/Calib/MeanVertex");
790
791 if(entry) {
792 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
793 } else {
794 AliError("No diamond profile found in OCDB!");
795 }
796
797 entry = 0;
798 entry = AliCDBManager::Instance()
799 ->Get("GRP/Calib/MeanVertexTPC");
800
801 if(entry) {
802 fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
803 } else {
804 AliError("No diamond profile found in OCDB!");
596a855f 805 }
325aa76f 806
807 ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
808 if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile);
2257f27e 809
810 // get vertexer
811 if (fRunVertexFinder && !CreateVertexer()) {
812 if (fStopOnError) {
813 CleanUp();
814 return kFALSE;
815 }
816 }
0f88822a 817 AliSysInfo::AddStamp("Vertexer");
596a855f 818
f08fc9f5 819 // get trackers
b8cd5251 820 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
24f7a148 821 if (fStopOnError) {
822 CleanUp();
823 return kFALSE;
824 }
596a855f 825 }
0f88822a 826 AliSysInfo::AddStamp("LoadTrackers");
24f7a148 827
b26c3770 828 // get the possibly already existing ESD file and tree
21a3aa09 829 fesd = new AliESDEvent(); fhltesd = new AliESDEvent();
b26c3770 830 if (!gSystem->AccessPathName("AliESDs.root")){
831 gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE);
21a3aa09 832 ffileOld = TFile::Open("AliESDs.old.root");
833 if (ffileOld && ffileOld->IsOpen()) {
834 ftreeOld = (TTree*) ffileOld->Get("esdTree");
835 if (ftreeOld)fesd->ReadFromTree(ftreeOld);
836 fhlttreeOld = (TTree*) ffileOld->Get("HLTesdTree");
837 if (fhlttreeOld) fhltesd->ReadFromTree(fhlttreeOld);
b26c3770 838 }
839 }
840
36711aa4 841 // create the ESD output file and tree
21a3aa09 842 ffile = TFile::Open("AliESDs.root", "RECREATE");
843 ffile->SetCompressionLevel(2);
844 if (!ffile->IsOpen()) {
815c2b38 845 AliError("opening AliESDs.root failed");
21a3aa09 846 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
596a855f 847 }
46698ae4 848
21a3aa09 849 ftree = new TTree("esdTree", "Tree with ESD objects");
850 fesd = new AliESDEvent();
851 fesd->CreateStdContent();
852 fesd->WriteToTree(ftree);
46698ae4 853
21a3aa09 854 fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
855 fhltesd = new AliESDEvent();
856 fhltesd->CreateStdContent();
857 fhltesd->WriteToTree(fhlttree);
46698ae4 858
5728d3d5 859
1d99986f 860 if (fWriteESDfriend) {
21a3aa09 861 fesdf = new AliESDfriend();
862 TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
46698ae4 863 br->SetFile("AliESDfriends.root");
21a3aa09 864 fesd->AddObject(fesdf);
1d99986f 865 }
5728d3d5 866
444753c6 867
c5e3e5d1 868
b649205a 869 if (fRawReader) fRawReader->RewindEvents();
a5fa6165 870
95cee32f 871 ProcInfo_t ProcInfo;
872 gSystem->GetProcInfo(&ProcInfo);
873 AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
8661738e 874
aa3c69a9 875
325aa76f 876 //QA
877 AliQADataMakerSteer qas ;
878 if (fRunQA && fRawReader) {
879 qas.Run(fRunLocalReconstruction, fRawReader) ;
880 fSameQACycle = kTRUE ;
881 }
aa3c69a9 882 //Initialize the QA and start of cycle for out-of-cycle QA
f6806ad3 883 if (fRunQA) {
459fdee0 884// TString detStr(fFillESD);
885// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
886// if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
887// AliQADataMakerRec *qadm = GetQADataMaker(iDet);
888// if (!qadm) continue;
889// AliInfo(Form("Initializing the QA data maker for %s",
890// fgkDetectorName[iDet]));
891// qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
892// qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
893// if (!fInLoopQA) {
894// qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
895// qadm->StartOfCycle(AliQA::kESDS,"same");
896// }
897// }
e4a998ed 898 if (fRunGlobalQA) {
899 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
900 AliInfo(Form("Initializing the global QA data maker"));
901 TObjArray *arr=
902 qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
903 AliTracker::SetResidualsArray(arr);
904 qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
905 if (!fInLoopQA) {
906 qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
907 qadm->StartOfCycle(AliQA::kESDS, "same");
908 }
909 }
910 if (!fInLoopQA)
911 fSameQACycle = kTRUE;
aa3c69a9 912 }
913
7167ae53 914 //Initialize the Plane Efficiency framework
915 if (fRunPlaneEff && !InitPlaneEff()) {
21a3aa09 916 if(fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
7167ae53 917 }
aa3c69a9 918
14dd053c 919 if (strcmp(gProgName,"alieve") == 0)
920 fRunAliEVE = InitAliEVE();
921
21a3aa09 922 return kTRUE;
923}
924
925//_____________________________________________________________________________
926Bool_t AliReconstruction::RunEvent(Int_t iEvent)
927{
928 // run the reconstruction over a single event
929 // The event loop is steered in Run method
930
931 AliCodeTimerAuto("");
932
933 if (iEvent >= fRunLoader->GetNumberOfEvents()) {
934 fRunLoader->SetEventNumber(iEvent);
935 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
936 iEvent, iEvent);
937 //?? fRunLoader->MakeTree("H");
938 fRunLoader->TreeE()->Fill();
939 }
940
941 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
942 // copy old ESD to the new one
943 if (ftreeOld) {
944 fesd->ReadFromTree(ftreeOld);
945 ftreeOld->GetEntry(iEvent);
946 ftree->Fill();
b26c3770 947 }
21a3aa09 948 if (fhlttreeOld) {
f6806ad3 949 fhltesd->ReadFromTree(fhlttreeOld);
21a3aa09 950 fhlttreeOld->GetEntry(iEvent);
951 fhlttree->Fill();
952 }
953 return kTRUE;
954 }
955
956 AliInfo(Form("processing event %d", iEvent));
aa3c69a9 957
958 //Start of cycle for the in-loop QA
3b378a42 959 if (fInLoopQA) {
960 if (fRunQA) {
961 TString detStr(fFillESD);
962 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
e4a998ed 963 if (!IsSelected(fgkDetectorName[iDet], detStr))
964 continue;
3b378a42 965 AliQADataMakerRec *qadm = GetQADataMaker(iDet);
e4a998ed 966 if (!qadm)
967 continue;
968 qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
3b378a42 969 qadm->StartOfCycle(AliQA::kESDS, "same") ;
970 }
e4a998ed 971 if (fRunGlobalQA) {
972 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
973 qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
974 qadm->StartOfCycle(AliQA::kESDS, "same");
975 }
976 }
aa3c69a9 977 }
978
596a855f 979 fRunLoader->GetEvent(iEvent);
24f7a148 980
bb0901a4 981 char aFileName[256];
982 sprintf(aFileName, "ESD_%d.%d_final.root",
f08fc9f5 983 fRunLoader->GetHeader()->GetRun(),
984 fRunLoader->GetHeader()->GetEventNrInRun());
21a3aa09 985 if (!gSystem->AccessPathName(aFileName)) return kTRUE;
24f7a148 986
d506c543 987 // local single event reconstruction
b26c3770 988 if (!fRunLocalReconstruction.IsNull()) {
d506c543 989 TString detectors=fRunLocalReconstruction;
a441bf51 990 // run HLT event reconstruction first
d506c543 991 // ;-( IsSelected changes the string
992 if (IsSelected("HLT", detectors) &&
993 !RunLocalEventReconstruction("HLT")) {
a441bf51 994 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
995 }
996 detectors=fRunLocalReconstruction;
997 detectors.ReplaceAll("HLT", "");
998 if (!RunLocalEventReconstruction(detectors)) {
21a3aa09 999 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
b26c3770 1000 }
1001 }
1002
21a3aa09 1003 fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1004 fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1005 fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1006 fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
46698ae4 1007
d6ee376f 1008 // Set magnetic field from the tracker
21a3aa09 1009 fesd->SetMagneticField(AliTracker::GetBz());
1010 fhltesd->SetMagneticField(AliTracker::GetBz());
596a855f 1011
46698ae4 1012
1013
2e3550da 1014 // Fill raw-data error log into the ESD
21a3aa09 1015 if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
2e3550da 1016
2257f27e 1017 // vertex finder
1018 if (fRunVertexFinder) {
21a3aa09 1019 if (!ReadESD(fesd, "vertex")) {
1020 if (!RunVertexFinder(fesd)) {
1021 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
2257f27e 1022 }
21a3aa09 1023 if (fCheckPointLevel > 0) WriteESD(fesd, "vertex");
2257f27e 1024 }
1025 }
1026
e66fbafb 1027 // Muon tracking
b8cd5251 1028 if (!fRunTracking.IsNull()) {
e66fbafb 1029 if (fRunMuonTracking) {
21a3aa09 1030 if (!RunMuonTracking(fesd)) {
1031 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
24f7a148 1032 }
596a855f 1033 }
1034 }
1035
e66fbafb 1036 // barrel tracking
1037 if (!fRunTracking.IsNull()) {
21a3aa09 1038 if (!ReadESD(fesd, "tracking")) {
1039 if (!RunTracking(fesd)) {
1040 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
e66fbafb 1041 }
21a3aa09 1042 if (fCheckPointLevel > 0) WriteESD(fesd, "tracking");
e66fbafb 1043 }
1044 }
21c573b7 1045
596a855f 1046 // fill ESD
1047 if (!fFillESD.IsNull()) {
d506c543 1048 TString detectors=fFillESD;
f6806ad3 1049 // run HLT first and on hltesd
d506c543 1050 // ;-( IsSelected changes the string
1051 if (IsSelected("HLT", detectors) &&
1052 !FillESD(fhltesd, "HLT")) {
f6806ad3 1053 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1054 }
1055 detectors=fFillESD;
d5105682 1056 // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
1057 if (detectors.Contains("ALL")) {
1058 detectors="";
1059 for (Int_t idet=0; idet<fgkNDetectors; ++idet){
1060 detectors += fgkDetectorName[idet];
1061 detectors += " ";
1062 }
1063 }
f6806ad3 1064 detectors.ReplaceAll("HLT", "");
1065 if (!FillESD(fesd, detectors)) {
21a3aa09 1066 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
596a855f 1067 }
1068 }
a5fa6165 1069
001397cd 1070 // fill Event header information from the RawEventHeader
21a3aa09 1071 if (fRawReader){FillRawEventHeaderESD(fesd);}
596a855f 1072
1073 // combined PID
21a3aa09 1074 AliESDpid::MakePID(fesd);
1075 if (fCheckPointLevel > 1) WriteESD(fesd, "PID");
596a855f 1076
b647652d 1077 if (fFillTriggerESD) {
21a3aa09 1078 if (!ReadESD(fesd, "trigger")) {
1079 if (!FillTriggerESD(fesd)) {
1080 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
b647652d 1081 }
21a3aa09 1082 if (fCheckPointLevel > 1) WriteESD(fesd, "trigger");
b647652d 1083 }
1084 }
1085
21a3aa09 1086 ffile->cd();
a6ee503a 1087
3c3709c4 1088 //
67be5c77 1089 // Propagate track to the beam pipe (if not already done by ITS)
3c3709c4 1090 //
21a3aa09 1091 const Int_t ntracks = fesd->GetNumberOfTracks();
1092 const Double_t kBz = fesd->GetMagneticField();
3c3709c4 1093 const Double_t kRadius = 2.8; //something less than the beam pipe radius
1094
1095 TObjArray trkArray;
1096 UShort_t *selectedIdx=new UShort_t[ntracks];
1097
1098 for (Int_t itrack=0; itrack<ntracks; itrack++){
1099 const Double_t kMaxStep = 5; //max step over the material
1100 Bool_t ok;
1101
21a3aa09 1102 AliESDtrack *track = fesd->GetTrack(itrack);
3c3709c4 1103 if (!track) continue;
1104
1105 AliExternalTrackParam *tpcTrack =
1106 (AliExternalTrackParam *)track->GetTPCInnerParam();
bcabd6af 1107 ok = kFALSE;
1108 if (tpcTrack)
1109 ok = AliTracker::
1110 PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE);
43c9dae1 1111
1112
1113
3c3709c4 1114 if (ok) {
1115 Int_t n=trkArray.GetEntriesFast();
1116 selectedIdx[n]=track->GetID();
1117 trkArray.AddLast(tpcTrack);
1118 }
1119
f6806ad3 1120 if (track->GetX() < kRadius) continue;
3c3709c4 1121
f6806ad3 1122 ok = AliTracker::
3c3709c4 1123 PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
f6806ad3 1124 if (ok) {
1125 track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kRadius);
1126 }
3c3709c4 1127 }
1128
1129 //
1130 // Improve the reconstructed primary vertex position using the tracks
1131 //
1132 TObject *obj = fOptions.FindObject("ITS");
c060d7fe 1133 if (obj) {
1134 TString optITS = obj->GetTitle();
1135 if (optITS.Contains("cosmics") || optITS.Contains("COSMICS"))
a84e2607 1136 fRunVertexFinderTracks=kFALSE;
c060d7fe 1137 }
3c3709c4 1138 if (fRunVertexFinderTracks) {
1139 // TPC + ITS primary vertex
21a3aa09 1140 ftVertexer->SetITSrefitRequired();
43c9dae1 1141 if(fDiamondProfile && fMeanVertexConstraint) {
21a3aa09 1142 ftVertexer->SetVtxStart(fDiamondProfile);
43c9dae1 1143 } else {
21a3aa09 1144 ftVertexer->SetConstraintOff();
43c9dae1 1145 }
21a3aa09 1146 AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
3c3709c4 1147 if (pvtx) {
1148 if (pvtx->GetStatus()) {
21a3aa09 1149 fesd->SetPrimaryVertex(pvtx);
3c3709c4 1150 for (Int_t i=0; i<ntracks; i++) {
21a3aa09 1151 AliESDtrack *t = fesd->GetTrack(i);
f6806ad3 1152 t->RelateToVertex(pvtx, kBz, kRadius);
3c3709c4 1153 }
1154 }
1155 }
1156
1157 // TPC-only primary vertex
21a3aa09 1158 ftVertexer->SetITSrefitNotRequired();
43c9dae1 1159 if(fDiamondProfileTPC && fMeanVertexConstraint) {
21a3aa09 1160 ftVertexer->SetVtxStart(fDiamondProfileTPC);
43c9dae1 1161 } else {
21a3aa09 1162 ftVertexer->SetConstraintOff();
43c9dae1 1163 }
21a3aa09 1164 pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
3c3709c4 1165 if (pvtx) {
1166 if (pvtx->GetStatus()) {
21a3aa09 1167 fesd->SetPrimaryVertexTPC(pvtx);
3c3709c4 1168 Int_t nsel=trkArray.GetEntriesFast();
1169 for (Int_t i=0; i<nsel; i++) {
1170 AliExternalTrackParam *t =
1171 (AliExternalTrackParam *)trkArray.UncheckedAt(i);
1172 t->PropagateToDCA(pvtx, kBz, kRadius);
1173 }
1174 }
1175 }
1176
1177 }
1178 delete[] selectedIdx;
1179
21a3aa09 1180 if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
17c86e90 1181
c5e3e5d1 1182
d1683eef 1183 if (fRunV0Finder) {
1184 // V0 finding
1185 AliV0vertexer vtxer;
21a3aa09 1186 vtxer.Tracks2V0vertices(fesd);
5e4ff34d 1187
d1683eef 1188 if (fRunCascadeFinder) {
1189 // Cascade finding
1190 AliCascadeVertexer cvtxer;
21a3aa09 1191 cvtxer.V0sTracks2CascadeVertices(fesd);
d1683eef 1192 }
5e4ff34d 1193 }
1194
596a855f 1195 // write ESD
21a3aa09 1196 if (fCleanESD) CleanESD(fesd);
854c6476 1197
79740dfc 1198 if (fRunQA) {
1199 if (fRunGlobalQA) {
1200 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
1201 if (qadm) qadm->Exec(AliQA::kESDS, fesd);
1202 }
1203 }
854c6476 1204
1d99986f 1205 if (fWriteESDfriend) {
21a3aa09 1206 fesdf->~AliESDfriend();
1207 new (fesdf) AliESDfriend(); // Reset...
1208 fesd->GetESDfriend(fesdf);
1d99986f 1209 }
21a3aa09 1210 ftree->Fill();
500d54ab 1211
1212 // write HLT ESD
21a3aa09 1213 fhlttree->Fill();
1d99986f 1214
14dd053c 1215 // call AliEVE
1216 if (fRunAliEVE) RunAliEVE();
1217
21a3aa09 1218 if (fCheckPointLevel > 0) WriteESD(fesd, "final");
1219 fesd->Reset();
1220 fhltesd->Reset();
5728d3d5 1221 if (fWriteESDfriend) {
21a3aa09 1222 fesdf->~AliESDfriend();
1223 new (fesdf) AliESDfriend(); // Reset...
5728d3d5 1224 }
a5fa6165 1225
21a3aa09 1226 ProcInfo_t ProcInfo;
95cee32f 1227 gSystem->GetProcInfo(&ProcInfo);
1228 AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
a5fa6165 1229
7e963665 1230
aa3c69a9 1231 // End of cycle for the in-loop QA
3b378a42 1232 if (fInLoopQA) {
1233 if (fRunQA) {
21a3aa09 1234 RunQA(fFillESD.Data(), fesd);
3b378a42 1235 TString detStr(fFillESD);
1236 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
7c002d48 1237 if (!IsSelected(fgkDetectorName[iDet], detStr))
1238 continue;
1239 AliQADataMakerRec * qadm = GetQADataMaker(iDet);
1240 if (!qadm)
1241 continue;
1242 qadm->EndOfCycle(AliQA::kRECPOINTS);
1243 qadm->EndOfCycle(AliQA::kESDS);
1244 qadm->Finish();
1245 }
aa3c69a9 1246 }
1247 if (fRunGlobalQA) {
7c002d48 1248 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
aa3c69a9 1249 if (qadm) {
1250 qadm->EndOfCycle(AliQA::kRECPOINTS);
d7259b2e 1251 qadm->EndOfCycle(AliQA::kESDS);
aa3c69a9 1252 qadm->Finish();
1253 }
1254 }
1255 }
aa3c69a9 1256
21a3aa09 1257 return kTRUE;
1258}
1259
21a3aa09 1260//_____________________________________________________________________________
1261Bool_t AliReconstruction::FinishRun()
1262{
1263 // Finalize the run
1264 // Called after the exit
1265 // from the event loop
1266 AliCodeTimerAuto("");
1267
1268 if (fIsNewRunLoader) { // galice.root didn't exist
1269 fRunLoader->WriteHeader("OVERWRITE");
1270 fRunLoader->CdGAFile();
1271 fRunLoader->Write(0, TObject::kOverwrite);
1272 }
1273
1274 ftree->GetUserInfo()->Add(fesd);
1275 fhlttree->GetUserInfo()->Add(fhltesd);
f747912b 1276
1277 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
1278 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
1279
1280 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
1281 cdbMapCopy->SetOwner(1);
1282 cdbMapCopy->SetName("cdbMap");
1283 TIter iter(cdbMap->GetTable());
1284
1285 TPair* pair = 0;
1286 while((pair = dynamic_cast<TPair*> (iter.Next()))){
1287 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
1288 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
1289 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
1290 }
1291
1292 TList *cdbListCopy = new TList();
1293 cdbListCopy->SetOwner(1);
1294 cdbListCopy->SetName("cdbList");
1295
1296 TIter iter2(cdbList);
1297
1298 AliCDBId* id=0;
1299 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
a4970db9 1300 cdbListCopy->Add(new TObjString(id->ToString().Data()));
f747912b 1301 }
1302
21a3aa09 1303 ftree->GetUserInfo()->Add(cdbMapCopy);
1304 ftree->GetUserInfo()->Add(cdbListCopy);
abe0c04e 1305
46698ae4 1306
1307 if(fESDPar.Contains("ESD.par")){
1308 AliInfo("Attaching ESD.par to Tree");
1309 TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
21a3aa09 1310 ftree->GetUserInfo()->Add(fn);
596a855f 1311 }
1312
46698ae4 1313
21a3aa09 1314 ffile->cd();
aa3c69a9 1315
a9c0e6db 1316 if (fWriteESDfriend)
21a3aa09 1317 ftree->SetBranchStatus("ESDfriend*",0);
562dd0b4 1318 // we want to have only one tree version number
21a3aa09 1319 ftree->Write(ftree->GetName(),TObject::kOverwrite);
1320 fhlttree->Write();
f3a97c86 1321
a7a1e1c7 1322// Finish with Plane Efficiency evaluation: before of CleanUp !!!
1323 if (fRunPlaneEff && !FinishPlaneEff()) {
1324 AliWarning("Finish PlaneEff evaluation failed");
1325 }
1326
eae191bc 1327 gROOT->cd();
21a3aa09 1328 CleanUp(ffile, ffileOld);
eae191bc 1329
a7807689 1330 if (fWriteAOD) {
7a3b2050 1331 AliWarning("AOD creation not supported anymore during reconstruction. See ANALYSIS/AliAnalysisTaskESDfilter.cxx instead.");
a7807689 1332 }
1333
f3a97c86 1334 // Create tags for the events in the ESD tree (the ESD tree is always present)
1335 // In case of empty events the tags will contain dummy values
08e1a23e 1336 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
6b6e4472 1337 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData);
a1069ee1 1338 if (fWriteAOD) {
7a3b2050 1339 AliWarning("AOD tag creation not supported anymore during reconstruction.");
a1069ee1 1340 }
596a855f 1341
aa3c69a9 1342 //Finish QA and end of cycle for out-of-loop QA
3b378a42 1343 if (!fInLoopQA) {
79740dfc 1344 if (fRunQA) {
1345 AliQADataMakerSteer qas;
1346 qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS, fSameQACycle);
1347 //qas.Reset() ;
459fdee0 1348 qas.Run(fRunLocalReconstruction.Data(), AliQA::kESDS, fSameQACycle);
79740dfc 1349 if (fRunGlobalQA) {
1350 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
1351 if (qadm) {
1352 qadm->EndOfCycle(AliQA::kRECPOINTS);
1353 qadm->EndOfCycle(AliQA::kESDS);
1354 qadm->Finish();
1355 }
1356 }
1357 }
759c1df1 1358 }
795e4a22 1359
1360 // Cleanup of CDB manager: cache and active storages!
1361 AliCDBManager::Instance()->ClearCache();
1362
596a855f 1363 return kTRUE;
1364}
1365
1366
1367//_____________________________________________________________________________
c4aa7a4c 1368Bool_t AliReconstruction::RunLocalReconstruction(const TString& /*detectors*/)
596a855f 1369{
59697224 1370// run the local reconstruction
0f88822a 1371 static Int_t eventNr=0;
87932dab 1372 AliCodeTimerAuto("")
030b532d 1373
d76c31f4 1374 // AliCDBManager* man = AliCDBManager::Instance();
1375// Bool_t origCache = man->GetCacheFlag();
8e245d15 1376
d76c31f4 1377// TString detStr = detectors;
1378// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1379// if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1380// AliReconstructor* reconstructor = GetReconstructor(iDet);
1381// if (!reconstructor) continue;
1382// if (reconstructor->HasLocalReconstruction()) continue;
b8cd5251 1383
d76c31f4 1384// AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1385// AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
87932dab 1386
d76c31f4 1387// AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
1388// AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
8e245d15 1389
d76c31f4 1390// man->SetCacheFlag(kTRUE);
1391// TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]);
1392// man->GetAll(calibPath); // entries are cached!
8e245d15 1393
d76c31f4 1394// AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
87932dab 1395
d76c31f4 1396// if (fRawReader) {
1397// fRawReader->RewindEvents();
1398// reconstructor->Reconstruct(fRunLoader, fRawReader);
1399// } else {
1400// reconstructor->Reconstruct(fRunLoader);
1401// }
87932dab 1402
d76c31f4 1403// AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
0f88822a 1404 // AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr));
8e245d15 1405
d76c31f4 1406// // unload calibration data
1407// man->UnloadFromCache(calibPath);
1408// //man->ClearCache();
1409// }
596a855f 1410
d76c31f4 1411// man->SetCacheFlag(origCache);
8e245d15 1412
d76c31f4 1413// if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1414// AliError(Form("the following detectors were not found: %s",
1415// detStr.Data()));
1416// if (fStopOnError) return kFALSE;
1417// }
596a855f 1418
0f88822a 1419 eventNr++;
596a855f 1420 return kTRUE;
1421}
1422
b26c3770 1423//_____________________________________________________________________________
1424Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
1425{
1426// run the local reconstruction
aa3c69a9 1427
0f88822a 1428 static Int_t eventNr=0;
87932dab 1429 AliCodeTimerAuto("")
b26c3770 1430
1431 TString detStr = detectors;
1432 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1433 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1434 AliReconstructor* reconstructor = GetReconstructor(iDet);
1435 if (!reconstructor) continue;
1436 AliLoader* loader = fLoader[iDet];
f6806ad3 1437 // Matthias April 2008: temporary fix to run HLT reconstruction
1438 // although the HLT loader is missing
1439 if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
1440 if (fRawReader) {
1441 reconstructor->Reconstruct(fRawReader, NULL);
1442 } else {
1443 TTree* dummy=NULL;
1444 reconstructor->Reconstruct(dummy, NULL);
1445 }
1446 continue;
1447 }
d76c31f4 1448 if (!loader) {
1449 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
1450 continue;
1451 }
b26c3770 1452 // conversion of digits
1453 if (fRawReader && reconstructor->HasDigitConversion()) {
1454 AliInfo(Form("converting raw data digits into root objects for %s",
1455 fgkDetectorName[iDet]));
87932dab 1456 AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
1457 fgkDetectorName[iDet]));
b26c3770 1458 loader->LoadDigits("update");
1459 loader->CleanDigits();
1460 loader->MakeDigitsContainer();
1461 TTree* digitsTree = loader->TreeD();
1462 reconstructor->ConvertDigits(fRawReader, digitsTree);
1463 loader->WriteDigits("OVERWRITE");
1464 loader->UnloadDigits();
b26c3770 1465 }
b26c3770 1466 // local reconstruction
b26c3770 1467 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
87932dab 1468 AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
b26c3770 1469 loader->LoadRecPoints("update");
1470 loader->CleanRecPoints();
1471 loader->MakeRecPointsContainer();
1472 TTree* clustersTree = loader->TreeR();
1473 if (fRawReader && !reconstructor->HasDigitConversion()) {
1474 reconstructor->Reconstruct(fRawReader, clustersTree);
1475 } else {
1476 loader->LoadDigits("read");
1477 TTree* digitsTree = loader->TreeD();
1478 if (!digitsTree) {
1479 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
1480 if (fStopOnError) return kFALSE;
1481 } else {
1482 reconstructor->Reconstruct(digitsTree, clustersTree);
1483 }
1484 loader->UnloadDigits();
1485 }
d76c31f4 1486
aa3c69a9 1487 // In-loop QA for local reconstrucion
1488 if (fRunQA && fInLoopQA) {
04236e67 1489 AliQADataMakerRec * qadm = GetQADataMaker(iDet);
aa3c69a9 1490 if (qadm) {
1491 //AliCodeTimerStart
1492 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1493 //AliInfo
1494 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1495
1496 qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
1497
1498 //AliCodeTimerStop
1499 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1500 }
1501 }
d76c31f4 1502
aa3c69a9 1503 loader->WriteRecPoints("OVERWRITE");
b26c3770 1504 loader->UnloadRecPoints();
6efecea1 1505 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
b26c3770 1506 }
1507
1508 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1509 AliError(Form("the following detectors were not found: %s",
1510 detStr.Data()));
1511 if (fStopOnError) return kFALSE;
1512 }
0f88822a 1513 eventNr++;
b26c3770 1514 return kTRUE;
1515}
1516
596a855f 1517//_____________________________________________________________________________
af885e0f 1518Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
596a855f 1519{
1520// run the barrel tracking
1521
87932dab 1522 AliCodeTimerAuto("")
030b532d 1523
2257f27e 1524 AliESDVertex* vertex = NULL;
1525 Double_t vtxPos[3] = {0, 0, 0};
1526 Double_t vtxErr[3] = {0.07, 0.07, 0.1};
1527 TArrayF mcVertex(3);
a6b0b91b 1528 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
1529 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
1530 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
1531 }
2257f27e 1532
b8cd5251 1533 if (fVertexer) {
17c86e90 1534 if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
815c2b38 1535 AliInfo("running the ITS vertex finder");
b26c3770 1536 if (fLoader[0]) fLoader[0]->LoadRecPoints();
b8cd5251 1537 vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
b26c3770 1538 if (fLoader[0]) fLoader[0]->UnloadRecPoints();
2257f27e 1539 if(!vertex){
815c2b38 1540 AliWarning("Vertex not found");
c710f220 1541 vertex = new AliESDVertex();
d1a50cb5 1542 vertex->SetName("default");
2257f27e 1543 }
1544 else {
d1a50cb5 1545 vertex->SetName("reconstructed");
2257f27e 1546 }
1547
1548 } else {
815c2b38 1549 AliInfo("getting the primary vertex from MC");
2257f27e 1550 vertex = new AliESDVertex(vtxPos, vtxErr);
1551 }
1552
1553 if (vertex) {
1554 vertex->GetXYZ(vtxPos);
1555 vertex->GetSigmaXYZ(vtxErr);
1556 } else {
815c2b38 1557 AliWarning("no vertex reconstructed");
2257f27e 1558 vertex = new AliESDVertex(vtxPos, vtxErr);
1559 }
06cc9d95 1560 esd->SetPrimaryVertexSPD(vertex);
32e449be 1561 // if SPD multiplicity has been determined, it is stored in the ESD
25be1e5c 1562 AliMultiplicity *mult = fVertexer->GetMultiplicity();
32e449be 1563 if(mult)esd->SetMultiplicity(mult);
1564
b8cd5251 1565 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1566 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
1567 }
2257f27e 1568 delete vertex;
1569
2257f27e 1570 return kTRUE;
1571}
1572
1f46a9ae 1573//_____________________________________________________________________________
af885e0f 1574Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
1f46a9ae 1575{
1576// run the HLT barrel tracking
1577
87932dab 1578 AliCodeTimerAuto("")
1f46a9ae 1579
1580 if (!fRunLoader) {
1581 AliError("Missing runLoader!");
1582 return kFALSE;
1583 }
1584
1585 AliInfo("running HLT tracking");
1586
1587 // Get a pointer to the HLT reconstructor
1588 AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
1589 if (!reconstructor) return kFALSE;
1590
1591 // TPC + ITS
1592 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1593 TString detName = fgkDetectorName[iDet];
1594 AliDebug(1, Form("%s HLT tracking", detName.Data()));
1595 reconstructor->SetOption(detName.Data());
d76c31f4 1596 AliTracker *tracker = reconstructor->CreateTracker();
1f46a9ae 1597 if (!tracker) {
1598 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
1599 if (fStopOnError) return kFALSE;
9dcc06e1 1600 continue;
1f46a9ae 1601 }
1602 Double_t vtxPos[3];
1603 Double_t vtxErr[3]={0.005,0.005,0.010};
1604 const AliESDVertex *vertex = esd->GetVertex();
1605 vertex->GetXYZ(vtxPos);
1606 tracker->SetVertex(vtxPos,vtxErr);
1607 if(iDet != 1) {
1608 fLoader[iDet]->LoadRecPoints("read");
1609 TTree* tree = fLoader[iDet]->TreeR();
1610 if (!tree) {
1611 AliError(Form("Can't get the %s cluster tree", detName.Data()));
1612 return kFALSE;
1613 }
1614 tracker->LoadClusters(tree);
1615 }
1616 if (tracker->Clusters2Tracks(esd) != 0) {
1617 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
1618 return kFALSE;
1619 }
1620 if(iDet != 1) {
1621 tracker->UnloadClusters();
1622 }
1623 delete tracker;
1624 }
1625
1f46a9ae 1626 return kTRUE;
1627}
1628
e66fbafb 1629//_____________________________________________________________________________
af885e0f 1630Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
e66fbafb 1631{
1632// run the muon spectrometer tracking
1633
87932dab 1634 AliCodeTimerAuto("")
e66fbafb 1635
1636 if (!fRunLoader) {
1637 AliError("Missing runLoader!");
1638 return kFALSE;
1639 }
1640 Int_t iDet = 7; // for MUON
1641
1642 AliInfo("is running...");
1643
1644 // Get a pointer to the MUON reconstructor
1645 AliReconstructor *reconstructor = GetReconstructor(iDet);
1646 if (!reconstructor) return kFALSE;
1647
1648
1649 TString detName = fgkDetectorName[iDet];
1650 AliDebug(1, Form("%s tracking", detName.Data()));
d76c31f4 1651 AliTracker *tracker = reconstructor->CreateTracker();
e66fbafb 1652 if (!tracker) {
1653 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
1654 return kFALSE;
1655 }
1656
e66fbafb 1657 // read RecPoints
761350a6 1658 fLoader[iDet]->LoadRecPoints("read");
c1954ee5 1659
761350a6 1660 tracker->LoadClusters(fLoader[iDet]->TreeR());
1661
1662 Int_t rv = tracker->Clusters2Tracks(esd);
1663
761350a6 1664 if ( rv )
1665 {
e66fbafb 1666 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
1667 return kFALSE;
1668 }
761350a6 1669
e66fbafb 1670 fLoader[iDet]->UnloadRecPoints();
1671
c1954ee5 1672 tracker->UnloadClusters();
1673
e66fbafb 1674 delete tracker;
1675
e66fbafb 1676 return kTRUE;
1677}
1678
1679
2257f27e 1680//_____________________________________________________________________________
af885e0f 1681Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
2257f27e 1682{
1683// run the barrel tracking
0f88822a 1684 static Int_t eventNr=0;
87932dab 1685 AliCodeTimerAuto("")
24f7a148 1686
815c2b38 1687 AliInfo("running tracking");
596a855f 1688
91b876d1 1689 //Fill the ESD with the T0 info (will be used by the TOF)
d76c31f4 1690 if (fReconstructor[11] && fLoader[11]) {
1691 fLoader[11]->LoadRecPoints("READ");
1692 TTree *treeR = fLoader[11]->TreeR();
1693 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
1694 }
91b876d1 1695
b8cd5251 1696 // pass 1: TPC + ITS inwards
1697 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1698 if (!fTracker[iDet]) continue;
1699 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
24f7a148 1700
b8cd5251 1701 // load clusters
1702 fLoader[iDet]->LoadRecPoints("read");
6efecea1 1703 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
b8cd5251 1704 TTree* tree = fLoader[iDet]->TreeR();
1705 if (!tree) {
1706 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
24f7a148 1707 return kFALSE;
1708 }
b8cd5251 1709 fTracker[iDet]->LoadClusters(tree);
6efecea1 1710 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 1711 // run tracking
1712 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
1713 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
24f7a148 1714 return kFALSE;
1715 }
b8cd5251 1716 if (fCheckPointLevel > 1) {
1717 WriteESD(esd, Form("%s.tracking", fgkDetectorName[iDet]));
1718 }
878e1fe1 1719 // preliminary PID in TPC needed by the ITS tracker
1720 if (iDet == 1) {
b26c3770 1721 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
878e1fe1 1722 AliESDpid::MakePID(esd);
0f88822a 1723 }
6efecea1 1724 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
b8cd5251 1725 }
596a855f 1726
b8cd5251 1727 // pass 2: ALL backwards
aa3c69a9 1728
b8cd5251 1729 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1730 if (!fTracker[iDet]) continue;
1731 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
1732
1733 // load clusters
1734 if (iDet > 1) { // all except ITS, TPC
1735 TTree* tree = NULL;
7b61cd9c 1736 fLoader[iDet]->LoadRecPoints("read");
6efecea1 1737 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
7b61cd9c 1738 tree = fLoader[iDet]->TreeR();
b8cd5251 1739 if (!tree) {
1740 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
24f7a148 1741 return kFALSE;
1742 }
0f88822a 1743 fTracker[iDet]->LoadClusters(tree);
6efecea1 1744 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 1745 }
24f7a148 1746
b8cd5251 1747 // run tracking
283f39c6 1748 if (iDet>1) // start filling residuals for the "outer" detectors
1749 if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
1750
b8cd5251 1751 if (fTracker[iDet]->PropagateBack(esd) != 0) {
1752 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
49dfd67a 1753 // return kFALSE;
b8cd5251 1754 }
1755 if (fCheckPointLevel > 1) {
1756 WriteESD(esd, Form("%s.back", fgkDetectorName[iDet]));
1757 }
24f7a148 1758
b8cd5251 1759 // unload clusters
1760 if (iDet > 2) { // all except ITS, TPC, TRD
1761 fTracker[iDet]->UnloadClusters();
7b61cd9c 1762 fLoader[iDet]->UnloadRecPoints();
b8cd5251 1763 }
8f37df88 1764 // updated PID in TPC needed by the ITS tracker -MI
1765 if (iDet == 1) {
8f37df88 1766 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
1767 AliESDpid::MakePID(esd);
1768 }
6efecea1 1769 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
b8cd5251 1770 }
283f39c6 1771 //stop filling residuals for the "outer" detectors
1772 if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
596a855f 1773
98937d93 1774 // write space-points to the ESD in case alignment data output
1775 // is switched on
1776 if (fWriteAlignmentData)
1777 WriteAlignmentData(esd);
1778
b8cd5251 1779 // pass 3: TRD + TPC + ITS refit inwards
aa3c69a9 1780
b8cd5251 1781 for (Int_t iDet = 2; iDet >= 0; iDet--) {
1782 if (!fTracker[iDet]) continue;
1783 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
596a855f 1784
b8cd5251 1785 // run tracking
283f39c6 1786 if (iDet<2) // start filling residuals for TPC and ITS
1787 if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
1788
b8cd5251 1789 if (fTracker[iDet]->RefitInward(esd) != 0) {
1790 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
49dfd67a 1791 // return kFALSE;
b8cd5251 1792 }
db2368d0 1793 // run postprocessing
1794 if (fTracker[iDet]->PostProcess(esd) != 0) {
1795 AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
1796 // return kFALSE;
1797 }
b8cd5251 1798 if (fCheckPointLevel > 1) {
1799 WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet]));
1800 }
6efecea1 1801 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
b8cd5251 1802 // unload clusters
1803 fTracker[iDet]->UnloadClusters();
6efecea1 1804 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
b8cd5251 1805 fLoader[iDet]->UnloadRecPoints();
6efecea1 1806 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
b8cd5251 1807 }
283f39c6 1808 // stop filling residuals for TPC and ITS
3b378a42 1809 if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
854c6476 1810
0f88822a 1811 eventNr++;
596a855f 1812 return kTRUE;
1813}
1814
d64bd07d 1815//_____________________________________________________________________________
1816Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
1817 //
1818 // Remove the data which are not needed for the physics analysis.
1819 //
1820
d64bd07d 1821 Int_t nTracks=esd->GetNumberOfTracks();
18571674 1822 Int_t nV0s=esd->GetNumberOfV0s();
cf37fd88 1823 AliInfo
1824 (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
d64bd07d 1825
18571674 1826 Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
7f68891d 1827 Bool_t rc=esd->Clean(cleanPars);
d64bd07d 1828
7f68891d 1829 nTracks=esd->GetNumberOfTracks();
18571674 1830 nV0s=esd->GetNumberOfV0s();
cf37fd88 1831 AliInfo
ae5d5566 1832 (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
d64bd07d 1833
7f68891d 1834 return rc;
d64bd07d 1835}
1836
596a855f 1837//_____________________________________________________________________________
af885e0f 1838Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
596a855f 1839{
1840// fill the event summary data
1841
87932dab 1842 AliCodeTimerAuto("")
0f88822a 1843 static Int_t eventNr=0;
596a855f 1844 TString detStr = detectors;
abe0c04e 1845
b8cd5251 1846 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
abe0c04e 1847 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
b8cd5251 1848 AliReconstructor* reconstructor = GetReconstructor(iDet);
1849 if (!reconstructor) continue;
b8cd5251 1850 if (!ReadESD(esd, fgkDetectorName[iDet])) {
1851 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
b26c3770 1852 TTree* clustersTree = NULL;
d76c31f4 1853 if (fLoader[iDet]) {
b26c3770 1854 fLoader[iDet]->LoadRecPoints("read");
1855 clustersTree = fLoader[iDet]->TreeR();
1856 if (!clustersTree) {
1857 AliError(Form("Can't get the %s clusters tree",
1858 fgkDetectorName[iDet]));
1859 if (fStopOnError) return kFALSE;
1860 }
1861 }
1862 if (fRawReader && !reconstructor->HasDigitConversion()) {
1863 reconstructor->FillESD(fRawReader, clustersTree, esd);
1864 } else {
1865 TTree* digitsTree = NULL;
1866 if (fLoader[iDet]) {
1867 fLoader[iDet]->LoadDigits("read");
1868 digitsTree = fLoader[iDet]->TreeD();
1869 if (!digitsTree) {
1870 AliError(Form("Can't get the %s digits tree",
1871 fgkDetectorName[iDet]));
1872 if (fStopOnError) return kFALSE;
1873 }
1874 }
1875 reconstructor->FillESD(digitsTree, clustersTree, esd);
1876 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
1877 }
d76c31f4 1878 if (fLoader[iDet]) {
b26c3770 1879 fLoader[iDet]->UnloadRecPoints();
1880 }
1881
b8cd5251 1882 if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
596a855f 1883 }
1884 }
1885
1886 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
815c2b38 1887 AliError(Form("the following detectors were not found: %s",
1888 detStr.Data()));
596a855f 1889 if (fStopOnError) return kFALSE;
1890 }
6efecea1 1891 AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
0f88822a 1892 eventNr++;
596a855f 1893 return kTRUE;
1894}
1895
b647652d 1896//_____________________________________________________________________________
af885e0f 1897Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
b647652d 1898{
1899 // Reads the trigger decision which is
1900 // stored in Trigger.root file and fills
1901 // the corresponding esd entries
1902
87932dab 1903 AliCodeTimerAuto("")
1904
b647652d 1905 AliInfo("Filling trigger information into the ESD");
1906
b024fd7f 1907 AliCentralTrigger *aCTP = NULL;
1908
b647652d 1909 if (fRawReader) {
1910 AliCTPRawStream input(fRawReader);
1911 if (!input.Next()) {
1912 AliError("No valid CTP (trigger) DDL raw data is found ! The trigger information is not stored in the ESD !");
1913 return kFALSE;
1914 }
1915 esd->SetTriggerMask(input.GetClassMask());
1916 esd->SetTriggerCluster(input.GetClusterMask());
b024fd7f 1917
1918 aCTP = new AliCentralTrigger();
1919 TString configstr("");
1920 if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
1921 AliError("No trigger configuration found in OCDB! The trigger classes information will no be stored in ESD!");
259e35c9 1922 delete aCTP;
b024fd7f 1923 return kFALSE;
1924 }
b647652d 1925 }
1926 else {
1927 AliRunLoader *runloader = AliRunLoader::GetRunLoader();
1928 if (runloader) {
1929 if (!runloader->LoadTrigger()) {
1ea86aa2 1930 aCTP = runloader->GetTrigger();
b647652d 1931 esd->SetTriggerMask(aCTP->GetClassMask());
1932 esd->SetTriggerCluster(aCTP->GetClusterMask());
1933 }
1934 else {
1935 AliWarning("No trigger can be loaded! The trigger information is not stored in the ESD !");
1936 return kFALSE;
1937 }
1938 }
1939 else {
1940 AliError("No run loader is available! The trigger information is not stored in the ESD !");
1941 return kFALSE;
1942 }
1943 }
1944
b024fd7f 1945 // Now fill the trigger class names into AliESDRun object
1946 AliTriggerConfiguration *config = aCTP->GetConfiguration();
1947 if (!config) {
1948 AliError("No trigger configuration has been found! The trigger classes information will no be stored in ESD!");
d74294be 1949 if (fRawReader) delete aCTP;
b024fd7f 1950 return kFALSE;
1951 }
1952
1953 const TObjArray& classesArray = config->GetClasses();
1954 Int_t nclasses = classesArray.GetEntriesFast();
1955 for( Int_t j=0; j<nclasses; j++ ) {
1956 AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At( j );
1957 Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask());
1958 esd->SetTriggerClass(trclass->GetName(),trindex);
1959 }
1960
d74294be 1961 if (fRawReader) delete aCTP;
b647652d 1962 return kTRUE;
1963}
596a855f 1964
001397cd 1965
1966
1967
1968
1969//_____________________________________________________________________________
af885e0f 1970Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
001397cd 1971{
1972 //
1973 // Filling information from RawReader Header
1974 //
1975
1976 AliInfo("Filling information from RawReader Header");
31fd97b2 1977 esd->SetBunchCrossNumber(0);
1978 esd->SetOrbitNumber(0);
9bcc1e45 1979 esd->SetPeriodNumber(0);
001397cd 1980 esd->SetTimeStamp(0);
1981 esd->SetEventType(0);
1982 const AliRawEventHeaderBase * eventHeader = fRawReader->GetEventHeader();
1983 if (eventHeader){
9bcc1e45 1984
1985 const UInt_t *id = eventHeader->GetP("Id");
1986 esd->SetBunchCrossNumber((id)[1]&0x00000fff);
1987 esd->SetOrbitNumber((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff));
1988 esd->SetPeriodNumber(((id)[0]>>4)&0x0fffffff);
1989
001397cd 1990 esd->SetTimeStamp((eventHeader->Get("Timestamp")));
31fd97b2 1991 esd->SetEventType((eventHeader->Get("Type")));
001397cd 1992 }
1993
1994 return kTRUE;
1995}
1996
1997
596a855f 1998//_____________________________________________________________________________
1999Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
2000{
2001// check whether detName is contained in detectors
2002// if yes, it is removed from detectors
2003
2004 // check if all detectors are selected
2005 if ((detectors.CompareTo("ALL") == 0) ||
2006 detectors.BeginsWith("ALL ") ||
2007 detectors.EndsWith(" ALL") ||
2008 detectors.Contains(" ALL ")) {
2009 detectors = "ALL";
2010 return kTRUE;
2011 }
2012
2013 // search for the given detector
2014 Bool_t result = kFALSE;
2015 if ((detectors.CompareTo(detName) == 0) ||
2016 detectors.BeginsWith(detName+" ") ||
2017 detectors.EndsWith(" "+detName) ||
2018 detectors.Contains(" "+detName+" ")) {
2019 detectors.ReplaceAll(detName, "");
2020 result = kTRUE;
2021 }
2022
2023 // clean up the detectors string
2024 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
2025 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
2026 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
2027
2028 return result;
2029}
e583c30d 2030
f08fc9f5 2031//_____________________________________________________________________________
2032Bool_t AliReconstruction::InitRunLoader()
2033{
2034// get or create the run loader
2035
2036 if (gAlice) delete gAlice;
2037 gAlice = NULL;
2038
b26c3770 2039 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
2040 // load all base libraries to get the loader classes
2041 TString libs = gSystem->GetLibraries();
2042 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2043 TString detName = fgkDetectorName[iDet];
2044 if (detName == "HLT") continue;
2045 if (libs.Contains("lib" + detName + "base.so")) continue;
2046 gSystem->Load("lib" + detName + "base.so");
2047 }
f08fc9f5 2048 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
2049 if (!fRunLoader) {
2050 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
2051 CleanUp();
2052 return kFALSE;
2053 }
325aa76f 2054
b26c3770 2055 fRunLoader->CdGAFile();
325aa76f 2056 fRunLoader->LoadgAlice();
f08fc9f5 2057
6cae184e 2058 //PH This is a temporary fix to give access to the kinematics
2059 //PH that is needed for the labels of ITS clusters
f2ee4290 2060 fRunLoader->LoadHeader();
6cae184e 2061 fRunLoader->LoadKinematics();
2062
f08fc9f5 2063 } else { // galice.root does not exist
2064 if (!fRawReader) {
2065 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
2066 CleanUp();
2067 return kFALSE;
2068 }
2069 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
2070 AliConfig::GetDefaultEventFolderName(),
2071 "recreate");
2072 if (!fRunLoader) {
2073 AliError(Form("could not create run loader in file %s",
2074 fGAliceFileName.Data()));
2075 CleanUp();
2076 return kFALSE;
2077 }
21a3aa09 2078 fIsNewRunLoader = kTRUE;
f08fc9f5 2079 fRunLoader->MakeTree("E");
21a3aa09 2080
973388c2 2081 if (fNumberOfEventsPerFile > 0)
2082 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
2083 else
21a3aa09 2084 fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
f08fc9f5 2085 }
2086
2087 return kTRUE;
2088}
2089
c757bafd 2090//_____________________________________________________________________________
b8cd5251 2091AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
c757bafd 2092{
f08fc9f5 2093// get the reconstructor object and the loader for a detector
c757bafd 2094
b8cd5251 2095 if (fReconstructor[iDet]) return fReconstructor[iDet];
2096
2097 // load the reconstructor object
2098 TPluginManager* pluginManager = gROOT->GetPluginManager();
2099 TString detName = fgkDetectorName[iDet];
2100 TString recName = "Ali" + detName + "Reconstructor";
f0999a9a 2101
2102 if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
b8cd5251 2103
b8cd5251 2104 AliReconstructor* reconstructor = NULL;
2105 // first check if a plugin is defined for the reconstructor
2106 TPluginHandler* pluginHandler =
2107 pluginManager->FindHandler("AliReconstructor", detName);
f08fc9f5 2108 // if not, add a plugin for it
2109 if (!pluginHandler) {
b8cd5251 2110 AliDebug(1, Form("defining plugin for %s", recName.Data()));
b26c3770 2111 TString libs = gSystem->GetLibraries();
2112 if (libs.Contains("lib" + detName + "base.so") ||
2113 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
b8cd5251 2114 pluginManager->AddHandler("AliReconstructor", detName,
2115 recName, detName + "rec", recName + "()");
2116 } else {
2117 pluginManager->AddHandler("AliReconstructor", detName,
2118 recName, detName, recName + "()");
c757bafd 2119 }
b8cd5251 2120 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
2121 }
2122 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2123 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
c757bafd 2124 }
b8cd5251 2125 if (reconstructor) {
2126 TObject* obj = fOptions.FindObject(detName.Data());
2127 if (obj) reconstructor->SetOption(obj->GetTitle());
d76c31f4 2128 reconstructor->Init();
b8cd5251 2129 fReconstructor[iDet] = reconstructor;
2130 }
2131
f08fc9f5 2132 // get or create the loader
2133 if (detName != "HLT") {
2134 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
2135 if (!fLoader[iDet]) {
2136 AliConfig::Instance()
2137 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
2138 detName, detName);
2139 // first check if a plugin is defined for the loader
bb0901a4 2140 pluginHandler =
f08fc9f5 2141 pluginManager->FindHandler("AliLoader", detName);
2142 // if not, add a plugin for it
2143 if (!pluginHandler) {
2144 TString loaderName = "Ali" + detName + "Loader";
2145 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
2146 pluginManager->AddHandler("AliLoader", detName,
2147 loaderName, detName + "base",
2148 loaderName + "(const char*, TFolder*)");
2149 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
2150 }
2151 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2152 fLoader[iDet] =
2153 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
2154 fRunLoader->GetEventFolder());
2155 }
2156 if (!fLoader[iDet]) { // use default loader
2157 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
2158 }
2159 if (!fLoader[iDet]) {
2160 AliWarning(Form("couldn't get loader for %s", detName.Data()));
6667b602 2161 if (fStopOnError) return NULL;
f08fc9f5 2162 } else {
2163 fRunLoader->AddLoader(fLoader[iDet]);
2164 fRunLoader->CdGAFile();
2165 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
2166 fRunLoader->Write(0, TObject::kOverwrite);
2167 }
2168 }
2169 }
2170
b8cd5251 2171 return reconstructor;
c757bafd 2172}
2173
2257f27e 2174//_____________________________________________________________________________
2175Bool_t AliReconstruction::CreateVertexer()
2176{
2177// create the vertexer
2178
b8cd5251 2179 fVertexer = NULL;
2180 AliReconstructor* itsReconstructor = GetReconstructor(0);
59697224 2181 if (itsReconstructor) {
d76c31f4 2182 fVertexer = itsReconstructor->CreateVertexer();
2257f27e 2183 }
b8cd5251 2184 if (!fVertexer) {
815c2b38 2185 AliWarning("couldn't create a vertexer for ITS");
2257f27e 2186 if (fStopOnError) return kFALSE;
2187 }
2188
2189 return kTRUE;
2190}
2191
24f7a148 2192//_____________________________________________________________________________
b8cd5251 2193Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
24f7a148 2194{
f08fc9f5 2195// create the trackers
24f7a148 2196
b8cd5251 2197 TString detStr = detectors;
2198 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2199 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2200 AliReconstructor* reconstructor = GetReconstructor(iDet);
2201 if (!reconstructor) continue;
2202 TString detName = fgkDetectorName[iDet];
1f46a9ae 2203 if (detName == "HLT") {
2204 fRunHLTTracking = kTRUE;
2205 continue;
2206 }
e66fbafb 2207 if (detName == "MUON") {
2208 fRunMuonTracking = kTRUE;
2209 continue;
2210 }
2211
f08fc9f5 2212
d76c31f4 2213 fTracker[iDet] = reconstructor->CreateTracker();
f08fc9f5 2214 if (!fTracker[iDet] && (iDet < 7)) {
2215 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
8250d5f5 2216 if (fStopOnError) return kFALSE;
2217 }
6efecea1 2218 AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
8250d5f5 2219 }
2220
24f7a148 2221 return kTRUE;
2222}
2223
e583c30d 2224//_____________________________________________________________________________
b26c3770 2225void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
e583c30d 2226{
2227// delete trackers and the run loader and close and delete the file
2228
b8cd5251 2229 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2230 delete fReconstructor[iDet];
2231 fReconstructor[iDet] = NULL;
2232 fLoader[iDet] = NULL;
2233 delete fTracker[iDet];
2234 fTracker[iDet] = NULL;
c65c502a 2235// delete fQADataMaker[iDet];
2236// fQADataMaker[iDet] = NULL;
b8cd5251 2237 }
2238 delete fVertexer;
2239 fVertexer = NULL;
21a3aa09 2240
2241 if (ftVertexer) delete ftVertexer;
2242 ftVertexer = NULL;
795e4a22 2243
2244 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
2245 delete fDiamondProfile;
2246 fDiamondProfile = NULL;
43c9dae1 2247 delete fDiamondProfileTPC;
2248 fDiamondProfileTPC = NULL;
6b6e4472 2249 delete fGRPData;
2250 fGRPData = NULL;
795e4a22 2251 }
e583c30d 2252
444753c6 2253
e583c30d 2254 delete fRunLoader;
2255 fRunLoader = NULL;
b649205a 2256 delete fRawReader;
2257 fRawReader = NULL;
cd0b062e 2258 if (fParentRawReader) delete fParentRawReader;
2259 fParentRawReader=NULL;
e583c30d 2260
2261 if (file) {
2262 file->Close();
2263 delete file;
2264 }
b26c3770 2265
2266 if (fileOld) {
2267 fileOld->Close();
2268 delete fileOld;
2269 gSystem->Unlink("AliESDs.old.root");
2270 }
21a3aa09 2271
e583c30d 2272}
24f7a148 2273
24f7a148 2274//_____________________________________________________________________________
af885e0f 2275
2276Bool_t AliReconstruction::ReadESD(AliESDEvent*& esd, const char* recStep) const
24f7a148 2277{
2278// read the ESD event from a file
2279
2280 if (!esd) return kFALSE;
2281 char fileName[256];
2282 sprintf(fileName, "ESD_%d.%d_%s.root",
31fd97b2 2283 esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
24f7a148 2284 if (gSystem->AccessPathName(fileName)) return kFALSE;
2285
f3a97c86 2286 AliInfo(Form("reading ESD from file %s", fileName));
815c2b38 2287 AliDebug(1, Form("reading ESD from file %s", fileName));
24f7a148 2288 TFile* file = TFile::Open(fileName);
2289 if (!file || !file->IsOpen()) {
815c2b38 2290 AliError(Form("opening %s failed", fileName));
24f7a148 2291 delete file;
2292 return kFALSE;
2293 }
2294
2295 gROOT->cd();
2296 delete esd;
af885e0f 2297 esd = (AliESDEvent*) file->Get("ESD");
24f7a148 2298 file->Close();
2299 delete file;
2300 return kTRUE;
af885e0f 2301
24f7a148 2302}
2303
af885e0f 2304
2305
24f7a148 2306//_____________________________________________________________________________
af885e0f 2307void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const
24f7a148 2308{
2309// write the ESD event to a file
2310
2311 if (!esd) return;
2312 char fileName[256];
2313 sprintf(fileName, "ESD_%d.%d_%s.root",
31fd97b2 2314 esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
24f7a148 2315
815c2b38 2316 AliDebug(1, Form("writing ESD to file %s", fileName));
24f7a148 2317 TFile* file = TFile::Open(fileName, "recreate");
2318 if (!file || !file->IsOpen()) {
815c2b38 2319 AliError(Form("opening %s failed", fileName));
24f7a148 2320 } else {
2321 esd->Write("ESD");
2322 file->Close();
2323 }
2324 delete file;
2325}
f3a97c86 2326
2327
af885e0f 2328void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
98937d93 2329{
2330 // Write space-points which are then used in the alignment procedures
2331 // For the moment only ITS, TRD and TPC
2332
2333 // Load TOF clusters
d528ee75 2334 if (fTracker[3]){
2335 fLoader[3]->LoadRecPoints("read");
2336 TTree* tree = fLoader[3]->TreeR();
2337 if (!tree) {
2338 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[3]));
2339 return;
2340 }
2341 fTracker[3]->LoadClusters(tree);
98937d93 2342 }
98937d93 2343 Int_t ntracks = esd->GetNumberOfTracks();
2344 for (Int_t itrack = 0; itrack < ntracks; itrack++)
2345 {
2346 AliESDtrack *track = esd->GetTrack(itrack);
2347 Int_t nsp = 0;
ef7253ac 2348 Int_t idx[200];
98937d93 2349 for (Int_t iDet = 3; iDet >= 0; iDet--)
2350 nsp += track->GetNcls(iDet);
2351 if (nsp) {
2352 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
2353 track->SetTrackPointArray(sp);
2354 Int_t isptrack = 0;
2355 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2356 AliTracker *tracker = fTracker[iDet];
2357 if (!tracker) continue;
2358 Int_t nspdet = track->GetNcls(iDet);
98937d93 2359 if (nspdet <= 0) continue;
2360 track->GetClusters(iDet,idx);
2361 AliTrackPoint p;
2362 Int_t isp = 0;
2363 Int_t isp2 = 0;
4ed6fb1c 2364 while (isp2 < nspdet) {
48ce48d1 2365 Bool_t isvalid;
c12b6e44 2366 TString dets = fgkDetectorName[iDet];
2367 if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
2368 fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
2369 fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
2370 fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
2371 isvalid = tracker->GetTrackPointTrackingError(idx[isp2],p,track);
48ce48d1 2372 } else {
2373 isvalid = tracker->GetTrackPoint(idx[isp2],p);
2374 }
2375 isp2++;
160db090 2376 const Int_t kNTPCmax = 159;
2377 if (iDet==1 && isp2>kNTPCmax) break; // to be fixed
98937d93 2378 if (!isvalid) continue;
2379 sp->AddPoint(isptrack,&p); isptrack++; isp++;
2380 }
98937d93 2381 }
2382 }
2383 }
d528ee75 2384 if (fTracker[3]){
2385 fTracker[3]->UnloadClusters();
2386 fLoader[3]->UnloadRecPoints();
2387 }
98937d93 2388}
2e3550da 2389
2390//_____________________________________________________________________________
af885e0f 2391void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
2e3550da 2392{
2393 // The method reads the raw-data error log
2394 // accumulated within the rawReader.
2395 // It extracts the raw-data errors related to
2396 // the current event and stores them into
2397 // a TClonesArray inside the esd object.
2398
2399 if (!fRawReader) return;
2400
2401 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
2402
2403 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
2404 if (!log) continue;
2405 if (iEvent != log->GetEventNumber()) continue;
2406
2407 esd->AddRawDataErrorLog(log);
2408 }
2409
2410}
46698ae4 2411
605cb8bb 2412TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString pName){
b545009a 2413 // Dump a file content into a char in TNamed
46698ae4 2414 ifstream in;
2415 in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
2416 Int_t kBytes = (Int_t)in.tellg();
2417 printf("Size: %d \n",kBytes);
2418 TNamed *fn = 0;
2419 if(in.good()){
2420 char* memblock = new char [kBytes];
2421 in.seekg (0, ios::beg);
2422 in.read (memblock, kBytes);
2423 in.close();
2424 TString fData(memblock,kBytes);
605cb8bb 2425 fn = new TNamed(pName,fData);
46698ae4 2426 printf("fData Size: %d \n",fData.Sizeof());
605cb8bb 2427 printf("pName Size: %d \n",pName.Sizeof());
46698ae4 2428 printf("fn Size: %d \n",fn->Sizeof());
2429 delete[] memblock;
2430 }
2431 else{
2432 AliInfo(Form("Could not Open %s\n",fPath.Data()));
2433 }
2434
2435 return fn;
2436}
2437
605cb8bb 2438void AliReconstruction::TNamedToFile(TTree* fTree, TString pName){
46698ae4 2439 // This is not really needed in AliReconstruction at the moment
2440 // but can serve as a template
2441
2442 TList *fList = fTree->GetUserInfo();
605cb8bb 2443 TNamed *fn = (TNamed*)fList->FindObject(pName.Data());
46698ae4 2444 printf("fn Size: %d \n",fn->Sizeof());
2445
605cb8bb 2446 TString fTmp(fn->GetName()); // to be 100% sure in principle pName also works
46698ae4 2447 const char* cdata = fn->GetTitle();
2448 printf("fTmp Size %d\n",fTmp.Sizeof());
2449
2450 int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
2451 printf("calculated size %d\n",size);
605cb8bb 2452 ofstream out(pName.Data(),ios::out | ios::binary);
46698ae4 2453 out.write(cdata,size);
2454 out.close();
2455
2456}
6efecea1 2457
7e963665 2458//_____________________________________________________________________________
04236e67 2459AliQADataMakerRec * AliReconstruction::GetQADataMaker(Int_t iDet)
7e963665 2460{
2461 // get the quality assurance data maker object and the loader for a detector
6efecea1 2462
7e963665 2463 if (fQADataMaker[iDet])
2464 return fQADataMaker[iDet];
2465
04236e67 2466 AliQADataMakerRec * qadm = NULL;
2467 if (iDet == fgkNDetectors) { //Global QA
2468 qadm = new AliGlobalQADataMaker();
aa3c69a9 2469 fQADataMaker[iDet] = qadm;
2470 return qadm;
2471 }
2472
7e963665 2473 // load the QA data maker object
2474 TPluginManager* pluginManager = gROOT->GetPluginManager();
2475 TString detName = fgkDetectorName[iDet];
04236e67 2476 TString qadmName = "Ali" + detName + "QADataMakerRec";
f0999a9a 2477 if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT"))
7e963665 2478 return NULL;
2479
7e963665 2480 // first check if a plugin is defined for the quality assurance data maker
04236e67 2481 TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
7e963665 2482 // if not, add a plugin for it
2483 if (!pluginHandler) {
2484 AliDebug(1, Form("defining plugin for %s", qadmName.Data()));
2485 TString libs = gSystem->GetLibraries();
2486 if (libs.Contains("lib" + detName + "base.so") ||
2487 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
04236e67 2488 pluginManager->AddHandler("AliQADataMakerRec", detName,
7e963665 2489 qadmName, detName + "qadm", qadmName + "()");
2490 } else {
04236e67 2491 pluginManager->AddHandler("AliQADataMakerRec", detName,
7e963665 2492 qadmName, detName, qadmName + "()");
2493 }
04236e67 2494 pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
7e963665 2495 }
2496 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
04236e67 2497 qadm = (AliQADataMakerRec *) pluginHandler->ExecPlugin(0);
7e963665 2498 }
aa3c69a9 2499
2500 fQADataMaker[iDet] = qadm;
7e963665 2501
2502 return qadm;
2503}
46698ae4 2504
a5fa6165 2505//_____________________________________________________________________________
7e963665 2506Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd)
2507{
2508 // run the Quality Assurance data producer
2509
2510 AliCodeTimerAuto("")
2511 TString detStr = detectors;
2512 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2513 if (!IsSelected(fgkDetectorName[iDet], detStr))
2514 continue;
04236e67 2515 AliQADataMakerRec * qadm = GetQADataMaker(iDet);
7e963665 2516 if (!qadm)
2517 continue;
2518 AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2519 AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2520
2521 qadm->Exec(AliQA::kESDS, esd) ;
2522 qadm->Increment() ;
2523
2524 AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2525 }
2526 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2527 AliError(Form("the following detectors were not found: %s",
2528 detStr.Data()));
2529 if (fStopOnError)
2530 return kFALSE;
2531 }
2532
2533 return kTRUE;
2534
2535}
8661738e 2536
2537//_____________________________________________________________________________
2538void AliReconstruction::CheckQA()
2539{
2540// check the QA of SIM for this run and remove the detectors
2541// with status Fatal
2542
abe0c04e 2543 TString newRunLocalReconstruction ;
2544 TString newRunTracking ;
2545 TString newFillESD ;
2546
8661738e 2547 for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
2548 TString detName(AliQA::GetDetName(iDet)) ;
96d67a8d 2549 AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ;
2550 if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, AliQA::kFATAL)) {
8661738e 2551 AliInfo(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed", detName.Data())) ;
abe0c04e 2552 } else {
2553 if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) ||
2554 fRunLocalReconstruction.Contains("ALL") ) {
2555 newRunLocalReconstruction += detName ;
2556 newRunLocalReconstruction += " " ;
2557 }
2558 if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) ||
2559 fRunTracking.Contains("ALL") ) {
2560 newRunTracking += detName ;
2561 newRunTracking += " " ;
2562 }
2563 if ( fFillESD.Contains(AliQA::GetDetName(iDet)) ||
2564 fFillESD.Contains("ALL") ) {
2565 newFillESD += detName ;
2566 newFillESD += " " ;
8661738e 2567 }
2568 }
2569 }
abe0c04e 2570 fRunLocalReconstruction = newRunLocalReconstruction ;
2571 fRunTracking = newRunTracking ;
2572 fFillESD = newFillESD ;
a5fa6165 2573}
5b188f2f 2574
2575//_____________________________________________________________________________
2576Int_t AliReconstruction::GetDetIndex(const char* detector)
2577{
2578 // return the detector index corresponding to detector
2579 Int_t index = -1 ;
2580 for (index = 0; index < fgkNDetectors ; index++) {
2581 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
2582 break ;
2583 }
2584 return index ;
2585}
7167ae53 2586//_____________________________________________________________________________
2587Bool_t AliReconstruction::FinishPlaneEff() {
2588 //
2589 // Here execute all the necessary operationis, at the end of the tracking phase,
2590 // in case that evaluation of PlaneEfficiencies was required for some detector.
2591 // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
2592 //
2593 // This Preliminary version works only FOR ITS !!!!!
2594 // other detectors (TOF,TRD, etc. have to develop their specific codes)
2595 //
2596 // Input: none
2597 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
2598 //
2599 Bool_t ret=kFALSE;
2600 //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2601 for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
2602 //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
5fbd4fd6 2603 if(fTracker[iDet]) {
2604 AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
2605 ret=planeeff->WriteIntoCDB();
2606 if(planeeff->GetCreateHistos()) {
2607 TString name="PlaneEffHisto";
2608 name+=fgkDetectorName[iDet];
2609 name+=".root";
2610 ret*=planeeff->WriteHistosToFile(name,"RECREATE");
2611 }
2612 }
7167ae53 2613 }
2614 return ret;
2615}
2616//_____________________________________________________________________________
2617Bool_t AliReconstruction::InitPlaneEff() {
2618//
2619 // Here execute all the necessary operations, before of the tracking phase,
2620 // for the evaluation of PlaneEfficiencies, in case required for some detectors.
2621 // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
2622 // which should be updated/recalculated.
2623 //
2624 // This Preliminary version will work only FOR ITS !!!!!
2625 // other detectors (TOF,TRD, etc. have to develop their specific codes)
2626 //
2627 // Input: none
2628 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
2629 //
2630 AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE"));
2631 return kTRUE;
7520312d 2632}
14dd053c 2633
2634//_____________________________________________________________________________
2635Bool_t AliReconstruction::InitAliEVE()
2636{
2637 // This method should be called only in case
2638 // AliReconstruction is run
2639 // within the alieve environment.
2640 // It will initialize AliEVE in a way
2641 // so that it can visualize event processed
2642 // by AliReconstruction.
2643 // The return flag shows whenever the
2644 // AliEVE initialization was successful or not.
2645
2646 TString macroStr;
2647 macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
2648 AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
2649 if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
2650
de33999e 2651 gROOT->ProcessLine("if (!gAliEveEvent) {gAliEveEvent = new AliEveEventManager();gAliEveEvent->SetAutoLoad(kTRUE);gAliEveEvent->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(gAliEveEvent);};");
2652 gROOT->ProcessLine("alieve_online_init()");
14dd053c 2653
2654 return kTRUE;
2655}
2656
2657//_____________________________________________________________________________
2658void AliReconstruction::RunAliEVE()
2659{
2660 // Runs AliEVE visualisation of
2661 // the current event.
2662 // Should be executed only after
2663 // successful initialization of AliEVE.
2664
2665 AliInfo("Running AliEVE...");
2666 gROOT->ProcessLine(Form("gAliEveEvent->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p);",fRunLoader,fRawReader,fesd));
2667 gROOT->ProcessLine("gAliEveEvent->StartStopAutoLoadTimer();");
2668 gSystem->Run();
2669}