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