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