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