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