Removing non used data members (Marian)
[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
f29f1726 180#include "AliAODEvent.h"
181#include "AliAODHeader.h"
182#include "AliAODTrack.h"
183#include "AliAODVertex.h"
3dd9f9e3 184#include "AliAODv0.h"
185#include "AliAODJet.h"
186#include "AliAODCaloCells.h"
187#include "AliAODCaloCluster.h"
188#include "AliAODPmdCluster.h"
189#include "AliAODFmdCluster.h"
190#include "AliAODTracklets.h"
f29f1726 191
04236e67 192#include "AliQADataMakerRec.h"
aa3c69a9 193#include "AliGlobalQADataMaker.h"
c65c502a 194#include "AliQA.h"
195#include "AliQADataMakerSteer.h"
f29f1726 196
7167ae53 197#include "AliPlaneEff.h"
198
0f88822a 199#include "AliSysInfo.h" // memory snapshots
cd0b062e 200#include "AliRawHLTManager.h"
0f88822a 201
6efecea1 202
596a855f 203ClassImp(AliReconstruction)
204
205
206//_____________________________________________________________________________
b384f8a4 207const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
c757bafd 208
209//_____________________________________________________________________________
795e4a22 210AliReconstruction::AliReconstruction(const char* gAliceFilename,
e583c30d 211 const char* name, const char* title) :
212 TNamed(name, title),
213
c84a5e9e 214 fUniformField(kTRUE),
2257f27e 215 fRunVertexFinder(kTRUE),
a84e2607 216 fRunVertexFinderTracks(kTRUE),
1f46a9ae 217 fRunHLTTracking(kFALSE),
e66fbafb 218 fRunMuonTracking(kFALSE),
d1683eef 219 fRunV0Finder(kTRUE),
220 fRunCascadeFinder(kTRUE),
1d99986f 221 fStopOnError(kFALSE),
222 fWriteAlignmentData(kFALSE),
223 fWriteESDfriend(kFALSE),
a7807689 224 fWriteAOD(kFALSE),
b647652d 225 fFillTriggerESD(kTRUE),
1d99986f 226
7f68891d 227 fCleanESD(kTRUE),
a023d8d8 228 fV0DCAmax(3.),
229 fV0CsPmin(0.),
7f68891d 230 fDmax(50.),
231 fZmax(50.),
232
1d99986f 233 fRunLocalReconstruction("ALL"),
b8cd5251 234 fRunTracking("ALL"),
e583c30d 235 fFillESD("ALL"),
48ce48d1 236 fUseTrackingErrorsForAlignment(""),
e583c30d 237 fGAliceFileName(gAliceFilename),
b649205a 238 fInput(""),
35042093 239 fEquipIdMap(""),
b26c3770 240 fFirstEvent(0),
241 fLastEvent(-1),
973388c2 242 fNumberOfEventsPerFile(1),
24f7a148 243 fCheckPointLevel(0),
b8cd5251 244 fOptions(),
6bae477a 245 fLoadAlignFromCDB(kTRUE),
246 fLoadAlignData("ALL"),
46698ae4 247 fESDPar(""),
cd0b062e 248 fUseHLTData(),
e583c30d 249
250 fRunLoader(NULL),
b649205a 251 fRawReader(NULL),
cd0b062e 252 fParentRawReader(NULL),
b8cd5251 253
98937d93 254 fVertexer(NULL),
9178838a 255 fDiamondProfile(NULL),
43c9dae1 256 fDiamondProfileTPC(NULL),
87317a47 257 fMeanVertexConstraint(kTRUE),
98937d93 258
444753c6 259 fGRPList(NULL),
260
6bae477a 261 fAlignObjArray(NULL),
795e4a22 262 fCDBUri(),
759c1df1 263 fSpecCDBUri(),
795e4a22 264 fInitCDBCalled(kFALSE),
265 fSetRunNumberFromDataCalled(kFALSE),
7e963665 266 fRunQA(kTRUE),
6b150027 267 fRunGlobalQA(kTRUE),
7167ae53 268 fInLoopQA(kFALSE),
269
270 fRunPlaneEff(kFALSE)
596a855f 271{
272// create reconstruction object with default parameters
b8cd5251 273
274 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
275 fReconstructor[iDet] = NULL;
276 fLoader[iDet] = NULL;
277 fTracker[iDet] = NULL;
7e963665 278 fQADataMaker[iDet] = NULL;
279 fQACycles[iDet] = 999999;
b8cd5251 280 }
aa3c69a9 281 fQADataMaker[fgkNDetectors]=NULL; //Global QA
e47c4c2e 282 AliPID pid;
596a855f 283}
284
285//_____________________________________________________________________________
286AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
e583c30d 287 TNamed(rec),
288
c84a5e9e 289 fUniformField(rec.fUniformField),
2257f27e 290 fRunVertexFinder(rec.fRunVertexFinder),
a84e2607 291 fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
1f46a9ae 292 fRunHLTTracking(rec.fRunHLTTracking),
e66fbafb 293 fRunMuonTracking(rec.fRunMuonTracking),
d1683eef 294 fRunV0Finder(rec.fRunV0Finder),
295 fRunCascadeFinder(rec.fRunCascadeFinder),
1d99986f 296 fStopOnError(rec.fStopOnError),
297 fWriteAlignmentData(rec.fWriteAlignmentData),
298 fWriteESDfriend(rec.fWriteESDfriend),
a7807689 299 fWriteAOD(rec.fWriteAOD),
b647652d 300 fFillTriggerESD(rec.fFillTriggerESD),
1d99986f 301
7f68891d 302 fCleanESD(rec.fCleanESD),
a023d8d8 303 fV0DCAmax(rec.fV0DCAmax),
5e5c1aa9 304 fV0CsPmin(rec.fV0CsPmin),
7f68891d 305 fDmax(rec.fDmax),
306 fZmax(rec.fZmax),
307
1d99986f 308 fRunLocalReconstruction(rec.fRunLocalReconstruction),
e583c30d 309 fRunTracking(rec.fRunTracking),
310 fFillESD(rec.fFillESD),
48ce48d1 311 fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
e583c30d 312 fGAliceFileName(rec.fGAliceFileName),
b649205a 313 fInput(rec.fInput),
35042093 314 fEquipIdMap(rec.fEquipIdMap),
b26c3770 315 fFirstEvent(rec.fFirstEvent),
316 fLastEvent(rec.fLastEvent),
973388c2 317 fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
24f7a148 318 fCheckPointLevel(0),
b8cd5251 319 fOptions(),
6bae477a 320 fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
321 fLoadAlignData(rec.fLoadAlignData),
46698ae4 322 fESDPar(rec.fESDPar),
2972d4eb 323 fUseHLTData(rec.fUseHLTData),
e583c30d 324
325 fRunLoader(NULL),
b649205a 326 fRawReader(NULL),
2972d4eb 327 fParentRawReader(NULL),
b8cd5251 328
98937d93 329 fVertexer(NULL),
9178838a 330 fDiamondProfile(NULL),
43c9dae1 331 fDiamondProfileTPC(NULL),
87317a47 332 fMeanVertexConstraint(rec.fMeanVertexConstraint),
98937d93 333
444753c6 334 fGRPList(NULL),
335
6bae477a 336 fAlignObjArray(rec.fAlignObjArray),
ec92bee0 337 fCDBUri(rec.fCDBUri),
7e963665 338 fSpecCDBUri(),
795e4a22 339 fInitCDBCalled(rec.fInitCDBCalled),
340 fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
aa3c69a9 341 fRunQA(rec.fRunQA),
342 fRunGlobalQA(rec.fRunGlobalQA),
7167ae53 343 fInLoopQA(rec.fInLoopQA),
344 fRunPlaneEff(rec.fRunPlaneEff)
596a855f 345{
346// copy constructor
347
ec92bee0 348 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
efd2085e 349 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
350 }
b8cd5251 351 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
352 fReconstructor[iDet] = NULL;
353 fLoader[iDet] = NULL;
354 fTracker[iDet] = NULL;
7e963665 355 fQADataMaker[iDet] = NULL;
356 fQACycles[iDet] = rec.fQACycles[iDet];
b8cd5251 357 }
aa3c69a9 358 fQADataMaker[fgkNDetectors]=NULL; //Global QA
ec92bee0 359 for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
360 if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
361 }
596a855f 362}
363
364//_____________________________________________________________________________
365AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
366{
367// assignment operator
368
369 this->~AliReconstruction();
370 new(this) AliReconstruction(rec);
371 return *this;
372}
373
374//_____________________________________________________________________________
375AliReconstruction::~AliReconstruction()
376{
377// clean up
378
e583c30d 379 CleanUp();
efd2085e 380 fOptions.Delete();
ec92bee0 381 fSpecCDBUri.Delete();
87932dab 382
383 AliCodeTimer::Instance()->Print();
596a855f 384}
385
024cf675 386//_____________________________________________________________________________
795e4a22 387void AliReconstruction::InitCDB()
024cf675 388{
389// activate a default CDB storage
390// First check if we have any CDB storage set, because it is used
391// to retrieve the calibration and alignment constants
392
795e4a22 393 if (fInitCDBCalled) return;
394 fInitCDBCalled = kTRUE;
395
024cf675 396 AliCDBManager* man = AliCDBManager::Instance();
ec92bee0 397 if (man->IsDefaultStorageSet())
024cf675 398 {
399 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
ec92bee0 400 AliWarning("Default CDB storage has been already set !");
401 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
024cf675 402 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
795e4a22 403 fCDBUri = man->GetDefaultStorage()->GetURI();
ec92bee0 404 }
405 else {
795e4a22 406 if (fCDBUri.Length() > 0)
407 {
408 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
409 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
410 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
411 } else {
412 fCDBUri="local://$ALICE_ROOT";
413 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
414 AliWarning("Default CDB storage not yet set !!!!");
415 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
416 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
417
418 }
ec92bee0 419 man->SetDefaultStorage(fCDBUri);
420 }
421
422 // Now activate the detector specific CDB storage locations
c3a7b59a 423 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
424 TObject* obj = fSpecCDBUri[i];
425 if (!obj) continue;
b8ec52f6 426 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
427 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
428 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
c3a7b59a 429 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
ec92bee0 430 }
795e4a22 431
024cf675 432}
433
434//_____________________________________________________________________________
435void AliReconstruction::SetDefaultStorage(const char* uri) {
ec92bee0 436// Store the desired default CDB storage location
437// Activate it later within the Run() method
024cf675 438
ec92bee0 439 fCDBUri = uri;
024cf675 440
441}
442
443//_____________________________________________________________________________
c3a7b59a 444void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
ec92bee0 445// Store a detector-specific CDB storage location
446// Activate it later within the Run() method
024cf675 447
c3a7b59a 448 AliCDBPath aPath(calibType);
449 if(!aPath.IsValid()){
450 // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
451 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
452 if(!strcmp(calibType, fgkDetectorName[iDet])) {
453 aPath.SetPath(Form("%s/*", calibType));
454 AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
455 break;
456 }
457 }
458 if(!aPath.IsValid()){
459 AliError(Form("Not a valid path or detector: %s", calibType));
460 return;
461 }
462 }
463
53dd3c3d 464// // check that calibType refers to a "valid" detector name
465// Bool_t isDetector = kFALSE;
466// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
467// TString detName = fgkDetectorName[iDet];
468// if(aPath.GetLevel0() == detName) {
469// isDetector = kTRUE;
470// break;
471// }
472// }
473//
474// if(!isDetector) {
475// AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
476// return;
477// }
c3a7b59a 478
479 TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
ec92bee0 480 if (obj) fSpecCDBUri.Remove(obj);
c3a7b59a 481 fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
024cf675 482
483}
484
6bae477a 485//_____________________________________________________________________________
795e4a22 486Bool_t AliReconstruction::SetRunNumberFromData()
6bae477a 487{
488 // The method is called in Run() in order
489 // to set a correct run number.
490 // In case of raw data reconstruction the
491 // run number is taken from the raw data header
492
795e4a22 493 if (fSetRunNumberFromDataCalled) return kTRUE;
494 fSetRunNumberFromDataCalled = kTRUE;
495
496 AliCDBManager* man = AliCDBManager::Instance();
497
498 if(man->GetRun() > 0) {
499 AliWarning("Run number is taken from event header! Ignoring settings in AliCDBManager!");
500 }
501
502 if (!fRunLoader) {
6bae477a 503 AliError("No run loader is found !");
504 return kFALSE;
505 }
506 // read run number from gAlice
ec92bee0 507 if(fRunLoader->GetAliRun())
f2ee4290 508 AliCDBManager::Instance()->SetRun(fRunLoader->GetHeader()->GetRun());
ec92bee0 509 else {
510 if(fRawReader) {
511 if(fRawReader->NextEvent()) {
512 AliCDBManager::Instance()->SetRun(fRawReader->GetRunNumber());
513 fRawReader->RewindEvents();
514 }
515 else {
516 AliError("No raw-data events found !");
517 return kFALSE;
518 }
519 }
520 else {
521 AliError("Neither gAlice nor RawReader objects are found !");
522 return kFALSE;
523 }
6bae477a 524 }
795e4a22 525
526 man->Print();
527
6bae477a 528 return kTRUE;
529}
530
531//_____________________________________________________________________________
795e4a22 532void AliReconstruction::SetCDBLock() {
533 // Set CDB lock: from now on it is forbidden to reset the run number
534 // or the default storage or to activate any further storage!
535
536 AliCDBManager::Instance()->SetLock(1);
537}
538
539//_____________________________________________________________________________
6bae477a 540Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
541{
542 // Read the alignment objects from CDB.
543 // Each detector is supposed to have the
544 // alignment objects in DET/Align/Data CDB path.
545 // All the detector objects are then collected,
546 // sorted by geometry level (starting from ALIC) and
547 // then applied to the TGeo geometry.
548 // Finally an overlaps check is performed.
549
550 // Load alignment data from CDB and fill fAlignObjArray
551 if(fLoadAlignFromCDB){
6bae477a 552
25be1e5c 553 TString detStr = detectors;
554 TString loadAlObjsListOfDets = "";
555
556 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
557 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
558 loadAlObjsListOfDets += fgkDetectorName[iDet];
559 loadAlObjsListOfDets += " ";
560 } // end loop over detectors
53dd3c3d 561 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
98e303d9 562 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
25be1e5c 563 }else{
564 // Check if the array with alignment objects was
565 // provided by the user. If yes, apply the objects
566 // to the present TGeo geometry
567 if (fAlignObjArray) {
568 if (gGeoManager && gGeoManager->IsClosed()) {
98e303d9 569 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
25be1e5c 570 AliError("The misalignment of one or more volumes failed!"
571 "Compare the list of simulated detectors and the list of detector alignment data!");
572 return kFALSE;
573 }
574 }
575 else {
576 AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
6bae477a 577 return kFALSE;
578 }
579 }
6bae477a 580 }
25be1e5c 581
8e245d15 582 delete fAlignObjArray; fAlignObjArray=0;
a03b0371 583
6bae477a 584 return kTRUE;
585}
596a855f 586
587//_____________________________________________________________________________
588void AliReconstruction::SetGAliceFile(const char* fileName)
589{
590// set the name of the galice file
591
592 fGAliceFileName = fileName;
593}
594
efd2085e 595//_____________________________________________________________________________
596void AliReconstruction::SetOption(const char* detector, const char* option)
597{
598// set options for the reconstruction of a detector
599
600 TObject* obj = fOptions.FindObject(detector);
601 if (obj) fOptions.Remove(obj);
602 fOptions.Add(new TNamed(detector, option));
603}
604
596a855f 605
606//_____________________________________________________________________________
e0027792 607Bool_t AliReconstruction::Run(const char* input, Bool_t IsOnline)
596a855f 608{
609// run the reconstruction
610
87932dab 611 AliCodeTimerAuto("")
612
b649205a 613 // set the input
e0027792 614 if (!IsOnline) {
615 if (!input) input = fInput.Data();
616 TString fileName(input);
617 if (fileName.EndsWith("/")) {
618 fRawReader = new AliRawReaderFile(fileName);
619 } else if (fileName.EndsWith(".root")) {
620 fRawReader = new AliRawReaderRoot(fileName);
621 } else if (!fileName.IsNull()) {
622 fRawReader = new AliRawReaderDate(fileName);
623 }
624 }
625 else {
626 if (!input) {
627 AliError("Null pointer to the event structure!");
628 return kFALSE;
629 }
630 fRawReader = new AliRawReaderDate((void *)input);
b649205a 631 }
e0027792 632
35042093 633 if (!fEquipIdMap.IsNull() && fRawReader)
634 fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
635
cd0b062e 636 if (!fUseHLTData.IsNull()) {
637 // create the RawReaderHLT which performs redirection of HLT input data for
638 // the specified detectors
639 AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
640 if (pRawReader) {
641 fParentRawReader=fRawReader;
642 fRawReader=pRawReader;
643 } else {
644 AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
645 }
646 }
647
0f88822a 648 AliSysInfo::AddStamp("Start");
f08fc9f5 649 // get the run loader
650 if (!InitRunLoader()) return kFALSE;
0f88822a 651 AliSysInfo::AddStamp("LoadLoader");
596a855f 652
ec92bee0 653 // Initialize the CDB storage
795e4a22 654 InitCDB();
655
656 AliSysInfo::AddStamp("LoadCDB");
ec92bee0 657
6bae477a 658 // Set run number in CDBManager (if it is not already set by the user)
795e4a22 659 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
660
661 // Set CDB lock: from now on it is forbidden to reset the run number
662 // or the default storage or to activate any further storage!
663 SetCDBLock();
664
6bae477a 665 // Import ideal TGeo geometry and apply misalignment
666 if (!gGeoManager) {
667 TString geom(gSystem->DirName(fGAliceFileName));
668 geom += "/geometry.root";
98e303d9 669 AliGeomManager::LoadGeometry(geom.Data());
6bae477a 670 if (!gGeoManager) if (fStopOnError) return kFALSE;
671 }
8e245d15 672
6bae477a 673 if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
0f88822a 674 AliSysInfo::AddStamp("LoadGeom");
6bae477a 675
e0176e97 676 //QA
677 AliQADataMakerSteer qas ;
aa3c69a9 678 if (fRunQA && fRawReader) qas.Run(fRunLocalReconstruction, fRawReader) ;
aa3c69a9 679 // checking the QA of previous steps
04236e67 680 //CheckQA() ;
e0176e97 681
aa3c69a9 682 /*
596a855f 683 // local reconstruction
59697224 684 if (!fRunLocalReconstruction.IsNull()) {
685 if (!RunLocalReconstruction(fRunLocalReconstruction)) {
e583c30d 686 if (fStopOnError) {CleanUp(); return kFALSE;}
596a855f 687 }
688 }
aa3c69a9 689 */
2257f27e 690
691 // get vertexer
692 if (fRunVertexFinder && !CreateVertexer()) {
693 if (fStopOnError) {
694 CleanUp();
695 return kFALSE;
696 }
697 }
0f88822a 698 AliSysInfo::AddStamp("Vertexer");
596a855f 699
f08fc9f5 700 // get trackers
b8cd5251 701 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
24f7a148 702 if (fStopOnError) {
703 CleanUp();
704 return kFALSE;
705 }
596a855f 706 }
0f88822a 707 AliSysInfo::AddStamp("LoadTrackers");
24f7a148 708
b26c3770 709 // get the possibly already existing ESD file and tree
af885e0f 710 AliESDEvent* esd = new AliESDEvent(); AliESDEvent* hltesd = new AliESDEvent();
b26c3770 711 TFile* fileOld = NULL;
1f46a9ae 712 TTree* treeOld = NULL; TTree *hlttreeOld = NULL;
b26c3770 713 if (!gSystem->AccessPathName("AliESDs.root")){
714 gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE);
715 fileOld = TFile::Open("AliESDs.old.root");
716 if (fileOld && fileOld->IsOpen()) {
717 treeOld = (TTree*) fileOld->Get("esdTree");
46698ae4 718 if (treeOld)esd->ReadFromTree(treeOld);
1f46a9ae 719 hlttreeOld = (TTree*) fileOld->Get("HLTesdTree");
46698ae4 720 if (hlttreeOld) hltesd->ReadFromTree(hlttreeOld);
b26c3770 721 }
722 }
723
36711aa4 724 // create the ESD output file and tree
596a855f 725 TFile* file = TFile::Open("AliESDs.root", "RECREATE");
46698ae4 726 file->SetCompressionLevel(2);
596a855f 727 if (!file->IsOpen()) {
815c2b38 728 AliError("opening AliESDs.root failed");
b26c3770 729 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
596a855f 730 }
46698ae4 731
36711aa4 732 TTree* tree = new TTree("esdTree", "Tree with ESD objects");
af885e0f 733 esd = new AliESDEvent();
46698ae4 734 esd->CreateStdContent();
735 esd->WriteToTree(tree);
736
1f46a9ae 737 TTree* hlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
af885e0f 738 hltesd = new AliESDEvent();
46698ae4 739 hltesd->CreateStdContent();
740 hltesd->WriteToTree(hlttree);
741
742 /* CKB Why?
1f46a9ae 743 delete esd; delete hltesd;
744 esd = NULL; hltesd = NULL;
46698ae4 745 */
500d54ab 746 // create the branch with ESD additions
5728d3d5 747
748
749
46698ae4 750 AliESDfriend *esdf = 0;
1d99986f 751 if (fWriteESDfriend) {
46698ae4 752 esdf = new AliESDfriend();
753 TBranch *br=tree->Branch("ESDfriend.","AliESDfriend", &esdf);
754 br->SetFile("AliESDfriends.root");
755 esd->AddObject(esdf);
1d99986f 756 }
5728d3d5 757
46698ae4 758
444753c6 759 // Get the GRP CDB entry
760 AliCDBEntry* entryGRP = AliCDBManager::Instance()->Get("GRP/GRP/Data");
761
762 if(entryGRP) {
763 fGRPList = dynamic_cast<TList*> (entryGRP->GetObject());
764 } else {
765 AliError("No GRP entry found in OCDB!");
766 }
767
17c86e90 768 // Get the diamond profile from OCDB
769 AliCDBEntry* entry = AliCDBManager::Instance()
770 ->Get("GRP/Calib/MeanVertex");
771
772 if(entry) {
773 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
774 } else {
775 AliError("No diamond profile found in OCDB!");
776 }
777
43c9dae1 778 entry = 0;
779 entry = AliCDBManager::Instance()
780 ->Get("GRP/Calib/MeanVertexTPC");
781
782 if(entry) {
783 fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
784 } else {
785 AliError("No diamond profile found in OCDB!");
786 }
787
20e5681c 788 AliVertexerTracks tVertexer(AliTracker::GetBz());
87317a47 789 if(fDiamondProfile && fMeanVertexConstraint) tVertexer.SetVtxStart(fDiamondProfile);
c5e3e5d1 790
b649205a 791 if (fRawReader) fRawReader->RewindEvents();
a5fa6165 792
95cee32f 793 ProcInfo_t ProcInfo;
794 gSystem->GetProcInfo(&ProcInfo);
795 AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
8661738e 796
aa3c69a9 797
798 //Initialize the QA and start of cycle for out-of-cycle QA
799 if (fRunQA) {
800 TString detStr(fFillESD);
801 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
802 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
04236e67 803 AliQADataMakerRec *qadm = GetQADataMaker(iDet);
aa3c69a9 804 if (!qadm) continue;
805 AliInfo(Form("Initializing the QA data maker for %s",
806 fgkDetectorName[iDet]));
807 qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
808 qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
809 if (!fInLoopQA) {
810 qadm->StartOfCycle(AliQA::kRECPOINTS);
811 qadm->StartOfCycle(AliQA::kESDS,"same");
812 }
813 }
3b378a42 814 }
815 if (fRunGlobalQA) {
816 AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
817 AliInfo(Form("Initializing the global QA data maker"));
818 TObjArray *arr=
aa3c69a9 819 qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
3b378a42 820 AliTracker::SetResidualsArray(arr);
821 qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
822 if (!fInLoopQA) {
823 qadm->StartOfCycle(AliQA::kRECPOINTS);
824 qadm->StartOfCycle(AliQA::kESDS,"same");
aa3c69a9 825 }
826 }
827
7167ae53 828 //Initialize the Plane Efficiency framework
829 if (fRunPlaneEff && !InitPlaneEff()) {
830 if(fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
831 }
aa3c69a9 832
833 //******* The loop over events
596a855f 834 for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) {
b26c3770 835 if (fRawReader) fRawReader->NextEvent();
4a33489c 836 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
b26c3770 837 // copy old ESD to the new one
838 if (treeOld) {
46698ae4 839 esd->ReadFromTree(treeOld);
b26c3770 840 treeOld->GetEntry(iEvent);
d5c2df59 841 tree->Fill();
b26c3770 842 }
1f46a9ae 843 if (hlttreeOld) {
46698ae4 844 esd->ReadFromTree(hlttreeOld);
1f46a9ae 845 hlttreeOld->GetEntry(iEvent);
d5c2df59 846 hlttree->Fill();
1f46a9ae 847 }
b26c3770 848 continue;
849 }
46698ae4 850
815c2b38 851 AliInfo(Form("processing event %d", iEvent));
aa3c69a9 852
853 //Start of cycle for the in-loop QA
3b378a42 854 if (fInLoopQA) {
855 if (fRunQA) {
856 TString detStr(fFillESD);
857 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
858 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
859 AliQADataMakerRec *qadm = GetQADataMaker(iDet);
860 if (!qadm) continue;
861 qadm->StartOfCycle(AliQA::kRECPOINTS);
862 qadm->StartOfCycle(AliQA::kESDS, "same") ;
863 }
aa3c69a9 864 }
865 if (fRunGlobalQA) {
04236e67 866 AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
aa3c69a9 867 qadm->StartOfCycle(AliQA::kRECPOINTS);
854c6476 868 qadm->StartOfCycle(AliQA::kESDS,"same");
aa3c69a9 869 }
870 }
871
596a855f 872 fRunLoader->GetEvent(iEvent);
24f7a148 873
bb0901a4 874 char aFileName[256];
875 sprintf(aFileName, "ESD_%d.%d_final.root",
f08fc9f5 876 fRunLoader->GetHeader()->GetRun(),
877 fRunLoader->GetHeader()->GetEventNrInRun());
bb0901a4 878 if (!gSystem->AccessPathName(aFileName)) continue;
24f7a148 879
aa3c69a9 880 // local signle event reconstruction
b26c3770 881 if (!fRunLocalReconstruction.IsNull()) {
882 if (!RunLocalEventReconstruction(fRunLocalReconstruction)) {
883 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
884 }
885 }
886
f08fc9f5 887 esd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1f46a9ae 888 hltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
31fd97b2 889 esd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
890 hltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
46698ae4 891
d6ee376f 892 // Set magnetic field from the tracker
893 esd->SetMagneticField(AliTracker::GetBz());
894 hltesd->SetMagneticField(AliTracker::GetBz());
596a855f 895
46698ae4 896
897
2e3550da 898 // Fill raw-data error log into the ESD
899 if (fRawReader) FillRawDataErrorLog(iEvent,esd);
900
2257f27e 901 // vertex finder
902 if (fRunVertexFinder) {
903 if (!ReadESD(esd, "vertex")) {
904 if (!RunVertexFinder(esd)) {
b26c3770 905 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
2257f27e 906 }
907 if (fCheckPointLevel > 0) WriteESD(esd, "vertex");
908 }
909 }
910
1f46a9ae 911 // HLT tracking
912 if (!fRunTracking.IsNull()) {
913 if (fRunHLTTracking) {
06cc9d95 914 hltesd->SetPrimaryVertexSPD(esd->GetVertex());
1f46a9ae 915 if (!RunHLTTracking(hltesd)) {
916 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
917 }
918 }
919 }
920
e66fbafb 921 // Muon tracking
b8cd5251 922 if (!fRunTracking.IsNull()) {
e66fbafb 923 if (fRunMuonTracking) {
761350a6 924 if (!RunMuonTracking(esd)) {
b26c3770 925 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
24f7a148 926 }
596a855f 927 }
928 }
929
e66fbafb 930 // barrel tracking
931 if (!fRunTracking.IsNull()) {
21c573b7 932 if (!ReadESD(esd, "tracking")) {
933 if (!RunTracking(esd)) {
934 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
e66fbafb 935 }
21c573b7 936 if (fCheckPointLevel > 0) WriteESD(esd, "tracking");
e66fbafb 937 }
938 }
21c573b7 939
596a855f 940 // fill ESD
941 if (!fFillESD.IsNull()) {
942 if (!FillESD(esd, fFillESD)) {
b26c3770 943 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
596a855f 944 }
945 }
a5fa6165 946
001397cd 947 // fill Event header information from the RawEventHeader
948 if (fRawReader){FillRawEventHeaderESD(esd);}
596a855f 949
950 // combined PID
951 AliESDpid::MakePID(esd);
24f7a148 952 if (fCheckPointLevel > 1) WriteESD(esd, "PID");
596a855f 953
b647652d 954 if (fFillTriggerESD) {
955 if (!ReadESD(esd, "trigger")) {
956 if (!FillTriggerESD(esd)) {
957 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
958 }
959 if (fCheckPointLevel > 1) WriteESD(esd, "trigger");
960 }
961 }
962
a6ee503a 963 file->cd();
964
3c3709c4 965 //
966 // Propagate track to the beam pipe (if not laready done by ITS)
967 //
968 const Int_t ntracks = esd->GetNumberOfTracks();
969 const Double_t kBz = esd->GetMagneticField();
970 const Double_t kRadius = 2.8; //something less than the beam pipe radius
971
972 TObjArray trkArray;
973 UShort_t *selectedIdx=new UShort_t[ntracks];
974
975 for (Int_t itrack=0; itrack<ntracks; itrack++){
976 const Double_t kMaxStep = 5; //max step over the material
977 Bool_t ok;
978
979 AliESDtrack *track = esd->GetTrack(itrack);
980 if (!track) continue;
981
982 AliExternalTrackParam *tpcTrack =
983 (AliExternalTrackParam *)track->GetTPCInnerParam();
bcabd6af 984 ok = kFALSE;
985 if (tpcTrack)
986 ok = AliTracker::
987 PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE);
43c9dae1 988
989
990
3c3709c4 991 if (ok) {
992 Int_t n=trkArray.GetEntriesFast();
993 selectedIdx[n]=track->GetID();
994 trkArray.AddLast(tpcTrack);
995 }
996
997 if (track->GetX() < kRadius) continue;
998
999 ok = AliTracker::
1000 PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
1001 if (ok) {
1002 track->RelateToVertex(esd->GetPrimaryVertexSPD(), kBz, kRadius);
1003 }
1004 }
1005
1006 //
1007 // Improve the reconstructed primary vertex position using the tracks
1008 //
1009 TObject *obj = fOptions.FindObject("ITS");
c060d7fe 1010 if (obj) {
1011 TString optITS = obj->GetTitle();
1012 if (optITS.Contains("cosmics") || optITS.Contains("COSMICS"))
a84e2607 1013 fRunVertexFinderTracks=kFALSE;
c060d7fe 1014 }
3c3709c4 1015 if (fRunVertexFinderTracks) {
1016 // TPC + ITS primary vertex
43c9dae1 1017 tVertexer.SetITSrefitRequired();
1018 if(fDiamondProfile && fMeanVertexConstraint) {
1019 tVertexer.SetVtxStart(fDiamondProfile);
1020 } else {
1021 tVertexer.SetConstraintOff();
1022 }
3c3709c4 1023 AliESDVertex *pvtx=tVertexer.FindPrimaryVertex(esd);
1024 if (pvtx) {
1025 if (pvtx->GetStatus()) {
1026 esd->SetPrimaryVertex(pvtx);
1027 for (Int_t i=0; i<ntracks; i++) {
1028 AliESDtrack *t = esd->GetTrack(i);
1029 t->RelateToVertex(pvtx, kBz, kRadius);
1030 }
1031 }
1032 }
1033
1034 // TPC-only primary vertex
43c9dae1 1035 tVertexer.SetITSrefitNotRequired();
1036 if(fDiamondProfileTPC && fMeanVertexConstraint) {
1037 tVertexer.SetVtxStart(fDiamondProfileTPC);
1038 } else {
1039 tVertexer.SetConstraintOff();
1040 }
3c3709c4 1041 pvtx=tVertexer.FindPrimaryVertex(&trkArray,selectedIdx);
1042 if (pvtx) {
1043 if (pvtx->GetStatus()) {
1044 esd->SetPrimaryVertexTPC(pvtx);
1045 Int_t nsel=trkArray.GetEntriesFast();
1046 for (Int_t i=0; i<nsel; i++) {
1047 AliExternalTrackParam *t =
1048 (AliExternalTrackParam *)trkArray.UncheckedAt(i);
1049 t->PropagateToDCA(pvtx, kBz, kRadius);
1050 }
1051 }
1052 }
1053
1054 }
1055 delete[] selectedIdx;
1056
17c86e90 1057 if(fDiamondProfile) esd->SetDiamond(fDiamondProfile);
1058
c5e3e5d1 1059
d1683eef 1060 if (fRunV0Finder) {
1061 // V0 finding
1062 AliV0vertexer vtxer;
1063 vtxer.Tracks2V0vertices(esd);
5e4ff34d 1064
d1683eef 1065 if (fRunCascadeFinder) {
1066 // Cascade finding
1067 AliCascadeVertexer cvtxer;
1068 cvtxer.V0sTracks2CascadeVertices(esd);
1069 }
5e4ff34d 1070 }
1071
596a855f 1072 // write ESD
d64bd07d 1073 if (fCleanESD) CleanESD(esd);
854c6476 1074
3b378a42 1075 if (fRunGlobalQA) {
854c6476 1076 AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
1077 if (qadm) qadm->Exec(AliQA::kESDS, esd);
1078 }
1079
1d99986f 1080 if (fWriteESDfriend) {
99f99e0e 1081 esdf->~AliESDfriend();
46698ae4 1082 new (esdf) AliESDfriend(); // Reset...
1083 esd->GetESDfriend(esdf);
1d99986f 1084 }
500d54ab 1085 tree->Fill();
1086
1087 // write HLT ESD
1088 hlttree->Fill();
1d99986f 1089
f3a97c86 1090 if (fCheckPointLevel > 0) WriteESD(esd, "final");
46698ae4 1091 esd->Reset();
1092 hltesd->Reset();
5728d3d5 1093 if (fWriteESDfriend) {
99f99e0e 1094 esdf->~AliESDfriend();
5728d3d5 1095 new (esdf) AliESDfriend(); // Reset...
1096 }
a5fa6165 1097
95cee32f 1098 gSystem->GetProcInfo(&ProcInfo);
1099 AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
a5fa6165 1100
7e963665 1101
aa3c69a9 1102 // End of cycle for the in-loop QA
3b378a42 1103 if (fInLoopQA) {
1104 if (fRunQA) {
1105 RunQA(fFillESD.Data(), esd);
1106 TString detStr(fFillESD);
1107 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1108 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1109 AliQADataMakerRec * qadm = GetQADataMaker(iDet);
1110 if (!qadm) continue;
1111 qadm->EndOfCycle(AliQA::kRECPOINTS);
1112 qadm->EndOfCycle(AliQA::kESDS);
1113 qadm->Finish();
1114 }
aa3c69a9 1115 }
1116 if (fRunGlobalQA) {
04236e67 1117 AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
aa3c69a9 1118 if (qadm) {
1119 qadm->EndOfCycle(AliQA::kRECPOINTS);
d7259b2e 1120 qadm->EndOfCycle(AliQA::kESDS);
aa3c69a9 1121 qadm->Finish();
1122 }
1123 }
1124 }
1125 }
1126 //******** End of the loop over events
1127
1128
5728d3d5 1129
46698ae4 1130 tree->GetUserInfo()->Add(esd);
1131 hlttree->GetUserInfo()->Add(hltesd);
f747912b 1132
1133 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
1134 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
1135
1136 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
1137 cdbMapCopy->SetOwner(1);
1138 cdbMapCopy->SetName("cdbMap");
1139 TIter iter(cdbMap->GetTable());
1140
1141 TPair* pair = 0;
1142 while((pair = dynamic_cast<TPair*> (iter.Next()))){
1143 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
1144 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
1145 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
1146 }
1147
1148 TList *cdbListCopy = new TList();
1149 cdbListCopy->SetOwner(1);
1150 cdbListCopy->SetName("cdbList");
1151
1152 TIter iter2(cdbList);
1153
1154 AliCDBId* id=0;
1155 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
a4970db9 1156 cdbListCopy->Add(new TObjString(id->ToString().Data()));
f747912b 1157 }
1158
1159 tree->GetUserInfo()->Add(cdbMapCopy);
1160 tree->GetUserInfo()->Add(cdbListCopy);
abe0c04e 1161
46698ae4 1162
1163 if(fESDPar.Contains("ESD.par")){
1164 AliInfo("Attaching ESD.par to Tree");
1165 TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
1166 tree->GetUserInfo()->Add(fn);
596a855f 1167 }
1168
46698ae4 1169
36711aa4 1170 file->cd();
aa3c69a9 1171
a9c0e6db 1172 if (fWriteESDfriend)
1173 tree->SetBranchStatus("ESDfriend*",0);
562dd0b4 1174 // we want to have only one tree version number
1175 tree->Write(tree->GetName(),TObject::kOverwrite);
1f46a9ae 1176 hlttree->Write();
f3a97c86 1177
a7a1e1c7 1178// Finish with Plane Efficiency evaluation: before of CleanUp !!!
1179 if (fRunPlaneEff && !FinishPlaneEff()) {
1180 AliWarning("Finish PlaneEff evaluation failed");
1181 }
1182
eae191bc 1183 gROOT->cd();
1184 CleanUp(file, fileOld);
1185
a7807689 1186 if (fWriteAOD) {
eae191bc 1187 TFile *esdFile = TFile::Open("AliESDs.root", "READONLY");
f29f1726 1188 TFile *aodFile = TFile::Open("AliAOD.root", "RECREATE");
eae191bc 1189 ESDFile2AODFile(esdFile, aodFile);
f29f1726 1190 aodFile->Close();
eae191bc 1191 esdFile->Close();
a7807689 1192 }
1193
f3a97c86 1194 // Create tags for the events in the ESD tree (the ESD tree is always present)
1195 // In case of empty events the tags will contain dummy values
08e1a23e 1196 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
444753c6 1197 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPList);
a1069ee1 1198 if (fWriteAOD) {
1199 AliAODTagCreator *aodtagCreator = new AliAODTagCreator();
444753c6 1200 aodtagCreator->CreateAODTags(fFirstEvent,fLastEvent,fGRPList);
a1069ee1 1201 }
596a855f 1202
aa3c69a9 1203 //Finish QA and end of cycle for out-of-loop QA
3b378a42 1204 if (!fInLoopQA) {
1205 if (fRunQA) {
1206 qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS);
1207 //qas.Reset() ;
1208 qas.Run(fRunTracking.Data(), AliQA::kESDS);
1209 }
aa3c69a9 1210 if (fRunGlobalQA) {
04236e67 1211 AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
aa3c69a9 1212 if (qadm) {
1213 qadm->EndOfCycle(AliQA::kRECPOINTS);
d7259b2e 1214 qadm->EndOfCycle(AliQA::kESDS);
aa3c69a9 1215 qadm->Finish();
1216 }
1217 }
759c1df1 1218 }
795e4a22 1219
1220 // Cleanup of CDB manager: cache and active storages!
1221 AliCDBManager::Instance()->ClearCache();
1222
1223
596a855f 1224 return kTRUE;
1225}
1226
1227
1228//_____________________________________________________________________________
c4aa7a4c 1229Bool_t AliReconstruction::RunLocalReconstruction(const TString& /*detectors*/)
596a855f 1230{
59697224 1231// run the local reconstruction
0f88822a 1232 static Int_t eventNr=0;
87932dab 1233 AliCodeTimerAuto("")
030b532d 1234
d76c31f4 1235 // AliCDBManager* man = AliCDBManager::Instance();
1236// Bool_t origCache = man->GetCacheFlag();
8e245d15 1237
d76c31f4 1238// TString detStr = detectors;
1239// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1240// if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1241// AliReconstructor* reconstructor = GetReconstructor(iDet);
1242// if (!reconstructor) continue;
1243// if (reconstructor->HasLocalReconstruction()) continue;
b8cd5251 1244
d76c31f4 1245// AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1246// AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
87932dab 1247
d76c31f4 1248// AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
1249// AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
8e245d15 1250
d76c31f4 1251// man->SetCacheFlag(kTRUE);
1252// TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]);
1253// man->GetAll(calibPath); // entries are cached!
8e245d15 1254
d76c31f4 1255// AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
87932dab 1256
d76c31f4 1257// if (fRawReader) {
1258// fRawReader->RewindEvents();
1259// reconstructor->Reconstruct(fRunLoader, fRawReader);
1260// } else {
1261// reconstructor->Reconstruct(fRunLoader);
1262// }
87932dab 1263
d76c31f4 1264// AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
0f88822a 1265 // AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr));
8e245d15 1266
d76c31f4 1267// // unload calibration data
1268// man->UnloadFromCache(calibPath);
1269// //man->ClearCache();
1270// }
596a855f 1271
d76c31f4 1272// man->SetCacheFlag(origCache);
8e245d15 1273
d76c31f4 1274// if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1275// AliError(Form("the following detectors were not found: %s",
1276// detStr.Data()));
1277// if (fStopOnError) return kFALSE;
1278// }
596a855f 1279
0f88822a 1280 eventNr++;
596a855f 1281 return kTRUE;
1282}
1283
1284//_____________________________________________________________________________
b26c3770 1285Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
1286{
1287// run the local reconstruction
aa3c69a9 1288
0f88822a 1289 static Int_t eventNr=0;
87932dab 1290 AliCodeTimerAuto("")
b26c3770 1291
1292 TString detStr = detectors;
1293 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1294 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1295 AliReconstructor* reconstructor = GetReconstructor(iDet);
1296 if (!reconstructor) continue;
1297 AliLoader* loader = fLoader[iDet];
d76c31f4 1298 if (!loader) {
1299 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
1300 continue;
1301 }
b26c3770 1302 // conversion of digits
1303 if (fRawReader && reconstructor->HasDigitConversion()) {
1304 AliInfo(Form("converting raw data digits into root objects for %s",
1305 fgkDetectorName[iDet]));
87932dab 1306 AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
1307 fgkDetectorName[iDet]));
b26c3770 1308 loader->LoadDigits("update");
1309 loader->CleanDigits();
1310 loader->MakeDigitsContainer();
1311 TTree* digitsTree = loader->TreeD();
1312 reconstructor->ConvertDigits(fRawReader, digitsTree);
1313 loader->WriteDigits("OVERWRITE");
1314 loader->UnloadDigits();
b26c3770 1315 }
b26c3770 1316 // local reconstruction
b26c3770 1317 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
87932dab 1318 AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
b26c3770 1319 loader->LoadRecPoints("update");
1320 loader->CleanRecPoints();
1321 loader->MakeRecPointsContainer();
1322 TTree* clustersTree = loader->TreeR();
1323 if (fRawReader && !reconstructor->HasDigitConversion()) {
1324 reconstructor->Reconstruct(fRawReader, clustersTree);
1325 } else {
1326 loader->LoadDigits("read");
1327 TTree* digitsTree = loader->TreeD();
1328 if (!digitsTree) {
1329 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
1330 if (fStopOnError) return kFALSE;
1331 } else {
1332 reconstructor->Reconstruct(digitsTree, clustersTree);
1333 }
1334 loader->UnloadDigits();
1335 }
d76c31f4 1336
aa3c69a9 1337 // In-loop QA for local reconstrucion
1338 if (fRunQA && fInLoopQA) {
04236e67 1339 AliQADataMakerRec * qadm = GetQADataMaker(iDet);
aa3c69a9 1340 if (qadm) {
1341 //AliCodeTimerStart
1342 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1343 //AliInfo
1344 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1345
1346 qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
1347
1348 //AliCodeTimerStop
1349 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1350 }
1351 }
d76c31f4 1352
aa3c69a9 1353 loader->WriteRecPoints("OVERWRITE");
b26c3770 1354 loader->UnloadRecPoints();
6efecea1 1355 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
b26c3770 1356 }
1357
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 }
0f88822a 1363 eventNr++;
b26c3770 1364 return kTRUE;
1365}
1366
1367//_____________________________________________________________________________
af885e0f 1368Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
596a855f 1369{
1370// run the barrel tracking
1371
87932dab 1372 AliCodeTimerAuto("")
030b532d 1373
2257f27e 1374 AliESDVertex* vertex = NULL;
1375 Double_t vtxPos[3] = {0, 0, 0};
1376 Double_t vtxErr[3] = {0.07, 0.07, 0.1};
1377 TArrayF mcVertex(3);
a6b0b91b 1378 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
1379 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
1380 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
1381 }
2257f27e 1382
b8cd5251 1383 if (fVertexer) {
17c86e90 1384 if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
815c2b38 1385 AliInfo("running the ITS vertex finder");
b26c3770 1386 if (fLoader[0]) fLoader[0]->LoadRecPoints();
b8cd5251 1387 vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
b26c3770 1388 if (fLoader[0]) fLoader[0]->UnloadRecPoints();
2257f27e 1389 if(!vertex){
815c2b38 1390 AliWarning("Vertex not found");
c710f220 1391 vertex = new AliESDVertex();
d1a50cb5 1392 vertex->SetName("default");
2257f27e 1393 }
1394 else {
d1a50cb5 1395 vertex->SetName("reconstructed");
2257f27e 1396 }
1397
1398 } else {
815c2b38 1399 AliInfo("getting the primary vertex from MC");
2257f27e 1400 vertex = new AliESDVertex(vtxPos, vtxErr);
1401 }
1402
1403 if (vertex) {
1404 vertex->GetXYZ(vtxPos);
1405 vertex->GetSigmaXYZ(vtxErr);
1406 } else {
815c2b38 1407 AliWarning("no vertex reconstructed");
2257f27e 1408 vertex = new AliESDVertex(vtxPos, vtxErr);
1409 }
06cc9d95 1410 esd->SetPrimaryVertexSPD(vertex);
32e449be 1411 // if SPD multiplicity has been determined, it is stored in the ESD
25be1e5c 1412 AliMultiplicity *mult = fVertexer->GetMultiplicity();
32e449be 1413 if(mult)esd->SetMultiplicity(mult);
1414
b8cd5251 1415 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1416 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
1417 }
2257f27e 1418 delete vertex;
1419
2257f27e 1420 return kTRUE;
1421}
1422
1423//_____________________________________________________________________________
af885e0f 1424Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
1f46a9ae 1425{
1426// run the HLT barrel tracking
1427
87932dab 1428 AliCodeTimerAuto("")
1f46a9ae 1429
1430 if (!fRunLoader) {
1431 AliError("Missing runLoader!");
1432 return kFALSE;
1433 }
1434
1435 AliInfo("running HLT tracking");
1436
1437 // Get a pointer to the HLT reconstructor
1438 AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
1439 if (!reconstructor) return kFALSE;
1440
1441 // TPC + ITS
1442 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1443 TString detName = fgkDetectorName[iDet];
1444 AliDebug(1, Form("%s HLT tracking", detName.Data()));
1445 reconstructor->SetOption(detName.Data());
d76c31f4 1446 AliTracker *tracker = reconstructor->CreateTracker();
1f46a9ae 1447 if (!tracker) {
1448 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
1449 if (fStopOnError) return kFALSE;
9dcc06e1 1450 continue;
1f46a9ae 1451 }
1452 Double_t vtxPos[3];
1453 Double_t vtxErr[3]={0.005,0.005,0.010};
1454 const AliESDVertex *vertex = esd->GetVertex();
1455 vertex->GetXYZ(vtxPos);
1456 tracker->SetVertex(vtxPos,vtxErr);
1457 if(iDet != 1) {
1458 fLoader[iDet]->LoadRecPoints("read");
1459 TTree* tree = fLoader[iDet]->TreeR();
1460 if (!tree) {
1461 AliError(Form("Can't get the %s cluster tree", detName.Data()));
1462 return kFALSE;
1463 }
1464 tracker->LoadClusters(tree);
1465 }
1466 if (tracker->Clusters2Tracks(esd) != 0) {
1467 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
1468 return kFALSE;
1469 }
1470 if(iDet != 1) {
1471 tracker->UnloadClusters();
1472 }
1473 delete tracker;
1474 }
1475
1f46a9ae 1476 return kTRUE;
1477}
1478
1479//_____________________________________________________________________________
af885e0f 1480Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
e66fbafb 1481{
1482// run the muon spectrometer tracking
1483
87932dab 1484 AliCodeTimerAuto("")
e66fbafb 1485
1486 if (!fRunLoader) {
1487 AliError("Missing runLoader!");
1488 return kFALSE;
1489 }
1490 Int_t iDet = 7; // for MUON
1491
1492 AliInfo("is running...");
1493
1494 // Get a pointer to the MUON reconstructor
1495 AliReconstructor *reconstructor = GetReconstructor(iDet);
1496 if (!reconstructor) return kFALSE;
1497
1498
1499 TString detName = fgkDetectorName[iDet];
1500 AliDebug(1, Form("%s tracking", detName.Data()));
d76c31f4 1501 AliTracker *tracker = reconstructor->CreateTracker();
e66fbafb 1502 if (!tracker) {
1503 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
1504 return kFALSE;
1505 }
1506
e66fbafb 1507 // read RecPoints
761350a6 1508 fLoader[iDet]->LoadRecPoints("read");
c1954ee5 1509
761350a6 1510 tracker->LoadClusters(fLoader[iDet]->TreeR());
1511
1512 Int_t rv = tracker->Clusters2Tracks(esd);
1513
761350a6 1514 if ( rv )
1515 {
e66fbafb 1516 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
1517 return kFALSE;
1518 }
761350a6 1519
e66fbafb 1520 fLoader[iDet]->UnloadRecPoints();
1521
c1954ee5 1522 tracker->UnloadClusters();
1523
e66fbafb 1524 delete tracker;
1525
e66fbafb 1526 return kTRUE;
1527}
1528
1529
1530//_____________________________________________________________________________
af885e0f 1531Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
2257f27e 1532{
1533// run the barrel tracking
0f88822a 1534 static Int_t eventNr=0;
87932dab 1535 AliCodeTimerAuto("")
24f7a148 1536
815c2b38 1537 AliInfo("running tracking");
596a855f 1538
91b876d1 1539 //Fill the ESD with the T0 info (will be used by the TOF)
d76c31f4 1540 if (fReconstructor[11] && fLoader[11]) {
1541 fLoader[11]->LoadRecPoints("READ");
1542 TTree *treeR = fLoader[11]->TreeR();
1543 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
1544 }
91b876d1 1545
b8cd5251 1546 // pass 1: TPC + ITS inwards
1547 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1548 if (!fTracker[iDet]) continue;
1549 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
24f7a148 1550
b8cd5251 1551 // load clusters
1552 fLoader[iDet]->LoadRecPoints("read");
6efecea1 1553 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
b8cd5251 1554 TTree* tree = fLoader[iDet]->TreeR();
1555 if (!tree) {
1556 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
24f7a148 1557 return kFALSE;
1558 }
b8cd5251 1559 fTracker[iDet]->LoadClusters(tree);
6efecea1 1560 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 1561 // run tracking
1562 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
1563 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
24f7a148 1564 return kFALSE;
1565 }
b8cd5251 1566 if (fCheckPointLevel > 1) {
1567 WriteESD(esd, Form("%s.tracking", fgkDetectorName[iDet]));
1568 }
878e1fe1 1569 // preliminary PID in TPC needed by the ITS tracker
1570 if (iDet == 1) {
b26c3770 1571 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
878e1fe1 1572 AliESDpid::MakePID(esd);
0f88822a 1573 }
6efecea1 1574 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
b8cd5251 1575 }
596a855f 1576
b8cd5251 1577 // pass 2: ALL backwards
aa3c69a9 1578
b8cd5251 1579 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1580 if (!fTracker[iDet]) continue;
1581 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
1582
1583 // load clusters
1584 if (iDet > 1) { // all except ITS, TPC
1585 TTree* tree = NULL;
7b61cd9c 1586 fLoader[iDet]->LoadRecPoints("read");
6efecea1 1587 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
7b61cd9c 1588 tree = fLoader[iDet]->TreeR();
b8cd5251 1589 if (!tree) {
1590 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
24f7a148 1591 return kFALSE;
1592 }
0f88822a 1593 fTracker[iDet]->LoadClusters(tree);
6efecea1 1594 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 1595 }
24f7a148 1596
b8cd5251 1597 // run tracking
1598 if (fTracker[iDet]->PropagateBack(esd) != 0) {
1599 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
49dfd67a 1600 // return kFALSE;
b8cd5251 1601 }
1602 if (fCheckPointLevel > 1) {
1603 WriteESD(esd, Form("%s.back", fgkDetectorName[iDet]));
1604 }
24f7a148 1605
b8cd5251 1606 // unload clusters
1607 if (iDet > 2) { // all except ITS, TPC, TRD
1608 fTracker[iDet]->UnloadClusters();
7b61cd9c 1609 fLoader[iDet]->UnloadRecPoints();
b8cd5251 1610 }
8f37df88 1611 // updated PID in TPC needed by the ITS tracker -MI
1612 if (iDet == 1) {
8f37df88 1613 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
1614 AliESDpid::MakePID(esd);
1615 }
6efecea1 1616 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
b8cd5251 1617 }
596a855f 1618
98937d93 1619 // write space-points to the ESD in case alignment data output
1620 // is switched on
1621 if (fWriteAlignmentData)
1622 WriteAlignmentData(esd);
1623
b8cd5251 1624 // pass 3: TRD + TPC + ITS refit inwards
aa3c69a9 1625
3b378a42 1626 if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
aa3c69a9 1627
b8cd5251 1628 for (Int_t iDet = 2; iDet >= 0; iDet--) {
1629 if (!fTracker[iDet]) continue;
1630 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
596a855f 1631
b8cd5251 1632 // run tracking
1633 if (fTracker[iDet]->RefitInward(esd) != 0) {
1634 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
49dfd67a 1635 // return kFALSE;
b8cd5251 1636 }
db2368d0 1637 // run postprocessing
1638 if (fTracker[iDet]->PostProcess(esd) != 0) {
1639 AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
1640 // return kFALSE;
1641 }
b8cd5251 1642 if (fCheckPointLevel > 1) {
1643 WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet]));
1644 }
6efecea1 1645 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
b8cd5251 1646 // unload clusters
1647 fTracker[iDet]->UnloadClusters();
6efecea1 1648 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
b8cd5251 1649 fLoader[iDet]->UnloadRecPoints();
6efecea1 1650 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
b8cd5251 1651 }
aa3c69a9 1652
3b378a42 1653 if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
854c6476 1654
0f88822a 1655 eventNr++;
596a855f 1656 return kTRUE;
1657}
1658
1659//_____________________________________________________________________________
d64bd07d 1660Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
1661 //
1662 // Remove the data which are not needed for the physics analysis.
1663 //
1664
d64bd07d 1665 Int_t nTracks=esd->GetNumberOfTracks();
18571674 1666 Int_t nV0s=esd->GetNumberOfV0s();
cf37fd88 1667 AliInfo
1668 (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
d64bd07d 1669
18571674 1670 Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
7f68891d 1671 Bool_t rc=esd->Clean(cleanPars);
d64bd07d 1672
7f68891d 1673 nTracks=esd->GetNumberOfTracks();
18571674 1674 nV0s=esd->GetNumberOfV0s();
cf37fd88 1675 AliInfo
ae5d5566 1676 (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
d64bd07d 1677
7f68891d 1678 return rc;
d64bd07d 1679}
1680
1681//_____________________________________________________________________________
af885e0f 1682Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
596a855f 1683{
1684// fill the event summary data
1685
87932dab 1686 AliCodeTimerAuto("")
0f88822a 1687 static Int_t eventNr=0;
596a855f 1688 TString detStr = detectors;
abe0c04e 1689
b8cd5251 1690 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
abe0c04e 1691 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
b8cd5251 1692 AliReconstructor* reconstructor = GetReconstructor(iDet);
1693 if (!reconstructor) continue;
b8cd5251 1694 if (!ReadESD(esd, fgkDetectorName[iDet])) {
1695 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
b26c3770 1696 TTree* clustersTree = NULL;
d76c31f4 1697 if (fLoader[iDet]) {
b26c3770 1698 fLoader[iDet]->LoadRecPoints("read");
1699 clustersTree = fLoader[iDet]->TreeR();
1700 if (!clustersTree) {
1701 AliError(Form("Can't get the %s clusters tree",
1702 fgkDetectorName[iDet]));
1703 if (fStopOnError) return kFALSE;
1704 }
1705 }
1706 if (fRawReader && !reconstructor->HasDigitConversion()) {
1707 reconstructor->FillESD(fRawReader, clustersTree, esd);
1708 } else {
1709 TTree* digitsTree = NULL;
1710 if (fLoader[iDet]) {
1711 fLoader[iDet]->LoadDigits("read");
1712 digitsTree = fLoader[iDet]->TreeD();
1713 if (!digitsTree) {
1714 AliError(Form("Can't get the %s digits tree",
1715 fgkDetectorName[iDet]));
1716 if (fStopOnError) return kFALSE;
1717 }
1718 }
1719 reconstructor->FillESD(digitsTree, clustersTree, esd);
1720 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
1721 }
d76c31f4 1722 if (fLoader[iDet]) {
b26c3770 1723 fLoader[iDet]->UnloadRecPoints();
1724 }
1725
b8cd5251 1726 if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
596a855f 1727 }
1728 }
1729
1730 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
815c2b38 1731 AliError(Form("the following detectors were not found: %s",
1732 detStr.Data()));
596a855f 1733 if (fStopOnError) return kFALSE;
1734 }
6efecea1 1735 AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
0f88822a 1736 eventNr++;
596a855f 1737 return kTRUE;
1738}
1739
b647652d 1740//_____________________________________________________________________________
af885e0f 1741Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
b647652d 1742{
1743 // Reads the trigger decision which is
1744 // stored in Trigger.root file and fills
1745 // the corresponding esd entries
1746
87932dab 1747 AliCodeTimerAuto("")
1748
b647652d 1749 AliInfo("Filling trigger information into the ESD");
1750
b024fd7f 1751 AliCentralTrigger *aCTP = NULL;
1752
b647652d 1753 if (fRawReader) {
1754 AliCTPRawStream input(fRawReader);
1755 if (!input.Next()) {
1756 AliError("No valid CTP (trigger) DDL raw data is found ! The trigger information is not stored in the ESD !");
1757 return kFALSE;
1758 }
1759 esd->SetTriggerMask(input.GetClassMask());
1760 esd->SetTriggerCluster(input.GetClusterMask());
b024fd7f 1761
1762 aCTP = new AliCentralTrigger();
1763 TString configstr("");
1764 if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
1765 AliError("No trigger configuration found in OCDB! The trigger classes information will no be stored in ESD!");
1766 return kFALSE;
1767 }
b647652d 1768 }
1769 else {
1770 AliRunLoader *runloader = AliRunLoader::GetRunLoader();
1771 if (runloader) {
1772 if (!runloader->LoadTrigger()) {
1ea86aa2 1773 aCTP = runloader->GetTrigger();
b647652d 1774 esd->SetTriggerMask(aCTP->GetClassMask());
1775 esd->SetTriggerCluster(aCTP->GetClusterMask());
1776 }
1777 else {
1778 AliWarning("No trigger can be loaded! The trigger information is not stored in the ESD !");
1779 return kFALSE;
1780 }
1781 }
1782 else {
1783 AliError("No run loader is available! The trigger information is not stored in the ESD !");
1784 return kFALSE;
1785 }
1786 }
1787
b024fd7f 1788 // Now fill the trigger class names into AliESDRun object
1789 AliTriggerConfiguration *config = aCTP->GetConfiguration();
1790 if (!config) {
1791 AliError("No trigger configuration has been found! The trigger classes information will no be stored in ESD!");
1792 return kFALSE;
1793 }
1794
1795 const TObjArray& classesArray = config->GetClasses();
1796 Int_t nclasses = classesArray.GetEntriesFast();
1797 for( Int_t j=0; j<nclasses; j++ ) {
1798 AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At( j );
1799 Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask());
1800 esd->SetTriggerClass(trclass->GetName(),trindex);
1801 }
1802
b647652d 1803 return kTRUE;
1804}
596a855f 1805
001397cd 1806
1807
1808
1809
1810//_____________________________________________________________________________
af885e0f 1811Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
001397cd 1812{
1813 //
1814 // Filling information from RawReader Header
1815 //
1816
1817 AliInfo("Filling information from RawReader Header");
31fd97b2 1818 esd->SetBunchCrossNumber(0);
1819 esd->SetOrbitNumber(0);
9bcc1e45 1820 esd->SetPeriodNumber(0);
001397cd 1821 esd->SetTimeStamp(0);
1822 esd->SetEventType(0);
1823 const AliRawEventHeaderBase * eventHeader = fRawReader->GetEventHeader();
1824 if (eventHeader){
9bcc1e45 1825
1826 const UInt_t *id = eventHeader->GetP("Id");
1827 esd->SetBunchCrossNumber((id)[1]&0x00000fff);
1828 esd->SetOrbitNumber((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff));
1829 esd->SetPeriodNumber(((id)[0]>>4)&0x0fffffff);
1830
001397cd 1831 esd->SetTimeStamp((eventHeader->Get("Timestamp")));
31fd97b2 1832 esd->SetEventType((eventHeader->Get("Type")));
001397cd 1833 }
1834
1835 return kTRUE;
1836}
1837
1838
596a855f 1839//_____________________________________________________________________________
1840Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
1841{
1842// check whether detName is contained in detectors
1843// if yes, it is removed from detectors
1844
1845 // check if all detectors are selected
1846 if ((detectors.CompareTo("ALL") == 0) ||
1847 detectors.BeginsWith("ALL ") ||
1848 detectors.EndsWith(" ALL") ||
1849 detectors.Contains(" ALL ")) {
1850 detectors = "ALL";
1851 return kTRUE;
1852 }
1853
1854 // search for the given detector
1855 Bool_t result = kFALSE;
1856 if ((detectors.CompareTo(detName) == 0) ||
1857 detectors.BeginsWith(detName+" ") ||
1858 detectors.EndsWith(" "+detName) ||
1859 detectors.Contains(" "+detName+" ")) {
1860 detectors.ReplaceAll(detName, "");
1861 result = kTRUE;
1862 }
1863
1864 // clean up the detectors string
1865 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
1866 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1867 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1868
1869 return result;
1870}
e583c30d 1871
1872//_____________________________________________________________________________
f08fc9f5 1873Bool_t AliReconstruction::InitRunLoader()
1874{
1875// get or create the run loader
1876
1877 if (gAlice) delete gAlice;
1878 gAlice = NULL;
1879
b26c3770 1880 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
1881 // load all base libraries to get the loader classes
1882 TString libs = gSystem->GetLibraries();
1883 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1884 TString detName = fgkDetectorName[iDet];
1885 if (detName == "HLT") continue;
1886 if (libs.Contains("lib" + detName + "base.so")) continue;
1887 gSystem->Load("lib" + detName + "base.so");
1888 }
f08fc9f5 1889 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
1890 if (!fRunLoader) {
1891 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
1892 CleanUp();
1893 return kFALSE;
1894 }
b26c3770 1895 fRunLoader->CdGAFile();
1896 if (gFile->GetKey(AliRunLoader::GetGAliceName())) {
1897 if (fRunLoader->LoadgAlice() == 0) {
1898 gAlice = fRunLoader->GetAliRun();
c84a5e9e 1899 AliTracker::SetFieldMap(gAlice->Field(),fUniformField);
b26c3770 1900 }
f08fc9f5 1901 }
1902 if (!gAlice && !fRawReader) {
1903 AliError(Form("no gAlice object found in file %s",
1904 fGAliceFileName.Data()));
1905 CleanUp();
1906 return kFALSE;
1907 }
1908
6cae184e 1909 //PH This is a temporary fix to give access to the kinematics
1910 //PH that is needed for the labels of ITS clusters
f2ee4290 1911 fRunLoader->LoadHeader();
6cae184e 1912 fRunLoader->LoadKinematics();
1913
f08fc9f5 1914 } else { // galice.root does not exist
1915 if (!fRawReader) {
1916 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
1917 CleanUp();
1918 return kFALSE;
1919 }
1920 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
1921 AliConfig::GetDefaultEventFolderName(),
1922 "recreate");
1923 if (!fRunLoader) {
1924 AliError(Form("could not create run loader in file %s",
1925 fGAliceFileName.Data()));
1926 CleanUp();
1927 return kFALSE;
1928 }
1929 fRunLoader->MakeTree("E");
1930 Int_t iEvent = 0;
1931 while (fRawReader->NextEvent()) {
1932 fRunLoader->SetEventNumber(iEvent);
1933 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
1934 iEvent, iEvent);
1935 fRunLoader->MakeTree("H");
1936 fRunLoader->TreeE()->Fill();
1937 iEvent++;
1938 }
1939 fRawReader->RewindEvents();
973388c2 1940 if (fNumberOfEventsPerFile > 0)
1941 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
1942 else
1943 fRunLoader->SetNumberOfEventsPerFile(iEvent);
f08fc9f5 1944 fRunLoader->WriteHeader("OVERWRITE");
1945 fRunLoader->CdGAFile();
1946 fRunLoader->Write(0, TObject::kOverwrite);
1947// AliTracker::SetFieldMap(???);
1948 }
1949
1950 return kTRUE;
1951}
1952
1953//_____________________________________________________________________________
b8cd5251 1954AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
c757bafd 1955{
f08fc9f5 1956// get the reconstructor object and the loader for a detector
c757bafd 1957
b8cd5251 1958 if (fReconstructor[iDet]) return fReconstructor[iDet];
1959
1960 // load the reconstructor object
1961 TPluginManager* pluginManager = gROOT->GetPluginManager();
1962 TString detName = fgkDetectorName[iDet];
1963 TString recName = "Ali" + detName + "Reconstructor";
f08fc9f5 1964 if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) return NULL;
b8cd5251 1965
b8cd5251 1966 AliReconstructor* reconstructor = NULL;
1967 // first check if a plugin is defined for the reconstructor
1968 TPluginHandler* pluginHandler =
1969 pluginManager->FindHandler("AliReconstructor", detName);
f08fc9f5 1970 // if not, add a plugin for it
1971 if (!pluginHandler) {
b8cd5251 1972 AliDebug(1, Form("defining plugin for %s", recName.Data()));
b26c3770 1973 TString libs = gSystem->GetLibraries();
1974 if (libs.Contains("lib" + detName + "base.so") ||
1975 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
b8cd5251 1976 pluginManager->AddHandler("AliReconstructor", detName,
1977 recName, detName + "rec", recName + "()");
1978 } else {
1979 pluginManager->AddHandler("AliReconstructor", detName,
1980 recName, detName, recName + "()");
c757bafd 1981 }
b8cd5251 1982 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
1983 }
1984 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
1985 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
c757bafd 1986 }
b8cd5251 1987 if (reconstructor) {
1988 TObject* obj = fOptions.FindObject(detName.Data());
1989 if (obj) reconstructor->SetOption(obj->GetTitle());
d76c31f4 1990 reconstructor->Init();
b8cd5251 1991 fReconstructor[iDet] = reconstructor;
1992 }
1993
f08fc9f5 1994 // get or create the loader
1995 if (detName != "HLT") {
1996 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
1997 if (!fLoader[iDet]) {
1998 AliConfig::Instance()
1999 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
2000 detName, detName);
2001 // first check if a plugin is defined for the loader
bb0901a4 2002 pluginHandler =
f08fc9f5 2003 pluginManager->FindHandler("AliLoader", detName);
2004 // if not, add a plugin for it
2005 if (!pluginHandler) {
2006 TString loaderName = "Ali" + detName + "Loader";
2007 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
2008 pluginManager->AddHandler("AliLoader", detName,
2009 loaderName, detName + "base",
2010 loaderName + "(const char*, TFolder*)");
2011 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
2012 }
2013 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2014 fLoader[iDet] =
2015 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
2016 fRunLoader->GetEventFolder());
2017 }
2018 if (!fLoader[iDet]) { // use default loader
2019 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
2020 }
2021 if (!fLoader[iDet]) {
2022 AliWarning(Form("couldn't get loader for %s", detName.Data()));
6667b602 2023 if (fStopOnError) return NULL;
f08fc9f5 2024 } else {
2025 fRunLoader->AddLoader(fLoader[iDet]);
2026 fRunLoader->CdGAFile();
2027 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
2028 fRunLoader->Write(0, TObject::kOverwrite);
2029 }
2030 }
2031 }
2032
b8cd5251 2033 return reconstructor;
c757bafd 2034}
2035
2036//_____________________________________________________________________________
2257f27e 2037Bool_t AliReconstruction::CreateVertexer()
2038{
2039// create the vertexer
2040
b8cd5251 2041 fVertexer = NULL;
2042 AliReconstructor* itsReconstructor = GetReconstructor(0);
59697224 2043 if (itsReconstructor) {
d76c31f4 2044 fVertexer = itsReconstructor->CreateVertexer();
2257f27e 2045 }
b8cd5251 2046 if (!fVertexer) {
815c2b38 2047 AliWarning("couldn't create a vertexer for ITS");
2257f27e 2048 if (fStopOnError) return kFALSE;
2049 }
2050
2051 return kTRUE;
2052}
2053
2054//_____________________________________________________________________________
b8cd5251 2055Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
24f7a148 2056{
f08fc9f5 2057// create the trackers
24f7a148 2058
b8cd5251 2059 TString detStr = detectors;
2060 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2061 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2062 AliReconstructor* reconstructor = GetReconstructor(iDet);
2063 if (!reconstructor) continue;
2064 TString detName = fgkDetectorName[iDet];
1f46a9ae 2065 if (detName == "HLT") {
2066 fRunHLTTracking = kTRUE;
2067 continue;
2068 }
e66fbafb 2069 if (detName == "MUON") {
2070 fRunMuonTracking = kTRUE;
2071 continue;
2072 }
2073
f08fc9f5 2074
d76c31f4 2075 fTracker[iDet] = reconstructor->CreateTracker();
f08fc9f5 2076 if (!fTracker[iDet] && (iDet < 7)) {
2077 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
8250d5f5 2078 if (fStopOnError) return kFALSE;
2079 }
6efecea1 2080 AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
8250d5f5 2081 }
2082
24f7a148 2083 return kTRUE;
2084}
2085
2086//_____________________________________________________________________________
b26c3770 2087void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
e583c30d 2088{
2089// delete trackers and the run loader and close and delete the file
2090
b8cd5251 2091 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2092 delete fReconstructor[iDet];
2093 fReconstructor[iDet] = NULL;
2094 fLoader[iDet] = NULL;
2095 delete fTracker[iDet];
2096 fTracker[iDet] = NULL;
c65c502a 2097// delete fQADataMaker[iDet];
2098// fQADataMaker[iDet] = NULL;
b8cd5251 2099 }
2100 delete fVertexer;
2101 fVertexer = NULL;
795e4a22 2102
2103 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
2104 delete fDiamondProfile;
2105 fDiamondProfile = NULL;
43c9dae1 2106 delete fDiamondProfileTPC;
2107 fDiamondProfileTPC = NULL;
de95c208 2108 delete fGRPList;
2109 fGRPList = NULL;
795e4a22 2110 }
e583c30d 2111
444753c6 2112
e583c30d 2113 delete fRunLoader;
2114 fRunLoader = NULL;
b649205a 2115 delete fRawReader;
2116 fRawReader = NULL;
cd0b062e 2117 if (fParentRawReader) delete fParentRawReader;
2118 fParentRawReader=NULL;
e583c30d 2119
2120 if (file) {
2121 file->Close();
2122 delete file;
2123 }
b26c3770 2124
2125 if (fileOld) {
2126 fileOld->Close();
2127 delete fileOld;
2128 gSystem->Unlink("AliESDs.old.root");
2129 }
e583c30d 2130}
24f7a148 2131
24f7a148 2132//_____________________________________________________________________________
af885e0f 2133
2134Bool_t AliReconstruction::ReadESD(AliESDEvent*& esd, const char* recStep) const
24f7a148 2135{
2136// read the ESD event from a file
2137
2138 if (!esd) return kFALSE;
2139 char fileName[256];
2140 sprintf(fileName, "ESD_%d.%d_%s.root",
31fd97b2 2141 esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
24f7a148 2142 if (gSystem->AccessPathName(fileName)) return kFALSE;
2143
f3a97c86 2144 AliInfo(Form("reading ESD from file %s", fileName));
815c2b38 2145 AliDebug(1, Form("reading ESD from file %s", fileName));
24f7a148 2146 TFile* file = TFile::Open(fileName);
2147 if (!file || !file->IsOpen()) {
815c2b38 2148 AliError(Form("opening %s failed", fileName));
24f7a148 2149 delete file;
2150 return kFALSE;
2151 }
2152
2153 gROOT->cd();
2154 delete esd;
af885e0f 2155 esd = (AliESDEvent*) file->Get("ESD");
24f7a148 2156 file->Close();
2157 delete file;
2158 return kTRUE;
af885e0f 2159
24f7a148 2160}
2161
af885e0f 2162
2163
24f7a148 2164//_____________________________________________________________________________
af885e0f 2165void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const
24f7a148 2166{
2167// write the ESD event to a file
2168
2169 if (!esd) return;
2170 char fileName[256];
2171 sprintf(fileName, "ESD_%d.%d_%s.root",
31fd97b2 2172 esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
24f7a148 2173
815c2b38 2174 AliDebug(1, Form("writing ESD to file %s", fileName));
24f7a148 2175 TFile* file = TFile::Open(fileName, "recreate");
2176 if (!file || !file->IsOpen()) {
815c2b38 2177 AliError(Form("opening %s failed", fileName));
24f7a148 2178 } else {
2179 esd->Write("ESD");
2180 file->Close();
2181 }
2182 delete file;
2183}
f3a97c86 2184
2185
2186
2187
f3a97c86 2188
a7807689 2189//_____________________________________________________________________________
f29f1726 2190void AliReconstruction::ESDFile2AODFile(TFile* esdFile, TFile* aodFile)
a7807689 2191{
f29f1726 2192 // write all files from the given esd file to an aod file
85ba66b8 2193
f29f1726 2194 // create an AliAOD object
2195 AliAODEvent *aod = new AliAODEvent();
2196 aod->CreateStdContent();
2197
2198 // go to the file
2199 aodFile->cd();
2200
2201 // create the tree
b97637d4 2202 TTree *aodTree = new TTree("aodTree", "AliAOD tree");
f29f1726 2203 aodTree->Branch(aod->GetList());
2204
2205 // connect to ESD
2206 TTree *t = (TTree*) esdFile->Get("esdTree");
af885e0f 2207 AliESDEvent *esd = new AliESDEvent();
53ec9628 2208 esd->ReadFromTree(t);
f29f1726 2209
53ec9628 2210 Int_t nEvents = t->GetEntries();
f29f1726 2211
2212 // set arrays and pointers
2213 Float_t posF[3];
2214 Double_t pos[3];
2215 Double_t p[3];
3dd9f9e3 2216 Double_t p_pos[3];
2217 Double_t p_neg[3];
f29f1726 2218 Double_t covVtx[6];
2219 Double_t covTr[21];
2220 Double_t pid[10];
2221
2222 // loop over events and fill them
2223 for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) {
3dd9f9e3 2224 //cout << "event: " << iEvent << endl;
53ec9628 2225 t->GetEntry(iEvent);
f29f1726 2226
2227 // Multiplicity information needed by the header (to be revised!)
2228 Int_t nTracks = esd->GetNumberOfTracks();
2229 Int_t nPosTracks = 0;
2230 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack)
b97637d4 2231 if (esd->GetTrack(iTrack)->Charge()> 0) nPosTracks++;
f29f1726 2232
85ba66b8 2233 // Access the header
2234 AliAODHeader *header = aod->GetHeader();
2235
2236 // fill the header
ade23daf 2237 header->SetRunNumber (esd->GetRunNumber() );
2238 header->SetBunchCrossNumber(esd->GetBunchCrossNumber());
2239 header->SetOrbitNumber (esd->GetOrbitNumber() );
2240 header->SetPeriodNumber (esd->GetPeriodNumber() );
2241 header->SetTriggerMask (esd->GetTriggerMask() );
2242 header->SetTriggerCluster (esd->GetTriggerCluster() );
2243 header->SetEventType (esd->GetEventType() );
2244 header->SetMagneticField (esd->GetMagneticField() );
2245 header->SetZDCN1Energy (esd->GetZDCN1Energy() );
2246 header->SetZDCP1Energy (esd->GetZDCP1Energy() );
2247 header->SetZDCN2Energy (esd->GetZDCN2Energy() );
2248 header->SetZDCP2Energy (esd->GetZDCP2Energy() );
a85132e7 2249 header->SetZDCEMEnergy (esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
a1d4139d 2250 header->SetRefMultiplicity (nTracks);
2251 header->SetRefMultiplicityPos(nPosTracks);
2252 header->SetRefMultiplicityNeg(nTracks - nPosTracks);
2253 header->SetMuonMagFieldScale(-999.); // FIXME
2254 header->SetCentrality(-999.); // FIXME
f29f1726 2255
2256 Int_t nV0s = esd->GetNumberOfV0s();
2257 Int_t nCascades = esd->GetNumberOfCascades();
2258 Int_t nKinks = esd->GetNumberOfKinks();
f747912b 2259 Int_t nVertices = nV0s + 2*nCascades /*could lead to two vertices, one V0 and the Xi */+ nKinks + 1 /* = prim. vtx*/;
2260 Int_t nJets = 0;
3dd9f9e3 2261 Int_t nCaloClus = esd->GetNumberOfCaloClusters();
2262 Int_t nFmdClus = 0;
2263 Int_t nPmdClus = esd->GetNumberOfPmdTracks();
2264
2265 aod->ResetStd(nTracks, nVertices, nV0s+nCascades, nJets, nCaloClus, nFmdClus, nPmdClus);
f29f1726 2266
f29f1726 2267 // Array to take into account the tracks already added to the AOD
2268 Bool_t * usedTrack = NULL;
2269 if (nTracks>0) {
2270 usedTrack = new Bool_t[nTracks];
2271 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) usedTrack[iTrack]=kFALSE;
2272 }
2273 // Array to take into account the V0s already added to the AOD
2274 Bool_t * usedV0 = NULL;
2275 if (nV0s>0) {
2276 usedV0 = new Bool_t[nV0s];
2277 for (Int_t iV0=0; iV0<nV0s; ++iV0) usedV0[iV0]=kFALSE;
2278 }
2279 // Array to take into account the kinks already added to the AOD
2280 Bool_t * usedKink = NULL;
2281 if (nKinks>0) {
2282 usedKink = new Bool_t[nKinks];
2283 for (Int_t iKink=0; iKink<nKinks; ++iKink) usedKink[iKink]=kFALSE;
2284 }
3dd9f9e3 2285
f29f1726 2286 // Access to the AOD container of vertices
2287 TClonesArray &vertices = *(aod->GetVertices());
2288 Int_t jVertices=0;
2289
2290 // Access to the AOD container of tracks
2291 TClonesArray &tracks = *(aod->GetTracks());
2292 Int_t jTracks=0;
3dd9f9e3 2293
2294 // Access to the AOD container of V0s
2295 TClonesArray &V0s = *(aod->GetV0s());
2296 Int_t jV0s=0;
2297
f29f1726 2298 // Add primary vertex. The primary tracks will be defined
2299 // after the loops on the composite objects (V0, cascades, kinks)
2300 const AliESDVertex *vtx = esd->GetPrimaryVertex();
2301
2302 vtx->GetXYZ(pos); // position
2303 vtx->GetCovMatrix(covVtx); //covariance matrix
2304
2305 AliAODVertex * primary = new(vertices[jVertices++])
02153d58 2306 AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);
f29f1726 2307
3dd9f9e3 2308
2309 AliAODTrack *aodTrack = 0x0;
2310
f29f1726 2311 // Create vertices starting from the most complex objects
3dd9f9e3 2312
f29f1726 2313 // Cascades
2314 for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) {
2315 AliESDcascade *cascade = esd->GetCascade(nCascade);
2316
3dd9f9e3 2317 cascade->GetXYZ(pos[0], pos[1], pos[2]);
f29f1726 2318 cascade->GetPosCovXi(covVtx);
2319
2320 // Add the cascade vertex
2321 AliAODVertex * vcascade = new(vertices[jVertices++]) AliAODVertex(pos,
2322 covVtx,
2323 cascade->GetChi2Xi(), // = chi2/NDF since NDF = 2*2-3
2324 primary,
02153d58 2325 nCascade,
f29f1726 2326 AliAODVertex::kCascade);
2327
3dd9f9e3 2328 primary->AddDaughter(vcascade); // the cascade 'particle' (represented by a vertex) is added as a daughter to the primary vertex
f29f1726 2329
2330 // Add the V0 from the cascade. The ESD class have to be optimized...
85ba66b8 2331 // Now we have to search for the corresponding V0 in the list of V0s
f29f1726 2332 // using the indeces of the positive and negative tracks
2333
2334 Int_t posFromV0 = cascade->GetPindex();
2335 Int_t negFromV0 = cascade->GetNindex();
2336
3dd9f9e3 2337
f29f1726 2338 AliESDv0 * v0 = 0x0;
2339 Int_t indV0 = -1;
2340
2341 for (Int_t iV0=0; iV0<nV0s; ++iV0) {
2342
2343 v0 = esd->GetV0(iV0);
2344 Int_t posV0 = v0->GetPindex();
2345 Int_t negV0 = v0->GetNindex();
2346
2347 if (posV0==posFromV0 && negV0==negFromV0) {
2348 indV0 = iV0;
2349 break;
2350 }
2351 }
2352
2353 AliAODVertex * vV0FromCascade = 0x0;
2354
3dd9f9e3 2355 if (indV0>-1 && !usedV0[indV0]) {
f29f1726 2356
2357 // the V0 exists in the array of V0s and is not used
2358
2359 usedV0[indV0] = kTRUE;
2360
2361 v0->GetXYZ(pos[0], pos[1], pos[2]);
2362 v0->GetPosCov(covVtx);
2363
2364 vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
2365 covVtx,
2366 v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
2367 vcascade,
02153d58 2368 indV0,
f29f1726 2369 AliAODVertex::kV0);
2370 } else {
2371
2372 // the V0 doesn't exist in the array of V0s or was used
2373 cerr << "Error: event " << iEvent << " cascade " << nCascade
2374 << " The V0 " << indV0
2375 << " doesn't exist in the array of V0s or was used!" << endl;
2376
2377 cascade->GetXYZ(pos[0], pos[1], pos[2]);
2378 cascade->GetPosCov(covVtx);
2379
2380 vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
2381 covVtx,
2382 v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
2383 vcascade,
02153d58 2384 indV0,
f29f1726 2385 AliAODVertex::kV0);
2386 vcascade->AddDaughter(vV0FromCascade);
3dd9f9e3 2387
f29f1726 2388 }
2389
2390 // Add the positive tracks from the V0
2391
2392 if (! usedTrack[posFromV0]) {
2393
2394 usedTrack[posFromV0] = kTRUE;
2395
2396 AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
3dd9f9e3 2397 esdTrack->GetPxPyPz(p_pos);
f29f1726 2398 esdTrack->GetXYZ(pos);
2399 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2400 esdTrack->GetESDpid(pid);
2401
2402 vV0FromCascade->AddDaughter(aodTrack =
2403 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2404 esdTrack->GetLabel(),
3dd9f9e3 2405 p_pos,
f29f1726 2406 kTRUE,
2407 pos,
2408 kFALSE,
2409 covTr,
b97637d4 2410 (Short_t)esdTrack->Charge(),
f29f1726 2411 esdTrack->GetITSClusterMap(),
2412 pid,
2413 vV0FromCascade,
2414 kTRUE, // check if this is right
2415 kFALSE, // check if this is right
2416 AliAODTrack::kSecondary)
2417 );
2418 aodTrack->ConvertAliPIDtoAODPID();
2419 }
2420 else {
2421 cerr << "Error: event " << iEvent << " cascade " << nCascade
2422 << " track " << posFromV0 << " has already been used!" << endl;
2423 }
2424
2425 // Add the negative tracks from the V0
2426
2427 if (!usedTrack[negFromV0]) {
2428
2429 usedTrack[negFromV0] = kTRUE;
2430
2431 AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
3dd9f9e3 2432 esdTrack->GetPxPyPz(p_neg);
f29f1726 2433 esdTrack->GetXYZ(pos);
2434 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2435 esdTrack->GetESDpid(pid);
2436
2437 vV0FromCascade->AddDaughter(aodTrack =
2438 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2439 esdTrack->GetLabel(),
3dd9f9e3 2440 p_neg,
f29f1726 2441 kTRUE,
2442 pos,
2443 kFALSE,
2444 covTr,
b97637d4 2445 (Short_t)esdTrack->Charge(),
f29f1726 2446 esdTrack->GetITSClusterMap(),
2447 pid,
2448 vV0FromCascade,
2449 kTRUE, // check if this is right
2450 kFALSE, // check if this is right
2451 AliAODTrack::kSecondary)
2452 );
2453 aodTrack->ConvertAliPIDtoAODPID();
2454 }
2455 else {
2456 cerr << "Error: event " << iEvent << " cascade " << nCascade
2457 << " track " << negFromV0 << " has already been used!" << endl;
2458 }
2459
3dd9f9e3 2460 // add it to the V0 array as well
2461 Double_t d0[2] = { -999., -99.};
2462 // counting is probably wrong
2463 new(V0s[jV0s++]) AliAODv0(vV0FromCascade, -999., -99., p_pos, p_neg, d0); // to be refined
2464
f29f1726 2465 // Add the bachelor track from the cascade
2466
2467 Int_t bachelor = cascade->GetBindex();
2468
2469 if(!usedTrack[bachelor]) {
2470
2471 usedTrack[bachelor] = kTRUE;
2472
2473 AliESDtrack *esdTrack = esd->GetTrack(bachelor);
2474 esdTrack->GetPxPyPz(p);
2475 esdTrack->GetXYZ(pos);
2476 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2477 esdTrack->GetESDpid(pid);
2478
2479 vcascade->AddDaughter(aodTrack =
2480 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2481 esdTrack->GetLabel(),
2482 p,
2483 kTRUE,
2484 pos,
2485 kFALSE,
2486 covTr,
b97637d4 2487 (Short_t)esdTrack->Charge(),
f29f1726 2488 esdTrack->GetITSClusterMap(),
2489 pid,
2490 vcascade,
2491 kTRUE, // check if this is right
2492 kFALSE, // check if this is right
2493 AliAODTrack::kSecondary)
2494 );
2495 aodTrack->ConvertAliPIDtoAODPID();
2496 }
2497 else {
2498 cerr << "Error: event " << iEvent << " cascade " << nCascade
2499 << " track " << bachelor << " has already been used!" << endl;
2500 }
3dd9f9e3 2501
f29f1726 2502 // Add the primary track of the cascade (if any)
3dd9f9e3 2503
f29f1726 2504 } // end of the loop on cascades
3dd9f9e3 2505
f29f1726 2506 // V0s
2507
2508 for (Int_t nV0 = 0; nV0 < nV0s; ++nV0) {
2509
2510 if (usedV0[nV0]) continue; // skip if aready added to the AOD
2511
3dd9f9e3 2512 AliESDv0 *v0 = esd->GetV0(nV0);
2513
f29f1726 2514 v0->GetXYZ(pos[0], pos[1], pos[2]);
2515 v0->GetPosCov(covVtx);
2516
2517 AliAODVertex * vV0 =
2518 new(vertices[jVertices++]) AliAODVertex(pos,
2519 covVtx,
2520 v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
2521 primary,
02153d58 2522 nV0,
f29f1726 2523 AliAODVertex::kV0);
2524 primary->AddDaughter(vV0);
2525
2526 Int_t posFromV0 = v0->GetPindex();
2527 Int_t negFromV0 = v0->GetNindex();
2528
2529 // Add the positive tracks from the V0
2530
2531 if (!usedTrack[posFromV0]) {
2532
2533 usedTrack[posFromV0] = kTRUE;
2534
2535 AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
3dd9f9e3 2536 esdTrack->GetPxPyPz(p_pos);
f29f1726 2537 esdTrack->GetXYZ(pos);
2538 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2539 esdTrack->GetESDpid(pid);
2540
2541 vV0->AddDaughter(aodTrack =
2542 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2543 esdTrack->GetLabel(),
3dd9f9e3 2544 p_pos,
f29f1726 2545 kTRUE,
2546 pos,
2547 kFALSE,
2548 covTr,
b97637d4 2549 (Short_t)esdTrack->Charge(),
f29f1726 2550 esdTrack->GetITSClusterMap(),
2551 pid,
2552 vV0,
2553 kTRUE, // check if this is right
2554 kFALSE, // check if this is right
2555 AliAODTrack::kSecondary)
2556 );
2557 aodTrack->ConvertAliPIDtoAODPID();
2558 }
2559 else {
2560 cerr << "Error: event " << iEvent << " V0 " << nV0
2561 << " track " << posFromV0 << " has already been used!" << endl;
2562 }
a7807689 2563
f29f1726 2564 // Add the negative tracks from the V0
2565
2566 if (!usedTrack[negFromV0]) {
2567
2568 usedTrack[negFromV0] = kTRUE;
2569
2570 AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
3dd9f9e3 2571 esdTrack->GetPxPyPz(p_neg);
f29f1726 2572 esdTrack->GetXYZ(pos);
2573 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2574 esdTrack->GetESDpid(pid);
2575
2576 vV0->AddDaughter(aodTrack =
2577 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2578 esdTrack->GetLabel(),
3dd9f9e3 2579 p_neg,
f29f1726 2580 kTRUE,
2581 pos,
2582 kFALSE,
2583 covTr,
b97637d4 2584 (Short_t)esdTrack->Charge(),
f29f1726 2585 esdTrack->GetITSClusterMap(),
2586 pid,
2587 vV0,
2588 kTRUE, // check if this is right
2589 kFALSE, // check if this is right
2590 AliAODTrack::kSecondary)
2591 );
2592 aodTrack->ConvertAliPIDtoAODPID();
2593 }
2594 else {
2595 cerr << "Error: event " << iEvent << " V0 " << nV0
2596 << " track " << negFromV0 << " has already been used!" << endl;
2597 }
2598
3dd9f9e3 2599 // add it to the V0 array as well
2600 Double_t d0[2] = { 999., 99.};
2601 new(V0s[jV0s++]) AliAODv0(vV0, 999., 99., p_pos, p_neg, d0); // to be refined
f747912b 2602 }
2603 V0s.Expand(jV0s);
2604 // end of the loop on V0s
f29f1726 2605
2606 // Kinks: it is a big mess the access to the information in the kinks
2607 // The loop is on the tracks in order to find the mother and daugther of each kink
2608
2609
2610 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) {
2611
f29f1726 2612 AliESDtrack * esdTrack = esd->GetTrack(iTrack);
2613
2614 Int_t ikink = esdTrack->GetKinkIndex(0);
2615
2616 if (ikink) {
2617 // Negative kink index: mother, positive: daughter
2618
2619 // Search for the second track of the kink
2620
2621 for (Int_t jTrack = iTrack+1; jTrack<nTracks; ++jTrack) {
2622
2623 AliESDtrack * esdTrack1 = esd->GetTrack(jTrack);
2624
2625 Int_t jkink = esdTrack1->GetKinkIndex(0);
2626
2627 if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {
2628
2629 // The two tracks are from the same kink
2630
2631 if (usedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks
2632
2633 Int_t imother = -1;
2634 Int_t idaughter = -1;
2635
2636 if (ikink<0 && jkink>0) {
2637
2638 imother = iTrack;
2639 idaughter = jTrack;
2640 }
2641 else if (ikink>0 && jkink<0) {
2642
2643 imother = jTrack;
2644 idaughter = iTrack;
2645 }
2646 else {
2647 cerr << "Error: Wrong combination of kink indexes: "
2648 << ikink << " " << jkink << endl;
2649 continue;
2650 }
2651
2652 // Add the mother track
2653
2654 AliAODTrack * mother = NULL;
2655
2656 if (!usedTrack[imother]) {
2657
2658 usedTrack[imother] = kTRUE;
2659
2660 AliESDtrack *esdTrack = esd->GetTrack(imother);
2661 esdTrack->GetPxPyPz(p);
2662 esdTrack->GetXYZ(pos);
2663 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2664 esdTrack->GetESDpid(pid);
2665
2666 mother =
2667 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2668 esdTrack->GetLabel(),
2669 p,
2670 kTRUE,
2671 pos,
2672 kFALSE,
2673 covTr,
b97637d4 2674 (Short_t)esdTrack->Charge(),
f29f1726 2675 esdTrack->GetITSClusterMap(),
2676 pid,
2677 primary,
2678 kTRUE, // check if this is right
2679 kTRUE, // check if this is right
2680 AliAODTrack::kPrimary);
2681 primary->AddDaughter(mother);
2682 mother->ConvertAliPIDtoAODPID();
2683 }
2684 else {
2685 cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
2686 << " track " << imother << " has already been used!" << endl;
2687 }
2688
2689 // Add the kink vertex
2690 AliESDkink * kink = esd->GetKink(TMath::Abs(ikink)-1);
2691
2692 AliAODVertex * vkink =
2693 new(vertices[jVertices++]) AliAODVertex(kink->GetPosition(),
2694 NULL,
2695 0.,
2696 mother,
02153d58 2697 esdTrack->GetID(), // This is the track ID of the mother's track!
f29f1726 2698 AliAODVertex::kKink);
2699 // Add the daughter track
2700
2701 AliAODTrack * daughter = NULL;
2702
2703 if (!usedTrack[idaughter]) {
2704
2705 usedTrack[idaughter] = kTRUE;
2706
2707 AliESDtrack *esdTrack = esd->GetTrack(idaughter);
2708 esdTrack->GetPxPyPz(p);
2709 esdTrack->GetXYZ(pos);
2710 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2711 esdTrack->GetESDpid(pid);
2712
2713 daughter =
2714 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2715 esdTrack->GetLabel(),
2716 p,
2717 kTRUE,
2718 pos,
2719 kFALSE,
2720 covTr,
b97637d4 2721 (Short_t)esdTrack->Charge(),
f29f1726 2722 esdTrack->GetITSClusterMap(),
2723 pid,
2724 vkink,
2725 kTRUE, // check if this is right
2726 kTRUE, // check if this is right
2727 AliAODTrack::kPrimary);
2728 vkink->AddDaughter(daughter);
2729 daughter->ConvertAliPIDtoAODPID();
2730 }
2731 else {
2732 cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
2733 << " track " << idaughter << " has already been used!" << endl;
2734 }
f29f1726 2735 }
2736 }
3dd9f9e3 2737 }
f29f1726 2738 }
f747912b 2739 vertices.Expand(jVertices);
f29f1726 2740
f29f1726 2741 // Tracks (primary and orphan)
f29f1726 2742 for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) {
f29f1726 2743
2744 if (usedTrack[nTrack]) continue;
2745
2746 AliESDtrack *esdTrack = esd->GetTrack(nTrack);
2747 esdTrack->GetPxPyPz(p);
2748 esdTrack->GetXYZ(pos);
2749 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2750 esdTrack->GetESDpid(pid);
2751
2752 Float_t impactXY, impactZ;
2753
2754 esdTrack->GetImpactParameters(impactXY,impactZ);
2755
3dd9f9e3 2756 if (impactXY<3.) {
f29f1726 2757 // track inside the beam pipe
2758
2759 primary->AddDaughter(aodTrack =
2760 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2761 esdTrack->GetLabel(),
2762 p,
2763 kTRUE,
2764 pos,
2765 kFALSE,
2766 covTr,
b97637d4 2767 (Short_t)esdTrack->Charge(),
f29f1726 2768 esdTrack->GetITSClusterMap(),
2769 pid,
2770 primary,
2771 kTRUE, // check if this is right
2772 kTRUE, // check if this is right
2773 AliAODTrack::kPrimary)
2774 );
2775 aodTrack->ConvertAliPIDtoAODPID();
2776 }
2777 else {
2778 // outside the beam pipe: orphan track
3dd9f9e3 2779 // Don't write them anymore!
2780 continue;
f29f1726 2781 }
2782 } // end of loop on tracks
3dd9f9e3 2783
f29f1726 2784 // muon tracks
2785 Int_t nMuTracks = esd->GetNumberOfMuonTracks();
2786 for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack) {
2787
2788 AliESDMuonTrack *esdMuTrack = esd->GetMuonTrack(nMuTrack);
2789 p[0] = esdMuTrack->Px();
2790 p[1] = esdMuTrack->Py();
2791 p[2] = esdMuTrack->Pz();
2792 pos[0] = primary->GetX();
2793 pos[1] = primary->GetY();
2794 pos[2] = primary->GetZ();
2795
2796 // has to be changed once the muon pid is provided by the ESD
2797 for (Int_t i = 0; i < 10; pid[i++] = 0.); pid[AliAODTrack::kMuon]=1.;
2798
85ba66b8 2799 primary->AddDaughter(aodTrack =
f29f1726 2800 new(tracks[jTracks++]) AliAODTrack(0, // no ID provided
2801 0, // no label provided
2802 p,
2803 kTRUE,
2804 pos,
2805 kFALSE,
2806 NULL, // no covariance matrix provided
b97637d4 2807 esdMuTrack->Charge(),
e704c7d4 2808 0, // ITSClusterMap is set below
f29f1726 2809 pid,
2810 primary,
85ba66b8 2811 kFALSE, // muon tracks are not used to fit the primary vtx
2812 kFALSE, // not used for vertex fit
f29f1726 2813 AliAODTrack::kPrimary)
2814 );
85ba66b8 2815
2816 aodTrack->SetHitsPatternInTrigCh(esdMuTrack->GetHitsPatternInTrigCh());
2817 Int_t track2Trigger = esdMuTrack->GetMatchTrigger();
2818 aodTrack->SetMatchTrigger(track2Trigger);
2819 if (track2Trigger)
2820 aodTrack->SetChi2MatchTrigger(esdMuTrack->GetChi2MatchTrigger());
2821 else
2822 aodTrack->SetChi2MatchTrigger(0.);
f29f1726 2823 }
f747912b 2824 tracks.Expand(jTracks); // remove 'empty slots' due to unwritten tracks
2825
3dd9f9e3 2826 // Access to the AOD container of PMD clusters
2827 TClonesArray &pmdClusters = *(aod->GetPmdClusters());
2828 Int_t jPmdClusters=0;
2829
2830 for (Int_t iPmd = 0; iPmd < nPmdClus; ++iPmd) {
2831 // file pmd clusters, to be revised!
2832 AliESDPmdTrack *pmdTrack = esd->GetPmdTrack(iPmd);
2833 Int_t nLabel = 0;
2834 Int_t *label = 0x0;
2835 Double_t pos[3] = { pmdTrack->GetClusterX(), pmdTrack->GetClusterY(), pmdTrack->GetClusterZ() };
2836 Double_t pid[9] = { 0., 0., 0., 0., 0., 0., 0., 0., 0. }; // to be revised!
2837 // type not set!
2838 // assoc cluster not set
2839 new(pmdClusters[jPmdClusters++]) AliAODPmdCluster(iPmd, nLabel, label, pmdTrack->GetClusterADC(), pos, pid);
2840 }
2841
f29f1726 2842 // Access to the AOD container of clusters
3dd9f9e3 2843 TClonesArray &caloClusters = *(aod->GetCaloClusters());
f29f1726 2844 Int_t jClusters=0;
3dd9f9e3 2845
2846 for (Int_t iClust=0; iClust<nCaloClus; ++iClust) {
f29f1726 2847
2848 AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust);
2849
2850 Int_t id = cluster->GetID();
3dd9f9e3 2851 Int_t nLabel = 0;
2852 Int_t *label = 0x0;
53ec9628 2853 Float_t energy = cluster->E();
2854 cluster->GetPosition(posF);
f29f1726 2855 Char_t ttype=AliAODCluster::kUndef;
85ba66b8 2856
3dd9f9e3 2857 if (cluster->GetClusterType() == AliESDCaloCluster::kPHOSCluster) {
2858 ttype=AliAODCluster::kPHOSNeutral;
2859 }
2860 else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALClusterv1) {
562dd0b4 2861 ttype = AliAODCluster::kEMCALClusterv1;
3dd9f9e3 2862 }
e649177a 2863
3dd9f9e3 2864
2865 AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++]) AliAODCaloCluster(id,
2866 nLabel,
2867 label,
2868 energy,
2869 pos,
2870 NULL,
2871 ttype);
2872
2873 caloCluster->SetCaloCluster(); // to be refined!
85ba66b8 2874
f747912b 2875 }
37792174 2876 caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters
2877 // end of loop on calo clusters
85ba66b8 2878
80472c78 2879 // fill EMCAL cell info
2880 if (esd->GetEMCALCells()) { // protection against missing ESD information
2881 AliESDCaloCells &esdEMcells = *(esd->GetEMCALCells());
2882 Int_t nEMcell = esdEMcells.GetNumberOfCells() ;
2883
2884 AliAODCaloCells &aodEMcells = *(aod->GetEMCALCells());
2885 aodEMcells.CreateContainer(nEMcell);
2886 aodEMcells.SetType(AliAODCaloCells::kEMCAL);
2887 for (Int_t iCell = 0; iCell < nEMcell; iCell++) {
2888 aodEMcells.SetCell(iCell,esdEMcells.GetCellNumber(iCell),esdEMcells.GetAmplitude(iCell));
2889 }
2890 aodEMcells.Sort();
e649177a 2891 }
e649177a 2892
2893 // fill PHOS cell info
80472c78 2894 if (esd->GetPHOSCells()) { // protection against missing ESD information
2895 AliESDCaloCells &esdPHcells = *(esd->GetPHOSCells());
2896 Int_t nPHcell = esdPHcells.GetNumberOfCells() ;
2897
2898 AliAODCaloCells &aodPHcells = *(aod->GetPHOSCells());
2899 aodPHcells.CreateContainer(nPHcell);
2900 aodPHcells.SetType(AliAODCaloCells::kPHOS);
2901 for (Int_t iCell = 0; iCell < nPHcell; iCell++) {
2902 aodPHcells.SetCell(iCell,esdPHcells.GetCellNumber(iCell),esdPHcells.GetAmplitude(iCell));
2903 }
2904 aodPHcells.Sort();
3dd9f9e3 2905 }
3dd9f9e3 2906
2907 // tracklets
2908 AliAODTracklets &SPDTracklets = *(aod->GetTracklets());
85ba66b8 2909 const AliMultiplicity *mult = esd->GetMultiplicity();
2910 if (mult) {
2911 if (mult->GetNumberOfTracklets()>0) {
3dd9f9e3 2912 SPDTracklets.CreateContainer(mult->GetNumberOfTracklets());
85ba66b8 2913
2914 for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {
3dd9f9e3 2915 SPDTracklets.SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n));
85ba66b8 2916 }
2917 }
2918 } else {
2919 Printf("ERROR: AliMultiplicity could not be retrieved from ESD");
2920 }
2921
f29f1726 2922 delete [] usedTrack;
2923 delete [] usedV0;
2924 delete [] usedKink;
85ba66b8 2925
f29f1726 2926 // fill the tree for this event
2927 aodTree->Fill();
2928 } // end of event loop
85ba66b8 2929
f29f1726 2930 aodTree->GetUserInfo()->Add(aod);
85ba66b8 2931
f29f1726 2932 // write the tree to the specified file
2933 aodFile = aodTree->GetCurrentFile();
2934 aodFile->cd();
2935 aodTree->Write();
85ba66b8 2936
a7807689 2937 return;
2938}
2939
af885e0f 2940void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
98937d93 2941{
2942 // Write space-points which are then used in the alignment procedures
2943 // For the moment only ITS, TRD and TPC
2944
2945 // Load TOF clusters
d528ee75 2946 if (fTracker[3]){
2947 fLoader[3]->LoadRecPoints("read");
2948 TTree* tree = fLoader[3]->TreeR();
2949 if (!tree) {
2950 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[3]));
2951 return;
2952 }
2953 fTracker[3]->LoadClusters(tree);
98937d93 2954 }
98937d93 2955 Int_t ntracks = esd->GetNumberOfTracks();
2956 for (Int_t itrack = 0; itrack < ntracks; itrack++)
2957 {
2958 AliESDtrack *track = esd->GetTrack(itrack);
2959 Int_t nsp = 0;
ef7253ac 2960 Int_t idx[200];
98937d93 2961 for (Int_t iDet = 3; iDet >= 0; iDet--)
2962 nsp += track->GetNcls(iDet);
2963 if (nsp) {
2964 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
2965 track->SetTrackPointArray(sp);
2966 Int_t isptrack = 0;
2967 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2968 AliTracker *tracker = fTracker[iDet];
2969 if (!tracker) continue;
2970 Int_t nspdet = track->GetNcls(iDet);
98937d93 2971 if (nspdet <= 0) continue;
2972 track->GetClusters(iDet,idx);
2973 AliTrackPoint p;
2974 Int_t isp = 0;
2975 Int_t isp2 = 0;
4ed6fb1c 2976 while (isp2 < nspdet) {
48ce48d1 2977 Bool_t isvalid;
c12b6e44 2978 TString dets = fgkDetectorName[iDet];
2979 if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
2980 fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
2981 fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
2982 fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
2983 isvalid = tracker->GetTrackPointTrackingError(idx[isp2],p,track);
48ce48d1 2984 } else {
2985 isvalid = tracker->GetTrackPoint(idx[isp2],p);
2986 }
2987 isp2++;
160db090 2988 const Int_t kNTPCmax = 159;
2989 if (iDet==1 && isp2>kNTPCmax) break; // to be fixed
98937d93 2990 if (!isvalid) continue;
2991 sp->AddPoint(isptrack,&p); isptrack++; isp++;
2992 }
98937d93 2993 }
2994 }
2995 }
d528ee75 2996 if (fTracker[3]){
2997 fTracker[3]->UnloadClusters();
2998 fLoader[3]->UnloadRecPoints();
2999 }
98937d93 3000}
2e3550da 3001
3002//_____________________________________________________________________________
af885e0f 3003void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
2e3550da 3004{
3005 // The method reads the raw-data error log
3006 // accumulated within the rawReader.
3007 // It extracts the raw-data errors related to
3008 // the current event and stores them into
3009 // a TClonesArray inside the esd object.
3010
3011 if (!fRawReader) return;
3012
3013 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
3014
3015 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
3016 if (!log) continue;
3017 if (iEvent != log->GetEventNumber()) continue;
3018
3019 esd->AddRawDataErrorLog(log);
3020 }
3021
3022}
46698ae4 3023
3024TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString fName){
b545009a 3025 // Dump a file content into a char in TNamed
46698ae4 3026 ifstream in;
3027 in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
3028 Int_t kBytes = (Int_t)in.tellg();
3029 printf("Size: %d \n",kBytes);
3030 TNamed *fn = 0;
3031 if(in.good()){
3032 char* memblock = new char [kBytes];
3033 in.seekg (0, ios::beg);
3034 in.read (memblock, kBytes);
3035 in.close();
3036 TString fData(memblock,kBytes);
3037 fn = new TNamed(fName,fData);
3038 printf("fData Size: %d \n",fData.Sizeof());
3039 printf("fName Size: %d \n",fName.Sizeof());
3040 printf("fn Size: %d \n",fn->Sizeof());
3041 delete[] memblock;
3042 }
3043 else{
3044 AliInfo(Form("Could not Open %s\n",fPath.Data()));
3045 }
3046
3047 return fn;
3048}
3049
3050void AliReconstruction::TNamedToFile(TTree* fTree, TString fName){
46698ae4 3051 // This is not really needed in AliReconstruction at the moment
3052 // but can serve as a template
3053
3054 TList *fList = fTree->GetUserInfo();
3055 TNamed *fn = (TNamed*)fList->FindObject(fName.Data());
3056 printf("fn Size: %d \n",fn->Sizeof());
3057
3058 TString fTmp(fn->GetName()); // to be 100% sure in principle fName also works
3059 const char* cdata = fn->GetTitle();
3060 printf("fTmp Size %d\n",fTmp.Sizeof());
3061
3062 int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
3063 printf("calculated size %d\n",size);
3064 ofstream out(fName.Data(),ios::out | ios::binary);
3065 out.write(cdata,size);
3066 out.close();
3067
3068}
6efecea1 3069
7e963665 3070//_____________________________________________________________________________
04236e67 3071AliQADataMakerRec * AliReconstruction::GetQADataMaker(Int_t iDet)
7e963665 3072{
3073 // get the quality assurance data maker object and the loader for a detector
6efecea1 3074
7e963665 3075 if (fQADataMaker[iDet])
3076 return fQADataMaker[iDet];
3077
04236e67 3078 AliQADataMakerRec * qadm = NULL;
3079 if (iDet == fgkNDetectors) { //Global QA
3080 qadm = new AliGlobalQADataMaker();
aa3c69a9 3081 fQADataMaker[iDet] = qadm;
3082 return qadm;
3083 }
3084
7e963665 3085 // load the QA data maker object
3086 TPluginManager* pluginManager = gROOT->GetPluginManager();
3087 TString detName = fgkDetectorName[iDet];
04236e67 3088 TString qadmName = "Ali" + detName + "QADataMakerRec";
7e963665 3089 if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT"))
3090 return NULL;
3091