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