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