]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - STEER/AliReconstruction.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
switch on ACORDE
[u/mrichter/AliRoot.git] / STEER / AliReconstruction.cxx
... / ...
CommitLineData
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. //
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// //
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// //
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// //
59// The name of the galice file can be changed from the default //
60// "galice.root" by passing it as argument to the AliReconstruction //
61// constructor or by //
62// //
63// rec.SetGAliceFile("..."); //
64// //
65// The local reconstruction can be switched on or off for individual //
66// detectors by //
67// //
68// rec.SetRunLocalReconstruction("..."); //
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// //
74// The reconstruction of the primary vertex position can be switched off by //
75// //
76// rec.SetRunVertexFinder(kFALSE); //
77// //
78// The tracking and the creation of ESD tracks can be switched on for //
79// selected detectors by //
80// //
81// rec.SetRunTracking("..."); //
82// //
83// Uniform/nonuniform field tracking switches (default: uniform field) //
84// //
85// rec.SetUniformFieldTracking(); ( rec.SetUniformFieldTracking(kFALSE); ) //
86// //
87// The filling of additional ESD information can be steered by //
88// //
89// rec.SetFillESD("..."); //
90// //
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. //
100// //
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. //
103// //
104// The input data of a detector can be replaced by the corresponding HLT //
105// data by calling (usual detector string) //
106// SetUseHLTData("..."); //
107// //
108// For debug purposes the method SetCheckPointLevel can be used. If the //
109// argument is greater than 0, files with ESD events will be written after //
110// selected steps of the reconstruction for each event: //
111// level 1: after tracking and after filling of ESD (final) //
112// level 2: in addition after each tracking step //
113// level 3: in addition after the filling of ESD for each detector //
114// If a final check point file exists for an event, this event will be //
115// skipped in the reconstruction. The tracking and the filling of ESD for //
116// a detector will be skipped as well, if the corresponding check point //
117// file exists. The ESD event will then be loaded from the file instead. //
118// //
119///////////////////////////////////////////////////////////////////////////////
120
121#include <TArrayF.h>
122#include <TFile.h>
123#include <TList.h>
124#include <TSystem.h>
125#include <TROOT.h>
126#include <TPluginManager.h>
127#include <TGeoManager.h>
128#include <TLorentzVector.h>
129#include <TArrayS.h>
130#include <TArrayD.h>
131#include <TObjArray.h>
132#include <TMap.h>
133
134#include "AliReconstruction.h"
135#include "AliCodeTimer.h"
136#include "AliReconstructor.h"
137#include "AliLog.h"
138#include "AliRunLoader.h"
139#include "AliRun.h"
140#include "AliRawReaderFile.h"
141#include "AliRawReaderDate.h"
142#include "AliRawReaderRoot.h"
143#include "AliRawEventHeaderBase.h"
144#include "AliESDEvent.h"
145#include "AliESDMuonTrack.h"
146#include "AliESDfriend.h"
147#include "AliESDVertex.h"
148#include "AliESDcascade.h"
149#include "AliESDkink.h"
150#include "AliESDtrack.h"
151#include "AliESDCaloCluster.h"
152#include "AliESDCaloCells.h"
153#include "AliMultiplicity.h"
154#include "AliTracker.h"
155#include "AliVertexer.h"
156#include "AliVertexerTracks.h"
157#include "AliV0vertexer.h"
158#include "AliCascadeVertexer.h"
159#include "AliHeader.h"
160#include "AliGenEventHeader.h"
161#include "AliPID.h"
162#include "AliESDpid.h"
163#include "AliESDtrack.h"
164#include "AliESDPmdTrack.h"
165
166#include "AliESDTagCreator.h"
167#include "AliAODTagCreator.h"
168
169#include "AliGeomManager.h"
170#include "AliTrackPointArray.h"
171#include "AliCDBManager.h"
172#include "AliCDBStorage.h"
173#include "AliCDBEntry.h"
174#include "AliAlignObj.h"
175
176#include "AliCentralTrigger.h"
177#include "AliTriggerConfiguration.h"
178#include "AliTriggerClass.h"
179#include "AliCTPRawStream.h"
180
181#include "AliQADataMakerRec.h"
182#include "AliGlobalQADataMaker.h"
183#include "AliQA.h"
184#include "AliQADataMakerSteer.h"
185
186#include "AliPlaneEff.h"
187
188#include "AliSysInfo.h" // memory snapshots
189#include "AliRawHLTManager.h"
190
191#include "AliMagWrapCheb.h"
192
193ClassImp(AliReconstruction)
194
195
196//_____________________________________________________________________________
197const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
198
199//_____________________________________________________________________________
200AliReconstruction::AliReconstruction(const char* gAliceFilename,
201 const char* name, const char* title) :
202 TNamed(name, title),
203
204 fUniformField(kFALSE),
205 fRunVertexFinder(kTRUE),
206 fRunVertexFinderTracks(kTRUE),
207 fRunHLTTracking(kFALSE),
208 fRunMuonTracking(kFALSE),
209 fRunV0Finder(kTRUE),
210 fRunCascadeFinder(kTRUE),
211 fStopOnError(kFALSE),
212 fWriteAlignmentData(kFALSE),
213 fWriteESDfriend(kFALSE),
214 fWriteAOD(kFALSE),
215 fFillTriggerESD(kTRUE),
216
217 fCleanESD(kTRUE),
218 fV0DCAmax(3.),
219 fV0CsPmin(0.),
220 fDmax(50.),
221 fZmax(50.),
222
223 fRunLocalReconstruction("ALL"),
224 fRunTracking("ALL"),
225 fFillESD("ALL"),
226 fUseTrackingErrorsForAlignment(""),
227 fGAliceFileName(gAliceFilename),
228 fInput(""),
229 fEquipIdMap(""),
230 fFirstEvent(0),
231 fLastEvent(-1),
232 fNumberOfEventsPerFile(1),
233 fCheckPointLevel(0),
234 fOptions(),
235 fLoadAlignFromCDB(kTRUE),
236 fLoadAlignData("ALL"),
237 fESDPar(""),
238 fUseHLTData(),
239
240 fRunLoader(NULL),
241 fRawReader(NULL),
242 fParentRawReader(NULL),
243
244 fVertexer(NULL),
245 fDiamondProfile(NULL),
246 fDiamondProfileTPC(NULL),
247 fMeanVertexConstraint(kTRUE),
248
249 fGRPData(NULL),
250
251 fAlignObjArray(NULL),
252 fCDBUri(),
253 fSpecCDBUri(),
254 fInitCDBCalled(kFALSE),
255 fSetRunNumberFromDataCalled(kFALSE),
256 fRunQA(kTRUE),
257 fRunGlobalQA(kTRUE),
258 fInLoopQA(kFALSE),
259 fSameQACycle(kFALSE),
260
261 fRunPlaneEff(kFALSE),
262
263 fesd(NULL),
264 fhltesd(NULL),
265 fesdf(NULL),
266 ffile(NULL),
267 ftree(NULL),
268 fhlttree(NULL),
269 ffileOld(NULL),
270 ftreeOld(NULL),
271 fhlttreeOld(NULL),
272 ftVertexer(NULL),
273 fIsNewRunLoader(kFALSE),
274 fRunAliEVE(kFALSE)
275{
276// create reconstruction object with default parameters
277
278 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
279 fReconstructor[iDet] = NULL;
280 fLoader[iDet] = NULL;
281 fTracker[iDet] = NULL;
282 fQADataMaker[iDet] = NULL;
283 fQACycles[iDet] = 999999;
284 }
285 fQADataMaker[fgkNDetectors]=NULL; //Global QA
286 AliPID pid;
287}
288
289//_____________________________________________________________________________
290AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
291 TNamed(rec),
292
293 fUniformField(rec.fUniformField),
294 fRunVertexFinder(rec.fRunVertexFinder),
295 fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
296 fRunHLTTracking(rec.fRunHLTTracking),
297 fRunMuonTracking(rec.fRunMuonTracking),
298 fRunV0Finder(rec.fRunV0Finder),
299 fRunCascadeFinder(rec.fRunCascadeFinder),
300 fStopOnError(rec.fStopOnError),
301 fWriteAlignmentData(rec.fWriteAlignmentData),
302 fWriteESDfriend(rec.fWriteESDfriend),
303 fWriteAOD(rec.fWriteAOD),
304 fFillTriggerESD(rec.fFillTriggerESD),
305
306 fCleanESD(rec.fCleanESD),
307 fV0DCAmax(rec.fV0DCAmax),
308 fV0CsPmin(rec.fV0CsPmin),
309 fDmax(rec.fDmax),
310 fZmax(rec.fZmax),
311
312 fRunLocalReconstruction(rec.fRunLocalReconstruction),
313 fRunTracking(rec.fRunTracking),
314 fFillESD(rec.fFillESD),
315 fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
316 fGAliceFileName(rec.fGAliceFileName),
317 fInput(rec.fInput),
318 fEquipIdMap(rec.fEquipIdMap),
319 fFirstEvent(rec.fFirstEvent),
320 fLastEvent(rec.fLastEvent),
321 fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
322 fCheckPointLevel(0),
323 fOptions(),
324 fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
325 fLoadAlignData(rec.fLoadAlignData),
326 fESDPar(rec.fESDPar),
327 fUseHLTData(rec.fUseHLTData),
328
329 fRunLoader(NULL),
330 fRawReader(NULL),
331 fParentRawReader(NULL),
332
333 fVertexer(NULL),
334 fDiamondProfile(NULL),
335 fDiamondProfileTPC(NULL),
336 fMeanVertexConstraint(rec.fMeanVertexConstraint),
337
338 fGRPData(NULL),
339
340 fAlignObjArray(rec.fAlignObjArray),
341 fCDBUri(rec.fCDBUri),
342 fSpecCDBUri(),
343 fInitCDBCalled(rec.fInitCDBCalled),
344 fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
345 fRunQA(rec.fRunQA),
346 fRunGlobalQA(rec.fRunGlobalQA),
347 fInLoopQA(rec.fInLoopQA),
348 fSameQACycle(rec.fSameQACycle),
349 fRunPlaneEff(rec.fRunPlaneEff),
350
351 fesd(NULL),
352 fhltesd(NULL),
353 fesdf(NULL),
354 ffile(NULL),
355 ftree(NULL),
356 fhlttree(NULL),
357 ffileOld(NULL),
358 ftreeOld(NULL),
359 fhlttreeOld(NULL),
360 ftVertexer(NULL),
361 fIsNewRunLoader(rec.fIsNewRunLoader),
362 fRunAliEVE(kFALSE)
363{
364// copy constructor
365
366 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
367 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
368 }
369 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
370 fReconstructor[iDet] = NULL;
371 fLoader[iDet] = NULL;
372 fTracker[iDet] = NULL;
373 fQADataMaker[iDet] = NULL;
374 fQACycles[iDet] = rec.fQACycles[iDet];
375 }
376 fQADataMaker[fgkNDetectors]=NULL; //Global QA
377 for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
378 if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
379 }
380}
381
382//_____________________________________________________________________________
383AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
384{
385// assignment operator
386
387 this->~AliReconstruction();
388 new(this) AliReconstruction(rec);
389 return *this;
390}
391
392//_____________________________________________________________________________
393AliReconstruction::~AliReconstruction()
394{
395// clean up
396
397 CleanUp();
398 fOptions.Delete();
399 fSpecCDBUri.Delete();
400
401 AliCodeTimer::Instance()->Print();
402}
403
404//_____________________________________________________________________________
405void AliReconstruction::InitCDB()
406{
407// activate a default CDB storage
408// First check if we have any CDB storage set, because it is used
409// to retrieve the calibration and alignment constants
410
411 if (fInitCDBCalled) return;
412 fInitCDBCalled = kTRUE;
413
414 AliCDBManager* man = AliCDBManager::Instance();
415 if (man->IsDefaultStorageSet())
416 {
417 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
418 AliWarning("Default CDB storage has been already set !");
419 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
420 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
421 fCDBUri = man->GetDefaultStorage()->GetURI();
422 }
423 else {
424 if (fCDBUri.Length() > 0)
425 {
426 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
427 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
428 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
429 } else {
430 fCDBUri="local://$ALICE_ROOT";
431 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
432 AliWarning("Default CDB storage not yet set !!!!");
433 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
434 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
435
436 }
437 man->SetDefaultStorage(fCDBUri);
438 }
439
440 // Now activate the detector specific CDB storage locations
441 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
442 TObject* obj = fSpecCDBUri[i];
443 if (!obj) continue;
444 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
445 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
446 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
447 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
448 }
449
450}
451
452//_____________________________________________________________________________
453void AliReconstruction::SetDefaultStorage(const char* uri) {
454// Store the desired default CDB storage location
455// Activate it later within the Run() method
456
457 fCDBUri = uri;
458
459}
460
461//_____________________________________________________________________________
462void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
463// Store a detector-specific CDB storage location
464// Activate it later within the Run() method
465
466 AliCDBPath aPath(calibType);
467 if(!aPath.IsValid()){
468 // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
469 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
470 if(!strcmp(calibType, fgkDetectorName[iDet])) {
471 aPath.SetPath(Form("%s/*", calibType));
472 AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
473 break;
474 }
475 }
476 if(!aPath.IsValid()){
477 AliError(Form("Not a valid path or detector: %s", calibType));
478 return;
479 }
480 }
481
482// // check that calibType refers to a "valid" detector name
483// Bool_t isDetector = kFALSE;
484// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
485// TString detName = fgkDetectorName[iDet];
486// if(aPath.GetLevel0() == detName) {
487// isDetector = kTRUE;
488// break;
489// }
490// }
491//
492// if(!isDetector) {
493// AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
494// return;
495// }
496
497 TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
498 if (obj) fSpecCDBUri.Remove(obj);
499 fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
500
501}
502
503//_____________________________________________________________________________
504Bool_t AliReconstruction::SetRunNumberFromData()
505{
506 // The method is called in Run() in order
507 // to set a correct run number.
508 // In case of raw data reconstruction the
509 // run number is taken from the raw data header
510
511 if (fSetRunNumberFromDataCalled) return kTRUE;
512 fSetRunNumberFromDataCalled = kTRUE;
513
514 AliCDBManager* man = AliCDBManager::Instance();
515
516 if(man->GetRun() > 0) {
517 AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
518 }
519
520 if (!fRunLoader) {
521 AliError("No run loader is found !");
522 return kFALSE;
523 }
524 // read run number from gAlice
525 if(fRunLoader->GetAliRun())
526 AliCDBManager::Instance()->SetRun(fRunLoader->GetHeader()->GetRun());
527 else {
528 if(fRawReader) {
529 if(fRawReader->NextEvent()) {
530 AliCDBManager::Instance()->SetRun(fRawReader->GetRunNumber());
531 fRawReader->RewindEvents();
532 }
533 else {
534 if(man->GetRun() > 0) {
535 AliWarning("No raw events is found ! Using settings in AliCDBManager !");
536 man->Print();
537 return kTRUE;
538 }
539 else {
540 AliWarning("Neither raw events nor settings in AliCDBManager are found !");
541 return kFALSE;
542 }
543 }
544 }
545 else {
546 AliError("Neither gAlice nor RawReader objects are found !");
547 return kFALSE;
548 }
549 }
550
551 man->Print();
552
553 return kTRUE;
554}
555
556//_____________________________________________________________________________
557void AliReconstruction::SetCDBLock() {
558 // Set CDB lock: from now on it is forbidden to reset the run number
559 // or the default storage or to activate any further storage!
560
561 AliCDBManager::Instance()->SetLock(1);
562}
563
564//_____________________________________________________________________________
565Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
566{
567 // Read the alignment objects from CDB.
568 // Each detector is supposed to have the
569 // alignment objects in DET/Align/Data CDB path.
570 // All the detector objects are then collected,
571 // sorted by geometry level (starting from ALIC) and
572 // then applied to the TGeo geometry.
573 // Finally an overlaps check is performed.
574
575 // Load alignment data from CDB and fill fAlignObjArray
576 if(fLoadAlignFromCDB){
577
578 TString detStr = detectors;
579 TString loadAlObjsListOfDets = "";
580
581 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
582 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
583 loadAlObjsListOfDets += fgkDetectorName[iDet];
584 loadAlObjsListOfDets += " ";
585 } // end loop over detectors
586 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
587 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
588 }else{
589 // Check if the array with alignment objects was
590 // provided by the user. If yes, apply the objects
591 // to the present TGeo geometry
592 if (fAlignObjArray) {
593 if (gGeoManager && gGeoManager->IsClosed()) {
594 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
595 AliError("The misalignment of one or more volumes failed!"
596 "Compare the list of simulated detectors and the list of detector alignment data!");
597 return kFALSE;
598 }
599 }
600 else {
601 AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
602 return kFALSE;
603 }
604 }
605 }
606
607 delete fAlignObjArray; fAlignObjArray=0;
608
609 return kTRUE;
610}
611
612//_____________________________________________________________________________
613void AliReconstruction::SetGAliceFile(const char* fileName)
614{
615// set the name of the galice file
616
617 fGAliceFileName = fileName;
618}
619
620//_____________________________________________________________________________
621void AliReconstruction::SetInput(const char* input)
622{
623 // In case the input string starts with 'mem://', we run in an online mode
624 // and AliRawReaderDateOnline object is created. In all other cases a raw-data
625 // file is assumed. One can give as an input:
626 // mem://: - events taken from DAQ monitoring libs online
627 // or
628 // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
629 fInput = input;
630}
631
632//_____________________________________________________________________________
633void AliReconstruction::SetOption(const char* detector, const char* option)
634{
635// set options for the reconstruction of a detector
636
637 TObject* obj = fOptions.FindObject(detector);
638 if (obj) fOptions.Remove(obj);
639 fOptions.Add(new TNamed(detector, option));
640}
641
642//_____________________________________________________________________________
643Bool_t AliReconstruction::Run(const char* input)
644{
645 // Run Run Run
646 AliCodeTimerAuto("");
647
648 if (!InitRun(input)) return kFALSE;
649
650 //******* The loop over events
651 Int_t iEvent = 0;
652 while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
653 (fRawReader && fRawReader->NextEvent())) {
654 if (!RunEvent(iEvent)) return kFALSE;
655 iEvent++;
656 }
657
658 if (!FinishRun()) return kFALSE;
659
660 return kTRUE;
661}
662
663//_____________________________________________________________________________
664Bool_t AliReconstruction::InitRun(const char* input)
665{
666 // Initialize all the stuff before
667 // going into the event loop
668 // If the second argument is given, the first one is ignored and
669 // the reconstruction works in an online mode
670 AliCodeTimerAuto("");
671
672 // Overwrite the previous setting
673 if (input) fInput = input;
674
675 // set the input in case of raw data
676 fRawReader = AliRawReader::Create(fInput.Data());
677 if (!fRawReader)
678 AliInfo("Reconstruction will run over digits");
679
680 if (!fEquipIdMap.IsNull() && fRawReader)
681 fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
682
683 if (!fUseHLTData.IsNull()) {
684 // create the RawReaderHLT which performs redirection of HLT input data for
685 // the specified detectors
686 AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
687 if (pRawReader) {
688 fParentRawReader=fRawReader;
689 fRawReader=pRawReader;
690 } else {
691 AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
692 }
693 }
694
695 AliSysInfo::AddStamp("Start");
696 // get the run loader
697 if (!InitRunLoader()) return kFALSE;
698 AliSysInfo::AddStamp("LoadLoader");
699
700 // Initialize the CDB storage
701 InitCDB();
702
703 AliSysInfo::AddStamp("LoadCDB");
704
705 // Set run number in CDBManager (if it is not already set by the user)
706 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
707
708 // Set CDB lock: from now on it is forbidden to reset the run number
709 // or the default storage or to activate any further storage!
710 SetCDBLock();
711
712 // Import ideal TGeo geometry and apply misalignment
713 if (!gGeoManager) {
714 TString geom(gSystem->DirName(fGAliceFileName));
715 geom += "/geometry.root";
716 AliGeomManager::LoadGeometry(geom.Data());
717 if(!AliGeomManager::CheckSymNamesLUT())
718 AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
719 if (!gGeoManager) if (fStopOnError) return kFALSE;
720 }
721
722 if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
723 AliSysInfo::AddStamp("LoadGeom");
724
725
726 // Get the GRP CDB entry
727 AliCDBEntry* entryGRP = AliCDBManager::Instance()->Get("GRP/GRP/Data");
728
729 if (entryGRP)
730 fGRPData = dynamic_cast<TMap*>(entryGRP->GetObject());
731
732 if (!fGRPData) {
733 AliError("No GRP entry found in OCDB!");
734 return kFALSE;
735 }
736
737
738 // Magnetic field map
739 if (!AliTracker::GetFieldMap()) {
740 // Construct the field map out of the information retrieved from GRP.
741 //
742 // For the moment, this is a dummy piece of code.
743 // The actual map is expected to be already created in rec.C !
744 //
745
746 Float_t factor=1.;
747 Int_t map=AliMagWrapCheb::k5kG;
748 Bool_t dipoleON=kTRUE;
749
750 // L3
751 TObjString *l3Current=
752 dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Current"));
753 if (!l3Current) {
754 AliError("GRP/GRP/Data entry: missing value for the L3 current !");
755 return kFALSE;
756 }
757 TObjString *l3Polarity=
758 dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Polarity"));
759 if (!l3Polarity) {
760 AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
761 return kFALSE;
762 }
763
764 // Dipole
765 TObjString *diCurrent=
766 dynamic_cast<TObjString*>(fGRPData->GetValue("fDipoleCurrent"));
767 if (!diCurrent) {
768 AliError("GRP/GRP/Data entry: missing value for the dipole current !");
769 return kFALSE;
770 }
771 TObjString *diPolarity=
772 dynamic_cast<TObjString*>(fGRPData->GetValue("fDipolePolarity"));
773 if (!diPolarity) {
774 AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
775 return kFALSE;
776 }
777
778
779 AliMagF *field=
780 new AliMagWrapCheb("Maps","Maps",2,factor,10.,map,dipoleON);
781 AliTracker::SetFieldMap(field,fUniformField);
782
783 //Temporary measure
784 AliFatal("Please, provide the field map ! Crashing deliberately...");
785
786 }
787
788
789 // Get the diamond profile from OCDB
790 AliCDBEntry* entry = AliCDBManager::Instance()
791 ->Get("GRP/Calib/MeanVertex");
792
793 if(entry) {
794 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
795 } else {
796 AliError("No diamond profile found in OCDB!");
797 }
798
799 entry = 0;
800 entry = AliCDBManager::Instance()
801 ->Get("GRP/Calib/MeanVertexTPC");
802
803 if(entry) {
804 fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
805 } else {
806 AliError("No diamond profile found in OCDB!");
807 }
808
809 ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
810 if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile);
811
812 // get vertexer
813 if (fRunVertexFinder && !CreateVertexer()) {
814 if (fStopOnError) {
815 CleanUp();
816 return kFALSE;
817 }
818 }
819 AliSysInfo::AddStamp("Vertexer");
820
821 // get trackers
822 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
823 if (fStopOnError) {
824 CleanUp();
825 return kFALSE;
826 }
827 }
828 AliSysInfo::AddStamp("LoadTrackers");
829
830 // get the possibly already existing ESD file and tree
831 fesd = new AliESDEvent(); fhltesd = new AliESDEvent();
832 if (!gSystem->AccessPathName("AliESDs.root")){
833 gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE);
834 ffileOld = TFile::Open("AliESDs.old.root");
835 if (ffileOld && ffileOld->IsOpen()) {
836 ftreeOld = (TTree*) ffileOld->Get("esdTree");
837 if (ftreeOld)fesd->ReadFromTree(ftreeOld);
838 fhlttreeOld = (TTree*) ffileOld->Get("HLTesdTree");
839 if (fhlttreeOld) fhltesd->ReadFromTree(fhlttreeOld);
840 }
841 }
842
843 // create the ESD output file and tree
844 ffile = TFile::Open("AliESDs.root", "RECREATE");
845 ffile->SetCompressionLevel(2);
846 if (!ffile->IsOpen()) {
847 AliError("opening AliESDs.root failed");
848 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
849 }
850
851 ftree = new TTree("esdTree", "Tree with ESD objects");
852 fesd = new AliESDEvent();
853 fesd->CreateStdContent();
854 fesd->WriteToTree(ftree);
855
856 fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
857 fhltesd = new AliESDEvent();
858 fhltesd->CreateStdContent();
859 fhltesd->WriteToTree(fhlttree);
860
861
862 if (fWriteESDfriend) {
863 fesdf = new AliESDfriend();
864 TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
865 br->SetFile("AliESDfriends.root");
866 fesd->AddObject(fesdf);
867 }
868
869
870
871 if (fRawReader) fRawReader->RewindEvents();
872
873 ProcInfo_t ProcInfo;
874 gSystem->GetProcInfo(&ProcInfo);
875 AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
876
877
878 //QA
879 AliQADataMakerSteer qas ;
880 if (fRunQA && fRawReader) {
881 qas.Run(fRunLocalReconstruction, fRawReader) ;
882 fSameQACycle = kTRUE ;
883 }
884 //Initialize the QA and start of cycle for out-of-cycle QA
885 if (fRunQA) {
886// TString detStr(fFillESD);
887// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
888// if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
889// AliQADataMakerRec *qadm = GetQADataMaker(iDet);
890// if (!qadm) continue;
891// AliInfo(Form("Initializing the QA data maker for %s",
892// fgkDetectorName[iDet]));
893// qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
894// qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
895// if (!fInLoopQA) {
896// qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
897// qadm->StartOfCycle(AliQA::kESDS,"same");
898// }
899// }
900 if (fRunGlobalQA) {
901 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
902 AliInfo(Form("Initializing the global QA data maker"));
903 TObjArray *arr=
904 qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
905 AliTracker::SetResidualsArray(arr);
906 qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
907 if (!fInLoopQA) {
908 qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
909 qadm->StartOfCycle(AliQA::kESDS, "same");
910 }
911 }
912 if (!fInLoopQA)
913 fSameQACycle = kTRUE;
914 }
915
916 //Initialize the Plane Efficiency framework
917 if (fRunPlaneEff && !InitPlaneEff()) {
918 if(fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
919 }
920
921 if (strcmp(gProgName,"alieve") == 0)
922 fRunAliEVE = InitAliEVE();
923
924 return kTRUE;
925}
926
927//_____________________________________________________________________________
928Bool_t AliReconstruction::RunEvent(Int_t iEvent)
929{
930 // run the reconstruction over a single event
931 // The event loop is steered in Run method
932
933 AliCodeTimerAuto("");
934
935 if (iEvent >= fRunLoader->GetNumberOfEvents()) {
936 fRunLoader->SetEventNumber(iEvent);
937 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
938 iEvent, iEvent);
939 //?? fRunLoader->MakeTree("H");
940 fRunLoader->TreeE()->Fill();
941 }
942
943 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
944 // copy old ESD to the new one
945 if (ftreeOld) {
946 fesd->ReadFromTree(ftreeOld);
947 ftreeOld->GetEntry(iEvent);
948 ftree->Fill();
949 }
950 if (fhlttreeOld) {
951 fhltesd->ReadFromTree(fhlttreeOld);
952 fhlttreeOld->GetEntry(iEvent);
953 fhlttree->Fill();
954 }
955 return kTRUE;
956 }
957
958 AliInfo(Form("processing event %d", iEvent));
959
960 //Start of cycle for the in-loop QA
961 if (fInLoopQA) {
962 if (fRunQA) {
963 TString detStr(fFillESD);
964 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
965 if (!IsSelected(fgkDetectorName[iDet], detStr))
966 continue;
967 AliQADataMakerRec *qadm = GetQADataMaker(iDet);
968 if (!qadm)
969 continue;
970 qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
971 qadm->StartOfCycle(AliQA::kESDS, "same") ;
972 }
973 if (fRunGlobalQA) {
974 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
975 qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
976 qadm->StartOfCycle(AliQA::kESDS, "same");
977 }
978 }
979 }
980
981 fRunLoader->GetEvent(iEvent);
982
983 char aFileName[256];
984 sprintf(aFileName, "ESD_%d.%d_final.root",
985 fRunLoader->GetHeader()->GetRun(),
986 fRunLoader->GetHeader()->GetEventNrInRun());
987 if (!gSystem->AccessPathName(aFileName)) return kTRUE;
988
989 // local single event reconstruction
990 if (!fRunLocalReconstruction.IsNull()) {
991 TString detectors=fRunLocalReconstruction;
992 // run HLT event reconstruction first
993 // ;-( IsSelected changes the string
994 if (IsSelected("HLT", detectors) &&
995 !RunLocalEventReconstruction("HLT")) {
996 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
997 }
998 detectors=fRunLocalReconstruction;
999 detectors.ReplaceAll("HLT", "");
1000 if (!RunLocalEventReconstruction(detectors)) {
1001 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1002 }
1003 }
1004
1005 fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1006 fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1007 fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1008 fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1009
1010 // Set magnetic field from the tracker
1011 fesd->SetMagneticField(AliTracker::GetBz());
1012 fhltesd->SetMagneticField(AliTracker::GetBz());
1013
1014
1015
1016 // Fill raw-data error log into the ESD
1017 if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
1018
1019 // vertex finder
1020 if (fRunVertexFinder) {
1021 if (!ReadESD(fesd, "vertex")) {
1022 if (!RunVertexFinder(fesd)) {
1023 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1024 }
1025 if (fCheckPointLevel > 0) WriteESD(fesd, "vertex");
1026 }
1027 }
1028
1029 // Muon tracking
1030 if (!fRunTracking.IsNull()) {
1031 if (fRunMuonTracking) {
1032 if (!RunMuonTracking(fesd)) {
1033 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1034 }
1035 }
1036 }
1037
1038 // barrel tracking
1039 if (!fRunTracking.IsNull()) {
1040 if (!ReadESD(fesd, "tracking")) {
1041 if (!RunTracking(fesd)) {
1042 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1043 }
1044 if (fCheckPointLevel > 0) WriteESD(fesd, "tracking");
1045 }
1046 }
1047
1048 // fill ESD
1049 if (!fFillESD.IsNull()) {
1050 TString detectors=fFillESD;
1051 // run HLT first and on hltesd
1052 // ;-( IsSelected changes the string
1053 if (IsSelected("HLT", detectors) &&
1054 !FillESD(fhltesd, "HLT")) {
1055 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1056 }
1057 detectors=fFillESD;
1058 // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
1059 if (detectors.Contains("ALL")) {
1060 detectors="";
1061 for (Int_t idet=0; idet<fgkNDetectors; ++idet){
1062 detectors += fgkDetectorName[idet];
1063 detectors += " ";
1064 }
1065 }
1066 detectors.ReplaceAll("HLT", "");
1067 if (!FillESD(fesd, detectors)) {
1068 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1069 }
1070 }
1071
1072 // fill Event header information from the RawEventHeader
1073 if (fRawReader){FillRawEventHeaderESD(fesd);}
1074
1075 // combined PID
1076 AliESDpid::MakePID(fesd);
1077 if (fCheckPointLevel > 1) WriteESD(fesd, "PID");
1078
1079 if (fFillTriggerESD) {
1080 if (!ReadESD(fesd, "trigger")) {
1081 if (!FillTriggerESD(fesd)) {
1082 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1083 }
1084 if (fCheckPointLevel > 1) WriteESD(fesd, "trigger");
1085 }
1086 }
1087
1088 ffile->cd();
1089
1090 //
1091 // Propagate track to the beam pipe (if not already done by ITS)
1092 //
1093 const Int_t ntracks = fesd->GetNumberOfTracks();
1094 const Double_t kBz = fesd->GetMagneticField();
1095 const Double_t kRadius = 2.8; //something less than the beam pipe radius
1096
1097 TObjArray trkArray;
1098 UShort_t *selectedIdx=new UShort_t[ntracks];
1099
1100 for (Int_t itrack=0; itrack<ntracks; itrack++){
1101 const Double_t kMaxStep = 5; //max step over the material
1102 Bool_t ok;
1103
1104 AliESDtrack *track = fesd->GetTrack(itrack);
1105 if (!track) continue;
1106
1107 AliExternalTrackParam *tpcTrack =
1108 (AliExternalTrackParam *)track->GetTPCInnerParam();
1109 ok = kFALSE;
1110 if (tpcTrack)
1111 ok = AliTracker::
1112 PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE);
1113
1114
1115
1116 if (ok) {
1117 Int_t n=trkArray.GetEntriesFast();
1118 selectedIdx[n]=track->GetID();
1119 trkArray.AddLast(tpcTrack);
1120 }
1121
1122 if (track->GetX() < kRadius) continue;
1123
1124 ok = AliTracker::
1125 PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
1126 if (ok) {
1127 track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kRadius);
1128 }
1129 }
1130
1131 //
1132 // Improve the reconstructed primary vertex position using the tracks
1133 //
1134 TObject *obj = fOptions.FindObject("ITS");
1135 if (obj) {
1136 TString optITS = obj->GetTitle();
1137 if (optITS.Contains("cosmics") || optITS.Contains("COSMICS"))
1138 fRunVertexFinderTracks=kFALSE;
1139 }
1140 if (fRunVertexFinderTracks) {
1141 // TPC + ITS primary vertex
1142 ftVertexer->SetITSrefitRequired();
1143 if(fDiamondProfile && fMeanVertexConstraint) {
1144 ftVertexer->SetVtxStart(fDiamondProfile);
1145 } else {
1146 ftVertexer->SetConstraintOff();
1147 }
1148 AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
1149 if (pvtx) {
1150 if (pvtx->GetStatus()) {
1151 fesd->SetPrimaryVertex(pvtx);
1152 for (Int_t i=0; i<ntracks; i++) {
1153 AliESDtrack *t = fesd->GetTrack(i);
1154 t->RelateToVertex(pvtx, kBz, kRadius);
1155 }
1156 }
1157 }
1158
1159 // TPC-only primary vertex
1160 ftVertexer->SetITSrefitNotRequired();
1161 if(fDiamondProfileTPC && fMeanVertexConstraint) {
1162 ftVertexer->SetVtxStart(fDiamondProfileTPC);
1163 } else {
1164 ftVertexer->SetConstraintOff();
1165 }
1166 pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
1167 if (pvtx) {
1168 if (pvtx->GetStatus()) {
1169 fesd->SetPrimaryVertexTPC(pvtx);
1170 Int_t nsel=trkArray.GetEntriesFast();
1171 for (Int_t i=0; i<nsel; i++) {
1172 AliExternalTrackParam *t =
1173 (AliExternalTrackParam *)trkArray.UncheckedAt(i);
1174 t->PropagateToDCA(pvtx, kBz, kRadius);
1175 }
1176 }
1177 }
1178
1179 }
1180 delete[] selectedIdx;
1181
1182 if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
1183
1184
1185 if (fRunV0Finder) {
1186 // V0 finding
1187 AliV0vertexer vtxer;
1188 vtxer.Tracks2V0vertices(fesd);
1189
1190 if (fRunCascadeFinder) {
1191 // Cascade finding
1192 AliCascadeVertexer cvtxer;
1193 cvtxer.V0sTracks2CascadeVertices(fesd);
1194 }
1195 }
1196
1197 // write ESD
1198 if (fCleanESD) CleanESD(fesd);
1199
1200 if (fRunQA) {
1201 if (fRunGlobalQA) {
1202 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
1203 if (qadm) qadm->Exec(AliQA::kESDS, fesd);
1204 }
1205 }
1206
1207 if (fWriteESDfriend) {
1208 fesdf->~AliESDfriend();
1209 new (fesdf) AliESDfriend(); // Reset...
1210 fesd->GetESDfriend(fesdf);
1211 }
1212 ftree->Fill();
1213
1214 // write HLT ESD
1215 fhlttree->Fill();
1216
1217 // call AliEVE
1218 if (fRunAliEVE) RunAliEVE();
1219
1220 if (fCheckPointLevel > 0) WriteESD(fesd, "final");
1221 fesd->Reset();
1222 fhltesd->Reset();
1223 if (fWriteESDfriend) {
1224 fesdf->~AliESDfriend();
1225 new (fesdf) AliESDfriend(); // Reset...
1226 }
1227
1228 ProcInfo_t ProcInfo;
1229 gSystem->GetProcInfo(&ProcInfo);
1230 AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
1231
1232
1233 // End of cycle for the in-loop QA
1234 if (fInLoopQA) {
1235 if (fRunQA) {
1236 RunQA(fFillESD.Data(), fesd);
1237 TString detStr(fFillESD);
1238 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1239 if (!IsSelected(fgkDetectorName[iDet], detStr))
1240 continue;
1241 AliQADataMakerRec * qadm = GetQADataMaker(iDet);
1242 if (!qadm)
1243 continue;
1244 qadm->EndOfCycle(AliQA::kRECPOINTS);
1245 qadm->EndOfCycle(AliQA::kESDS);
1246 qadm->Finish();
1247 }
1248 }
1249 if (fRunGlobalQA) {
1250 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
1251 if (qadm) {
1252 qadm->EndOfCycle(AliQA::kRECPOINTS);
1253 qadm->EndOfCycle(AliQA::kESDS);
1254 qadm->Finish();
1255 }
1256 }
1257 }
1258
1259 return kTRUE;
1260}
1261
1262//_____________________________________________________________________________
1263Bool_t AliReconstruction::FinishRun()
1264{
1265 // Finalize the run
1266 // Called after the exit
1267 // from the event loop
1268 AliCodeTimerAuto("");
1269
1270 if (fIsNewRunLoader) { // galice.root didn't exist
1271 fRunLoader->WriteHeader("OVERWRITE");
1272 fRunLoader->CdGAFile();
1273 fRunLoader->Write(0, TObject::kOverwrite);
1274 }
1275
1276 ftree->GetUserInfo()->Add(fesd);
1277 fhlttree->GetUserInfo()->Add(fhltesd);
1278
1279 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
1280 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
1281
1282 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
1283 cdbMapCopy->SetOwner(1);
1284 cdbMapCopy->SetName("cdbMap");
1285 TIter iter(cdbMap->GetTable());
1286
1287 TPair* pair = 0;
1288 while((pair = dynamic_cast<TPair*> (iter.Next()))){
1289 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
1290 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
1291 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
1292 }
1293
1294 TList *cdbListCopy = new TList();
1295 cdbListCopy->SetOwner(1);
1296 cdbListCopy->SetName("cdbList");
1297
1298 TIter iter2(cdbList);
1299
1300 AliCDBId* id=0;
1301 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
1302 cdbListCopy->Add(new TObjString(id->ToString().Data()));
1303 }
1304
1305 ftree->GetUserInfo()->Add(cdbMapCopy);
1306 ftree->GetUserInfo()->Add(cdbListCopy);
1307
1308
1309 if(fESDPar.Contains("ESD.par")){
1310 AliInfo("Attaching ESD.par to Tree");
1311 TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
1312 ftree->GetUserInfo()->Add(fn);
1313 }
1314
1315
1316 ffile->cd();
1317
1318 if (fWriteESDfriend)
1319 ftree->SetBranchStatus("ESDfriend*",0);
1320 // we want to have only one tree version number
1321 ftree->Write(ftree->GetName(),TObject::kOverwrite);
1322 fhlttree->Write();
1323
1324// Finish with Plane Efficiency evaluation: before of CleanUp !!!
1325 if (fRunPlaneEff && !FinishPlaneEff()) {
1326 AliWarning("Finish PlaneEff evaluation failed");
1327 }
1328
1329 gROOT->cd();
1330 CleanUp(ffile, ffileOld);
1331
1332 if (fWriteAOD) {
1333 AliWarning("AOD creation not supported anymore during reconstruction. See ANALYSIS/AliAnalysisTaskESDfilter.cxx instead.");
1334 }
1335
1336 // Create tags for the events in the ESD tree (the ESD tree is always present)
1337 // In case of empty events the tags will contain dummy values
1338 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
1339 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData);
1340 if (fWriteAOD) {
1341 AliWarning("AOD tag creation not supported anymore during reconstruction.");
1342 }
1343
1344 //Finish QA and end of cycle for out-of-loop QA
1345 if (!fInLoopQA) {
1346 if (fRunQA) {
1347 AliQADataMakerSteer qas;
1348 qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS, fSameQACycle);
1349 //qas.Reset() ;
1350 qas.Run(fRunLocalReconstruction.Data(), AliQA::kESDS, fSameQACycle);
1351 if (fRunGlobalQA) {
1352 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
1353 if (qadm) {
1354 qadm->EndOfCycle(AliQA::kRECPOINTS);
1355 qadm->EndOfCycle(AliQA::kESDS);
1356 qadm->Finish();
1357 }
1358 }
1359 }
1360 }
1361
1362 // Cleanup of CDB manager: cache and active storages!
1363 AliCDBManager::Instance()->ClearCache();
1364
1365 return kTRUE;
1366}
1367
1368
1369//_____________________________________________________________________________
1370Bool_t AliReconstruction::RunLocalReconstruction(const TString& /*detectors*/)
1371{
1372// run the local reconstruction
1373 static Int_t eventNr=0;
1374 AliCodeTimerAuto("")
1375
1376 // AliCDBManager* man = AliCDBManager::Instance();
1377// Bool_t origCache = man->GetCacheFlag();
1378
1379// TString detStr = detectors;
1380// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1381// if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1382// AliReconstructor* reconstructor = GetReconstructor(iDet);
1383// if (!reconstructor) continue;
1384// if (reconstructor->HasLocalReconstruction()) continue;
1385
1386// AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1387// AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1388
1389// AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
1390// AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
1391
1392// man->SetCacheFlag(kTRUE);
1393// TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]);
1394// man->GetAll(calibPath); // entries are cached!
1395
1396// AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
1397
1398// if (fRawReader) {
1399// fRawReader->RewindEvents();
1400// reconstructor->Reconstruct(fRunLoader, fRawReader);
1401// } else {
1402// reconstructor->Reconstruct(fRunLoader);
1403// }
1404
1405// AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1406 // AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr));
1407
1408// // unload calibration data
1409// man->UnloadFromCache(calibPath);
1410// //man->ClearCache();
1411// }
1412
1413// man->SetCacheFlag(origCache);
1414
1415// if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1416// AliError(Form("the following detectors were not found: %s",
1417// detStr.Data()));
1418// if (fStopOnError) return kFALSE;
1419// }
1420
1421 eventNr++;
1422 return kTRUE;
1423}
1424
1425//_____________________________________________________________________________
1426Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
1427{
1428// run the local reconstruction
1429
1430 static Int_t eventNr=0;
1431 AliCodeTimerAuto("")
1432
1433 TString detStr = detectors;
1434 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1435 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1436 AliReconstructor* reconstructor = GetReconstructor(iDet);
1437 if (!reconstructor) continue;
1438 AliLoader* loader = fLoader[iDet];
1439 // Matthias April 2008: temporary fix to run HLT reconstruction
1440 // although the HLT loader is missing
1441 if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
1442 if (fRawReader) {
1443 reconstructor->Reconstruct(fRawReader, NULL);
1444 } else {
1445 TTree* dummy=NULL;
1446 reconstructor->Reconstruct(dummy, NULL);
1447 }
1448 continue;
1449 }
1450 if (!loader) {
1451 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
1452 continue;
1453 }
1454 // conversion of digits
1455 if (fRawReader && reconstructor->HasDigitConversion()) {
1456 AliInfo(Form("converting raw data digits into root objects for %s",
1457 fgkDetectorName[iDet]));
1458 AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
1459 fgkDetectorName[iDet]));
1460 loader->LoadDigits("update");
1461 loader->CleanDigits();
1462 loader->MakeDigitsContainer();
1463 TTree* digitsTree = loader->TreeD();
1464 reconstructor->ConvertDigits(fRawReader, digitsTree);
1465 loader->WriteDigits("OVERWRITE");
1466 loader->UnloadDigits();
1467 }
1468 // local reconstruction
1469 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1470 AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1471 loader->LoadRecPoints("update");
1472 loader->CleanRecPoints();
1473 loader->MakeRecPointsContainer();
1474 TTree* clustersTree = loader->TreeR();
1475 if (fRawReader && !reconstructor->HasDigitConversion()) {
1476 reconstructor->Reconstruct(fRawReader, clustersTree);
1477 } else {
1478 loader->LoadDigits("read");
1479 TTree* digitsTree = loader->TreeD();
1480 if (!digitsTree) {
1481 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
1482 if (fStopOnError) return kFALSE;
1483 } else {
1484 reconstructor->Reconstruct(digitsTree, clustersTree);
1485 }
1486 loader->UnloadDigits();
1487 }
1488
1489 // In-loop QA for local reconstrucion
1490 if (fRunQA && fInLoopQA) {
1491 AliQADataMakerRec * qadm = GetQADataMaker(iDet);
1492 if (qadm) {
1493 //AliCodeTimerStart
1494 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1495 //AliInfo
1496 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1497
1498 qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
1499
1500 //AliCodeTimerStop
1501 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1502 }
1503 }
1504
1505 loader->WriteRecPoints("OVERWRITE");
1506 loader->UnloadRecPoints();
1507 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
1508 }
1509
1510 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1511 AliError(Form("the following detectors were not found: %s",
1512 detStr.Data()));
1513 if (fStopOnError) return kFALSE;
1514 }
1515 eventNr++;
1516 return kTRUE;
1517}
1518
1519//_____________________________________________________________________________
1520Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
1521{
1522// run the barrel tracking
1523
1524 AliCodeTimerAuto("")
1525
1526 AliESDVertex* vertex = NULL;
1527 Double_t vtxPos[3] = {0, 0, 0};
1528 Double_t vtxErr[3] = {0.07, 0.07, 0.1};
1529 TArrayF mcVertex(3);
1530 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
1531 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
1532 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
1533 }
1534
1535 if (fVertexer) {
1536 if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
1537 AliInfo("running the ITS vertex finder");
1538 if (fLoader[0]) fLoader[0]->LoadRecPoints();
1539 vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
1540 if (fLoader[0]) fLoader[0]->UnloadRecPoints();
1541 if(!vertex){
1542 AliWarning("Vertex not found");
1543 vertex = new AliESDVertex();
1544 vertex->SetName("default");
1545 }
1546 else {
1547 vertex->SetName("reconstructed");
1548 }
1549
1550 } else {
1551 AliInfo("getting the primary vertex from MC");
1552 vertex = new AliESDVertex(vtxPos, vtxErr);
1553 }
1554
1555 if (vertex) {
1556 vertex->GetXYZ(vtxPos);
1557 vertex->GetSigmaXYZ(vtxErr);
1558 } else {
1559 AliWarning("no vertex reconstructed");
1560 vertex = new AliESDVertex(vtxPos, vtxErr);
1561 }
1562 esd->SetPrimaryVertexSPD(vertex);
1563 // if SPD multiplicity has been determined, it is stored in the ESD
1564 AliMultiplicity *mult = fVertexer->GetMultiplicity();
1565 if(mult)esd->SetMultiplicity(mult);
1566
1567 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1568 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
1569 }
1570 delete vertex;
1571
1572 return kTRUE;
1573}
1574
1575//_____________________________________________________________________________
1576Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
1577{
1578// run the HLT barrel tracking
1579
1580 AliCodeTimerAuto("")
1581
1582 if (!fRunLoader) {
1583 AliError("Missing runLoader!");
1584 return kFALSE;
1585 }
1586
1587 AliInfo("running HLT tracking");
1588
1589 // Get a pointer to the HLT reconstructor
1590 AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
1591 if (!reconstructor) return kFALSE;
1592
1593 // TPC + ITS
1594 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1595 TString detName = fgkDetectorName[iDet];
1596 AliDebug(1, Form("%s HLT tracking", detName.Data()));
1597 reconstructor->SetOption(detName.Data());
1598 AliTracker *tracker = reconstructor->CreateTracker();
1599 if (!tracker) {
1600 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
1601 if (fStopOnError) return kFALSE;
1602 continue;
1603 }
1604 Double_t vtxPos[3];
1605 Double_t vtxErr[3]={0.005,0.005,0.010};
1606 const AliESDVertex *vertex = esd->GetVertex();
1607 vertex->GetXYZ(vtxPos);
1608 tracker->SetVertex(vtxPos,vtxErr);
1609 if(iDet != 1) {
1610 fLoader[iDet]->LoadRecPoints("read");
1611 TTree* tree = fLoader[iDet]->TreeR();
1612 if (!tree) {
1613 AliError(Form("Can't get the %s cluster tree", detName.Data()));
1614 return kFALSE;
1615 }
1616 tracker->LoadClusters(tree);
1617 }
1618 if (tracker->Clusters2Tracks(esd) != 0) {
1619 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
1620 return kFALSE;
1621 }
1622 if(iDet != 1) {
1623 tracker->UnloadClusters();
1624 }
1625 delete tracker;
1626 }
1627
1628 return kTRUE;
1629}
1630
1631//_____________________________________________________________________________
1632Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
1633{
1634// run the muon spectrometer tracking
1635
1636 AliCodeTimerAuto("")
1637
1638 if (!fRunLoader) {
1639 AliError("Missing runLoader!");
1640 return kFALSE;
1641 }
1642 Int_t iDet = 7; // for MUON
1643
1644 AliInfo("is running...");
1645
1646 // Get a pointer to the MUON reconstructor
1647 AliReconstructor *reconstructor = GetReconstructor(iDet);
1648 if (!reconstructor) return kFALSE;
1649
1650
1651 TString detName = fgkDetectorName[iDet];
1652 AliDebug(1, Form("%s tracking", detName.Data()));
1653 AliTracker *tracker = reconstructor->CreateTracker();
1654 if (!tracker) {
1655 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
1656 return kFALSE;
1657 }
1658
1659 // read RecPoints
1660 fLoader[iDet]->LoadRecPoints("read");
1661
1662 tracker->LoadClusters(fLoader[iDet]->TreeR());
1663
1664 Int_t rv = tracker->Clusters2Tracks(esd);
1665
1666 if ( rv )
1667 {
1668 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
1669 return kFALSE;
1670 }
1671
1672 fLoader[iDet]->UnloadRecPoints();
1673
1674 tracker->UnloadClusters();
1675
1676 delete tracker;
1677
1678 return kTRUE;
1679}
1680
1681
1682//_____________________________________________________________________________
1683Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
1684{
1685// run the barrel tracking
1686 static Int_t eventNr=0;
1687 AliCodeTimerAuto("")
1688
1689 AliInfo("running tracking");
1690
1691 //Fill the ESD with the T0 info (will be used by the TOF)
1692 if (fReconstructor[11] && fLoader[11]) {
1693 fLoader[11]->LoadRecPoints("READ");
1694 TTree *treeR = fLoader[11]->TreeR();
1695 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
1696 }
1697
1698 // pass 1: TPC + ITS inwards
1699 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1700 if (!fTracker[iDet]) continue;
1701 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
1702
1703 // load clusters
1704 fLoader[iDet]->LoadRecPoints("read");
1705 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
1706 TTree* tree = fLoader[iDet]->TreeR();
1707 if (!tree) {
1708 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
1709 return kFALSE;
1710 }
1711 fTracker[iDet]->LoadClusters(tree);
1712 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
1713 // run tracking
1714 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
1715 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
1716 return kFALSE;
1717 }
1718 if (fCheckPointLevel > 1) {
1719 WriteESD(esd, Form("%s.tracking", fgkDetectorName[iDet]));
1720 }
1721 // preliminary PID in TPC needed by the ITS tracker
1722 if (iDet == 1) {
1723 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
1724 AliESDpid::MakePID(esd);
1725 }
1726 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
1727 }
1728
1729 // pass 2: ALL backwards
1730
1731 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1732 if (!fTracker[iDet]) continue;
1733 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
1734
1735 // load clusters
1736 if (iDet > 1) { // all except ITS, TPC
1737 TTree* tree = NULL;
1738 fLoader[iDet]->LoadRecPoints("read");
1739 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
1740 tree = fLoader[iDet]->TreeR();
1741 if (!tree) {
1742 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
1743 return kFALSE;
1744 }
1745 fTracker[iDet]->LoadClusters(tree);
1746 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
1747 }
1748
1749 // run tracking
1750 if (iDet>1) // start filling residuals for the "outer" detectors
1751 if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
1752
1753 if (fTracker[iDet]->PropagateBack(esd) != 0) {
1754 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
1755 // return kFALSE;
1756 }
1757 if (fCheckPointLevel > 1) {
1758 WriteESD(esd, Form("%s.back", fgkDetectorName[iDet]));
1759 }
1760
1761 // unload clusters
1762 if (iDet > 2) { // all except ITS, TPC, TRD
1763 fTracker[iDet]->UnloadClusters();
1764 fLoader[iDet]->UnloadRecPoints();
1765 }
1766 // updated PID in TPC needed by the ITS tracker -MI
1767 if (iDet == 1) {
1768 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
1769 AliESDpid::MakePID(esd);
1770 }
1771 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
1772 }
1773 //stop filling residuals for the "outer" detectors
1774 if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
1775
1776 // write space-points to the ESD in case alignment data output
1777 // is switched on
1778 if (fWriteAlignmentData)
1779 WriteAlignmentData(esd);
1780
1781 // pass 3: TRD + TPC + ITS refit inwards
1782
1783 for (Int_t iDet = 2; iDet >= 0; iDet--) {
1784 if (!fTracker[iDet]) continue;
1785 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
1786
1787 // run tracking
1788 if (iDet<2) // start filling residuals for TPC and ITS
1789 if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
1790
1791 if (fTracker[iDet]->RefitInward(esd) != 0) {
1792 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
1793 // return kFALSE;
1794 }
1795 // run postprocessing
1796 if (fTracker[iDet]->PostProcess(esd) != 0) {
1797 AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
1798 // return kFALSE;
1799 }
1800 if (fCheckPointLevel > 1) {
1801 WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet]));
1802 }
1803 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
1804 // unload clusters
1805 fTracker[iDet]->UnloadClusters();
1806 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
1807 fLoader[iDet]->UnloadRecPoints();
1808 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
1809 }
1810 // stop filling residuals for TPC and ITS
1811 if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
1812
1813 eventNr++;
1814 return kTRUE;
1815}
1816
1817//_____________________________________________________________________________
1818Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
1819 //
1820 // Remove the data which are not needed for the physics analysis.
1821 //
1822
1823 Int_t nTracks=esd->GetNumberOfTracks();
1824 Int_t nV0s=esd->GetNumberOfV0s();
1825 AliInfo
1826 (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
1827
1828 Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
1829 Bool_t rc=esd->Clean(cleanPars);
1830
1831 nTracks=esd->GetNumberOfTracks();
1832 nV0s=esd->GetNumberOfV0s();
1833 AliInfo
1834 (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
1835
1836 return rc;
1837}
1838
1839//_____________________________________________________________________________
1840Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
1841{
1842// fill the event summary data
1843
1844 AliCodeTimerAuto("")
1845 static Int_t eventNr=0;
1846 TString detStr = detectors;
1847
1848 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1849 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1850 AliReconstructor* reconstructor = GetReconstructor(iDet);
1851 if (!reconstructor) continue;
1852 if (!ReadESD(esd, fgkDetectorName[iDet])) {
1853 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
1854 TTree* clustersTree = NULL;
1855 if (fLoader[iDet]) {
1856 fLoader[iDet]->LoadRecPoints("read");
1857 clustersTree = fLoader[iDet]->TreeR();
1858 if (!clustersTree) {
1859 AliError(Form("Can't get the %s clusters tree",
1860 fgkDetectorName[iDet]));
1861 if (fStopOnError) return kFALSE;
1862 }
1863 }
1864 if (fRawReader && !reconstructor->HasDigitConversion()) {
1865 reconstructor->FillESD(fRawReader, clustersTree, esd);
1866 } else {
1867 TTree* digitsTree = NULL;
1868 if (fLoader[iDet]) {
1869 fLoader[iDet]->LoadDigits("read");
1870 digitsTree = fLoader[iDet]->TreeD();
1871 if (!digitsTree) {
1872 AliError(Form("Can't get the %s digits tree",
1873 fgkDetectorName[iDet]));
1874 if (fStopOnError) return kFALSE;
1875 }
1876 }
1877 reconstructor->FillESD(digitsTree, clustersTree, esd);
1878 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
1879 }
1880 if (fLoader[iDet]) {
1881 fLoader[iDet]->UnloadRecPoints();
1882 }
1883
1884 if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
1885 }
1886 }
1887
1888 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1889 AliError(Form("the following detectors were not found: %s",
1890 detStr.Data()));
1891 if (fStopOnError) return kFALSE;
1892 }
1893 AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
1894 eventNr++;
1895 return kTRUE;
1896}
1897
1898//_____________________________________________________________________________
1899Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
1900{
1901 // Reads the trigger decision which is
1902 // stored in Trigger.root file and fills
1903 // the corresponding esd entries
1904
1905 AliCodeTimerAuto("")
1906
1907 AliInfo("Filling trigger information into the ESD");
1908
1909 AliCentralTrigger *aCTP = NULL;
1910
1911 if (fRawReader) {
1912 AliCTPRawStream input(fRawReader);
1913 if (!input.Next()) {
1914 AliError("No valid CTP (trigger) DDL raw data is found ! The trigger information is not stored in the ESD !");
1915 return kFALSE;
1916 }
1917 esd->SetTriggerMask(input.GetClassMask());
1918 esd->SetTriggerCluster(input.GetClusterMask());
1919
1920 aCTP = new AliCentralTrigger();
1921 TString configstr("");
1922 if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
1923 AliError("No trigger configuration found in OCDB! The trigger classes information will no be stored in ESD!");
1924 delete aCTP;
1925 return kFALSE;
1926 }
1927 }
1928 else {
1929 AliRunLoader *runloader = AliRunLoader::GetRunLoader();
1930 if (runloader) {
1931 if (!runloader->LoadTrigger()) {
1932 aCTP = runloader->GetTrigger();
1933 esd->SetTriggerMask(aCTP->GetClassMask());
1934 esd->SetTriggerCluster(aCTP->GetClusterMask());
1935 }
1936 else {
1937 AliWarning("No trigger can be loaded! The trigger information is not stored in the ESD !");
1938 return kFALSE;
1939 }
1940 }
1941 else {
1942 AliError("No run loader is available! The trigger information is not stored in the ESD !");
1943 return kFALSE;
1944 }
1945 }
1946
1947 // Now fill the trigger class names into AliESDRun object
1948 AliTriggerConfiguration *config = aCTP->GetConfiguration();
1949 if (!config) {
1950 AliError("No trigger configuration has been found! The trigger classes information will no be stored in ESD!");
1951 if (fRawReader) delete aCTP;
1952 return kFALSE;
1953 }
1954
1955 const TObjArray& classesArray = config->GetClasses();
1956 Int_t nclasses = classesArray.GetEntriesFast();
1957 for( Int_t j=0; j<nclasses; j++ ) {
1958 AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At( j );
1959 Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask());
1960 esd->SetTriggerClass(trclass->GetName(),trindex);
1961 }
1962
1963 if (fRawReader) delete aCTP;
1964 return kTRUE;
1965}
1966
1967
1968
1969
1970
1971//_____________________________________________________________________________
1972Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
1973{
1974 //
1975 // Filling information from RawReader Header
1976 //
1977
1978 AliInfo("Filling information from RawReader Header");
1979 esd->SetBunchCrossNumber(0);
1980 esd->SetOrbitNumber(0);
1981 esd->SetPeriodNumber(0);
1982 esd->SetTimeStamp(0);
1983 esd->SetEventType(0);
1984 const AliRawEventHeaderBase * eventHeader = fRawReader->GetEventHeader();
1985 if (eventHeader){
1986
1987 const UInt_t *id = eventHeader->GetP("Id");
1988 esd->SetBunchCrossNumber((id)[1]&0x00000fff);
1989 esd->SetOrbitNumber((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff));
1990 esd->SetPeriodNumber(((id)[0]>>4)&0x0fffffff);
1991
1992 esd->SetTimeStamp((eventHeader->Get("Timestamp")));
1993 esd->SetEventType((eventHeader->Get("Type")));
1994 }
1995
1996 return kTRUE;
1997}
1998
1999
2000//_____________________________________________________________________________
2001Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
2002{
2003// check whether detName is contained in detectors
2004// if yes, it is removed from detectors
2005
2006 // check if all detectors are selected
2007 if ((detectors.CompareTo("ALL") == 0) ||
2008 detectors.BeginsWith("ALL ") ||
2009 detectors.EndsWith(" ALL") ||
2010 detectors.Contains(" ALL ")) {
2011 detectors = "ALL";
2012 return kTRUE;
2013 }
2014
2015 // search for the given detector
2016 Bool_t result = kFALSE;
2017 if ((detectors.CompareTo(detName) == 0) ||
2018 detectors.BeginsWith(detName+" ") ||
2019 detectors.EndsWith(" "+detName) ||
2020 detectors.Contains(" "+detName+" ")) {
2021 detectors.ReplaceAll(detName, "");
2022 result = kTRUE;
2023 }
2024
2025 // clean up the detectors string
2026 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
2027 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
2028 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
2029
2030 return result;
2031}
2032
2033//_____________________________________________________________________________
2034Bool_t AliReconstruction::InitRunLoader()
2035{
2036// get or create the run loader
2037
2038 if (gAlice) delete gAlice;
2039 gAlice = NULL;
2040
2041 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
2042 // load all base libraries to get the loader classes
2043 TString libs = gSystem->GetLibraries();
2044 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2045 TString detName = fgkDetectorName[iDet];
2046 if (detName == "HLT") continue;
2047 if (libs.Contains("lib" + detName + "base.so")) continue;
2048 gSystem->Load("lib" + detName + "base.so");
2049 }
2050 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
2051 if (!fRunLoader) {
2052 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
2053 CleanUp();
2054 return kFALSE;
2055 }
2056
2057 fRunLoader->CdGAFile();
2058 fRunLoader->LoadgAlice();
2059
2060 //PH This is a temporary fix to give access to the kinematics
2061 //PH that is needed for the labels of ITS clusters
2062 fRunLoader->LoadHeader();
2063 fRunLoader->LoadKinematics();
2064
2065 } else { // galice.root does not exist
2066 if (!fRawReader) {
2067 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
2068 CleanUp();
2069 return kFALSE;
2070 }
2071 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
2072 AliConfig::GetDefaultEventFolderName(),
2073 "recreate");
2074 if (!fRunLoader) {
2075 AliError(Form("could not create run loader in file %s",
2076 fGAliceFileName.Data()));
2077 CleanUp();
2078 return kFALSE;
2079 }
2080 fIsNewRunLoader = kTRUE;
2081 fRunLoader->MakeTree("E");
2082
2083 if (fNumberOfEventsPerFile > 0)
2084 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
2085 else
2086 fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
2087 }
2088
2089 return kTRUE;
2090}
2091
2092//_____________________________________________________________________________
2093AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
2094{
2095// get the reconstructor object and the loader for a detector
2096
2097 if (fReconstructor[iDet]) return fReconstructor[iDet];
2098
2099 // load the reconstructor object
2100 TPluginManager* pluginManager = gROOT->GetPluginManager();
2101 TString detName = fgkDetectorName[iDet];
2102 TString recName = "Ali" + detName + "Reconstructor";
2103
2104 if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
2105
2106 AliReconstructor* reconstructor = NULL;
2107 // first check if a plugin is defined for the reconstructor
2108 TPluginHandler* pluginHandler =
2109 pluginManager->FindHandler("AliReconstructor", detName);
2110 // if not, add a plugin for it
2111 if (!pluginHandler) {
2112 AliDebug(1, Form("defining plugin for %s", recName.Data()));
2113 TString libs = gSystem->GetLibraries();
2114 if (libs.Contains("lib" + detName + "base.so") ||
2115 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
2116 pluginManager->AddHandler("AliReconstructor", detName,
2117 recName, detName + "rec", recName + "()");
2118 } else {
2119 pluginManager->AddHandler("AliReconstructor", detName,
2120 recName, detName, recName + "()");
2121 }
2122 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
2123 }
2124 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2125 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
2126 }
2127 if (reconstructor) {
2128 TObject* obj = fOptions.FindObject(detName.Data());
2129 if (obj) reconstructor->SetOption(obj->GetTitle());
2130 reconstructor->Init();
2131 fReconstructor[iDet] = reconstructor;
2132 }
2133
2134 // get or create the loader
2135 if (detName != "HLT") {
2136 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
2137 if (!fLoader[iDet]) {
2138 AliConfig::Instance()
2139 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
2140 detName, detName);
2141 // first check if a plugin is defined for the loader
2142 pluginHandler =
2143 pluginManager->FindHandler("AliLoader", detName);
2144 // if not, add a plugin for it
2145 if (!pluginHandler) {
2146 TString loaderName = "Ali" + detName + "Loader";
2147 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
2148 pluginManager->AddHandler("AliLoader", detName,
2149 loaderName, detName + "base",
2150 loaderName + "(const char*, TFolder*)");
2151 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
2152 }
2153 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2154 fLoader[iDet] =
2155 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
2156 fRunLoader->GetEventFolder());
2157 }
2158 if (!fLoader[iDet]) { // use default loader
2159 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
2160 }
2161 if (!fLoader[iDet]) {
2162 AliWarning(Form("couldn't get loader for %s", detName.Data()));
2163 if (fStopOnError) return NULL;
2164 } else {
2165 fRunLoader->AddLoader(fLoader[iDet]);
2166 fRunLoader->CdGAFile();
2167 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
2168 fRunLoader->Write(0, TObject::kOverwrite);
2169 }
2170 }
2171 }
2172
2173 return reconstructor;
2174}
2175
2176//_____________________________________________________________________________
2177Bool_t AliReconstruction::CreateVertexer()
2178{
2179// create the vertexer
2180
2181 fVertexer = NULL;
2182 AliReconstructor* itsReconstructor = GetReconstructor(0);
2183 if (itsReconstructor) {
2184 fVertexer = itsReconstructor->CreateVertexer();
2185 }
2186 if (!fVertexer) {
2187 AliWarning("couldn't create a vertexer for ITS");
2188 if (fStopOnError) return kFALSE;
2189 }
2190
2191 return kTRUE;
2192}
2193
2194//_____________________________________________________________________________
2195Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
2196{
2197// create the trackers
2198
2199 TString detStr = detectors;
2200 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2201 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2202 AliReconstructor* reconstructor = GetReconstructor(iDet);
2203 if (!reconstructor) continue;
2204 TString detName = fgkDetectorName[iDet];
2205 if (detName == "HLT") {
2206 fRunHLTTracking = kTRUE;
2207 continue;
2208 }
2209 if (detName == "MUON") {
2210 fRunMuonTracking = kTRUE;
2211 continue;
2212 }
2213
2214
2215 fTracker[iDet] = reconstructor->CreateTracker();
2216 if (!fTracker[iDet] && (iDet < 7)) {
2217 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2218 if (fStopOnError) return kFALSE;
2219 }
2220 AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
2221 }
2222
2223 return kTRUE;
2224}
2225
2226//_____________________________________________________________________________
2227void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
2228{
2229// delete trackers and the run loader and close and delete the file
2230
2231 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2232 delete fReconstructor[iDet];
2233 fReconstructor[iDet] = NULL;
2234 fLoader[iDet] = NULL;
2235 delete fTracker[iDet];
2236 fTracker[iDet] = NULL;
2237// delete fQADataMaker[iDet];
2238// fQADataMaker[iDet] = NULL;
2239 }
2240 delete fVertexer;
2241 fVertexer = NULL;
2242
2243 if (ftVertexer) delete ftVertexer;
2244 ftVertexer = NULL;
2245
2246 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
2247 delete fDiamondProfile;
2248 fDiamondProfile = NULL;
2249 delete fDiamondProfileTPC;
2250 fDiamondProfileTPC = NULL;
2251 delete fGRPData;
2252 fGRPData = NULL;
2253 }
2254
2255
2256 delete fRunLoader;
2257 fRunLoader = NULL;
2258 delete fRawReader;
2259 fRawReader = NULL;
2260 if (fParentRawReader) delete fParentRawReader;
2261 fParentRawReader=NULL;
2262
2263 if (file) {
2264 file->Close();
2265 delete file;
2266 }
2267
2268 if (fileOld) {
2269 fileOld->Close();
2270 delete fileOld;
2271 gSystem->Unlink("AliESDs.old.root");
2272 }
2273
2274}
2275
2276//_____________________________________________________________________________
2277
2278Bool_t AliReconstruction::ReadESD(AliESDEvent*& esd, const char* recStep) const
2279{
2280// read the ESD event from a file
2281
2282 if (!esd) return kFALSE;
2283 char fileName[256];
2284 sprintf(fileName, "ESD_%d.%d_%s.root",
2285 esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
2286 if (gSystem->AccessPathName(fileName)) return kFALSE;
2287
2288 AliInfo(Form("reading ESD from file %s", fileName));
2289 AliDebug(1, Form("reading ESD from file %s", fileName));
2290 TFile* file = TFile::Open(fileName);
2291 if (!file || !file->IsOpen()) {
2292 AliError(Form("opening %s failed", fileName));
2293 delete file;
2294 return kFALSE;
2295 }
2296
2297 gROOT->cd();
2298 delete esd;
2299 esd = (AliESDEvent*) file->Get("ESD");
2300 file->Close();
2301 delete file;
2302 return kTRUE;
2303
2304}
2305
2306
2307
2308//_____________________________________________________________________________
2309void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const
2310{
2311// write the ESD event to a file
2312
2313 if (!esd) return;
2314 char fileName[256];
2315 sprintf(fileName, "ESD_%d.%d_%s.root",
2316 esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
2317
2318 AliDebug(1, Form("writing ESD to file %s", fileName));
2319 TFile* file = TFile::Open(fileName, "recreate");
2320 if (!file || !file->IsOpen()) {
2321 AliError(Form("opening %s failed", fileName));
2322 } else {
2323 esd->Write("ESD");
2324 file->Close();
2325 }
2326 delete file;
2327}
2328
2329
2330void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
2331{
2332 // Write space-points which are then used in the alignment procedures
2333 // For the moment only ITS, TRD and TPC
2334
2335 // Load TOF clusters
2336 if (fTracker[3]){
2337 fLoader[3]->LoadRecPoints("read");
2338 TTree* tree = fLoader[3]->TreeR();
2339 if (!tree) {
2340 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[3]));
2341 return;
2342 }
2343 fTracker[3]->LoadClusters(tree);
2344 }
2345 Int_t ntracks = esd->GetNumberOfTracks();
2346 for (Int_t itrack = 0; itrack < ntracks; itrack++)
2347 {
2348 AliESDtrack *track = esd->GetTrack(itrack);
2349 Int_t nsp = 0;
2350 Int_t idx[200];
2351 for (Int_t iDet = 3; iDet >= 0; iDet--)
2352 nsp += track->GetNcls(iDet);
2353 if (nsp) {
2354 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
2355 track->SetTrackPointArray(sp);
2356 Int_t isptrack = 0;
2357 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2358 AliTracker *tracker = fTracker[iDet];
2359 if (!tracker) continue;
2360 Int_t nspdet = track->GetNcls(iDet);
2361 if (nspdet <= 0) continue;
2362 track->GetClusters(iDet,idx);
2363 AliTrackPoint p;
2364 Int_t isp = 0;
2365 Int_t isp2 = 0;
2366 while (isp2 < nspdet) {
2367 Bool_t isvalid;
2368 TString dets = fgkDetectorName[iDet];
2369 if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
2370 fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
2371 fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
2372 fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
2373 isvalid = tracker->GetTrackPointTrackingError(idx[isp2],p,track);
2374 } else {
2375 isvalid = tracker->GetTrackPoint(idx[isp2],p);
2376 }
2377 isp2++;
2378 const Int_t kNTPCmax = 159;
2379 if (iDet==1 && isp2>kNTPCmax) break; // to be fixed
2380 if (!isvalid) continue;
2381 sp->AddPoint(isptrack,&p); isptrack++; isp++;
2382 }
2383 }
2384 }
2385 }
2386 if (fTracker[3]){
2387 fTracker[3]->UnloadClusters();
2388 fLoader[3]->UnloadRecPoints();
2389 }
2390}
2391
2392//_____________________________________________________________________________
2393void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
2394{
2395 // The method reads the raw-data error log
2396 // accumulated within the rawReader.
2397 // It extracts the raw-data errors related to
2398 // the current event and stores them into
2399 // a TClonesArray inside the esd object.
2400
2401 if (!fRawReader) return;
2402
2403 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
2404
2405 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
2406 if (!log) continue;
2407 if (iEvent != log->GetEventNumber()) continue;
2408
2409 esd->AddRawDataErrorLog(log);
2410 }
2411
2412}
2413
2414TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString pName){
2415 // Dump a file content into a char in TNamed
2416 ifstream in;
2417 in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
2418 Int_t kBytes = (Int_t)in.tellg();
2419 printf("Size: %d \n",kBytes);
2420 TNamed *fn = 0;
2421 if(in.good()){
2422 char* memblock = new char [kBytes];
2423 in.seekg (0, ios::beg);
2424 in.read (memblock, kBytes);
2425 in.close();
2426 TString fData(memblock,kBytes);
2427 fn = new TNamed(pName,fData);
2428 printf("fData Size: %d \n",fData.Sizeof());
2429 printf("pName Size: %d \n",pName.Sizeof());
2430 printf("fn Size: %d \n",fn->Sizeof());
2431 delete[] memblock;
2432 }
2433 else{
2434 AliInfo(Form("Could not Open %s\n",fPath.Data()));
2435 }
2436
2437 return fn;
2438}
2439
2440void AliReconstruction::TNamedToFile(TTree* fTree, TString pName){
2441 // This is not really needed in AliReconstruction at the moment
2442 // but can serve as a template
2443
2444 TList *fList = fTree->GetUserInfo();
2445 TNamed *fn = (TNamed*)fList->FindObject(pName.Data());
2446 printf("fn Size: %d \n",fn->Sizeof());
2447
2448 TString fTmp(fn->GetName()); // to be 100% sure in principle pName also works
2449 const char* cdata = fn->GetTitle();
2450 printf("fTmp Size %d\n",fTmp.Sizeof());
2451
2452 int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
2453 printf("calculated size %d\n",size);
2454 ofstream out(pName.Data(),ios::out | ios::binary);
2455 out.write(cdata,size);
2456 out.close();
2457
2458}
2459
2460//_____________________________________________________________________________
2461AliQADataMakerRec * AliReconstruction::GetQADataMaker(Int_t iDet)
2462{
2463 // get the quality assurance data maker object and the loader for a detector
2464
2465 if (fQADataMaker[iDet])
2466 return fQADataMaker[iDet];
2467
2468 AliQADataMakerRec * qadm = NULL;
2469 if (iDet == fgkNDetectors) { //Global QA
2470 qadm = new AliGlobalQADataMaker();
2471 fQADataMaker[iDet] = qadm;
2472 return qadm;
2473 }
2474
2475 // load the QA data maker object
2476 TPluginManager* pluginManager = gROOT->GetPluginManager();
2477 TString detName = fgkDetectorName[iDet];
2478 TString qadmName = "Ali" + detName + "QADataMakerRec";
2479 if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT"))
2480 return NULL;
2481
2482 // first check if a plugin is defined for the quality assurance data maker
2483 TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
2484 // if not, add a plugin for it
2485 if (!pluginHandler) {
2486 AliDebug(1, Form("defining plugin for %s", qadmName.Data()));
2487 TString libs = gSystem->GetLibraries();
2488 if (libs.Contains("lib" + detName + "base.so") ||
2489 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
2490 pluginManager->AddHandler("AliQADataMakerRec", detName,
2491 qadmName, detName + "qadm", qadmName + "()");
2492 } else {
2493 pluginManager->AddHandler("AliQADataMakerRec", detName,
2494 qadmName, detName, qadmName + "()");
2495 }
2496 pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
2497 }
2498 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2499 qadm = (AliQADataMakerRec *) pluginHandler->ExecPlugin(0);
2500 }
2501
2502 fQADataMaker[iDet] = qadm;
2503
2504 return qadm;
2505}
2506
2507//_____________________________________________________________________________
2508Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd)
2509{
2510 // run the Quality Assurance data producer
2511
2512 AliCodeTimerAuto("")
2513 TString detStr = detectors;
2514 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2515 if (!IsSelected(fgkDetectorName[iDet], detStr))
2516 continue;
2517 AliQADataMakerRec * qadm = GetQADataMaker(iDet);
2518 if (!qadm)
2519 continue;
2520 AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2521 AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2522
2523 qadm->Exec(AliQA::kESDS, esd) ;
2524 qadm->Increment() ;
2525
2526 AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2527 }
2528 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2529 AliError(Form("the following detectors were not found: %s",
2530 detStr.Data()));
2531 if (fStopOnError)
2532 return kFALSE;
2533 }
2534
2535 return kTRUE;
2536
2537}
2538
2539//_____________________________________________________________________________
2540void AliReconstruction::CheckQA()
2541{
2542// check the QA of SIM for this run and remove the detectors
2543// with status Fatal
2544
2545 TString newRunLocalReconstruction ;
2546 TString newRunTracking ;
2547 TString newFillESD ;
2548
2549 for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
2550 TString detName(AliQA::GetDetName(iDet)) ;
2551 AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ;
2552 if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, AliQA::kFATAL)) {
2553 AliInfo(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed", detName.Data())) ;
2554 } else {
2555 if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) ||
2556 fRunLocalReconstruction.Contains("ALL") ) {
2557 newRunLocalReconstruction += detName ;
2558 newRunLocalReconstruction += " " ;
2559 }
2560 if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) ||
2561 fRunTracking.Contains("ALL") ) {
2562 newRunTracking += detName ;
2563 newRunTracking += " " ;
2564 }
2565 if ( fFillESD.Contains(AliQA::GetDetName(iDet)) ||
2566 fFillESD.Contains("ALL") ) {
2567 newFillESD += detName ;
2568 newFillESD += " " ;
2569 }
2570 }
2571 }
2572 fRunLocalReconstruction = newRunLocalReconstruction ;
2573 fRunTracking = newRunTracking ;
2574 fFillESD = newFillESD ;
2575}
2576
2577//_____________________________________________________________________________
2578Int_t AliReconstruction::GetDetIndex(const char* detector)
2579{
2580 // return the detector index corresponding to detector
2581 Int_t index = -1 ;
2582 for (index = 0; index < fgkNDetectors ; index++) {
2583 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
2584 break ;
2585 }
2586 return index ;
2587}
2588//_____________________________________________________________________________
2589Bool_t AliReconstruction::FinishPlaneEff() {
2590 //
2591 // Here execute all the necessary operationis, at the end of the tracking phase,
2592 // in case that evaluation of PlaneEfficiencies was required for some detector.
2593 // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
2594 //
2595 // This Preliminary version works only FOR ITS !!!!!
2596 // other detectors (TOF,TRD, etc. have to develop their specific codes)
2597 //
2598 // Input: none
2599 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
2600 //
2601 Bool_t ret=kFALSE;
2602 //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2603 for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
2604 //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2605 if(fTracker[iDet]) {
2606 AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
2607 ret=planeeff->WriteIntoCDB();
2608 if(planeeff->GetCreateHistos()) {
2609 TString name="PlaneEffHisto";
2610 name+=fgkDetectorName[iDet];
2611 name+=".root";
2612 ret*=planeeff->WriteHistosToFile(name,"RECREATE");
2613 }
2614 }
2615 }
2616 return ret;
2617}
2618//_____________________________________________________________________________
2619Bool_t AliReconstruction::InitPlaneEff() {
2620//
2621 // Here execute all the necessary operations, before of the tracking phase,
2622 // for the evaluation of PlaneEfficiencies, in case required for some detectors.
2623 // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
2624 // which should be updated/recalculated.
2625 //
2626 // This Preliminary version will work only FOR ITS !!!!!
2627 // other detectors (TOF,TRD, etc. have to develop their specific codes)
2628 //
2629 // Input: none
2630 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
2631 //
2632 AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE"));
2633 return kTRUE;
2634}
2635
2636//_____________________________________________________________________________
2637Bool_t AliReconstruction::InitAliEVE()
2638{
2639 // This method should be called only in case
2640 // AliReconstruction is run
2641 // within the alieve environment.
2642 // It will initialize AliEVE in a way
2643 // so that it can visualize event processed
2644 // by AliReconstruction.
2645 // The return flag shows whenever the
2646 // AliEVE initialization was successful or not.
2647
2648 TString macroStr;
2649 macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
2650 AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
2651 if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
2652
2653 gROOT->ProcessLine("if (!gAliEveEvent) {gAliEveEvent = new AliEveEventManager();gAliEveEvent->SetAutoLoad(kTRUE);gAliEveEvent->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(gAliEveEvent);};");
2654 gROOT->ProcessLine("alieve_online_init()");
2655
2656 return kTRUE;
2657}
2658
2659//_____________________________________________________________________________
2660void AliReconstruction::RunAliEVE()
2661{
2662 // Runs AliEVE visualisation of
2663 // the current event.
2664 // Should be executed only after
2665 // successful initialization of AliEVE.
2666
2667 AliInfo("Running AliEVE...");
2668 gROOT->ProcessLine(Form("gAliEveEvent->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p);",fRunLoader,fRawReader,fesd));
2669 gROOT->ProcessLine("gAliEveEvent->StartStopAutoLoadTimer();");
2670 gSystem->Run();
2671}