1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 ///////////////////////////////////////////////////////////////////////////////
20 // class for running the reconstruction //
22 // Clusters and tracks are created for all detectors and all events by //
25 // AliReconstruction rec; //
28 // The Run method returns kTRUE in case of successful execution. //
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 //
33 // rec.SetInput("..."); //
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 //
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 //
45 // rec.SetEventRange(..., ...); //
47 // The index -1 (default) can be used for the last event to indicate no //
48 // upper limit of the event range. //
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): //
56 // rec.SetNumberOfEventsPerFile(...); //
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 //
63 // rec.SetGAliceFile("..."); //
65 // The local reconstruction can be switched on or off for individual //
68 // rec.SetRunLocalReconstruction("..."); //
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. //
74 // The reconstruction of the primary vertex position can be switched off by //
76 // rec.SetRunVertexFinder(kFALSE); //
78 // The tracking and the creation of ESD tracks can be switched on for //
79 // selected detectors by //
81 // rec.SetRunTracking("..."); //
83 // Uniform/nonuniform field tracking switches (default: uniform field) //
85 // rec.SetUniformFieldTracking(); ( rec.SetUniformFieldTracking(kFALSE); ) //
87 // The filling of additional ESD information can be steered by //
89 // rec.SetFillESD("..."); //
91 // Again, for both methods the string specifies the list of detectors. //
92 // The default is "ALL". //
94 // The call of the shortcut method //
96 // rec.SetRunReconstruction("..."); //
98 // is equivalent to calling SetRunLocalReconstruction, SetRunTracking and //
99 // SetFillESD with the same detector selecting string as argument. //
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. //
104 // The input data of a detector can be replaced by the corresponding HLT //
105 // data by calling (usual detector string) //
106 // SetUseHLTData("..."); //
109 ///////////////////////////////////////////////////////////////////////////////
116 #include <TGeoGlobalMagField.h>
117 #include <TGeoManager.h>
119 #include <TLorentzVector.h>
121 #include <TObjArray.h>
122 #include <TPRegexp.h>
123 #include <TParameter.h>
124 #include <TPluginManager.h>
126 #include <TProofOutputFile.h>
130 #include "AliAlignObj.h"
131 #include "AliCDBEntry.h"
132 #include "AliCDBManager.h"
133 #include "AliCDBStorage.h"
134 #include "AliCTPRawStream.h"
135 #include "AliCascadeVertexer.h"
136 #include "AliCentralTrigger.h"
137 #include "AliCodeTimer.h"
139 #include "AliDetectorRecoParam.h"
140 #include "AliESDCaloCells.h"
141 #include "AliESDCaloCluster.h"
142 #include "AliESDEvent.h"
143 #include "AliESDMuonTrack.h"
144 #include "AliESDPmdTrack.h"
145 #include "AliESDTagCreator.h"
146 #include "AliESDVertex.h"
147 #include "AliESDcascade.h"
148 #include "AliESDfriend.h"
149 #include "AliESDkink.h"
150 #include "AliESDpid.h"
151 #include "AliESDtrack.h"
152 #include "AliESDtrack.h"
153 #include "AliEventInfo.h"
154 #include "AliGRPObject.h"
155 #include "AliGRPRecoParam.h"
156 #include "AliGenEventHeader.h"
157 #include "AliGeomManager.h"
158 #include "AliGlobalQADataMaker.h"
159 #include "AliHeader.h"
162 #include "AliMultiplicity.h"
164 #include "AliPlaneEff.h"
166 #include "AliQADataMakerRec.h"
167 #include "AliQADataMakerSteer.h"
168 #include "AliRawEvent.h"
169 #include "AliRawEventHeaderBase.h"
170 #include "AliRawHLTManager.h"
171 #include "AliRawReaderDate.h"
172 #include "AliRawReaderFile.h"
173 #include "AliRawReaderRoot.h"
174 #include "AliReconstruction.h"
175 #include "AliReconstructor.h"
177 #include "AliRunInfo.h"
178 #include "AliRunLoader.h"
179 #include "AliSysInfo.h" // memory snapshots
180 #include "AliTrackPointArray.h"
181 #include "AliTracker.h"
182 #include "AliTriggerClass.h"
183 #include "AliTriggerCluster.h"
184 #include "AliTriggerConfiguration.h"
185 #include "AliV0vertexer.h"
186 #include "AliVertexer.h"
187 #include "AliVertexerTracks.h"
189 ClassImp(AliReconstruction)
191 //_____________________________________________________________________________
192 const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
194 //_____________________________________________________________________________
195 AliReconstruction::AliReconstruction(const char* gAliceFilename) :
197 fUniformField(kFALSE),
198 fRunVertexFinder(kTRUE),
199 fRunVertexFinderTracks(kTRUE),
200 fRunHLTTracking(kFALSE),
201 fRunMuonTracking(kFALSE),
203 fRunCascadeFinder(kTRUE),
204 fStopOnError(kFALSE),
205 fWriteAlignmentData(kFALSE),
206 fWriteESDfriend(kFALSE),
207 fFillTriggerESD(kTRUE),
215 fRunLocalReconstruction("ALL"),
219 fUseTrackingErrorsForAlignment(""),
220 fGAliceFileName(gAliceFilename),
225 fNumberOfEventsPerFile((UInt_t)-1),
227 fLoadAlignFromCDB(kTRUE),
228 fLoadAlignData("ALL"),
235 fParentRawReader(NULL),
239 fDiamondProfileSPD(NULL),
240 fDiamondProfile(NULL),
241 fDiamondProfileTPC(NULL),
245 fAlignObjArray(NULL),
248 fInitCDBCalled(kFALSE),
249 fSetRunNumberFromDataCalled(kFALSE),
255 fSameQACycle(kFALSE),
257 fRunPlaneEff(kFALSE),
266 fIsNewRunLoader(kFALSE),
270 // create reconstruction object with default parameters
273 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
274 fReconstructor[iDet] = NULL;
275 fLoader[iDet] = NULL;
276 fTracker[iDet] = NULL;
278 for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
279 fQACycles[iDet] = 999999 ;
280 fQAWriteExpert[iDet] = kFALSE ;
286 //_____________________________________________________________________________
287 AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
289 fUniformField(rec.fUniformField),
290 fRunVertexFinder(rec.fRunVertexFinder),
291 fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
292 fRunHLTTracking(rec.fRunHLTTracking),
293 fRunMuonTracking(rec.fRunMuonTracking),
294 fRunV0Finder(rec.fRunV0Finder),
295 fRunCascadeFinder(rec.fRunCascadeFinder),
296 fStopOnError(rec.fStopOnError),
297 fWriteAlignmentData(rec.fWriteAlignmentData),
298 fWriteESDfriend(rec.fWriteESDfriend),
299 fFillTriggerESD(rec.fFillTriggerESD),
301 fCleanESD(rec.fCleanESD),
302 fV0DCAmax(rec.fV0DCAmax),
303 fV0CsPmin(rec.fV0CsPmin),
307 fRunLocalReconstruction(rec.fRunLocalReconstruction),
308 fRunTracking(rec.fRunTracking),
309 fFillESD(rec.fFillESD),
310 fLoadCDB(rec.fLoadCDB),
311 fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
312 fGAliceFileName(rec.fGAliceFileName),
313 fRawInput(rec.fRawInput),
314 fEquipIdMap(rec.fEquipIdMap),
315 fFirstEvent(rec.fFirstEvent),
316 fLastEvent(rec.fLastEvent),
317 fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
319 fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
320 fLoadAlignData(rec.fLoadAlignData),
321 fUseHLTData(rec.fUseHLTData),
327 fParentRawReader(NULL),
329 fRecoParam(rec.fRecoParam),
331 fDiamondProfileSPD(rec.fDiamondProfileSPD),
332 fDiamondProfile(rec.fDiamondProfile),
333 fDiamondProfileTPC(rec.fDiamondProfileTPC),
337 fAlignObjArray(rec.fAlignObjArray),
338 fCDBUri(rec.fCDBUri),
340 fInitCDBCalled(rec.fInitCDBCalled),
341 fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
342 fQADetectors(rec.fQADetectors),
344 fQATasks(rec.fQATasks),
346 fRunGlobalQA(rec.fRunGlobalQA),
347 fSameQACycle(rec.fSameQACycle),
348 fRunPlaneEff(rec.fRunPlaneEff),
357 fIsNewRunLoader(rec.fIsNewRunLoader),
363 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
364 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
366 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
367 fReconstructor[iDet] = NULL;
368 fLoader[iDet] = NULL;
369 fTracker[iDet] = NULL;
372 for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
373 fQACycles[iDet] = rec.fQACycles[iDet];
374 fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
377 for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
378 if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
382 //_____________________________________________________________________________
383 AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
385 // assignment operator
386 // Used in PROOF mode
387 // Be very careful while modifing it!
388 // Simple rules to follow:
389 // for persistent data members - use their assignment operators
390 // for non-persistent ones - do nothing or take the default values from constructor
391 // TSelector members should not be touched
392 if(&rec == this) return *this;
394 fUniformField = rec.fUniformField;
395 fRunVertexFinder = rec.fRunVertexFinder;
396 fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
397 fRunHLTTracking = rec.fRunHLTTracking;
398 fRunMuonTracking = rec.fRunMuonTracking;
399 fRunV0Finder = rec.fRunV0Finder;
400 fRunCascadeFinder = rec.fRunCascadeFinder;
401 fStopOnError = rec.fStopOnError;
402 fWriteAlignmentData = rec.fWriteAlignmentData;
403 fWriteESDfriend = rec.fWriteESDfriend;
404 fFillTriggerESD = rec.fFillTriggerESD;
406 fCleanESD = rec.fCleanESD;
407 fV0DCAmax = rec.fV0DCAmax;
408 fV0CsPmin = rec.fV0CsPmin;
412 fRunLocalReconstruction = rec.fRunLocalReconstruction;
413 fRunTracking = rec.fRunTracking;
414 fFillESD = rec.fFillESD;
415 fLoadCDB = rec.fLoadCDB;
416 fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
417 fGAliceFileName = rec.fGAliceFileName;
418 fRawInput = rec.fRawInput;
419 fEquipIdMap = rec.fEquipIdMap;
420 fFirstEvent = rec.fFirstEvent;
421 fLastEvent = rec.fLastEvent;
422 fNumberOfEventsPerFile = rec.fNumberOfEventsPerFile;
424 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
425 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
428 fLoadAlignFromCDB = rec.fLoadAlignFromCDB;
429 fLoadAlignData = rec.fLoadAlignData;
430 fUseHLTData = rec.fUseHLTData;
432 delete fRunInfo; fRunInfo = NULL;
433 if (rec.fRunInfo) fRunInfo = new AliRunInfo(*rec.fRunInfo);
435 fEventInfo = rec.fEventInfo;
439 fParentRawReader = NULL;
441 fRecoParam = rec.fRecoParam;
443 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
444 delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
445 delete fLoader[iDet]; fLoader[iDet] = NULL;
446 delete fTracker[iDet]; fTracker[iDet] = NULL;
449 for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
450 fQACycles[iDet] = rec.fQACycles[iDet];
451 fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
454 delete fDiamondProfileSPD; fDiamondProfileSPD = NULL;
455 if (rec.fDiamondProfileSPD) fDiamondProfileSPD = new AliESDVertex(*rec.fDiamondProfileSPD);
456 delete fDiamondProfile; fDiamondProfile = NULL;
457 if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile);
458 delete fDiamondProfileTPC; fDiamondProfileTPC = NULL;
459 if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC);
461 delete fGRPData; fGRPData = NULL;
462 // if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
463 if (rec.fGRPData) fGRPData = (AliGRPObject*)((rec.fGRPData)->Clone());
465 delete fAlignObjArray; fAlignObjArray = NULL;
468 fSpecCDBUri.Delete();
469 fInitCDBCalled = rec.fInitCDBCalled;
470 fSetRunNumberFromDataCalled = rec.fSetRunNumberFromDataCalled;
471 fQADetectors = rec.fQADetectors;
473 fQATasks = rec.fQATasks;
475 fRunGlobalQA = rec.fRunGlobalQA;
476 fSameQACycle = rec.fSameQACycle;
477 fRunPlaneEff = rec.fRunPlaneEff;
486 fIsNewRunLoader = rec.fIsNewRunLoader;
493 //_____________________________________________________________________________
494 AliReconstruction::~AliReconstruction()
501 if (fAlignObjArray) {
502 fAlignObjArray->Delete();
503 delete fAlignObjArray;
505 fSpecCDBUri.Delete();
507 AliCodeTimer::Instance()->Print();
510 //_____________________________________________________________________________
511 void AliReconstruction::InitCDB()
513 // activate a default CDB storage
514 // First check if we have any CDB storage set, because it is used
515 // to retrieve the calibration and alignment constants
516 AliCodeTimerAuto("");
518 if (fInitCDBCalled) return;
519 fInitCDBCalled = kTRUE;
521 AliCDBManager* man = AliCDBManager::Instance();
522 if (man->IsDefaultStorageSet())
524 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
525 AliWarning("Default CDB storage has been already set !");
526 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
527 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
528 fCDBUri = man->GetDefaultStorage()->GetURI();
531 if (fCDBUri.Length() > 0)
533 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
534 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
535 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
537 fCDBUri="local://$ALICE_ROOT";
538 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
539 AliWarning("Default CDB storage not yet set !!!!");
540 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
541 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
544 man->SetDefaultStorage(fCDBUri);
547 // Now activate the detector specific CDB storage locations
548 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
549 TObject* obj = fSpecCDBUri[i];
551 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
552 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
553 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
554 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
556 AliSysInfo::AddStamp("InitCDB");
559 //_____________________________________________________________________________
560 void AliReconstruction::SetDefaultStorage(const char* uri) {
561 // Store the desired default CDB storage location
562 // Activate it later within the Run() method
568 //_____________________________________________________________________________
569 void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
570 // Store a detector-specific CDB storage location
571 // Activate it later within the Run() method
573 AliCDBPath aPath(calibType);
574 if(!aPath.IsValid()){
575 // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
576 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
577 if(!strcmp(calibType, fgkDetectorName[iDet])) {
578 aPath.SetPath(Form("%s/*", calibType));
579 AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
583 if(!aPath.IsValid()){
584 AliError(Form("Not a valid path or detector: %s", calibType));
589 // // check that calibType refers to a "valid" detector name
590 // Bool_t isDetector = kFALSE;
591 // for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
592 // TString detName = fgkDetectorName[iDet];
593 // if(aPath.GetLevel0() == detName) {
594 // isDetector = kTRUE;
600 // AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
604 TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
605 if (obj) fSpecCDBUri.Remove(obj);
606 fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
610 //_____________________________________________________________________________
611 Bool_t AliReconstruction::SetRunNumberFromData()
613 // The method is called in Run() in order
614 // to set a correct run number.
615 // In case of raw data reconstruction the
616 // run number is taken from the raw data header
618 if (fSetRunNumberFromDataCalled) return kTRUE;
619 fSetRunNumberFromDataCalled = kTRUE;
621 AliCDBManager* man = AliCDBManager::Instance();
624 if(fRawReader->NextEvent()) {
625 if(man->GetRun() > 0) {
626 AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
628 man->SetRun(fRawReader->GetRunNumber());
629 fRawReader->RewindEvents();
632 if(man->GetRun() > 0) {
633 AliWarning("No raw-data events are found ! Using settings in AliCDBManager !");
636 AliWarning("Neither raw events nor settings in AliCDBManager are found !");
642 AliRunLoader *rl = AliRunLoader::Open(fGAliceFileName.Data());
644 AliError(Form("No run loader found in file %s", fGAliceFileName.Data()));
649 // read run number from gAlice
650 if(rl->GetHeader()) {
651 man->SetRun(rl->GetHeader()->GetRun());
656 AliError("Neither run-loader header nor RawReader objects are found !");
668 //_____________________________________________________________________________
669 void AliReconstruction::SetCDBLock() {
670 // Set CDB lock: from now on it is forbidden to reset the run number
671 // or the default storage or to activate any further storage!
673 AliCDBManager::Instance()->SetLock(1);
676 //_____________________________________________________________________________
677 Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
679 // Read the alignment objects from CDB.
680 // Each detector is supposed to have the
681 // alignment objects in DET/Align/Data CDB path.
682 // All the detector objects are then collected,
683 // sorted by geometry level (starting from ALIC) and
684 // then applied to the TGeo geometry.
685 // Finally an overlaps check is performed.
687 // Load alignment data from CDB and fill fAlignObjArray
688 if(fLoadAlignFromCDB){
690 TString detStr = detectors;
691 TString loadAlObjsListOfDets = "";
693 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
694 if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
695 if(!strcmp(fgkDetectorName[iDet],"HLT")) continue;
697 if(AliGeomManager::GetNalignable(fgkDetectorName[iDet]) != 0)
699 loadAlObjsListOfDets += fgkDetectorName[iDet];
700 loadAlObjsListOfDets += " ";
702 } // end loop over detectors
704 if(AliGeomManager::GetNalignable("GRP") != 0)
705 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
706 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
707 AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
709 // Check if the array with alignment objects was
710 // provided by the user. If yes, apply the objects
711 // to the present TGeo geometry
712 if (fAlignObjArray) {
713 if (gGeoManager && gGeoManager->IsClosed()) {
714 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
715 AliError("The misalignment of one or more volumes failed!"
716 "Compare the list of simulated detectors and the list of detector alignment data!");
721 AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
727 if (fAlignObjArray) {
728 fAlignObjArray->Delete();
729 delete fAlignObjArray; fAlignObjArray=NULL;
735 //_____________________________________________________________________________
736 void AliReconstruction::SetGAliceFile(const char* fileName)
738 // set the name of the galice file
740 fGAliceFileName = fileName;
743 //_____________________________________________________________________________
744 void AliReconstruction::SetInput(const char* input)
746 // In case the input string starts with 'mem://', we run in an online mode
747 // and AliRawReaderDateOnline object is created. In all other cases a raw-data
748 // file is assumed. One can give as an input:
749 // mem://: - events taken from DAQ monitoring libs online
751 // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
752 if (input) fRawInput = input;
755 //_____________________________________________________________________________
756 void AliReconstruction::SetOption(const char* detector, const char* option)
758 // set options for the reconstruction of a detector
760 TObject* obj = fOptions.FindObject(detector);
761 if (obj) fOptions.Remove(obj);
762 fOptions.Add(new TNamed(detector, option));
765 //_____________________________________________________________________________
766 void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam *par)
768 // Set custom reconstruction parameters for a given detector
769 // Single set of parameters for all the events
771 // First check if the reco-params are global
772 if(!strcmp(detector, "GRP")) {
774 fRecoParam.AddDetRecoParam(kNDetectors,par);
778 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
779 if(!strcmp(detector, fgkDetectorName[iDet])) {
781 fRecoParam.AddDetRecoParam(iDet,par);
788 //_____________________________________________________________________________
789 Bool_t AliReconstruction::SetFieldMap(Float_t l3Cur, Float_t diCur, Float_t l3Pol,
790 Float_t diPol, Float_t beamenergy,
791 const Char_t *beamtype, const Char_t *path)
793 //------------------------------------------------
794 // The magnetic field map, defined externally...
795 // L3 current 30000 A -> 0.5 T
796 // L3 current 12000 A -> 0.2 T
797 // dipole current 6000 A
798 // The polarities must be the same
799 //------------------------------------------------
800 const Float_t l3NominalCurrent1=30000.; // (A)
801 const Float_t l3NominalCurrent2=12000.; // (A)
802 const Float_t diNominalCurrent =6000. ; // (A)
804 const Float_t tolerance=0.03; // relative current tolerance
805 const Float_t zero=77.; // "zero" current (A)
807 TString s=(l3Pol < 0) ? "L3: -" : "L3: +";
809 AliMagF::BMap_t map = AliMagF::k5kG;
813 l3Cur = TMath::Abs(l3Cur);
814 if (TMath::Abs(l3Cur-l3NominalCurrent1)/l3NominalCurrent1 < tolerance) {
815 fcL3 = l3Cur/l3NominalCurrent1;
818 } else if (TMath::Abs(l3Cur-l3NominalCurrent2)/l3NominalCurrent2 < tolerance) {
819 fcL3 = l3Cur/l3NominalCurrent2;
822 } else if (l3Cur <= zero) {
824 map = AliMagF::k5kGUniform;
826 fUniformField=kTRUE; // track with the uniform (zero) B field
828 AliError(Form("Wrong L3 current (%f A)!",l3Cur));
832 diCur = TMath::Abs(diCur);
833 if (TMath::Abs(diCur-diNominalCurrent)/diNominalCurrent < tolerance) {
834 // 3% current tolerance...
835 fcDip = diCur/diNominalCurrent;
837 } else if (diCur <= zero) { // some small current..
841 AliError(Form("Wrong dipole current (%f A)!",diCur));
845 if (l3Pol!=diPol && (map==AliMagF::k5kG || map==AliMagF::k2kG) && fcDip!=0) {
846 AliError("L3 and Dipole polarities must be the same");
850 if (l3Pol<0) fcL3 = -fcL3;
851 if (diPol<0) fcDip = -fcDip;
853 AliMagF::BeamType_t btype = AliMagF::kNoBeamField;
854 TString btypestr = beamtype;
856 TPRegexp protonBeam("(proton|p)\\s*-?\\s*\\1");
857 TPRegexp ionBeam("(lead|pb|ion|a)\\s*-?\\s*\\1");
858 if (btypestr.Contains(ionBeam)) btype = AliMagF::kBeamTypeAA;
859 else if (btypestr.Contains(protonBeam)) btype = AliMagF::kBeamTypepp;
861 AliInfo(Form("Cannot determine the beam type from %s, assume no LHC magnet field",beamtype));
864 AliMagF* fld = new AliMagF("MagneticFieldMap", s.Data(), 2, fcL3, fcDip, 10., map, path,
865 btype,beamenergy,kTRUE);
866 TGeoGlobalMagField::Instance()->SetField( fld );
867 TGeoGlobalMagField::Instance()->Lock();
873 Bool_t AliReconstruction::InitGRP() {
874 //------------------------------------
875 // Initialization of the GRP entry
876 //------------------------------------
877 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
881 TMap* m = dynamic_cast<TMap*>(entry->GetObject()); // old GRP entry
884 AliInfo("Found a TMap in GRP/GRP/Data, converting it into an AliGRPObject");
886 fGRPData = new AliGRPObject();
887 fGRPData->ReadValuesFromMap(m);
891 AliInfo("Found an AliGRPObject in GRP/GRP/Data, reading it");
892 fGRPData = dynamic_cast<AliGRPObject*>(entry->GetObject()); // new GRP entry
896 AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
900 AliError("No GRP entry found in OCDB!");
904 TString lhcState = fGRPData->GetLHCState();
905 if (lhcState==AliGRPObject::GetInvalidString()) {
906 AliError("GRP/GRP/Data entry: missing value for the LHC state ! Using UNKNOWN");
907 lhcState = "UNKNOWN";
910 TString beamType = fGRPData->GetBeamType();
911 if (beamType==AliGRPObject::GetInvalidString()) {
912 AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN");
913 beamType = "UNKNOWN";
916 Float_t beamEnergy = fGRPData->GetBeamEnergy();
917 if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
918 AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
921 // energy is provided in MeV*120
924 TString runType = fGRPData->GetRunType();
925 if (runType==AliGRPObject::GetInvalidString()) {
926 AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN");
930 Int_t activeDetectors = fGRPData->GetDetectorMask();
931 if (activeDetectors==AliGRPObject::GetInvalidUInt()) {
932 AliError("GRP/GRP/Data entry: missing value for the detector mask ! Using 1074790399");
933 activeDetectors = 1074790399;
936 fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
937 printf("qqqqqqqqqqqqqqqqqqqqqqq %s %s %f %s %d\n", lhcState.Data(), beamType.Data(), beamEnergy, runType.Data(), activeDetectors);
941 // Process the list of active detectors
942 if (activeDetectors) {
943 UInt_t detMask = activeDetectors;
944 fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
945 fRunTracking = MatchDetectorList(fRunTracking,detMask);
946 fFillESD = MatchDetectorList(fFillESD,detMask);
947 fQADetectors = MatchDetectorList(fQADetectors,detMask);
948 fLoadCDB.Form("%s %s %s %s",
949 fRunLocalReconstruction.Data(),
952 fQADetectors.Data());
953 fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
954 if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1)) {
955 // switch off the vertexer
956 AliInfo("SPD is not in the list of active detectors. Vertexer switched off.");
957 fRunVertexFinder = kFALSE;
959 if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) {
960 // switch off the reading of CTP raw-data payload
961 if (fFillTriggerESD) {
962 AliInfo("CTP is not in the list of active detectors. CTP data reading switched off.");
963 fFillTriggerESD = kFALSE;
968 AliInfo("===================================================================================");
969 AliInfo(Form("Running local reconstruction for detectors: %s",fRunLocalReconstruction.Data()));
970 AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data()));
971 AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data()));
972 AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data()));
973 AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data()));
974 AliInfo("===================================================================================");
976 //*** Dealing with the magnetic field map
977 if ( TGeoGlobalMagField::Instance()->IsLocked() ) {AliInfo("Running with the externally locked B field !");}
979 // Construct the field map out of the information retrieved from GRP.
982 Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0);
983 if (l3Current == AliGRPObject::GetInvalidFloat()) {
984 AliError("GRP/GRP/Data entry: missing value for the L3 current !");
988 Char_t l3Polarity = fGRPData->GetL3Polarity();
989 if (l3Polarity == AliGRPObject::GetInvalidChar()) {
990 AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
995 Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0);
996 if (diCurrent == AliGRPObject::GetInvalidFloat()) {
997 AliError("GRP/GRP/Data entry: missing value for the dipole current !");
1001 Char_t diPolarity = fGRPData->GetDipolePolarity();
1002 if (diPolarity == AliGRPObject::GetInvalidChar()) {
1003 AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
1008 TObjString *l3Current=
1009 dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Current"));
1011 AliError("GRP/GRP/Data entry: missing value for the L3 current !");
1014 TObjString *l3Polarity=
1015 dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Polarity"));
1017 AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
1022 TObjString *diCurrent=
1023 dynamic_cast<TObjString*>(fGRPData->GetValue("fDipoleCurrent"));
1025 AliError("GRP/GRP/Data entry: missing value for the dipole current !");
1028 TObjString *diPolarity=
1029 dynamic_cast<TObjString*>(fGRPData->GetValue("fDipolePolarity"));
1031 AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
1037 if ( !SetFieldMap(l3Current, diCurrent, l3Polarity ? -1:1, diPolarity ? -1:1) )
1038 AliFatal("Failed to creat a B field map ! Exiting...");
1039 AliInfo("Running with the B field constructed out of GRP !");
1041 else AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
1045 //*** Get the diamond profiles from OCDB
1046 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1048 fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
1050 AliError("No SPD diamond profile found in OCDB!");
1053 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1055 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
1057 AliError("No diamond profile found in OCDB!");
1060 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1062 fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
1064 AliError("No TPC diamond profile found in OCDB!");
1070 //_____________________________________________________________________________
1071 Bool_t AliReconstruction::LoadCDB()
1073 AliCodeTimerAuto("");
1075 AliCDBManager::Instance()->Get("GRP/CTP/Config");
1077 TString detStr = fLoadCDB;
1078 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1079 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1080 AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
1085 //_____________________________________________________________________________
1086 Bool_t AliReconstruction::Run(const char* input)
1089 AliCodeTimerAuto("");
1092 if (GetAbort() != TSelector::kContinue) return kFALSE;
1094 TChain *chain = NULL;
1095 if (fRawReader && (chain = fRawReader->GetChain())) {
1098 gProof->AddInput(this);
1100 outputFile.SetProtocol("root",kTRUE);
1101 outputFile.SetHost(gSystem->HostName());
1102 outputFile.SetFile(Form("%s/AliESDs.root",gSystem->pwd()));
1103 AliInfo(Form("Output file with ESDs is %s",outputFile.GetUrl()));
1104 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",outputFile.GetUrl()));
1106 chain->Process("AliReconstruction");
1109 chain->Process(this);
1114 if (GetAbort() != TSelector::kContinue) return kFALSE;
1116 if (GetAbort() != TSelector::kContinue) return kFALSE;
1117 //******* The loop over events
1118 AliInfo("Starting looping over events");
1120 while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
1121 (fRawReader && fRawReader->NextEvent())) {
1122 if (!ProcessEvent(iEvent)) {
1123 Abort("ProcessEvent",TSelector::kAbortFile);
1129 if (GetAbort() != TSelector::kContinue) return kFALSE;
1131 if (GetAbort() != TSelector::kContinue) return kFALSE;
1137 //_____________________________________________________________________________
1138 void AliReconstruction::InitRawReader(const char* input)
1140 AliCodeTimerAuto("");
1142 // Init raw-reader and
1143 // set the input in case of raw data
1144 if (input) fRawInput = input;
1145 fRawReader = AliRawReader::Create(fRawInput.Data());
1147 AliInfo("Reconstruction will run over digits");
1149 if (!fEquipIdMap.IsNull() && fRawReader)
1150 fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1152 if (!fUseHLTData.IsNull()) {
1153 // create the RawReaderHLT which performs redirection of HLT input data for
1154 // the specified detectors
1155 AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
1157 fParentRawReader=fRawReader;
1158 fRawReader=pRawReader;
1160 AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
1163 AliSysInfo::AddStamp("CreateRawReader");
1166 //_____________________________________________________________________________
1167 void AliReconstruction::InitRun(const char* input)
1169 // Initialization of raw-reader,
1170 // run number, CDB etc.
1171 AliCodeTimerAuto("");
1172 AliSysInfo::AddStamp("Start");
1174 // Initialize raw-reader if any
1175 InitRawReader(input);
1177 // Initialize the CDB storage
1180 // Set run number in CDBManager (if it is not already set by the user)
1181 if (!SetRunNumberFromData()) {
1182 Abort("SetRunNumberFromData", TSelector::kAbortProcess);
1186 // Set CDB lock: from now on it is forbidden to reset the run number
1187 // or the default storage or to activate any further storage!
1192 //_____________________________________________________________________________
1193 void AliReconstruction::Begin(TTree *)
1195 // Initialize AlReconstruction before
1196 // going into the event loop
1197 // Should follow the TSelector convention
1198 // i.e. initialize only the object on the client side
1199 AliCodeTimerAuto("");
1201 AliReconstruction *reco = NULL;
1203 if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
1206 AliSysInfo::AddStamp("ReadInputInBegin");
1209 // Import ideal TGeo geometry and apply misalignment
1211 TString geom(gSystem->DirName(fGAliceFileName));
1212 geom += "/geometry.root";
1213 AliGeomManager::LoadGeometry(geom.Data());
1215 Abort("LoadGeometry", TSelector::kAbortProcess);
1218 AliSysInfo::AddStamp("LoadGeom");
1219 TString detsToCheck=fRunLocalReconstruction;
1220 if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) {
1221 Abort("CheckSymNamesLUT", TSelector::kAbortProcess);
1224 AliSysInfo::AddStamp("CheckGeom");
1227 if (!MisalignGeometry(fLoadAlignData)) {
1228 Abort("MisalignGeometry", TSelector::kAbortProcess);
1231 AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
1232 AliSysInfo::AddStamp("MisalignGeom");
1235 Abort("InitGRP", TSelector::kAbortProcess);
1238 AliSysInfo::AddStamp("InitGRP");
1241 Abort("LoadCDB", TSelector::kAbortProcess);
1244 AliSysInfo::AddStamp("LoadCDB");
1246 // Read the reconstruction parameters from OCDB
1247 if (!InitRecoParams()) {
1248 AliWarning("Not all detectors have correct RecoParam objects initialized");
1250 AliSysInfo::AddStamp("InitRecoParams");
1253 if (reco) *reco = *this;
1254 fInput->Add(gGeoManager);
1256 fInput->Add(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()));
1257 fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
1258 AliMagF *magFieldMap = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
1259 magFieldMap->SetName("MagneticFieldMap");
1260 fInput->Add(magFieldMap);
1265 //_____________________________________________________________________________
1266 void AliReconstruction::SlaveBegin(TTree*)
1268 // Initialization related to run-loader,
1269 // vertexer, trackers, recontructors
1270 // In proof mode it is executed on the slave
1271 AliCodeTimerAuto("");
1273 TProofOutputFile *outProofFile = NULL;
1275 if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
1278 if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) {
1280 AliGeomManager::SetGeometry(tgeo);
1282 if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) {
1283 Int_t runNumber = -1;
1284 if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) {
1285 AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber);
1286 man->SetCacheFlag(kTRUE);
1287 man->SetLock(kTRUE);
1291 if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
1292 TGeoGlobalMagField::Instance()->SetField(map);
1294 if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) {
1295 outProofFile = new TProofOutputFile(gSystem->BaseName(TUrl(outputFileName->GetTitle()).GetFile()));
1296 outProofFile->SetOutputFileName(outputFileName->GetTitle());
1297 fOutput->Add(outProofFile);
1299 AliSysInfo::AddStamp("ReadInputInSlaveBegin");
1302 // get the run loader
1303 if (!InitRunLoader()) {
1304 Abort("InitRunLoader", TSelector::kAbortProcess);
1307 AliSysInfo::AddStamp("LoadLoader");
1309 ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
1312 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
1313 Abort("CreateTrackers", TSelector::kAbortProcess);
1316 AliSysInfo::AddStamp("CreateTrackers");
1318 // create the ESD output file and tree
1319 if (!outProofFile) {
1320 ffile = TFile::Open("AliESDs.root", "RECREATE");
1321 ffile->SetCompressionLevel(2);
1322 if (!ffile->IsOpen()) {
1323 Abort("OpenESDFile", TSelector::kAbortProcess);
1328 if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
1329 Abort(Form("Problems opening output PROOF file: %s/%s",
1330 outProofFile->GetDir(), outProofFile->GetFileName()),
1331 TSelector::kAbortProcess);
1336 ftree = new TTree("esdTree", "Tree with ESD objects");
1337 fesd = new AliESDEvent();
1338 fesd->CreateStdContent();
1340 fesd->WriteToTree(ftree);
1341 if (fWriteESDfriend) {
1343 // Since we add the branch manually we must
1344 // book and add it after WriteToTree
1345 // otherwise it is created twice,
1346 // once via writetotree and once here.
1347 // The case for AliESDfriend is now
1348 // caught also in AlIESDEvent::WriteToTree but
1349 // be careful when changing the name (AliESDfriend is not
1350 // a TNamed so we had to hardwire it)
1351 fesdf = new AliESDfriend();
1352 TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
1353 br->SetFile("AliESDfriends.root");
1354 fesd->AddObject(fesdf);
1356 ftree->GetUserInfo()->Add(fesd);
1358 fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
1359 fhltesd = new AliESDEvent();
1360 fhltesd->CreateStdContent();
1362 // read the ESD template from CDB
1363 // HLT is allowed to put non-std content to its ESD, the non-std
1364 // objects need to be created before invocation of WriteToTree in
1365 // order to create all branches. Initialization is done from an
1366 // ESD layout template in CDB
1367 AliCDBManager* man = AliCDBManager::Instance();
1368 AliCDBPath hltESDConfigPath("HLT/ConfigHLT/esdLayout");
1369 AliCDBEntry* hltESDConfig=NULL;
1370 if (man->GetId(hltESDConfigPath)!=NULL &&
1371 (hltESDConfig=man->Get(hltESDConfigPath))!=NULL) {
1372 AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
1374 // init all internal variables from the list of objects
1375 pESDLayout->GetStdContent();
1377 // copy content and create non-std objects
1378 *fhltesd=*pESDLayout;
1381 AliError(Form("error setting hltEsd layout from %s: invalid object type",
1382 hltESDConfigPath.GetPath().Data()));
1386 fhltesd->WriteToTree(fhlttree);
1387 fhlttree->GetUserInfo()->Add(fhltesd);
1389 ProcInfo_t procInfo;
1390 gSystem->GetProcInfo(&procInfo);
1391 AliInfo(Form("Current memory usage %d %d", procInfo.fMemResident, procInfo.fMemVirtual));
1394 //Initialize the QA and start of cycle
1396 fQASteer = new AliQADataMakerSteer("rec") ;
1397 fQASteer->SetActiveDetectors(fQADetectors) ;
1398 for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
1399 fQASteer->SetCycleLength(AliQA::DETECTORINDEX_t(det), fQACycles[det]) ;
1400 fQASteer->SetWriteExpert(AliQA::DETECTORINDEX_t(det)) ;
1402 if (!fRawReader && fQATasks.Contains(AliQA::kRAWS))
1403 fQATasks.ReplaceAll(Form("%d",AliQA::kRAWS), "") ;
1404 fQASteer->SetTasks(fQATasks) ;
1405 fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ;
1409 Bool_t sameCycle = kFALSE ;
1410 if (!fQASteer) fQASteer = new AliQADataMakerSteer("rec") ;
1411 AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
1412 AliInfo(Form("Initializing the global QA data maker"));
1413 if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
1414 qadm->StartOfCycle(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
1415 TObjArray **arr=qadm->Init(AliQA::kRECPOINTS);
1416 AliTracker::SetResidualsArray(arr);
1419 if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
1420 qadm->StartOfCycle(AliQA::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
1421 qadm->Init(AliQA::kESDS);
1425 //Initialize the Plane Efficiency framework
1426 if (fRunPlaneEff && !InitPlaneEff()) {
1427 Abort("InitPlaneEff", TSelector::kAbortProcess);
1431 if (strcmp(gProgName,"alieve") == 0)
1432 fRunAliEVE = InitAliEVE();
1437 //_____________________________________________________________________________
1438 Bool_t AliReconstruction::Process(Long64_t entry)
1440 // run the reconstruction over a single entry
1441 // from the chain with raw data
1442 AliCodeTimerAuto("");
1444 TTree *currTree = fChain->GetTree();
1445 AliRawEvent *event = new AliRawEvent;
1446 currTree->SetBranchAddress("rawevent",&event);
1447 currTree->GetEntry(entry);
1448 fRawReader = new AliRawReaderRoot(event);
1449 fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
1457 //_____________________________________________________________________________
1458 void AliReconstruction::Init(TTree *tree)
1461 AliError("The input tree is not found!");
1467 //_____________________________________________________________________________
1468 Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
1470 // run the reconstruction over a single event
1471 // The event loop is steered in Run method
1473 AliCodeTimerAuto("");
1475 if (iEvent >= fRunLoader->GetNumberOfEvents()) {
1476 fRunLoader->SetEventNumber(iEvent);
1477 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
1479 fRunLoader->TreeE()->Fill();
1480 if (fRawReader && fRawReader->UseAutoSaveESD())
1481 fRunLoader->TreeE()->AutoSave("SaveSelf");
1484 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
1488 AliInfo(Form("processing event %d", iEvent));
1490 fRunLoader->GetEvent(iEvent);
1492 // Fill Event-info object
1494 fRecoParam.SetEventSpecie(fRunInfo,fEventInfo);
1495 AliInfo(Form("Current event specie: %s",fRecoParam.PrintEventSpecie()));
1497 // Set the reco-params
1499 TString detStr = fLoadCDB;
1500 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1501 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1502 AliReconstructor *reconstructor = GetReconstructor(iDet);
1503 if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
1504 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
1505 reconstructor->SetRecoParam(par);
1507 fQASteer->SetRecoParam(iDet, par) ;
1515 fQASteer->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1516 fQASteer->RunOneEvent(fRawReader) ;
1518 // local single event reconstruction
1519 if (!fRunLocalReconstruction.IsNull()) {
1520 TString detectors=fRunLocalReconstruction;
1521 // run HLT event reconstruction first
1522 // ;-( IsSelected changes the string
1523 if (IsSelected("HLT", detectors) &&
1524 !RunLocalEventReconstruction("HLT")) {
1525 if (fStopOnError) {CleanUp(); return kFALSE;}
1527 detectors=fRunLocalReconstruction;
1528 detectors.ReplaceAll("HLT", "");
1529 if (!RunLocalEventReconstruction(detectors)) {
1530 if (fStopOnError) {CleanUp(); return kFALSE;}
1534 fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1535 fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1536 fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1537 fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1539 // Set magnetic field from the tracker
1540 fesd->SetMagneticField(AliTracker::GetBz());
1541 fhltesd->SetMagneticField(AliTracker::GetBz());
1543 // Set most probable pt, for B=0 tracking
1544 // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
1545 const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
1546 if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
1548 // Fill raw-data error log into the ESD
1549 if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
1552 if (fRunVertexFinder) {
1553 if (!RunVertexFinder(fesd)) {
1554 if (fStopOnError) {CleanUp(); return kFALSE;}
1559 if (!fRunTracking.IsNull()) {
1560 if (fRunMuonTracking) {
1561 if (!RunMuonTracking(fesd)) {
1562 if (fStopOnError) {CleanUp(); return kFALSE;}
1568 if (!fRunTracking.IsNull()) {
1569 if (!RunTracking(fesd)) {
1570 if (fStopOnError) {CleanUp(); return kFALSE;}
1575 if (!fFillESD.IsNull()) {
1576 TString detectors=fFillESD;
1577 // run HLT first and on hltesd
1578 // ;-( IsSelected changes the string
1579 if (IsSelected("HLT", detectors) &&
1580 !FillESD(fhltesd, "HLT")) {
1581 if (fStopOnError) {CleanUp(); return kFALSE;}
1584 // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
1585 if (detectors.Contains("ALL")) {
1587 for (Int_t idet=0; idet<kNDetectors; ++idet){
1588 detectors += fgkDetectorName[idet];
1592 detectors.ReplaceAll("HLT", "");
1593 if (!FillESD(fesd, detectors)) {
1594 if (fStopOnError) {CleanUp(); return kFALSE;}
1598 // fill Event header information from the RawEventHeader
1599 if (fRawReader){FillRawEventHeaderESD(fesd);}
1602 AliESDpid::MakePID(fesd);
1604 if (fFillTriggerESD) {
1605 if (!FillTriggerESD(fesd)) {
1606 if (fStopOnError) {CleanUp(); return kFALSE;}
1613 // Propagate track to the beam pipe (if not already done by ITS)
1615 const Int_t ntracks = fesd->GetNumberOfTracks();
1616 const Double_t kBz = fesd->GetMagneticField();
1617 const Double_t kRadius = 2.8; //something less than the beam pipe radius
1620 UShort_t *selectedIdx=new UShort_t[ntracks];
1622 for (Int_t itrack=0; itrack<ntracks; itrack++){
1623 const Double_t kMaxStep = 1; //max step over the material
1626 AliESDtrack *track = fesd->GetTrack(itrack);
1627 if (!track) continue;
1629 AliExternalTrackParam *tpcTrack =
1630 (AliExternalTrackParam *)track->GetTPCInnerParam();
1634 PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
1637 Int_t n=trkArray.GetEntriesFast();
1638 selectedIdx[n]=track->GetID();
1639 trkArray.AddLast(tpcTrack);
1642 //Tracks refitted by ITS should already be at the SPD vertex
1643 if (track->IsOn(AliESDtrack::kITSrefit)) continue;
1646 PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
1647 track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kVeryBig);
1652 // Improve the reconstructed primary vertex position using the tracks
1654 Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
1655 if(fesd->GetPrimaryVertexSPD()) {
1656 TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
1657 if(vtitle.Contains("cosmics")) {
1658 runVertexFinderTracks=kFALSE;
1662 if (runVertexFinderTracks) {
1663 // TPC + ITS primary vertex
1664 ftVertexer->SetITSMode();
1665 ftVertexer->SetConstraintOff();
1666 // get cuts for vertexer from AliGRPRecoParam
1668 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1669 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1670 grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer);
1671 ftVertexer->SetCuts(cutsVertexer);
1672 delete [] cutsVertexer; cutsVertexer = NULL;
1673 if(fDiamondProfile && grpRecoParam->GetVertexerTracksConstraintITS())
1674 ftVertexer->SetVtxStart(fDiamondProfile);
1676 AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
1678 if (pvtx->GetStatus()) {
1679 fesd->SetPrimaryVertexTracks(pvtx);
1680 for (Int_t i=0; i<ntracks; i++) {
1681 AliESDtrack *t = fesd->GetTrack(i);
1682 t->RelateToVertex(pvtx, kBz, kVeryBig);
1687 // TPC-only primary vertex
1688 ftVertexer->SetTPCMode();
1689 ftVertexer->SetConstraintOff();
1690 // get cuts for vertexer from AliGRPRecoParam
1692 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1693 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1694 grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer);
1695 ftVertexer->SetCuts(cutsVertexer);
1696 delete [] cutsVertexer; cutsVertexer = NULL;
1697 if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC())
1698 ftVertexer->SetVtxStart(fDiamondProfileTPC);
1700 pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
1702 if (pvtx->GetStatus()) {
1703 fesd->SetPrimaryVertexTPC(pvtx);
1704 for (Int_t i=0; i<ntracks; i++) {
1705 AliESDtrack *t = fesd->GetTrack(i);
1706 t->RelateToVertexTPC(pvtx, kBz, kVeryBig);
1712 delete[] selectedIdx;
1714 if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
1719 AliV0vertexer vtxer;
1720 vtxer.Tracks2V0vertices(fesd);
1722 if (fRunCascadeFinder) {
1724 AliCascadeVertexer cvtxer;
1725 cvtxer.V0sTracks2CascadeVertices(fesd);
1730 if (fCleanESD) CleanESD(fesd);
1733 fQASteer->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1734 fQASteer->RunOneEvent(fesd) ;
1737 AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
1738 qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1739 if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS)))
1740 qadm->Exec(AliQA::kESDS, fesd);
1743 if (fWriteESDfriend) {
1744 // fesdf->~AliESDfriend();
1745 // new (fesdf) AliESDfriend(); // Reset...
1746 fesd->GetESDfriend(fesdf);
1750 // Auto-save the ESD tree in case of prompt reco @P2
1751 if (fRawReader && fRawReader->UseAutoSaveESD()) {
1752 ftree->AutoSave("SaveSelf");
1753 TFile *friendfile = (TFile *)(gROOT->GetListOfFiles()->FindObject("AliESDfriends.root"));
1754 if (friendfile) friendfile->Save();
1761 if (fRunAliEVE) RunAliEVE();
1765 if (fWriteESDfriend) {
1766 fesdf->~AliESDfriend();
1767 new (fesdf) AliESDfriend(); // Reset...
1770 ProcInfo_t procInfo;
1771 gSystem->GetProcInfo(&procInfo);
1772 AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, procInfo.fMemResident, procInfo.fMemVirtual));
1775 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1776 if (fReconstructor[iDet])
1777 fReconstructor[iDet]->SetRecoParam(NULL);
1780 if (fRunQA || fRunGlobalQA)
1781 fQASteer->Increment() ;
1786 //_____________________________________________________________________________
1787 void AliReconstruction::SlaveTerminate()
1789 // Finalize the run on the slave side
1790 // Called after the exit
1791 // from the event loop
1792 AliCodeTimerAuto("");
1794 if (fIsNewRunLoader) { // galice.root didn't exist
1795 fRunLoader->WriteHeader("OVERWRITE");
1796 fRunLoader->CdGAFile();
1797 fRunLoader->Write(0, TObject::kOverwrite);
1800 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
1801 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
1803 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
1804 cdbMapCopy->SetOwner(1);
1805 cdbMapCopy->SetName("cdbMap");
1806 TIter iter(cdbMap->GetTable());
1809 while((pair = dynamic_cast<TPair*> (iter.Next()))){
1810 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
1811 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
1812 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
1815 TList *cdbListCopy = new TList();
1816 cdbListCopy->SetOwner(1);
1817 cdbListCopy->SetName("cdbList");
1819 TIter iter2(cdbList);
1822 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
1823 cdbListCopy->Add(new TObjString(id->ToString().Data()));
1826 ftree->GetUserInfo()->Add(cdbMapCopy);
1827 ftree->GetUserInfo()->Add(cdbListCopy);
1832 if (fWriteESDfriend)
1833 ftree->SetBranchStatus("ESDfriend*",0);
1834 // we want to have only one tree version number
1835 ftree->Write(ftree->GetName(),TObject::kOverwrite);
1838 // Finish with Plane Efficiency evaluation: before of CleanUp !!!
1839 if (fRunPlaneEff && !FinishPlaneEff()) {
1840 AliWarning("Finish PlaneEff evaluation failed");
1843 // End of cycle for the in-loop
1845 fQASteer->EndOfCycle() ;
1848 AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
1850 if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
1851 qadm->EndOfCycle(AliQA::kRECPOINTS);
1852 if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
1853 qadm->EndOfCycle(AliQA::kESDS);
1861 //_____________________________________________________________________________
1862 void AliReconstruction::Terminate()
1864 // Create tags for the events in the ESD tree (the ESD tree is always present)
1865 // In case of empty events the tags will contain dummy values
1866 AliCodeTimerAuto("");
1868 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
1869 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQA::Instance()->GetQA(), AliQA::Instance()->GetEventSpecies(), AliQA::kNDET, AliRecoParam::kNSpecies);
1871 // Cleanup of CDB manager: cache and active storages!
1872 AliCDBManager::Instance()->ClearCache();
1875 //_____________________________________________________________________________
1876 Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
1878 // run the local reconstruction
1880 static Int_t eventNr=0;
1881 AliCodeTimerAuto("")
1883 TString detStr = detectors;
1884 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1885 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1886 AliReconstructor* reconstructor = GetReconstructor(iDet);
1887 if (!reconstructor) continue;
1888 AliLoader* loader = fLoader[iDet];
1889 // Matthias April 2008: temporary fix to run HLT reconstruction
1890 // although the HLT loader is missing
1891 if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
1893 reconstructor->Reconstruct(fRawReader, NULL);
1896 reconstructor->Reconstruct(dummy, NULL);
1901 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
1904 // conversion of digits
1905 if (fRawReader && reconstructor->HasDigitConversion()) {
1906 AliInfo(Form("converting raw data digits into root objects for %s",
1907 fgkDetectorName[iDet]));
1908 // AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
1909 // fgkDetectorName[iDet]));
1910 loader->LoadDigits("update");
1911 loader->CleanDigits();
1912 loader->MakeDigitsContainer();
1913 TTree* digitsTree = loader->TreeD();
1914 reconstructor->ConvertDigits(fRawReader, digitsTree);
1915 loader->WriteDigits("OVERWRITE");
1916 loader->UnloadDigits();
1918 // local reconstruction
1919 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1920 //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1921 loader->LoadRecPoints("update");
1922 loader->CleanRecPoints();
1923 loader->MakeRecPointsContainer();
1924 TTree* clustersTree = loader->TreeR();
1925 if (fRawReader && !reconstructor->HasDigitConversion()) {
1926 reconstructor->Reconstruct(fRawReader, clustersTree);
1928 loader->LoadDigits("read");
1929 TTree* digitsTree = loader->TreeD();
1931 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
1932 if (fStopOnError) return kFALSE;
1934 reconstructor->Reconstruct(digitsTree, clustersTree);
1936 loader->UnloadDigits();
1939 TString detQAStr(fQADetectors) ;
1941 fQASteer->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1942 fQASteer->RunOneEventInOneDetector(iDet, clustersTree) ;
1944 loader->WriteRecPoints("OVERWRITE");
1945 loader->UnloadRecPoints();
1946 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
1948 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1949 AliError(Form("the following detectors were not found: %s",
1951 if (fStopOnError) return kFALSE;
1957 //_____________________________________________________________________________
1958 Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
1960 // run the barrel tracking
1962 AliCodeTimerAuto("")
1964 AliVertexer *vertexer = CreateVertexer();
1965 if (!vertexer) return kFALSE;
1967 AliInfo("running the ITS vertex finder");
1968 AliESDVertex* vertex = NULL;
1970 fLoader[0]->LoadRecPoints();
1971 TTree* cltree = fLoader[0]->TreeR();
1973 if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
1974 vertex = vertexer->FindVertexForCurrentEvent(cltree);
1977 AliError("Can't get the ITS cluster tree");
1979 fLoader[0]->UnloadRecPoints();
1982 AliError("Can't get the ITS loader");
1985 AliWarning("Vertex not found");
1986 vertex = new AliESDVertex();
1987 vertex->SetName("default");
1990 vertex->SetName("reconstructed");
1995 vertex->GetXYZ(vtxPos);
1996 vertex->GetSigmaXYZ(vtxErr);
1998 esd->SetPrimaryVertexSPD(vertex);
1999 // if SPD multiplicity has been determined, it is stored in the ESD
2000 AliMultiplicity *mult = vertexer->GetMultiplicity();
2001 if(mult)esd->SetMultiplicity(mult);
2003 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2004 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
2013 //_____________________________________________________________________________
2014 Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
2016 // run the HLT barrel tracking
2018 AliCodeTimerAuto("")
2021 AliError("Missing runLoader!");
2025 AliInfo("running HLT tracking");
2027 // Get a pointer to the HLT reconstructor
2028 AliReconstructor *reconstructor = GetReconstructor(kNDetectors-1);
2029 if (!reconstructor) return kFALSE;
2032 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2033 TString detName = fgkDetectorName[iDet];
2034 AliDebug(1, Form("%s HLT tracking", detName.Data()));
2035 reconstructor->SetOption(detName.Data());
2036 AliTracker *tracker = reconstructor->CreateTracker();
2038 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
2039 if (fStopOnError) return kFALSE;
2043 Double_t vtxErr[3]={0.005,0.005,0.010};
2044 const AliESDVertex *vertex = esd->GetVertex();
2045 vertex->GetXYZ(vtxPos);
2046 tracker->SetVertex(vtxPos,vtxErr);
2048 fLoader[iDet]->LoadRecPoints("read");
2049 TTree* tree = fLoader[iDet]->TreeR();
2051 AliError(Form("Can't get the %s cluster tree", detName.Data()));
2054 tracker->LoadClusters(tree);
2056 if (tracker->Clusters2Tracks(esd) != 0) {
2057 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
2061 tracker->UnloadClusters();
2069 //_____________________________________________________________________________
2070 Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
2072 // run the muon spectrometer tracking
2074 AliCodeTimerAuto("")
2077 AliError("Missing runLoader!");
2080 Int_t iDet = 7; // for MUON
2082 AliInfo("is running...");
2084 // Get a pointer to the MUON reconstructor
2085 AliReconstructor *reconstructor = GetReconstructor(iDet);
2086 if (!reconstructor) return kFALSE;
2089 TString detName = fgkDetectorName[iDet];
2090 AliDebug(1, Form("%s tracking", detName.Data()));
2091 AliTracker *tracker = reconstructor->CreateTracker();
2093 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2098 fLoader[iDet]->LoadRecPoints("read");
2100 tracker->LoadClusters(fLoader[iDet]->TreeR());
2102 Int_t rv = tracker->Clusters2Tracks(esd);
2106 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2110 fLoader[iDet]->UnloadRecPoints();
2112 tracker->UnloadClusters();
2120 //_____________________________________________________________________________
2121 Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
2123 // run the barrel tracking
2124 static Int_t eventNr=0;
2125 AliCodeTimerAuto("")
2127 AliInfo("running tracking");
2129 //Fill the ESD with the T0 info (will be used by the TOF)
2130 if (fReconstructor[11] && fLoader[11]) {
2131 fLoader[11]->LoadRecPoints("READ");
2132 TTree *treeR = fLoader[11]->TreeR();
2134 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
2138 // pass 1: TPC + ITS inwards
2139 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2140 if (!fTracker[iDet]) continue;
2141 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
2144 fLoader[iDet]->LoadRecPoints("read");
2145 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
2146 TTree* tree = fLoader[iDet]->TreeR();
2148 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2151 fTracker[iDet]->LoadClusters(tree);
2152 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
2154 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
2155 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2158 // preliminary PID in TPC needed by the ITS tracker
2160 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2161 AliESDpid::MakePID(esd);
2163 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
2166 // pass 2: ALL backwards
2168 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2169 if (!fTracker[iDet]) continue;
2170 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
2173 if (iDet > 1) { // all except ITS, TPC
2175 fLoader[iDet]->LoadRecPoints("read");
2176 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
2177 tree = fLoader[iDet]->TreeR();
2179 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2182 fTracker[iDet]->LoadClusters(tree);
2183 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
2187 if (iDet>1) // start filling residuals for the "outer" detectors
2188 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2190 if (fTracker[iDet]->PropagateBack(esd) != 0) {
2191 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
2196 if (iDet > 3) { // all except ITS, TPC, TRD and TOF
2197 fTracker[iDet]->UnloadClusters();
2198 fLoader[iDet]->UnloadRecPoints();
2200 // updated PID in TPC needed by the ITS tracker -MI
2202 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2203 AliESDpid::MakePID(esd);
2205 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
2207 //stop filling residuals for the "outer" detectors
2208 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
2210 // pass 3: TRD + TPC + ITS refit inwards
2212 for (Int_t iDet = 2; iDet >= 0; iDet--) {
2213 if (!fTracker[iDet]) continue;
2214 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
2217 if (iDet<2) // start filling residuals for TPC and ITS
2218 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2220 if (fTracker[iDet]->RefitInward(esd) != 0) {
2221 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
2224 // run postprocessing
2225 if (fTracker[iDet]->PostProcess(esd) != 0) {
2226 AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
2229 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
2232 // write space-points to the ESD in case alignment data output
2234 if (fWriteAlignmentData)
2235 WriteAlignmentData(esd);
2237 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2238 if (!fTracker[iDet]) continue;
2240 fTracker[iDet]->UnloadClusters();
2241 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
2242 fLoader[iDet]->UnloadRecPoints();
2243 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
2245 // stop filling residuals for TPC and ITS
2246 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
2252 //_____________________________________________________________________________
2253 Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
2255 // Remove the data which are not needed for the physics analysis.
2258 Int_t nTracks=esd->GetNumberOfTracks();
2259 Int_t nV0s=esd->GetNumberOfV0s();
2261 (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
2263 Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
2264 Bool_t rc=esd->Clean(cleanPars);
2266 nTracks=esd->GetNumberOfTracks();
2267 nV0s=esd->GetNumberOfV0s();
2269 (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
2274 //_____________________________________________________________________________
2275 Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
2277 // fill the event summary data
2279 AliCodeTimerAuto("")
2280 static Int_t eventNr=0;
2281 TString detStr = detectors;
2283 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2284 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2285 AliReconstructor* reconstructor = GetReconstructor(iDet);
2286 if (!reconstructor) continue;
2287 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
2288 TTree* clustersTree = NULL;
2289 if (fLoader[iDet]) {
2290 fLoader[iDet]->LoadRecPoints("read");
2291 clustersTree = fLoader[iDet]->TreeR();
2292 if (!clustersTree) {
2293 AliError(Form("Can't get the %s clusters tree",
2294 fgkDetectorName[iDet]));
2295 if (fStopOnError) return kFALSE;
2298 if (fRawReader && !reconstructor->HasDigitConversion()) {
2299 reconstructor->FillESD(fRawReader, clustersTree, esd);
2301 TTree* digitsTree = NULL;
2302 if (fLoader[iDet]) {
2303 fLoader[iDet]->LoadDigits("read");
2304 digitsTree = fLoader[iDet]->TreeD();
2306 AliError(Form("Can't get the %s digits tree",
2307 fgkDetectorName[iDet]));
2308 if (fStopOnError) return kFALSE;
2311 reconstructor->FillESD(digitsTree, clustersTree, esd);
2312 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
2314 if (fLoader[iDet]) {
2315 fLoader[iDet]->UnloadRecPoints();
2319 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2320 AliError(Form("the following detectors were not found: %s",
2322 if (fStopOnError) return kFALSE;
2324 AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
2329 //_____________________________________________________________________________
2330 Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
2332 // Reads the trigger decision which is
2333 // stored in Trigger.root file and fills
2334 // the corresponding esd entries
2336 AliCodeTimerAuto("")
2338 AliInfo("Filling trigger information into the ESD");
2341 AliCTPRawStream input(fRawReader);
2342 if (!input.Next()) {
2343 AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
2346 if (esd->GetTriggerMask() != input.GetClassMask())
2347 AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
2348 input.GetClassMask(),esd->GetTriggerMask()));
2349 if (esd->GetOrbitNumber() != input.GetOrbitID())
2350 AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
2351 input.GetOrbitID(),esd->GetOrbitNumber()));
2352 if (esd->GetBunchCrossNumber() != input.GetBCID())
2353 AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
2354 input.GetBCID(),esd->GetBunchCrossNumber()));
2357 // Here one has to add the filling of trigger inputs and
2358 // interaction records
2368 //_____________________________________________________________________________
2369 Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
2372 // Filling information from RawReader Header
2375 if (!fRawReader) return kFALSE;
2377 AliInfo("Filling information from RawReader Header");
2379 esd->SetBunchCrossNumber(fRawReader->GetBCID());
2380 esd->SetOrbitNumber(fRawReader->GetOrbitID());
2381 esd->SetPeriodNumber(fRawReader->GetPeriod());
2383 esd->SetTimeStamp(fRawReader->GetTimestamp());
2384 esd->SetEventType(fRawReader->GetType());
2390 //_____________________________________________________________________________
2391 Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
2393 // check whether detName is contained in detectors
2394 // if yes, it is removed from detectors
2396 // check if all detectors are selected
2397 if ((detectors.CompareTo("ALL") == 0) ||
2398 detectors.BeginsWith("ALL ") ||
2399 detectors.EndsWith(" ALL") ||
2400 detectors.Contains(" ALL ")) {
2405 // search for the given detector
2406 Bool_t result = kFALSE;
2407 if ((detectors.CompareTo(detName) == 0) ||
2408 detectors.BeginsWith(detName+" ") ||
2409 detectors.EndsWith(" "+detName) ||
2410 detectors.Contains(" "+detName+" ")) {
2411 detectors.ReplaceAll(detName, "");
2415 // clean up the detectors string
2416 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
2417 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
2418 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
2423 //_____________________________________________________________________________
2424 Bool_t AliReconstruction::InitRunLoader()
2426 // get or create the run loader
2428 if (gAlice) delete gAlice;
2431 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
2432 // load all base libraries to get the loader classes
2433 TString libs = gSystem->GetLibraries();
2434 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2435 TString detName = fgkDetectorName[iDet];
2436 if (detName == "HLT") continue;
2437 if (libs.Contains("lib" + detName + "base.so")) continue;
2438 gSystem->Load("lib" + detName + "base.so");
2440 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
2442 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
2447 fRunLoader->CdGAFile();
2448 fRunLoader->LoadgAlice();
2450 //PH This is a temporary fix to give access to the kinematics
2451 //PH that is needed for the labels of ITS clusters
2452 fRunLoader->LoadHeader();
2453 fRunLoader->LoadKinematics();
2455 } else { // galice.root does not exist
2457 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
2459 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
2460 AliConfig::GetDefaultEventFolderName(),
2463 AliError(Form("could not create run loader in file %s",
2464 fGAliceFileName.Data()));
2468 fIsNewRunLoader = kTRUE;
2469 fRunLoader->MakeTree("E");
2471 if (fNumberOfEventsPerFile > 0)
2472 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
2474 fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
2480 //_____________________________________________________________________________
2481 AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
2483 // get the reconstructor object and the loader for a detector
2485 if (fReconstructor[iDet]) {
2486 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
2487 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2488 fReconstructor[iDet]->SetRecoParam(par);
2490 return fReconstructor[iDet];
2493 // load the reconstructor object
2494 TPluginManager* pluginManager = gROOT->GetPluginManager();
2495 TString detName = fgkDetectorName[iDet];
2496 TString recName = "Ali" + detName + "Reconstructor";
2498 if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
2500 AliReconstructor* reconstructor = NULL;
2501 // first check if a plugin is defined for the reconstructor
2502 TPluginHandler* pluginHandler =
2503 pluginManager->FindHandler("AliReconstructor", detName);
2504 // if not, add a plugin for it
2505 if (!pluginHandler) {
2506 AliDebug(1, Form("defining plugin for %s", recName.Data()));
2507 TString libs = gSystem->GetLibraries();
2508 if (libs.Contains("lib" + detName + "base.so") ||
2509 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
2510 pluginManager->AddHandler("AliReconstructor", detName,
2511 recName, detName + "rec", recName + "()");
2513 pluginManager->AddHandler("AliReconstructor", detName,
2514 recName, detName, recName + "()");
2516 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
2518 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2519 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
2521 if (reconstructor) {
2522 TObject* obj = fOptions.FindObject(detName.Data());
2523 if (obj) reconstructor->SetOption(obj->GetTitle());
2524 reconstructor->Init();
2525 fReconstructor[iDet] = reconstructor;
2528 // get or create the loader
2529 if (detName != "HLT") {
2530 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
2531 if (!fLoader[iDet]) {
2532 AliConfig::Instance()
2533 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
2535 // first check if a plugin is defined for the loader
2537 pluginManager->FindHandler("AliLoader", detName);
2538 // if not, add a plugin for it
2539 if (!pluginHandler) {
2540 TString loaderName = "Ali" + detName + "Loader";
2541 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
2542 pluginManager->AddHandler("AliLoader", detName,
2543 loaderName, detName + "base",
2544 loaderName + "(const char*, TFolder*)");
2545 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
2547 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2549 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
2550 fRunLoader->GetEventFolder());
2552 if (!fLoader[iDet]) { // use default loader
2553 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
2555 if (!fLoader[iDet]) {
2556 AliWarning(Form("couldn't get loader for %s", detName.Data()));
2557 if (fStopOnError) return NULL;
2559 fRunLoader->AddLoader(fLoader[iDet]);
2560 fRunLoader->CdGAFile();
2561 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
2562 fRunLoader->Write(0, TObject::kOverwrite);
2567 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
2568 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2569 reconstructor->SetRecoParam(par);
2571 return reconstructor;
2574 //_____________________________________________________________________________
2575 AliVertexer* AliReconstruction::CreateVertexer()
2577 // create the vertexer
2578 // Please note that the caller is the owner of the
2581 AliVertexer* vertexer = NULL;
2582 AliReconstructor* itsReconstructor = GetReconstructor(0);
2583 if (itsReconstructor) {
2584 vertexer = itsReconstructor->CreateVertexer();
2587 AliWarning("couldn't create a vertexer for ITS");
2593 //_____________________________________________________________________________
2594 Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
2596 // create the trackers
2597 AliInfo("Creating trackers");
2599 TString detStr = detectors;
2600 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2601 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2602 AliReconstructor* reconstructor = GetReconstructor(iDet);
2603 if (!reconstructor) continue;
2604 TString detName = fgkDetectorName[iDet];
2605 if (detName == "HLT") {
2606 fRunHLTTracking = kTRUE;
2609 if (detName == "MUON") {
2610 fRunMuonTracking = kTRUE;
2615 fTracker[iDet] = reconstructor->CreateTracker();
2616 if (!fTracker[iDet] && (iDet < 7)) {
2617 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2618 if (fStopOnError) return kFALSE;
2620 AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
2626 //_____________________________________________________________________________
2627 void AliReconstruction::CleanUp()
2629 // delete trackers and the run loader and close and delete the file
2631 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2632 delete fReconstructor[iDet];
2633 fReconstructor[iDet] = NULL;
2634 fLoader[iDet] = NULL;
2635 delete fTracker[iDet];
2636 fTracker[iDet] = NULL;
2644 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
2645 delete fDiamondProfileSPD;
2646 fDiamondProfileSPD = NULL;
2647 delete fDiamondProfile;
2648 fDiamondProfile = NULL;
2649 delete fDiamondProfileTPC;
2650 fDiamondProfileTPC = NULL;
2656 delete fParentRawReader;
2657 fParentRawReader=NULL;
2666 void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
2668 // Write space-points which are then used in the alignment procedures
2669 // For the moment only ITS, TPC, TRD and TOF
2671 Int_t ntracks = esd->GetNumberOfTracks();
2672 for (Int_t itrack = 0; itrack < ntracks; itrack++)
2674 AliESDtrack *track = esd->GetTrack(itrack);
2677 for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
2678 nsp += track->GetNcls(iDet);
2680 if (iDet==0) { // ITS "extra" clusters
2681 track->GetClusters(iDet,idx);
2682 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++;
2687 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
2688 track->SetTrackPointArray(sp);
2690 for (Int_t iDet = 5; iDet >= 0; iDet--) {
2691 AliTracker *tracker = fTracker[iDet];
2692 if (!tracker) continue;
2693 Int_t nspdet = track->GetClusters(iDet,idx);
2695 if (iDet==0) // ITS "extra" clusters
2696 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++;
2698 if (nspdet <= 0) continue;
2702 while (isp2 < nspdet) {
2703 Bool_t isvalid=kTRUE;
2705 Int_t index=idx[isp++];
2706 if (index < 0) continue;
2708 TString dets = fgkDetectorName[iDet];
2709 if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
2710 fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
2711 fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
2712 fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
2713 isvalid = tracker->GetTrackPointTrackingError(index,p,track);
2715 isvalid = tracker->GetTrackPoint(index,p);
2718 if (!isvalid) continue;
2719 if (iDet==0 && (isp-1)>=6) p.SetExtra();
2720 sp->AddPoint(isptrack,&p); isptrack++;
2727 //_____________________________________________________________________________
2728 void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
2730 // The method reads the raw-data error log
2731 // accumulated within the rawReader.
2732 // It extracts the raw-data errors related to
2733 // the current event and stores them into
2734 // a TClonesArray inside the esd object.
2736 if (!fRawReader) return;
2738 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
2740 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
2742 if (iEvent != log->GetEventNumber()) continue;
2744 esd->AddRawDataErrorLog(log);
2749 //_____________________________________________________________________________
2750 void AliReconstruction::CheckQA()
2752 // check the QA of SIM for this run and remove the detectors
2753 // with status Fatal
2755 // TString newRunLocalReconstruction ;
2756 // TString newRunTracking ;
2757 // TString newFillESD ;
2759 // for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
2760 // TString detName(AliQA::GetDetName(iDet)) ;
2761 // AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ;
2762 // if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, specie, AliQA::kFATAL)) {
2763 // AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed",
2764 // detName.Data(), AliRecoParam::GetEventSpecieName(es))) ;
2766 // if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) ||
2767 // fRunLocalReconstruction.Contains("ALL") ) {
2768 // newRunLocalReconstruction += detName ;
2769 // newRunLocalReconstruction += " " ;
2771 // if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) ||
2772 // fRunTracking.Contains("ALL") ) {
2773 // newRunTracking += detName ;
2774 // newRunTracking += " " ;
2776 // if ( fFillESD.Contains(AliQA::GetDetName(iDet)) ||
2777 // fFillESD.Contains("ALL") ) {
2778 // newFillESD += detName ;
2779 // newFillESD += " " ;
2783 // fRunLocalReconstruction = newRunLocalReconstruction ;
2784 // fRunTracking = newRunTracking ;
2785 // fFillESD = newFillESD ;
2788 //_____________________________________________________________________________
2789 Int_t AliReconstruction::GetDetIndex(const char* detector)
2791 // return the detector index corresponding to detector
2793 for (index = 0; index < kNDetectors ; index++) {
2794 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
2799 //_____________________________________________________________________________
2800 Bool_t AliReconstruction::FinishPlaneEff() {
2802 // Here execute all the necessary operationis, at the end of the tracking phase,
2803 // in case that evaluation of PlaneEfficiencies was required for some detector.
2804 // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
2806 // This Preliminary version works only FOR ITS !!!!!
2807 // other detectors (TOF,TRD, etc. have to develop their specific codes)
2810 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
2813 //for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2814 for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
2815 //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2816 if(fTracker[iDet]) {
2817 AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
2818 TString name=planeeff->GetName();
2820 TFile* pefile = TFile::Open(name, "RECREATE");
2821 ret=(Bool_t)planeeff->Write();
2823 if(planeeff->GetCreateHistos()) {
2824 TString hname=planeeff->GetName();
2825 hname+="Histo.root";
2826 ret*=planeeff->WriteHistosToFile(hname,"RECREATE");
2832 //_____________________________________________________________________________
2833 Bool_t AliReconstruction::InitPlaneEff() {
2835 // Here execute all the necessary operations, before of the tracking phase,
2836 // for the evaluation of PlaneEfficiencies, in case required for some detectors.
2837 // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
2838 // which should be updated/recalculated.
2840 // This Preliminary version will work only FOR ITS !!!!!
2841 // other detectors (TOF,TRD, etc. have to develop their specific codes)
2844 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
2846 AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE"));
2850 //_____________________________________________________________________________
2851 Bool_t AliReconstruction::InitAliEVE()
2853 // This method should be called only in case
2854 // AliReconstruction is run
2855 // within the alieve environment.
2856 // It will initialize AliEVE in a way
2857 // so that it can visualize event processed
2858 // by AliReconstruction.
2859 // The return flag shows whenever the
2860 // AliEVE initialization was successful or not.
2863 macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
2864 AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
2865 if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
2867 gROOT->ProcessLine("if (!AliEveEventManager::GetMaster()){new AliEveEventManager();AliEveEventManager::GetMaster()->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(AliEveEventManager::GetMaster());};");
2868 gROOT->ProcessLine("alieve_online_init()");
2873 //_____________________________________________________________________________
2874 void AliReconstruction::RunAliEVE()
2876 // Runs AliEVE visualisation of
2877 // the current event.
2878 // Should be executed only after
2879 // successful initialization of AliEVE.
2881 AliInfo("Running AliEVE...");
2882 gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)0x%lx,(AliRawReader*)0x%lx,(AliESDEvent*)0x%lx,(AliESDfriend*)0x%lx);",fRunLoader,fRawReader,fesd,fesdf));
2886 //_____________________________________________________________________________
2887 Bool_t AliReconstruction::SetRunQA(TString detAndAction)
2889 // Allows to run QA for a selected set of detectors
2890 // and a selected set of tasks among RAWS, RECPOINTS and ESDS
2891 // all selected detectors run the same selected tasks
2893 if (!detAndAction.Contains(":")) {
2894 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
2898 Int_t colon = detAndAction.Index(":") ;
2899 fQADetectors = detAndAction(0, colon) ;
2900 if (fQADetectors.Contains("ALL") )
2901 fQADetectors = fFillESD ;
2902 fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
2903 if (fQATasks.Contains("ALL") ) {
2904 fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ;
2906 fQATasks.ToUpper() ;
2908 if ( fQATasks.Contains("RAW") )
2909 tempo = Form("%d ", AliQA::kRAWS) ;
2910 if ( fQATasks.Contains("RECPOINT") )
2911 tempo += Form("%d ", AliQA::kRECPOINTS) ;
2912 if ( fQATasks.Contains("ESD") )
2913 tempo += Form("%d ", AliQA::kESDS) ;
2915 if (fQATasks.IsNull()) {
2916 AliInfo("No QA requested\n") ;
2921 TString tempo(fQATasks) ;
2922 tempo.ReplaceAll(Form("%d", AliQA::kRAWS), AliQA::GetTaskName(AliQA::kRAWS)) ;
2923 tempo.ReplaceAll(Form("%d", AliQA::kRECPOINTS), AliQA::GetTaskName(AliQA::kRECPOINTS)) ;
2924 tempo.ReplaceAll(Form("%d", AliQA::kESDS), AliQA::GetTaskName(AliQA::kESDS)) ;
2925 AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
2930 //_____________________________________________________________________________
2931 Bool_t AliReconstruction::InitRecoParams()
2933 // The method accesses OCDB and retrieves all
2934 // the available reco-param objects from there.
2936 Bool_t isOK = kTRUE;
2938 TString detStr = fLoadCDB;
2939 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2941 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2943 if (fRecoParam.GetDetRecoParamArray(iDet)) {
2944 AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
2948 AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]));
2950 AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
2951 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
2953 AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]));
2957 TObject *recoParamObj = entry->GetObject();
2958 if (dynamic_cast<TObjArray*>(recoParamObj)) {
2959 // The detector has a normal TobjArray of AliDetectorRecoParam objects
2960 // Registering them in AliRecoParam
2961 fRecoParam.AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
2963 else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
2964 // The detector has only onse set of reco parameters
2965 // Registering it in AliRecoParam
2966 AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]));
2967 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
2968 fRecoParam.AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
2971 AliError(Form("No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]));
2975 AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
2979 if (AliDebugLevel() > 0) fRecoParam.Print();
2984 //_____________________________________________________________________________
2985 Bool_t AliReconstruction::GetEventInfo()
2987 // Fill the event info object
2989 AliCodeTimerAuto("")
2991 AliCentralTrigger *aCTP = NULL;
2993 fEventInfo.SetEventType(fRawReader->GetType());
2995 ULong64_t mask = fRawReader->GetClassMask();
2996 fEventInfo.SetTriggerMask(mask);
2997 UInt_t clmask = fRawReader->GetDetectorPattern()[0];
2998 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
3000 aCTP = new AliCentralTrigger();
3001 TString configstr("");
3002 if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
3003 AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
3007 aCTP->SetClassMask(mask);
3008 aCTP->SetClusterMask(clmask);
3011 fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
3013 if (fRunLoader && (!fRunLoader->LoadTrigger())) {
3014 aCTP = fRunLoader->GetTrigger();
3015 fEventInfo.SetTriggerMask(aCTP->GetClassMask());
3016 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
3019 AliWarning("No trigger can be loaded! The trigger information will not be used!");
3024 AliTriggerConfiguration *config = aCTP->GetConfiguration();
3026 AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
3027 if (fRawReader) delete aCTP;
3031 UChar_t clustmask = 0;
3033 ULong64_t trmask = fEventInfo.GetTriggerMask();
3034 const TObjArray& classesArray = config->GetClasses();
3035 Int_t nclasses = classesArray.GetEntriesFast();
3036 for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
3037 AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
3039 Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
3040 fesd->SetTriggerClass(trclass->GetName(),trindex);
3041 if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
3042 if (trmask & (1 << trindex)) {
3044 trclasses += trclass->GetName();
3046 clustmask |= trclass->GetCluster()->GetClusterMask();
3050 fEventInfo.SetTriggerClasses(trclasses);
3052 // Set the information in ESD
3053 fesd->SetTriggerMask(trmask);
3054 fesd->SetTriggerCluster(clustmask);
3056 if (!aCTP->CheckTriggeredDetectors()) {
3057 if (fRawReader) delete aCTP;
3061 if (fRawReader) delete aCTP;
3063 // We have to fill also the HLT decision here!!
3069 const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_t detectorMask)
3071 // Match the detector list found in the rec.C or the default 'ALL'
3072 // to the list found in the GRP (stored there by the shuttle PP which
3073 // gets the information from ECS)
3074 static TString resultList;
3075 TString detList = detectorList;
3079 for(Int_t iDet = 0; iDet < (AliDAQ::kNDetectors-1); iDet++) {
3080 if ((detectorMask >> iDet) & 0x1) {
3081 TString det = AliDAQ::OfflineModuleName(iDet);
3082 if ((detList.CompareTo("ALL") == 0) ||
3083 ((detList.BeginsWith("ALL ") ||
3084 detList.EndsWith(" ALL") ||
3085 detList.Contains(" ALL ")) &&
3086 !(detList.BeginsWith("-"+det+" ") ||
3087 detList.EndsWith(" -"+det) ||
3088 detList.Contains(" -"+det+" "))) ||
3089 (detList.CompareTo(det) == 0) ||
3090 detList.BeginsWith(det+" ") ||
3091 detList.EndsWith(" "+det) ||
3092 detList.Contains( " "+det+" " )) {
3093 if (!resultList.EndsWith(det + " ")) {
3102 if ((detectorMask >> AliDAQ::kHLTId) & 0x1) {
3103 TString hltDet = AliDAQ::OfflineModuleName(AliDAQ::kNDetectors-1);
3104 if ((detList.CompareTo("ALL") == 0) ||
3105 ((detList.BeginsWith("ALL ") ||
3106 detList.EndsWith(" ALL") ||
3107 detList.Contains(" ALL ")) &&
3108 !(detList.BeginsWith("-"+hltDet+" ") ||
3109 detList.EndsWith(" -"+hltDet) ||
3110 detList.Contains(" -"+hltDet+" "))) ||
3111 (detList.CompareTo(hltDet) == 0) ||
3112 detList.BeginsWith(hltDet+" ") ||
3113 detList.EndsWith(" "+hltDet) ||
3114 detList.Contains( " "+hltDet+" " )) {
3115 resultList += hltDet;
3119 return resultList.Data();
3123 //______________________________________________________________________________
3124 void AliReconstruction::Abort(const char *method, EAbort what)
3126 // Abort processing. If what = kAbortProcess, the Process() loop will be
3127 // aborted. If what = kAbortFile, the current file in a chain will be
3128 // aborted and the processing will continue with the next file, if there
3129 // is no next file then Process() will be aborted. Abort() can also be
3130 // called from Begin(), SlaveBegin(), Init() and Notify(). After abort
3131 // the SlaveTerminate() and Terminate() are always called. The abort flag
3132 // can be checked in these methods using GetAbort().
3134 // The method is overwritten in AliReconstruction for better handling of
3135 // reco specific errors
3137 if (!fStopOnError) return;
3141 TString whyMess = method;
3142 whyMess += " failed! Aborting...";
3144 AliError(whyMess.Data());
3147 TString mess = "Abort";
3148 if (fAbort == kAbortProcess)
3149 mess = "AbortProcess";
3150 else if (fAbort == kAbortFile)
3153 Info(mess, whyMess.Data());