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("..."); //
108 // For debug purposes the method SetCheckPointLevel can be used. If the //
109 // argument is greater than 0, files with ESD events will be written after //
110 // selected steps of the reconstruction for each event: //
111 // level 1: after tracking and after filling of ESD (final) //
112 // level 2: in addition after each tracking step //
113 // level 3: in addition after the filling of ESD for each detector //
114 // If a final check point file exists for an event, this event will be //
115 // skipped in the reconstruction. The tracking and the filling of ESD for //
116 // a detector will be skipped as well, if the corresponding check point //
117 // file exists. The ESD event will then be loaded from the file instead. //
119 ///////////////////////////////////////////////////////////////////////////////
126 #include <TPluginManager.h>
127 #include <TGeoManager.h>
128 #include <TLorentzVector.h>
131 #include <TObjArray.h>
133 #include "AliReconstruction.h"
134 #include "AliCodeTimer.h"
135 #include "AliReconstructor.h"
137 #include "AliRunLoader.h"
139 #include "AliRawReaderFile.h"
140 #include "AliRawReaderDate.h"
141 #include "AliRawReaderRoot.h"
142 #include "AliRawEventHeaderBase.h"
143 #include "AliESDEvent.h"
144 #include "AliESDMuonTrack.h"
145 #include "AliESDfriend.h"
146 #include "AliESDVertex.h"
147 #include "AliESDcascade.h"
148 #include "AliESDkink.h"
149 #include "AliESDtrack.h"
150 #include "AliESDCaloCluster.h"
151 #include "AliESDCaloCells.h"
152 #include "AliMultiplicity.h"
153 #include "AliTracker.h"
154 #include "AliVertexer.h"
155 #include "AliVertexerTracks.h"
156 #include "AliV0vertexer.h"
157 #include "AliCascadeVertexer.h"
158 #include "AliHeader.h"
159 #include "AliGenEventHeader.h"
161 #include "AliESDpid.h"
162 #include "AliESDtrack.h"
163 #include "AliESDPmdTrack.h"
165 #include "AliESDTagCreator.h"
166 #include "AliAODTagCreator.h"
168 #include "AliGeomManager.h"
169 #include "AliTrackPointArray.h"
170 #include "AliCDBManager.h"
171 #include "AliCDBStorage.h"
172 #include "AliCDBEntry.h"
173 #include "AliAlignObj.h"
175 #include "AliCentralTrigger.h"
176 #include "AliTriggerConfiguration.h"
177 #include "AliTriggerClass.h"
178 #include "AliCTPRawStream.h"
180 #include "AliQADataMakerRec.h"
181 #include "AliGlobalQADataMaker.h"
183 #include "AliQADataMakerSteer.h"
185 #include "AliPlaneEff.h"
187 #include "AliSysInfo.h" // memory snapshots
188 #include "AliRawHLTManager.h"
191 ClassImp(AliReconstruction)
194 //_____________________________________________________________________________
195 const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
197 //_____________________________________________________________________________
198 AliReconstruction::AliReconstruction(const char* gAliceFilename,
199 const char* name, const char* title) :
202 fUniformField(kTRUE),
203 fRunVertexFinder(kTRUE),
204 fRunVertexFinderTracks(kTRUE),
205 fRunHLTTracking(kFALSE),
206 fRunMuonTracking(kFALSE),
208 fRunCascadeFinder(kTRUE),
209 fStopOnError(kFALSE),
210 fWriteAlignmentData(kFALSE),
211 fWriteESDfriend(kFALSE),
213 fFillTriggerESD(kTRUE),
221 fRunLocalReconstruction("ALL"),
224 fUseTrackingErrorsForAlignment(""),
225 fGAliceFileName(gAliceFilename),
230 fNumberOfEventsPerFile(1),
233 fLoadAlignFromCDB(kTRUE),
234 fLoadAlignData("ALL"),
240 fParentRawReader(NULL),
243 fDiamondProfile(NULL),
244 fDiamondProfileTPC(NULL),
245 fMeanVertexConstraint(kTRUE),
249 fAlignObjArray(NULL),
252 fInitCDBCalled(kFALSE),
253 fSetRunNumberFromDataCalled(kFALSE),
257 fSameQACycle(kFALSE),
259 fRunPlaneEff(kFALSE),
271 fIsNewRunLoader(kFALSE)
273 // create reconstruction object with default parameters
275 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
276 fReconstructor[iDet] = NULL;
277 fLoader[iDet] = NULL;
278 fTracker[iDet] = NULL;
279 fQADataMaker[iDet] = NULL;
280 fQACycles[iDet] = 999999;
282 fQADataMaker[fgkNDetectors]=NULL; //Global QA
286 //_____________________________________________________________________________
287 AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
290 fUniformField(rec.fUniformField),
291 fRunVertexFinder(rec.fRunVertexFinder),
292 fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
293 fRunHLTTracking(rec.fRunHLTTracking),
294 fRunMuonTracking(rec.fRunMuonTracking),
295 fRunV0Finder(rec.fRunV0Finder),
296 fRunCascadeFinder(rec.fRunCascadeFinder),
297 fStopOnError(rec.fStopOnError),
298 fWriteAlignmentData(rec.fWriteAlignmentData),
299 fWriteESDfriend(rec.fWriteESDfriend),
300 fWriteAOD(rec.fWriteAOD),
301 fFillTriggerESD(rec.fFillTriggerESD),
303 fCleanESD(rec.fCleanESD),
304 fV0DCAmax(rec.fV0DCAmax),
305 fV0CsPmin(rec.fV0CsPmin),
309 fRunLocalReconstruction(rec.fRunLocalReconstruction),
310 fRunTracking(rec.fRunTracking),
311 fFillESD(rec.fFillESD),
312 fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
313 fGAliceFileName(rec.fGAliceFileName),
315 fEquipIdMap(rec.fEquipIdMap),
316 fFirstEvent(rec.fFirstEvent),
317 fLastEvent(rec.fLastEvent),
318 fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
321 fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
322 fLoadAlignData(rec.fLoadAlignData),
323 fESDPar(rec.fESDPar),
324 fUseHLTData(rec.fUseHLTData),
328 fParentRawReader(NULL),
331 fDiamondProfile(NULL),
332 fDiamondProfileTPC(NULL),
333 fMeanVertexConstraint(rec.fMeanVertexConstraint),
337 fAlignObjArray(rec.fAlignObjArray),
338 fCDBUri(rec.fCDBUri),
340 fInitCDBCalled(rec.fInitCDBCalled),
341 fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
343 fRunGlobalQA(rec.fRunGlobalQA),
344 fInLoopQA(rec.fInLoopQA),
345 fSameQACycle(rec.fSameQACycle),
346 fRunPlaneEff(rec.fRunPlaneEff),
358 fIsNewRunLoader(rec.fIsNewRunLoader)
362 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
363 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
365 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
366 fReconstructor[iDet] = NULL;
367 fLoader[iDet] = NULL;
368 fTracker[iDet] = NULL;
369 fQADataMaker[iDet] = NULL;
370 fQACycles[iDet] = rec.fQACycles[iDet];
372 fQADataMaker[fgkNDetectors]=NULL; //Global QA
373 for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
374 if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
378 //_____________________________________________________________________________
379 AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
381 // assignment operator
383 this->~AliReconstruction();
384 new(this) AliReconstruction(rec);
388 //_____________________________________________________________________________
389 AliReconstruction::~AliReconstruction()
395 fSpecCDBUri.Delete();
397 AliCodeTimer::Instance()->Print();
400 //_____________________________________________________________________________
401 void AliReconstruction::InitCDB()
403 // activate a default CDB storage
404 // First check if we have any CDB storage set, because it is used
405 // to retrieve the calibration and alignment constants
407 if (fInitCDBCalled) return;
408 fInitCDBCalled = kTRUE;
410 AliCDBManager* man = AliCDBManager::Instance();
411 if (man->IsDefaultStorageSet())
413 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
414 AliWarning("Default CDB storage has been already set !");
415 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
416 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
417 fCDBUri = man->GetDefaultStorage()->GetURI();
420 if (fCDBUri.Length() > 0)
422 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
423 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
424 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
426 fCDBUri="local://$ALICE_ROOT";
427 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
428 AliWarning("Default CDB storage not yet set !!!!");
429 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
430 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
433 man->SetDefaultStorage(fCDBUri);
436 // Now activate the detector specific CDB storage locations
437 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
438 TObject* obj = fSpecCDBUri[i];
440 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
441 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
442 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
443 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
448 //_____________________________________________________________________________
449 void AliReconstruction::SetDefaultStorage(const char* uri) {
450 // Store the desired default CDB storage location
451 // Activate it later within the Run() method
457 //_____________________________________________________________________________
458 void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
459 // Store a detector-specific CDB storage location
460 // Activate it later within the Run() method
462 AliCDBPath aPath(calibType);
463 if(!aPath.IsValid()){
464 // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
465 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
466 if(!strcmp(calibType, fgkDetectorName[iDet])) {
467 aPath.SetPath(Form("%s/*", calibType));
468 AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
472 if(!aPath.IsValid()){
473 AliError(Form("Not a valid path or detector: %s", calibType));
478 // // check that calibType refers to a "valid" detector name
479 // Bool_t isDetector = kFALSE;
480 // for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
481 // TString detName = fgkDetectorName[iDet];
482 // if(aPath.GetLevel0() == detName) {
483 // isDetector = kTRUE;
489 // AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
493 TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
494 if (obj) fSpecCDBUri.Remove(obj);
495 fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
499 //_____________________________________________________________________________
500 Bool_t AliReconstruction::SetRunNumberFromData()
502 // The method is called in Run() in order
503 // to set a correct run number.
504 // In case of raw data reconstruction the
505 // run number is taken from the raw data header
507 if (fSetRunNumberFromDataCalled) return kTRUE;
508 fSetRunNumberFromDataCalled = kTRUE;
510 AliCDBManager* man = AliCDBManager::Instance();
512 if(man->GetRun() > 0) {
513 AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
517 AliError("No run loader is found !");
520 // read run number from gAlice
521 if(fRunLoader->GetAliRun())
522 AliCDBManager::Instance()->SetRun(fRunLoader->GetHeader()->GetRun());
525 if(fRawReader->NextEvent()) {
526 AliCDBManager::Instance()->SetRun(fRawReader->GetRunNumber());
527 fRawReader->RewindEvents();
530 if(man->GetRun() > 0) {
531 AliWarning("No raw events is found ! Using settings in AliCDBManager !");
536 AliWarning("Neither raw events nor settings in AliCDBManager are found !");
542 AliError("Neither gAlice nor RawReader objects are found !");
552 //_____________________________________________________________________________
553 void AliReconstruction::SetCDBLock() {
554 // Set CDB lock: from now on it is forbidden to reset the run number
555 // or the default storage or to activate any further storage!
557 AliCDBManager::Instance()->SetLock(1);
560 //_____________________________________________________________________________
561 Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
563 // Read the alignment objects from CDB.
564 // Each detector is supposed to have the
565 // alignment objects in DET/Align/Data CDB path.
566 // All the detector objects are then collected,
567 // sorted by geometry level (starting from ALIC) and
568 // then applied to the TGeo geometry.
569 // Finally an overlaps check is performed.
571 // Load alignment data from CDB and fill fAlignObjArray
572 if(fLoadAlignFromCDB){
574 TString detStr = detectors;
575 TString loadAlObjsListOfDets = "";
577 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
578 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
579 loadAlObjsListOfDets += fgkDetectorName[iDet];
580 loadAlObjsListOfDets += " ";
581 } // end loop over detectors
582 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
583 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
585 // Check if the array with alignment objects was
586 // provided by the user. If yes, apply the objects
587 // to the present TGeo geometry
588 if (fAlignObjArray) {
589 if (gGeoManager && gGeoManager->IsClosed()) {
590 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
591 AliError("The misalignment of one or more volumes failed!"
592 "Compare the list of simulated detectors and the list of detector alignment data!");
597 AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
603 delete fAlignObjArray; fAlignObjArray=0;
608 //_____________________________________________________________________________
609 void AliReconstruction::SetGAliceFile(const char* fileName)
611 // set the name of the galice file
613 fGAliceFileName = fileName;
616 //_____________________________________________________________________________
617 void AliReconstruction::SetInput(const char* input)
619 // In case the input string starts with 'mem://', we run in an online mode
620 // and AliRawReaderDateOnline object is created. In all other cases a raw-data
621 // file is assumed. One can give as an input:
622 // mem://: - events taken from DAQ monitoring libs online
624 // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
628 //_____________________________________________________________________________
629 void AliReconstruction::SetOption(const char* detector, const char* option)
631 // set options for the reconstruction of a detector
633 TObject* obj = fOptions.FindObject(detector);
634 if (obj) fOptions.Remove(obj);
635 fOptions.Add(new TNamed(detector, option));
638 //_____________________________________________________________________________
639 Bool_t AliReconstruction::Run(const char* input)
642 AliCodeTimerAuto("");
644 if (!InitRun(input)) return kFALSE;
646 //******* The loop over events
648 while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
649 (fRawReader && fRawReader->NextEvent())) {
650 if (!RunEvent(iEvent)) return kFALSE;
654 if (!FinishRun()) return kFALSE;
659 //_____________________________________________________________________________
660 Bool_t AliReconstruction::InitRun(const char* input)
662 // Initialize all the stuff before
663 // going into the event loop
664 // If the second argument is given, the first one is ignored and
665 // the reconstruction works in an online mode
666 AliCodeTimerAuto("");
668 // Overwrite the previous setting
669 if (input) fInput = input;
671 // set the input in case of raw data
672 fRawReader = AliRawReader::Create(fInput.Data());
674 AliInfo("Reconstruction will run over digits");
676 if (!fEquipIdMap.IsNull() && fRawReader)
677 fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
679 if (!fUseHLTData.IsNull()) {
680 // create the RawReaderHLT which performs redirection of HLT input data for
681 // the specified detectors
682 AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
684 fParentRawReader=fRawReader;
685 fRawReader=pRawReader;
687 AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
691 AliSysInfo::AddStamp("Start");
692 // get the run loader
693 if (!InitRunLoader()) return kFALSE;
694 AliSysInfo::AddStamp("LoadLoader");
696 // Initialize the CDB storage
699 AliSysInfo::AddStamp("LoadCDB");
701 // Set run number in CDBManager (if it is not already set by the user)
702 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
704 // Set CDB lock: from now on it is forbidden to reset the run number
705 // or the default storage or to activate any further storage!
708 // Import ideal TGeo geometry and apply misalignment
710 TString geom(gSystem->DirName(fGAliceFileName));
711 geom += "/geometry.root";
712 AliGeomManager::LoadGeometry(geom.Data());
713 if (!gGeoManager) if (fStopOnError) return kFALSE;
716 if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
717 AliSysInfo::AddStamp("LoadGeom");
720 AliQADataMakerSteer qas ;
721 if (fRunQA && fRawReader) {
722 qas.Run(fRunLocalReconstruction, fRawReader) ;
723 fSameQACycle = kTRUE ;
725 // checking the QA of previous steps
729 // local reconstruction
730 if (!fRunLocalReconstruction.IsNull()) {
731 if (!RunLocalReconstruction(fRunLocalReconstruction)) {
732 if (fStopOnError) {CleanUp(); return kFALSE;}
738 if (fRunVertexFinder && !CreateVertexer()) {
744 AliSysInfo::AddStamp("Vertexer");
747 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
753 AliSysInfo::AddStamp("LoadTrackers");
755 // get the possibly already existing ESD file and tree
756 fesd = new AliESDEvent(); fhltesd = new AliESDEvent();
757 if (!gSystem->AccessPathName("AliESDs.root")){
758 gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE);
759 ffileOld = TFile::Open("AliESDs.old.root");
760 if (ffileOld && ffileOld->IsOpen()) {
761 ftreeOld = (TTree*) ffileOld->Get("esdTree");
762 if (ftreeOld)fesd->ReadFromTree(ftreeOld);
763 fhlttreeOld = (TTree*) ffileOld->Get("HLTesdTree");
764 if (fhlttreeOld) fhltesd->ReadFromTree(fhlttreeOld);
768 // create the ESD output file and tree
769 ffile = TFile::Open("AliESDs.root", "RECREATE");
770 ffile->SetCompressionLevel(2);
771 if (!ffile->IsOpen()) {
772 AliError("opening AliESDs.root failed");
773 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
776 ftree = new TTree("esdTree", "Tree with ESD objects");
777 fesd = new AliESDEvent();
778 fesd->CreateStdContent();
779 fesd->WriteToTree(ftree);
781 fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
782 fhltesd = new AliESDEvent();
783 fhltesd->CreateStdContent();
784 fhltesd->WriteToTree(fhlttree);
787 delete esd; delete hltesd;
788 esd = NULL; hltesd = NULL;
790 // create the branch with ESD additions
794 if (fWriteESDfriend) {
795 fesdf = new AliESDfriend();
796 TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
797 br->SetFile("AliESDfriends.root");
798 fesd->AddObject(fesdf);
801 // Get the GRP CDB entry
802 AliCDBEntry* entryGRP = AliCDBManager::Instance()->Get("GRP/GRP/Data");
805 fGRPData = dynamic_cast<TMap*> (entryGRP->GetObject());
808 AliError("No GRP entry found in OCDB!");
810 // Get the diamond profile from OCDB
811 AliCDBEntry* entry = AliCDBManager::Instance()
812 ->Get("GRP/Calib/MeanVertex");
815 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
817 AliError("No diamond profile found in OCDB!");
821 entry = AliCDBManager::Instance()
822 ->Get("GRP/Calib/MeanVertexTPC");
825 fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
827 AliError("No diamond profile found in OCDB!");
830 ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
831 if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile);
833 if (fRawReader) fRawReader->RewindEvents();
836 gSystem->GetProcInfo(&ProcInfo);
837 AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
840 //Initialize the QA and start of cycle for out-of-cycle QA
842 TString detStr(fFillESD);
843 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
844 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
845 AliQADataMakerRec *qadm = GetQADataMaker(iDet);
847 AliInfo(Form("Initializing the QA data maker for %s",
848 fgkDetectorName[iDet]));
849 qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
850 qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
852 qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
853 qadm->StartOfCycle(AliQA::kESDS,"same");
857 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
858 AliInfo(Form("Initializing the global QA data maker"));
860 qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
861 AliTracker::SetResidualsArray(arr);
862 qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
864 qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
865 qadm->StartOfCycle(AliQA::kESDS, "same");
869 fSameQACycle = kTRUE;
872 //Initialize the Plane Efficiency framework
873 if (fRunPlaneEff && !InitPlaneEff()) {
874 if(fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
880 //_____________________________________________________________________________
881 Bool_t AliReconstruction::RunEvent(Int_t iEvent)
883 // run the reconstruction over a single event
884 // The event loop is steered in Run method
886 AliCodeTimerAuto("");
888 if (iEvent >= fRunLoader->GetNumberOfEvents()) {
889 fRunLoader->SetEventNumber(iEvent);
890 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
892 //?? fRunLoader->MakeTree("H");
893 fRunLoader->TreeE()->Fill();
896 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
897 // copy old ESD to the new one
899 fesd->ReadFromTree(ftreeOld);
900 ftreeOld->GetEntry(iEvent);
904 fhltesd->ReadFromTree(fhlttreeOld);
905 fhlttreeOld->GetEntry(iEvent);
911 AliInfo(Form("processing event %d", iEvent));
913 //Start of cycle for the in-loop QA
916 TString detStr(fFillESD);
917 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
918 if (!IsSelected(fgkDetectorName[iDet], detStr))
920 AliQADataMakerRec *qadm = GetQADataMaker(iDet);
923 qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
924 qadm->StartOfCycle(AliQA::kESDS, "same") ;
927 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
928 qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
929 qadm->StartOfCycle(AliQA::kESDS, "same");
934 fRunLoader->GetEvent(iEvent);
937 sprintf(aFileName, "ESD_%d.%d_final.root",
938 fRunLoader->GetHeader()->GetRun(),
939 fRunLoader->GetHeader()->GetEventNrInRun());
940 if (!gSystem->AccessPathName(aFileName)) return kTRUE;
942 // local single event reconstruction
943 if (!fRunLocalReconstruction.IsNull()) {
944 TString detectors=fRunLocalReconstruction;
945 // run HLT event reconstruction first
946 // ;-( IsSelected changes the string
947 if (IsSelected("HLT", detectors) &&
948 !RunLocalEventReconstruction("HLT")) {
949 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
951 detectors=fRunLocalReconstruction;
952 detectors.ReplaceAll("HLT", "");
953 if (!RunLocalEventReconstruction(detectors)) {
954 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
958 fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
959 fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
960 fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
961 fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
963 // Set magnetic field from the tracker
964 fesd->SetMagneticField(AliTracker::GetBz());
965 fhltesd->SetMagneticField(AliTracker::GetBz());
969 // Fill raw-data error log into the ESD
970 if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
973 if (fRunVertexFinder) {
974 if (!ReadESD(fesd, "vertex")) {
975 if (!RunVertexFinder(fesd)) {
976 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
978 if (fCheckPointLevel > 0) WriteESD(fesd, "vertex");
983 if (!fRunTracking.IsNull()) {
984 if (fRunMuonTracking) {
985 if (!RunMuonTracking(fesd)) {
986 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
992 if (!fRunTracking.IsNull()) {
993 if (!ReadESD(fesd, "tracking")) {
994 if (!RunTracking(fesd)) {
995 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
997 if (fCheckPointLevel > 0) WriteESD(fesd, "tracking");
1002 if (!fFillESD.IsNull()) {
1003 TString detectors=fFillESD;
1004 // run HLT first and on hltesd
1005 // ;-( IsSelected changes the string
1006 if (IsSelected("HLT", detectors) &&
1007 !FillESD(fhltesd, "HLT")) {
1008 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1011 detectors.ReplaceAll("HLT", "");
1012 if (!FillESD(fesd, detectors)) {
1013 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1017 // fill Event header information from the RawEventHeader
1018 if (fRawReader){FillRawEventHeaderESD(fesd);}
1021 AliESDpid::MakePID(fesd);
1022 if (fCheckPointLevel > 1) WriteESD(fesd, "PID");
1024 if (fFillTriggerESD) {
1025 if (!ReadESD(fesd, "trigger")) {
1026 if (!FillTriggerESD(fesd)) {
1027 if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1029 if (fCheckPointLevel > 1) WriteESD(fesd, "trigger");
1036 // Propagate track to the beam pipe (if not laready done by ITS)
1038 const Int_t ntracks = fesd->GetNumberOfTracks();
1039 const Double_t kBz = fesd->GetMagneticField();
1040 const Double_t kRadius = 2.8; //something less than the beam pipe radius
1043 UShort_t *selectedIdx=new UShort_t[ntracks];
1045 for (Int_t itrack=0; itrack<ntracks; itrack++){
1046 const Double_t kMaxStep = 5; //max step over the material
1049 AliESDtrack *track = fesd->GetTrack(itrack);
1050 if (!track) continue;
1052 AliExternalTrackParam *tpcTrack =
1053 (AliExternalTrackParam *)track->GetTPCInnerParam();
1057 PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE);
1062 Int_t n=trkArray.GetEntriesFast();
1063 selectedIdx[n]=track->GetID();
1064 trkArray.AddLast(tpcTrack);
1067 if (track->GetX() < kRadius) continue;
1070 PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
1072 track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kRadius);
1077 // Improve the reconstructed primary vertex position using the tracks
1079 TObject *obj = fOptions.FindObject("ITS");
1081 TString optITS = obj->GetTitle();
1082 if (optITS.Contains("cosmics") || optITS.Contains("COSMICS"))
1083 fRunVertexFinderTracks=kFALSE;
1085 if (fRunVertexFinderTracks) {
1086 // TPC + ITS primary vertex
1087 ftVertexer->SetITSrefitRequired();
1088 if(fDiamondProfile && fMeanVertexConstraint) {
1089 ftVertexer->SetVtxStart(fDiamondProfile);
1091 ftVertexer->SetConstraintOff();
1093 AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
1095 if (pvtx->GetStatus()) {
1096 fesd->SetPrimaryVertex(pvtx);
1097 for (Int_t i=0; i<ntracks; i++) {
1098 AliESDtrack *t = fesd->GetTrack(i);
1099 t->RelateToVertex(pvtx, kBz, kRadius);
1104 // TPC-only primary vertex
1105 ftVertexer->SetITSrefitNotRequired();
1106 if(fDiamondProfileTPC && fMeanVertexConstraint) {
1107 ftVertexer->SetVtxStart(fDiamondProfileTPC);
1109 ftVertexer->SetConstraintOff();
1111 pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
1113 if (pvtx->GetStatus()) {
1114 fesd->SetPrimaryVertexTPC(pvtx);
1115 Int_t nsel=trkArray.GetEntriesFast();
1116 for (Int_t i=0; i<nsel; i++) {
1117 AliExternalTrackParam *t =
1118 (AliExternalTrackParam *)trkArray.UncheckedAt(i);
1119 t->PropagateToDCA(pvtx, kBz, kRadius);
1125 delete[] selectedIdx;
1127 if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
1132 AliV0vertexer vtxer;
1133 vtxer.Tracks2V0vertices(fesd);
1135 if (fRunCascadeFinder) {
1137 AliCascadeVertexer cvtxer;
1138 cvtxer.V0sTracks2CascadeVertices(fesd);
1143 if (fCleanESD) CleanESD(fesd);
1147 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
1148 if (qadm) qadm->Exec(AliQA::kESDS, fesd);
1152 if (fWriteESDfriend) {
1153 fesdf->~AliESDfriend();
1154 new (fesdf) AliESDfriend(); // Reset...
1155 fesd->GetESDfriend(fesdf);
1162 if (fCheckPointLevel > 0) WriteESD(fesd, "final");
1165 if (fWriteESDfriend) {
1166 fesdf->~AliESDfriend();
1167 new (fesdf) AliESDfriend(); // Reset...
1170 ProcInfo_t ProcInfo;
1171 gSystem->GetProcInfo(&ProcInfo);
1172 AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
1175 // End of cycle for the in-loop QA
1178 RunQA(fFillESD.Data(), fesd);
1179 TString detStr(fFillESD);
1180 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1181 if (!IsSelected(fgkDetectorName[iDet], detStr))
1183 AliQADataMakerRec * qadm = GetQADataMaker(iDet);
1186 qadm->EndOfCycle(AliQA::kRECPOINTS);
1187 qadm->EndOfCycle(AliQA::kESDS);
1192 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
1194 qadm->EndOfCycle(AliQA::kRECPOINTS);
1195 qadm->EndOfCycle(AliQA::kESDS);
1204 //_____________________________________________________________________________
1205 Bool_t AliReconstruction::FinishRun()
1208 // Called after the exit
1209 // from the event loop
1210 AliCodeTimerAuto("");
1212 if (fIsNewRunLoader) { // galice.root didn't exist
1213 fRunLoader->WriteHeader("OVERWRITE");
1214 fRunLoader->CdGAFile();
1215 fRunLoader->Write(0, TObject::kOverwrite);
1218 ftree->GetUserInfo()->Add(fesd);
1219 fhlttree->GetUserInfo()->Add(fhltesd);
1221 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
1222 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
1224 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
1225 cdbMapCopy->SetOwner(1);
1226 cdbMapCopy->SetName("cdbMap");
1227 TIter iter(cdbMap->GetTable());
1230 while((pair = dynamic_cast<TPair*> (iter.Next()))){
1231 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
1232 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
1233 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
1236 TList *cdbListCopy = new TList();
1237 cdbListCopy->SetOwner(1);
1238 cdbListCopy->SetName("cdbList");
1240 TIter iter2(cdbList);
1243 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
1244 cdbListCopy->Add(new TObjString(id->ToString().Data()));
1247 ftree->GetUserInfo()->Add(cdbMapCopy);
1248 ftree->GetUserInfo()->Add(cdbListCopy);
1251 if(fESDPar.Contains("ESD.par")){
1252 AliInfo("Attaching ESD.par to Tree");
1253 TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
1254 ftree->GetUserInfo()->Add(fn);
1260 if (fWriteESDfriend)
1261 ftree->SetBranchStatus("ESDfriend*",0);
1262 // we want to have only one tree version number
1263 ftree->Write(ftree->GetName(),TObject::kOverwrite);
1266 // Finish with Plane Efficiency evaluation: before of CleanUp !!!
1267 if (fRunPlaneEff && !FinishPlaneEff()) {
1268 AliWarning("Finish PlaneEff evaluation failed");
1272 CleanUp(ffile, ffileOld);
1275 AliWarning("AOD creation not supported anymore during reconstruction. See ANALYSIS/AliAnalysisTaskESDfilter.cxx instead.");
1278 // Create tags for the events in the ESD tree (the ESD tree is always present)
1279 // In case of empty events the tags will contain dummy values
1280 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
1281 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData);
1283 AliWarning("AOD tag creation not supported anymore during reconstruction.");
1286 //Finish QA and end of cycle for out-of-loop QA
1289 AliQADataMakerSteer qas;
1290 qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS, fSameQACycle);
1292 qas.Run(fRunTracking.Data(), AliQA::kESDS, fSameQACycle);
1294 AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
1296 qadm->EndOfCycle(AliQA::kRECPOINTS);
1297 qadm->EndOfCycle(AliQA::kESDS);
1304 // Cleanup of CDB manager: cache and active storages!
1305 AliCDBManager::Instance()->ClearCache();
1311 //_____________________________________________________________________________
1312 Bool_t AliReconstruction::RunLocalReconstruction(const TString& /*detectors*/)
1314 // run the local reconstruction
1315 static Int_t eventNr=0;
1316 AliCodeTimerAuto("")
1318 // AliCDBManager* man = AliCDBManager::Instance();
1319 // Bool_t origCache = man->GetCacheFlag();
1321 // TString detStr = detectors;
1322 // for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1323 // if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1324 // AliReconstructor* reconstructor = GetReconstructor(iDet);
1325 // if (!reconstructor) continue;
1326 // if (reconstructor->HasLocalReconstruction()) continue;
1328 // AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1329 // AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1331 // AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
1332 // AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
1334 // man->SetCacheFlag(kTRUE);
1335 // TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]);
1336 // man->GetAll(calibPath); // entries are cached!
1338 // AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
1340 // if (fRawReader) {
1341 // fRawReader->RewindEvents();
1342 // reconstructor->Reconstruct(fRunLoader, fRawReader);
1344 // reconstructor->Reconstruct(fRunLoader);
1347 // AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1348 // AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr));
1350 // // unload calibration data
1351 // man->UnloadFromCache(calibPath);
1352 // //man->ClearCache();
1355 // man->SetCacheFlag(origCache);
1357 // if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1358 // AliError(Form("the following detectors were not found: %s",
1360 // if (fStopOnError) return kFALSE;
1367 //_____________________________________________________________________________
1368 Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
1370 // run the local reconstruction
1372 static Int_t eventNr=0;
1373 AliCodeTimerAuto("")
1375 TString detStr = detectors;
1376 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1377 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1378 AliReconstructor* reconstructor = GetReconstructor(iDet);
1379 if (!reconstructor) continue;
1380 AliLoader* loader = fLoader[iDet];
1381 // Matthias April 2008: temporary fix to run HLT reconstruction
1382 // although the HLT loader is missing
1383 if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
1385 reconstructor->Reconstruct(fRawReader, NULL);
1388 reconstructor->Reconstruct(dummy, NULL);
1393 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
1396 // conversion of digits
1397 if (fRawReader && reconstructor->HasDigitConversion()) {
1398 AliInfo(Form("converting raw data digits into root objects for %s",
1399 fgkDetectorName[iDet]));
1400 AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
1401 fgkDetectorName[iDet]));
1402 loader->LoadDigits("update");
1403 loader->CleanDigits();
1404 loader->MakeDigitsContainer();
1405 TTree* digitsTree = loader->TreeD();
1406 reconstructor->ConvertDigits(fRawReader, digitsTree);
1407 loader->WriteDigits("OVERWRITE");
1408 loader->UnloadDigits();
1410 // local reconstruction
1411 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1412 AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1413 loader->LoadRecPoints("update");
1414 loader->CleanRecPoints();
1415 loader->MakeRecPointsContainer();
1416 TTree* clustersTree = loader->TreeR();
1417 if (fRawReader && !reconstructor->HasDigitConversion()) {
1418 reconstructor->Reconstruct(fRawReader, clustersTree);
1420 loader->LoadDigits("read");
1421 TTree* digitsTree = loader->TreeD();
1423 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
1424 if (fStopOnError) return kFALSE;
1426 reconstructor->Reconstruct(digitsTree, clustersTree);
1428 loader->UnloadDigits();
1431 // In-loop QA for local reconstrucion
1432 if (fRunQA && fInLoopQA) {
1433 AliQADataMakerRec * qadm = GetQADataMaker(iDet);
1436 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1438 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1440 qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
1443 //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1447 loader->WriteRecPoints("OVERWRITE");
1448 loader->UnloadRecPoints();
1449 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
1452 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1453 AliError(Form("the following detectors were not found: %s",
1455 if (fStopOnError) return kFALSE;
1461 //_____________________________________________________________________________
1462 Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
1464 // run the barrel tracking
1466 AliCodeTimerAuto("")
1468 AliESDVertex* vertex = NULL;
1469 Double_t vtxPos[3] = {0, 0, 0};
1470 Double_t vtxErr[3] = {0.07, 0.07, 0.1};
1471 TArrayF mcVertex(3);
1472 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
1473 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
1474 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
1478 if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
1479 AliInfo("running the ITS vertex finder");
1480 if (fLoader[0]) fLoader[0]->LoadRecPoints();
1481 vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
1482 if (fLoader[0]) fLoader[0]->UnloadRecPoints();
1484 AliWarning("Vertex not found");
1485 vertex = new AliESDVertex();
1486 vertex->SetName("default");
1489 vertex->SetName("reconstructed");
1493 AliInfo("getting the primary vertex from MC");
1494 vertex = new AliESDVertex(vtxPos, vtxErr);
1498 vertex->GetXYZ(vtxPos);
1499 vertex->GetSigmaXYZ(vtxErr);
1501 AliWarning("no vertex reconstructed");
1502 vertex = new AliESDVertex(vtxPos, vtxErr);
1504 esd->SetPrimaryVertexSPD(vertex);
1505 // if SPD multiplicity has been determined, it is stored in the ESD
1506 AliMultiplicity *mult = fVertexer->GetMultiplicity();
1507 if(mult)esd->SetMultiplicity(mult);
1509 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1510 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
1517 //_____________________________________________________________________________
1518 Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
1520 // run the HLT barrel tracking
1522 AliCodeTimerAuto("")
1525 AliError("Missing runLoader!");
1529 AliInfo("running HLT tracking");
1531 // Get a pointer to the HLT reconstructor
1532 AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
1533 if (!reconstructor) return kFALSE;
1536 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1537 TString detName = fgkDetectorName[iDet];
1538 AliDebug(1, Form("%s HLT tracking", detName.Data()));
1539 reconstructor->SetOption(detName.Data());
1540 AliTracker *tracker = reconstructor->CreateTracker();
1542 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
1543 if (fStopOnError) return kFALSE;
1547 Double_t vtxErr[3]={0.005,0.005,0.010};
1548 const AliESDVertex *vertex = esd->GetVertex();
1549 vertex->GetXYZ(vtxPos);
1550 tracker->SetVertex(vtxPos,vtxErr);
1552 fLoader[iDet]->LoadRecPoints("read");
1553 TTree* tree = fLoader[iDet]->TreeR();
1555 AliError(Form("Can't get the %s cluster tree", detName.Data()));
1558 tracker->LoadClusters(tree);
1560 if (tracker->Clusters2Tracks(esd) != 0) {
1561 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
1565 tracker->UnloadClusters();
1573 //_____________________________________________________________________________
1574 Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
1576 // run the muon spectrometer tracking
1578 AliCodeTimerAuto("")
1581 AliError("Missing runLoader!");
1584 Int_t iDet = 7; // for MUON
1586 AliInfo("is running...");
1588 // Get a pointer to the MUON reconstructor
1589 AliReconstructor *reconstructor = GetReconstructor(iDet);
1590 if (!reconstructor) return kFALSE;
1593 TString detName = fgkDetectorName[iDet];
1594 AliDebug(1, Form("%s tracking", detName.Data()));
1595 AliTracker *tracker = reconstructor->CreateTracker();
1597 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
1602 fLoader[iDet]->LoadRecPoints("read");
1604 tracker->LoadClusters(fLoader[iDet]->TreeR());
1606 Int_t rv = tracker->Clusters2Tracks(esd);
1610 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
1614 fLoader[iDet]->UnloadRecPoints();
1616 tracker->UnloadClusters();
1624 //_____________________________________________________________________________
1625 Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
1627 // run the barrel tracking
1628 static Int_t eventNr=0;
1629 AliCodeTimerAuto("")
1631 AliInfo("running tracking");
1633 //Fill the ESD with the T0 info (will be used by the TOF)
1634 if (fReconstructor[11] && fLoader[11]) {
1635 fLoader[11]->LoadRecPoints("READ");
1636 TTree *treeR = fLoader[11]->TreeR();
1637 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
1640 // pass 1: TPC + ITS inwards
1641 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1642 if (!fTracker[iDet]) continue;
1643 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
1646 fLoader[iDet]->LoadRecPoints("read");
1647 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
1648 TTree* tree = fLoader[iDet]->TreeR();
1650 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
1653 fTracker[iDet]->LoadClusters(tree);
1654 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
1656 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
1657 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
1660 if (fCheckPointLevel > 1) {
1661 WriteESD(esd, Form("%s.tracking", fgkDetectorName[iDet]));
1663 // preliminary PID in TPC needed by the ITS tracker
1665 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
1666 AliESDpid::MakePID(esd);
1668 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
1671 // pass 2: ALL backwards
1673 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1674 if (!fTracker[iDet]) continue;
1675 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
1678 if (iDet > 1) { // all except ITS, TPC
1680 fLoader[iDet]->LoadRecPoints("read");
1681 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
1682 tree = fLoader[iDet]->TreeR();
1684 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
1687 fTracker[iDet]->LoadClusters(tree);
1688 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
1692 if (iDet>1) // start filling residuals for the "outer" detectors
1693 if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
1695 if (fTracker[iDet]->PropagateBack(esd) != 0) {
1696 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
1699 if (fCheckPointLevel > 1) {
1700 WriteESD(esd, Form("%s.back", fgkDetectorName[iDet]));
1704 if (iDet > 2) { // all except ITS, TPC, TRD
1705 fTracker[iDet]->UnloadClusters();
1706 fLoader[iDet]->UnloadRecPoints();
1708 // updated PID in TPC needed by the ITS tracker -MI
1710 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
1711 AliESDpid::MakePID(esd);
1713 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
1715 //stop filling residuals for the "outer" detectors
1716 if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
1718 // write space-points to the ESD in case alignment data output
1720 if (fWriteAlignmentData)
1721 WriteAlignmentData(esd);
1723 // pass 3: TRD + TPC + ITS refit inwards
1725 for (Int_t iDet = 2; iDet >= 0; iDet--) {
1726 if (!fTracker[iDet]) continue;
1727 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
1730 if (iDet<2) // start filling residuals for TPC and ITS
1731 if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
1733 if (fTracker[iDet]->RefitInward(esd) != 0) {
1734 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
1737 // run postprocessing
1738 if (fTracker[iDet]->PostProcess(esd) != 0) {
1739 AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
1742 if (fCheckPointLevel > 1) {
1743 WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet]));
1745 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
1747 fTracker[iDet]->UnloadClusters();
1748 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
1749 fLoader[iDet]->UnloadRecPoints();
1750 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
1752 // stop filling residuals for TPC and ITS
1753 if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
1759 //_____________________________________________________________________________
1760 Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
1762 // Remove the data which are not needed for the physics analysis.
1765 Int_t nTracks=esd->GetNumberOfTracks();
1766 Int_t nV0s=esd->GetNumberOfV0s();
1768 (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
1770 Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
1771 Bool_t rc=esd->Clean(cleanPars);
1773 nTracks=esd->GetNumberOfTracks();
1774 nV0s=esd->GetNumberOfV0s();
1776 (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
1781 //_____________________________________________________________________________
1782 Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
1784 // fill the event summary data
1786 AliCodeTimerAuto("")
1787 static Int_t eventNr=0;
1788 TString detStr = detectors;
1790 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1791 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1792 AliReconstructor* reconstructor = GetReconstructor(iDet);
1793 if (!reconstructor) continue;
1794 if (!ReadESD(esd, fgkDetectorName[iDet])) {
1795 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
1796 TTree* clustersTree = NULL;
1797 if (fLoader[iDet]) {
1798 fLoader[iDet]->LoadRecPoints("read");
1799 clustersTree = fLoader[iDet]->TreeR();
1800 if (!clustersTree) {
1801 AliError(Form("Can't get the %s clusters tree",
1802 fgkDetectorName[iDet]));
1803 if (fStopOnError) return kFALSE;
1806 if (fRawReader && !reconstructor->HasDigitConversion()) {
1807 reconstructor->FillESD(fRawReader, clustersTree, esd);
1809 TTree* digitsTree = NULL;
1810 if (fLoader[iDet]) {
1811 fLoader[iDet]->LoadDigits("read");
1812 digitsTree = fLoader[iDet]->TreeD();
1814 AliError(Form("Can't get the %s digits tree",
1815 fgkDetectorName[iDet]));
1816 if (fStopOnError) return kFALSE;
1819 reconstructor->FillESD(digitsTree, clustersTree, esd);
1820 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
1822 if (fLoader[iDet]) {
1823 fLoader[iDet]->UnloadRecPoints();
1826 if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
1830 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1831 AliError(Form("the following detectors were not found: %s",
1833 if (fStopOnError) return kFALSE;
1835 AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
1840 //_____________________________________________________________________________
1841 Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
1843 // Reads the trigger decision which is
1844 // stored in Trigger.root file and fills
1845 // the corresponding esd entries
1847 AliCodeTimerAuto("")
1849 AliInfo("Filling trigger information into the ESD");
1851 AliCentralTrigger *aCTP = NULL;
1854 AliCTPRawStream input(fRawReader);
1855 if (!input.Next()) {
1856 AliError("No valid CTP (trigger) DDL raw data is found ! The trigger information is not stored in the ESD !");
1859 esd->SetTriggerMask(input.GetClassMask());
1860 esd->SetTriggerCluster(input.GetClusterMask());
1862 aCTP = new AliCentralTrigger();
1863 TString configstr("");
1864 if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
1865 AliError("No trigger configuration found in OCDB! The trigger classes information will no be stored in ESD!");
1871 AliRunLoader *runloader = AliRunLoader::GetRunLoader();
1873 if (!runloader->LoadTrigger()) {
1874 aCTP = runloader->GetTrigger();
1875 esd->SetTriggerMask(aCTP->GetClassMask());
1876 esd->SetTriggerCluster(aCTP->GetClusterMask());
1879 AliWarning("No trigger can be loaded! The trigger information is not stored in the ESD !");
1884 AliError("No run loader is available! The trigger information is not stored in the ESD !");
1889 // Now fill the trigger class names into AliESDRun object
1890 AliTriggerConfiguration *config = aCTP->GetConfiguration();
1892 AliError("No trigger configuration has been found! The trigger classes information will no be stored in ESD!");
1893 if (fRawReader) delete aCTP;
1897 const TObjArray& classesArray = config->GetClasses();
1898 Int_t nclasses = classesArray.GetEntriesFast();
1899 for( Int_t j=0; j<nclasses; j++ ) {
1900 AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At( j );
1901 Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask());
1902 esd->SetTriggerClass(trclass->GetName(),trindex);
1905 if (fRawReader) delete aCTP;
1913 //_____________________________________________________________________________
1914 Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
1917 // Filling information from RawReader Header
1920 AliInfo("Filling information from RawReader Header");
1921 esd->SetBunchCrossNumber(0);
1922 esd->SetOrbitNumber(0);
1923 esd->SetPeriodNumber(0);
1924 esd->SetTimeStamp(0);
1925 esd->SetEventType(0);
1926 const AliRawEventHeaderBase * eventHeader = fRawReader->GetEventHeader();
1929 const UInt_t *id = eventHeader->GetP("Id");
1930 esd->SetBunchCrossNumber((id)[1]&0x00000fff);
1931 esd->SetOrbitNumber((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff));
1932 esd->SetPeriodNumber(((id)[0]>>4)&0x0fffffff);
1934 esd->SetTimeStamp((eventHeader->Get("Timestamp")));
1935 esd->SetEventType((eventHeader->Get("Type")));
1942 //_____________________________________________________________________________
1943 Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
1945 // check whether detName is contained in detectors
1946 // if yes, it is removed from detectors
1948 // check if all detectors are selected
1949 if ((detectors.CompareTo("ALL") == 0) ||
1950 detectors.BeginsWith("ALL ") ||
1951 detectors.EndsWith(" ALL") ||
1952 detectors.Contains(" ALL ")) {
1957 // search for the given detector
1958 Bool_t result = kFALSE;
1959 if ((detectors.CompareTo(detName) == 0) ||
1960 detectors.BeginsWith(detName+" ") ||
1961 detectors.EndsWith(" "+detName) ||
1962 detectors.Contains(" "+detName+" ")) {
1963 detectors.ReplaceAll(detName, "");
1967 // clean up the detectors string
1968 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
1969 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1970 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1975 //_____________________________________________________________________________
1976 Bool_t AliReconstruction::InitRunLoader()
1978 // get or create the run loader
1980 if (gAlice) delete gAlice;
1983 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
1984 // load all base libraries to get the loader classes
1985 TString libs = gSystem->GetLibraries();
1986 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1987 TString detName = fgkDetectorName[iDet];
1988 if (detName == "HLT") continue;
1989 if (libs.Contains("lib" + detName + "base.so")) continue;
1990 gSystem->Load("lib" + detName + "base.so");
1992 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
1994 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
1998 fRunLoader->CdGAFile();
1999 if (gFile->GetKey(AliRunLoader::GetGAliceName())) {
2000 if (fRunLoader->LoadgAlice() == 0) {
2001 gAlice = fRunLoader->GetAliRun();
2002 AliTracker::SetFieldMap(gAlice->Field(),fUniformField);
2005 if (!gAlice && !fRawReader) {
2006 AliError(Form("no gAlice object found in file %s",
2007 fGAliceFileName.Data()));
2012 //PH This is a temporary fix to give access to the kinematics
2013 //PH that is needed for the labels of ITS clusters
2014 fRunLoader->LoadHeader();
2015 fRunLoader->LoadKinematics();
2017 } else { // galice.root does not exist
2019 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
2023 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
2024 AliConfig::GetDefaultEventFolderName(),
2027 AliError(Form("could not create run loader in file %s",
2028 fGAliceFileName.Data()));
2032 fIsNewRunLoader = kTRUE;
2033 fRunLoader->MakeTree("E");
2035 if (fNumberOfEventsPerFile > 0)
2036 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
2038 fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
2044 //_____________________________________________________________________________
2045 AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
2047 // get the reconstructor object and the loader for a detector
2049 if (fReconstructor[iDet]) return fReconstructor[iDet];
2051 // load the reconstructor object
2052 TPluginManager* pluginManager = gROOT->GetPluginManager();
2053 TString detName = fgkDetectorName[iDet];
2054 TString recName = "Ali" + detName + "Reconstructor";
2055 if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) return NULL;
2057 AliReconstructor* reconstructor = NULL;
2058 // first check if a plugin is defined for the reconstructor
2059 TPluginHandler* pluginHandler =
2060 pluginManager->FindHandler("AliReconstructor", detName);
2061 // if not, add a plugin for it
2062 if (!pluginHandler) {
2063 AliDebug(1, Form("defining plugin for %s", recName.Data()));
2064 TString libs = gSystem->GetLibraries();
2065 if (libs.Contains("lib" + detName + "base.so") ||
2066 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
2067 pluginManager->AddHandler("AliReconstructor", detName,
2068 recName, detName + "rec", recName + "()");
2070 pluginManager->AddHandler("AliReconstructor", detName,
2071 recName, detName, recName + "()");
2073 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
2075 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2076 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
2078 if (reconstructor) {
2079 TObject* obj = fOptions.FindObject(detName.Data());
2080 if (obj) reconstructor->SetOption(obj->GetTitle());
2081 reconstructor->Init();
2082 fReconstructor[iDet] = reconstructor;
2085 // get or create the loader
2086 if (detName != "HLT") {
2087 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
2088 if (!fLoader[iDet]) {
2089 AliConfig::Instance()
2090 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
2092 // first check if a plugin is defined for the loader
2094 pluginManager->FindHandler("AliLoader", detName);
2095 // if not, add a plugin for it
2096 if (!pluginHandler) {
2097 TString loaderName = "Ali" + detName + "Loader";
2098 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
2099 pluginManager->AddHandler("AliLoader", detName,
2100 loaderName, detName + "base",
2101 loaderName + "(const char*, TFolder*)");
2102 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
2104 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2106 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
2107 fRunLoader->GetEventFolder());
2109 if (!fLoader[iDet]) { // use default loader
2110 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
2112 if (!fLoader[iDet]) {
2113 AliWarning(Form("couldn't get loader for %s", detName.Data()));
2114 if (fStopOnError) return NULL;
2116 fRunLoader->AddLoader(fLoader[iDet]);
2117 fRunLoader->CdGAFile();
2118 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
2119 fRunLoader->Write(0, TObject::kOverwrite);
2124 return reconstructor;
2127 //_____________________________________________________________________________
2128 Bool_t AliReconstruction::CreateVertexer()
2130 // create the vertexer
2133 AliReconstructor* itsReconstructor = GetReconstructor(0);
2134 if (itsReconstructor) {
2135 fVertexer = itsReconstructor->CreateVertexer();
2138 AliWarning("couldn't create a vertexer for ITS");
2139 if (fStopOnError) return kFALSE;
2145 //_____________________________________________________________________________
2146 Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
2148 // create the trackers
2150 TString detStr = detectors;
2151 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2152 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2153 AliReconstructor* reconstructor = GetReconstructor(iDet);
2154 if (!reconstructor) continue;
2155 TString detName = fgkDetectorName[iDet];
2156 if (detName == "HLT") {
2157 fRunHLTTracking = kTRUE;
2160 if (detName == "MUON") {
2161 fRunMuonTracking = kTRUE;
2166 fTracker[iDet] = reconstructor->CreateTracker();
2167 if (!fTracker[iDet] && (iDet < 7)) {
2168 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2169 if (fStopOnError) return kFALSE;
2171 AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
2177 //_____________________________________________________________________________
2178 void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
2180 // delete trackers and the run loader and close and delete the file
2182 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2183 delete fReconstructor[iDet];
2184 fReconstructor[iDet] = NULL;
2185 fLoader[iDet] = NULL;
2186 delete fTracker[iDet];
2187 fTracker[iDet] = NULL;
2188 // delete fQADataMaker[iDet];
2189 // fQADataMaker[iDet] = NULL;
2194 if (ftVertexer) delete ftVertexer;
2197 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
2198 delete fDiamondProfile;
2199 fDiamondProfile = NULL;
2200 delete fDiamondProfileTPC;
2201 fDiamondProfileTPC = NULL;
2211 if (fParentRawReader) delete fParentRawReader;
2212 fParentRawReader=NULL;
2222 gSystem->Unlink("AliESDs.old.root");
2227 //_____________________________________________________________________________
2229 Bool_t AliReconstruction::ReadESD(AliESDEvent*& esd, const char* recStep) const
2231 // read the ESD event from a file
2233 if (!esd) return kFALSE;
2235 sprintf(fileName, "ESD_%d.%d_%s.root",
2236 esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
2237 if (gSystem->AccessPathName(fileName)) return kFALSE;
2239 AliInfo(Form("reading ESD from file %s", fileName));
2240 AliDebug(1, Form("reading ESD from file %s", fileName));
2241 TFile* file = TFile::Open(fileName);
2242 if (!file || !file->IsOpen()) {
2243 AliError(Form("opening %s failed", fileName));
2250 esd = (AliESDEvent*) file->Get("ESD");
2259 //_____________________________________________________________________________
2260 void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const
2262 // write the ESD event to a file
2266 sprintf(fileName, "ESD_%d.%d_%s.root",
2267 esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
2269 AliDebug(1, Form("writing ESD to file %s", fileName));
2270 TFile* file = TFile::Open(fileName, "recreate");
2271 if (!file || !file->IsOpen()) {
2272 AliError(Form("opening %s failed", fileName));
2281 void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
2283 // Write space-points which are then used in the alignment procedures
2284 // For the moment only ITS, TRD and TPC
2286 // Load TOF clusters
2288 fLoader[3]->LoadRecPoints("read");
2289 TTree* tree = fLoader[3]->TreeR();
2291 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[3]));
2294 fTracker[3]->LoadClusters(tree);
2296 Int_t ntracks = esd->GetNumberOfTracks();
2297 for (Int_t itrack = 0; itrack < ntracks; itrack++)
2299 AliESDtrack *track = esd->GetTrack(itrack);
2302 for (Int_t iDet = 3; iDet >= 0; iDet--)
2303 nsp += track->GetNcls(iDet);
2305 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
2306 track->SetTrackPointArray(sp);
2308 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2309 AliTracker *tracker = fTracker[iDet];
2310 if (!tracker) continue;
2311 Int_t nspdet = track->GetNcls(iDet);
2312 if (nspdet <= 0) continue;
2313 track->GetClusters(iDet,idx);
2317 while (isp2 < nspdet) {
2319 TString dets = fgkDetectorName[iDet];
2320 if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
2321 fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
2322 fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
2323 fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
2324 isvalid = tracker->GetTrackPointTrackingError(idx[isp2],p,track);
2326 isvalid = tracker->GetTrackPoint(idx[isp2],p);
2329 const Int_t kNTPCmax = 159;
2330 if (iDet==1 && isp2>kNTPCmax) break; // to be fixed
2331 if (!isvalid) continue;
2332 sp->AddPoint(isptrack,&p); isptrack++; isp++;
2338 fTracker[3]->UnloadClusters();
2339 fLoader[3]->UnloadRecPoints();
2343 //_____________________________________________________________________________
2344 void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
2346 // The method reads the raw-data error log
2347 // accumulated within the rawReader.
2348 // It extracts the raw-data errors related to
2349 // the current event and stores them into
2350 // a TClonesArray inside the esd object.
2352 if (!fRawReader) return;
2354 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
2356 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
2358 if (iEvent != log->GetEventNumber()) continue;
2360 esd->AddRawDataErrorLog(log);
2365 TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString fName){
2366 // Dump a file content into a char in TNamed
2368 in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
2369 Int_t kBytes = (Int_t)in.tellg();
2370 printf("Size: %d \n",kBytes);
2373 char* memblock = new char [kBytes];
2374 in.seekg (0, ios::beg);
2375 in.read (memblock, kBytes);
2377 TString fData(memblock,kBytes);
2378 fn = new TNamed(fName,fData);
2379 printf("fData Size: %d \n",fData.Sizeof());
2380 printf("fName Size: %d \n",fName.Sizeof());
2381 printf("fn Size: %d \n",fn->Sizeof());
2385 AliInfo(Form("Could not Open %s\n",fPath.Data()));
2391 void AliReconstruction::TNamedToFile(TTree* fTree, TString fName){
2392 // This is not really needed in AliReconstruction at the moment
2393 // but can serve as a template
2395 TList *fList = fTree->GetUserInfo();
2396 TNamed *fn = (TNamed*)fList->FindObject(fName.Data());
2397 printf("fn Size: %d \n",fn->Sizeof());
2399 TString fTmp(fn->GetName()); // to be 100% sure in principle fName also works
2400 const char* cdata = fn->GetTitle();
2401 printf("fTmp Size %d\n",fTmp.Sizeof());
2403 int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
2404 printf("calculated size %d\n",size);
2405 ofstream out(fName.Data(),ios::out | ios::binary);
2406 out.write(cdata,size);
2411 //_____________________________________________________________________________
2412 AliQADataMakerRec * AliReconstruction::GetQADataMaker(Int_t iDet)
2414 // get the quality assurance data maker object and the loader for a detector
2416 if (fQADataMaker[iDet])
2417 return fQADataMaker[iDet];
2419 AliQADataMakerRec * qadm = NULL;
2420 if (iDet == fgkNDetectors) { //Global QA
2421 qadm = new AliGlobalQADataMaker();
2422 fQADataMaker[iDet] = qadm;
2426 // load the QA data maker object
2427 TPluginManager* pluginManager = gROOT->GetPluginManager();
2428 TString detName = fgkDetectorName[iDet];
2429 TString qadmName = "Ali" + detName + "QADataMakerRec";
2430 if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT"))
2433 // first check if a plugin is defined for the quality assurance data maker
2434 TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
2435 // if not, add a plugin for it
2436 if (!pluginHandler) {
2437 AliDebug(1, Form("defining plugin for %s", qadmName.Data()));
2438 TString libs = gSystem->GetLibraries();
2439 if (libs.Contains("lib" + detName + "base.so") ||
2440 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
2441 pluginManager->AddHandler("AliQADataMakerRec", detName,
2442 qadmName, detName + "qadm", qadmName + "()");
2444 pluginManager->AddHandler("AliQADataMakerRec", detName,
2445 qadmName, detName, qadmName + "()");
2447 pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
2449 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2450 qadm = (AliQADataMakerRec *) pluginHandler->ExecPlugin(0);
2453 fQADataMaker[iDet] = qadm;
2458 //_____________________________________________________________________________
2459 Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd)
2461 // run the Quality Assurance data producer
2463 AliCodeTimerAuto("")
2464 TString detStr = detectors;
2465 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2466 if (!IsSelected(fgkDetectorName[iDet], detStr))
2468 AliQADataMakerRec * qadm = GetQADataMaker(iDet);
2471 AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2472 AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2474 qadm->Exec(AliQA::kESDS, esd) ;
2477 AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2479 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2480 AliError(Form("the following detectors were not found: %s",
2490 //_____________________________________________________________________________
2491 void AliReconstruction::CheckQA()
2493 // check the QA of SIM for this run and remove the detectors
2494 // with status Fatal
2496 TString newRunLocalReconstruction ;
2497 TString newRunTracking ;
2498 TString newFillESD ;
2500 for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
2501 TString detName(AliQA::GetDetName(iDet)) ;
2502 AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ;
2503 if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, AliQA::kFATAL)) {
2504 AliInfo(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed", detName.Data())) ;
2506 if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) ||
2507 fRunLocalReconstruction.Contains("ALL") ) {
2508 newRunLocalReconstruction += detName ;
2509 newRunLocalReconstruction += " " ;
2511 if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) ||
2512 fRunTracking.Contains("ALL") ) {
2513 newRunTracking += detName ;
2514 newRunTracking += " " ;
2516 if ( fFillESD.Contains(AliQA::GetDetName(iDet)) ||
2517 fFillESD.Contains("ALL") ) {
2518 newFillESD += detName ;
2523 fRunLocalReconstruction = newRunLocalReconstruction ;
2524 fRunTracking = newRunTracking ;
2525 fFillESD = newFillESD ;
2528 //_____________________________________________________________________________
2529 Int_t AliReconstruction::GetDetIndex(const char* detector)
2531 // return the detector index corresponding to detector
2533 for (index = 0; index < fgkNDetectors ; index++) {
2534 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
2539 //_____________________________________________________________________________
2540 Bool_t AliReconstruction::FinishPlaneEff() {
2542 // Here execute all the necessary operationis, at the end of the tracking phase,
2543 // in case that evaluation of PlaneEfficiencies was required for some detector.
2544 // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
2546 // This Preliminary version works only FOR ITS !!!!!
2547 // other detectors (TOF,TRD, etc. have to develop their specific codes)
2550 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
2553 //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2554 for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
2555 //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2556 if(fTracker[iDet]) {
2557 AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
2558 ret=planeeff->WriteIntoCDB();
2559 if(planeeff->GetCreateHistos()) {
2560 TString name="PlaneEffHisto";
2561 name+=fgkDetectorName[iDet];
2563 ret*=planeeff->WriteHistosToFile(name,"RECREATE");
2569 //_____________________________________________________________________________
2570 Bool_t AliReconstruction::InitPlaneEff() {
2572 // Here execute all the necessary operations, before of the tracking phase,
2573 // for the evaluation of PlaneEfficiencies, in case required for some detectors.
2574 // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
2575 // which should be updated/recalculated.
2577 // This Preliminary version will work only FOR ITS !!!!!
2578 // other detectors (TOF,TRD, etc. have to develop their specific codes)
2581 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
2583 AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE"));