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