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>
129 #include <THashTable.h>
131 #include <TMessage.h>
135 #include "AliAlignObj.h"
136 #include "AliAnalysisManager.h"
137 #include "AliAnalysisDataContainer.h"
138 #include "AliCDBEntry.h"
139 #include "AliCDBManager.h"
140 #include "AliCDBStorage.h"
141 #include "AliCTPRawStream.h"
142 #include "AliCascadeVertexer.h"
143 #include "AliCentralTrigger.h"
144 #include "AliCodeTimer.h"
146 #include "AliDetectorRecoParam.h"
147 #include "AliESDCaloCells.h"
148 #include "AliESDCaloCluster.h"
149 #include "AliESDEvent.h"
150 #include "AliESDMuonTrack.h"
151 #include "AliESDPmdTrack.h"
152 #include "AliESDTagCreator.h"
153 #include "AliESDVertex.h"
154 #include "AliESDcascade.h"
155 #include "AliESDfriend.h"
156 #include "AliESDkink.h"
157 #include "AliESDpid.h"
158 #include "AliESDtrack.h"
159 #include "AliESDtrack.h"
160 #include "AliEventInfo.h"
161 #include "AliGRPObject.h"
162 #include "AliGRPRecoParam.h"
163 #include "AliGenEventHeader.h"
164 #include "AliGeomManager.h"
165 #include "AliGlobalQADataMaker.h"
166 #include "AliHeader.h"
169 #include "AliMultiplicity.h"
171 #include "AliPlaneEff.h"
173 #include "AliQADataMakerRec.h"
174 #include "AliQAManager.h"
175 #include "AliRawVEvent.h"
176 #include "AliRawEventHeaderBase.h"
177 #include "AliRawHLTManager.h"
178 #include "AliRawReaderDate.h"
179 #include "AliRawReaderFile.h"
180 #include "AliRawReaderRoot.h"
181 #include "AliRecoInputHandler.h"
182 #include "AliReconstruction.h"
183 #include "AliReconstructor.h"
185 #include "AliRunInfo.h"
186 #include "AliRunLoader.h"
187 #include "AliSysInfo.h" // memory snapshots
188 #include "AliTrackPointArray.h"
189 #include "AliTracker.h"
190 #include "AliTriggerClass.h"
191 #include "AliTriggerCluster.h"
192 #include "AliTriggerIR.h"
193 #include "AliTriggerConfiguration.h"
194 #include "AliV0vertexer.h"
195 #include "AliVertexer.h"
196 #include "AliTrackleter.h"
197 #include "AliVertexerTracks.h"
198 #include "AliTriggerRunScalers.h"
199 #include "AliCTPTimeParams.h"
200 #include "AliESDHLTDecision.h"
201 #include "AliTriggerInput.h"
202 #include "AliLHCData.h"
203 #include "ARVersion.h"
204 #include <RVersion.h>
206 #include <sys/resource.h>
207 ClassImp(AliReconstruction)
209 //_____________________________________________________________________________
210 const char* AliReconstruction::fgkStopEvFName = "_stopEvent_";
211 const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE"
212 // #ifdef MFT_UPGRADE
219 //_____________________________________________________________________________
220 AliReconstruction::AliReconstruction(const char* gAliceFilename) :
222 fRunVertexFinder(kTRUE),
223 fRunVertexFinderTracks(kTRUE),
224 fRunHLTTracking(kFALSE),
225 fRunMuonTracking(kFALSE),
227 fRunCascadeFinder(kTRUE),
228 fRunMultFinder(kTRUE),
230 fWriteAlignmentData(kFALSE),
231 fWriteESDfriend(kFALSE),
232 fFillTriggerESD(kTRUE),
240 fRunLocalReconstruction("ALL"),
243 fDeleteRecPoints(""),
246 fUseTrackingErrorsForAlignment(""),
247 fGAliceFileName(gAliceFilename),
250 fProofOutputFileName(""),
251 fProofOutputLocation(""),
252 fProofOutputDataset(kFALSE),
253 fProofOutputArchive(""),
257 fNumberOfEventsPerFile((UInt_t)-1),
258 fFractionFriends(0.04),
260 fLoadAlignFromCDB(kTRUE),
261 fLoadAlignData("ALL"),
266 fCTPTimeParams(NULL),
271 fParentRawReader(NULL),
275 fSPDTrackleter(NULL),
277 fDiamondProfileSPD(NULL),
278 fDiamondProfile(NULL),
279 fDiamondProfileTPC(NULL),
280 fListOfCosmicTriggers(NULL),
284 fAlignObjArray(NULL),
288 fInitCDBCalled(kFALSE),
289 fFromCDBSnapshot(kFALSE),
290 fSnapshotFileName(""),
291 fSetRunNumberFromDataCalled(kFALSE),
296 fSameQACycle(kFALSE),
297 fInitQACalled(kFALSE),
298 fWriteQAExpertData(kTRUE),
299 fRunPlaneEff(kFALSE),
310 fIsNewRunLoader(kFALSE),
322 fDeclTriggerClasses(""),
327 // create reconstruction object with default parameters
330 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
331 fReconstructor[iDet] = NULL;
332 fUpgradeMask[iDet]=kFALSE;
333 fLoader[iDet] = NULL;
334 fTracker[iDet] = NULL;
336 for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
337 fQACycles[iDet] = 999999 ;
338 fQAWriteExpert[iDet] = kFALSE ;
340 fBeamInt[0][0]=fBeamInt[0][1]=fBeamInt[1][0]=fBeamInt[1][1] = -1;
345 //_____________________________________________________________________________
346 AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
348 fRunVertexFinder(rec.fRunVertexFinder),
349 fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
350 fRunHLTTracking(rec.fRunHLTTracking),
351 fRunMuonTracking(rec.fRunMuonTracking),
352 fRunV0Finder(rec.fRunV0Finder),
353 fRunCascadeFinder(rec.fRunCascadeFinder),
354 fRunMultFinder(rec.fRunMultFinder),
355 fStopOnError(rec.fStopOnError),
356 fWriteAlignmentData(rec.fWriteAlignmentData),
357 fWriteESDfriend(rec.fWriteESDfriend),
358 fFillTriggerESD(rec.fFillTriggerESD),
360 fCleanESD(rec.fCleanESD),
361 fV0DCAmax(rec.fV0DCAmax),
362 fV0CsPmin(rec.fV0CsPmin),
366 fRunLocalReconstruction(rec.fRunLocalReconstruction),
367 fRunTracking(rec.fRunTracking),
368 fFillESD(rec.fFillESD),
369 fDeleteRecPoints(""),
371 fLoadCDB(rec.fLoadCDB),
372 fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
373 fGAliceFileName(rec.fGAliceFileName),
374 fRawInput(rec.fRawInput),
375 fESDOutput(rec.fESDOutput),
376 fProofOutputFileName(rec.fProofOutputFileName),
377 fProofOutputLocation(rec.fProofOutputLocation),
378 fProofOutputDataset(rec.fProofOutputDataset),
379 fProofOutputArchive(rec.fProofOutputArchive),
380 fEquipIdMap(rec.fEquipIdMap),
381 fFirstEvent(rec.fFirstEvent),
382 fLastEvent(rec.fLastEvent),
383 fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
384 fFractionFriends(rec.fFractionFriends),
386 fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
387 fLoadAlignData(rec.fLoadAlignData),
388 fUseHLTData(rec.fUseHLTData),
392 fCTPTimeParams(NULL),
397 fParentRawReader(NULL),
399 fRecoParam(rec.fRecoParam),
401 fSPDTrackleter(NULL),
403 fDiamondProfileSPD(rec.fDiamondProfileSPD),
404 fDiamondProfile(rec.fDiamondProfile),
405 fDiamondProfileTPC(rec.fDiamondProfileTPC),
406 fListOfCosmicTriggers(NULL),
410 fAlignObjArray(rec.fAlignObjArray),
411 fCDBUri(rec.fCDBUri),
412 fQARefUri(rec.fQARefUri),
414 fInitCDBCalled(rec.fInitCDBCalled),
415 fFromCDBSnapshot(rec.fFromCDBSnapshot),
416 fSnapshotFileName(rec.fSnapshotFileName),
417 fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
418 fQADetectors(rec.fQADetectors),
419 fQATasks(rec.fQATasks),
421 fRunGlobalQA(rec.fRunGlobalQA),
422 fSameQACycle(rec.fSameQACycle),
423 fInitQACalled(rec.fInitQACalled),
424 fWriteQAExpertData(rec.fWriteQAExpertData),
425 fRunPlaneEff(rec.fRunPlaneEff),
436 fIsNewRunLoader(rec.fIsNewRunLoader),
445 fAnalysisMacro(rec.fAnalysisMacro),
448 fDeclTriggerClasses(rec.fDeclTriggerClasses),
455 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
456 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
458 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
459 fReconstructor[iDet] = NULL;
460 fUpgradeMask[iDet] = kFALSE;
461 fLoader[iDet] = NULL;
462 fTracker[iDet] = NULL;
465 for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
466 fQACycles[iDet] = rec.fQACycles[iDet];
467 fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
470 for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
471 if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
474 for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
478 //_____________________________________________________________________________
479 AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
481 // assignment operator
482 // Used in PROOF mode
483 // Be very careful while modifing it!
484 // Simple rules to follow:
485 // for persistent data members - use their assignment operators
486 // for non-persistent ones - do nothing or take the default values from constructor
487 // TSelector members should not be touched
488 if(&rec == this) return *this;
490 fRunVertexFinder = rec.fRunVertexFinder;
491 fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
492 fRunHLTTracking = rec.fRunHLTTracking;
493 fRunMuonTracking = rec.fRunMuonTracking;
494 fRunV0Finder = rec.fRunV0Finder;
495 fRunCascadeFinder = rec.fRunCascadeFinder;
496 fRunMultFinder = rec.fRunMultFinder;
497 fStopOnError = rec.fStopOnError;
498 fWriteAlignmentData = rec.fWriteAlignmentData;
499 fWriteESDfriend = rec.fWriteESDfriend;
500 fFillTriggerESD = rec.fFillTriggerESD;
502 fCleanESD = rec.fCleanESD;
503 fV0DCAmax = rec.fV0DCAmax;
504 fV0CsPmin = rec.fV0CsPmin;
508 fRunLocalReconstruction = rec.fRunLocalReconstruction;
509 fRunTracking = rec.fRunTracking;
510 fFillESD = rec.fFillESD;
511 fDeleteRecPoints = rec.fDeleteRecPoints;
512 fDeleteDigits = rec.fDeleteDigits;
513 fLoadCDB = rec.fLoadCDB;
514 fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
515 fGAliceFileName = rec.fGAliceFileName;
516 fRawInput = rec.fRawInput;
517 fESDOutput = rec.fESDOutput;
518 fProofOutputFileName = rec.fProofOutputFileName;
519 fProofOutputLocation = rec.fProofOutputLocation;
520 fProofOutputDataset = rec.fProofOutputDataset;
521 fProofOutputArchive = rec.fProofOutputArchive;
522 fEquipIdMap = rec.fEquipIdMap;
523 fFirstEvent = rec.fFirstEvent;
524 fLastEvent = rec.fLastEvent;
525 fNumberOfEventsPerFile = rec.fNumberOfEventsPerFile;
526 fFractionFriends = rec.fFractionFriends;
528 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
529 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
532 fLoadAlignFromCDB = rec.fLoadAlignFromCDB;
533 fLoadAlignData = rec.fLoadAlignData;
534 fUseHLTData = rec.fUseHLTData;
536 delete fRunInfo; fRunInfo = NULL;
537 if (rec.fRunInfo) fRunInfo = new AliRunInfo(*rec.fRunInfo);
539 fEventInfo = rec.fEventInfo;
541 delete fRunScalers; fRunScalers = NULL;
542 if (rec.fRunScalers) fRunScalers = new AliTriggerRunScalers(*rec.fRunScalers);
544 delete fCTPTimeParams; fCTPTimeParams = NULL;
545 if (rec.fCTPTimeParams) fCTPTimeParams = new AliCTPTimeParams(*rec.fCTPTimeParams);
546 delete fCTPTimeAlign; fCTPTimeAlign = NULL;
547 if (rec.fCTPTimeAlign) fCTPTimeAlign = new AliCTPTimeParams(*rec.fCTPTimeAlign);
551 fParentRawReader = NULL;
553 fRecoParam = rec.fRecoParam;
555 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
556 fUpgradeMask[iDet] = kFALSE;
557 delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
558 delete fLoader[iDet]; fLoader[iDet] = NULL;
559 delete fTracker[iDet]; fTracker[iDet] = NULL;
562 for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
563 fQACycles[iDet] = rec.fQACycles[iDet];
564 fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
567 delete fSPDTrackleter; fSPDTrackleter = NULL;
569 delete fDiamondProfileSPD; fDiamondProfileSPD = NULL;
570 if (rec.fDiamondProfileSPD) fDiamondProfileSPD = new AliESDVertex(*rec.fDiamondProfileSPD);
571 delete fDiamondProfile; fDiamondProfile = NULL;
572 if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile);
573 delete fDiamondProfileTPC; fDiamondProfileTPC = NULL;
574 if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC);
576 delete fListOfCosmicTriggers; fListOfCosmicTriggers = NULL;
577 if (rec.fListOfCosmicTriggers) fListOfCosmicTriggers = (THashTable*)((rec.fListOfCosmicTriggers)->Clone());
579 delete fGRPData; fGRPData = NULL;
580 // if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
581 if (rec.fGRPData) fGRPData = (AliGRPObject*)((rec.fGRPData)->Clone());
583 delete fAlignObjArray; fAlignObjArray = NULL;
586 fQARefUri = rec.fQARefUri;
587 fSpecCDBUri.Delete();
588 fInitCDBCalled = rec.fInitCDBCalled;
589 fFromCDBSnapshot = rec.fFromCDBSnapshot;
590 fSnapshotFileName = rec.fSnapshotFileName;
591 fSetRunNumberFromDataCalled = rec.fSetRunNumberFromDataCalled;
592 fQADetectors = rec.fQADetectors;
593 fQATasks = rec.fQATasks;
595 fRunGlobalQA = rec.fRunGlobalQA;
596 fSameQACycle = rec.fSameQACycle;
597 fInitQACalled = rec.fInitQACalled;
598 fWriteQAExpertData = rec.fWriteQAExpertData;
599 fRunPlaneEff = rec.fRunPlaneEff;
600 for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
610 fIsNewRunLoader = rec.fIsNewRunLoader;
619 fAnalysisMacro = rec.fAnalysisMacro;
622 fDeclTriggerClasses = rec.fDeclTriggerClasses;
627 //_____________________________________________________________________________
628 AliReconstruction::~AliReconstruction()
633 if (fListOfCosmicTriggers) {
634 fListOfCosmicTriggers->Delete();
635 delete fListOfCosmicTriggers;
639 delete fCTPTimeParams;
640 delete fCTPTimeAlign;
642 if (fAlignObjArray) {
643 fAlignObjArray->Delete();
644 delete fAlignObjArray;
646 fSpecCDBUri.Delete();
648 AliCodeTimer::Instance()->Print();
651 //_____________________________________________________________________________
652 void AliReconstruction::InitQA()
654 //Initialize the QA and start of cycle
655 AliCodeTimerAuto("",0);
657 if (fInitQACalled) return;
658 fInitQACalled = kTRUE;
660 if (fGRPData) AliQADataMaker::SetCloningRequest( fGRPData->GetQATrigClasses(), fGRPData->GetQACloningRequest());
663 AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kRECMODE) ;
664 if (fWriteQAExpertData)
665 qam->SetWriteExpert() ;
667 if (qam->IsDefaultStorageSet()) {
668 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
669 AliWarning("Default QA reference storage has been already set !");
670 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fQARefUri.Data()));
671 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
672 fQARefUri = qam->GetDefaultStorage()->GetURI();
674 if (fQARefUri.Length() > 0) {
675 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
676 AliDebug(2, Form("Default QA reference storage is set to: %s", fQARefUri.Data()));
677 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
679 fQARefUri="local://$ALICE_ROOT/QAref";
680 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
681 AliWarning("Default QA refeference storage not yet set !!!!");
682 AliWarning(Form("Setting it now to: %s", fQARefUri.Data()));
683 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
686 qam->SetDefaultStorage(fQARefUri);
690 qam->SetActiveDetectors(fQADetectors) ;
691 for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) {
692 qam->SetCycleLength(AliQAv1::DETECTORINDEX_t(det), fQACycles[det]) ;
693 qam->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
695 if (!fRawReader && !fInput && IsInTasks(AliQAv1::kRAWS))
696 fQATasks.ReplaceAll(Form("%d",AliQAv1::kRAWS), "") ;
697 qam->SetTasks(fQATasks) ;
698 qam->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ;
701 Bool_t sameCycle = kFALSE ;
702 AliQADataMaker *qadm = qam->GetQADataMaker(AliQAv1::kGLOBAL);
703 AliInfo(Form("Initializing the global QA data maker"));
704 if (IsInTasks(AliQAv1::kRECPOINTS)) {
705 qadm->StartOfCycle(AliQAv1::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
706 TObjArray **arr=qadm->Init(AliQAv1::kRECPOINTS);
707 AliTracker::SetResidualsArray(arr);
710 if (IsInTasks(AliQAv1::kESDS)) {
711 qadm->StartOfCycle(AliQAv1::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
712 qadm->Init(AliQAv1::kESDS);
715 AliSysInfo::AddStamp("InitQA") ;
718 //_____________________________________________________________________________
719 void AliReconstruction::MergeQA(const char *fileName)
721 //Initialize the QA and start of cycle
722 AliCodeTimerAuto("",0) ;
723 AliQAManager::QAManager()->Merge(AliCDBManager::Instance()->GetRun(),fileName) ;
724 AliSysInfo::AddStamp("MergeQA") ;
727 //_____________________________________________________________________________
728 void AliReconstruction::InitCDB()
730 // activate a default CDB storage
731 // First check if we have any CDB storage set, because it is used
732 // to retrieve the calibration and alignment constants
733 AliCodeTimerAuto("",0);
735 if (fInitCDBCalled) return;
736 fInitCDBCalled = kTRUE;
738 AliCDBManager* man = AliCDBManager::Instance();
739 if (man->IsDefaultStorageSet())
741 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
742 AliWarning("Default CDB storage has been already set !");
743 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
744 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
745 fCDBUri = man->GetDefaultStorage()->GetURI();
748 if (fCDBUri.Length() > 0)
750 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
751 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
752 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
753 man->SetDefaultStorage(fCDBUri);
755 else if (!man->GetRaw()){
756 fCDBUri="local://$ALICE_ROOT/OCDB";
757 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
758 AliWarning("Default CDB storage not yet set !!!!");
759 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
760 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
761 man->SetDefaultStorage(fCDBUri);
764 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
765 AliWarning("Default storage will be set after setting the Run Number!!!");
766 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
770 // Now activate the detector specific CDB storage locations
771 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
772 TObject* obj = fSpecCDBUri[i];
774 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
775 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
776 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
777 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
779 AliSysInfo::AddStamp("InitCDB");
782 //_____________________________________________________________________________
783 void AliReconstruction::SetDefaultStorage(const char* uri) {
784 // Store the desired default CDB storage location
785 // Activate it later within the Run() method
791 //_____________________________________________________________________________
792 void AliReconstruction::SetQARefDefaultStorage(const char* uri) {
793 // Store the desired default CDB storage location
794 // Activate it later within the Run() method
797 AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
800 //_____________________________________________________________________________
801 void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
802 // Store a detector-specific CDB storage location
803 // Activate it later within the Run() method
805 AliCDBPath aPath(calibType);
806 if(!aPath.IsValid()){
807 // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
808 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
809 if(!strcmp(calibType, fgkDetectorName[iDet])) {
810 aPath.SetPath(Form("%s/*", calibType));
811 AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
815 if(!aPath.IsValid()){
816 AliError(Form("Not a valid path or detector: %s", calibType));
821 // // check that calibType refers to a "valid" detector name
822 // Bool_t isDetector = kFALSE;
823 // for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
824 // TString detName = fgkDetectorName[iDet];
825 // if(aPath.GetLevel0() == detName) {
826 // isDetector = kTRUE;
832 // AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
836 TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
837 if (obj) fSpecCDBUri.Remove(obj);
838 fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
842 //_____________________________________________________________________________
843 Bool_t AliReconstruction::SetRunNumberFromData()
845 // The method is called in Run() in order
846 // to set a correct run number.
847 // In case of raw data reconstruction the
848 // run number is taken from the raw data header
850 if (fSetRunNumberFromDataCalled) return kTRUE;
851 fSetRunNumberFromDataCalled = kTRUE;
853 AliCDBManager* man = AliCDBManager::Instance();
856 if(fRawReader->NextEvent()) {
857 if(man->GetRun() > 0) {
858 AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
860 man->SetRun(fRawReader->GetRunNumber());
861 fRawReader->RewindEvents();
864 if(man->GetRun() > 0) {
865 AliWarning("No raw-data events are found ! Using settings in AliCDBManager !");
868 AliWarning("Neither raw events nor settings in AliCDBManager are found !");
874 AliRunLoader *rl = AliRunLoader::Open(fGAliceFileName.Data());
876 AliError(Form("No run loader found in file %s", fGAliceFileName.Data()));
881 // read run number from gAlice
882 if(rl->GetHeader()) {
883 man->SetRun(rl->GetHeader()->GetRun());
888 AliError("Neither run-loader header nor RawReader objects are found !");
900 //_____________________________________________________________________________
901 void AliReconstruction::SetCDBLock() {
902 // Set CDB lock: from now on it is forbidden to reset the run number
903 // or the default storage or to activate any further storage!
905 AliCDBManager::Instance()->SetLock(1);
908 //_____________________________________________________________________________
909 void AliReconstruction::MatchUpgradeDetector() {
910 // Translates detector name in a boolean.
911 // The boolean is used in GetReconstructor to load the
912 // upgrade reconstructor instead of the standard one.
913 for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
914 if(fUpgradeModule.Contains(fgkDetectorName[iDet])) fUpgradeMask[iDet]=kTRUE;
917 //_____________________________________________________________________________
918 Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
920 // Read the alignment objects from CDB.
921 // Each detector is supposed to have the
922 // alignment objects in DET/Align/Data CDB path.
923 // All the detector objects are then collected,
924 // sorted by geometry level (starting from ALIC) and
925 // then applied to the TGeo geometry.
926 // Finally an overlaps check is performed.
928 // Load alignment data from CDB and fill fAlignObjArray
929 if(fLoadAlignFromCDB){
931 TString detStr = detectors;
932 TString loadAlObjsListOfDets = "";
934 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
935 if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
936 if(!strcmp(fgkDetectorName[iDet],"HLT")) continue;
938 if(AliGeomManager::GetNalignable(fgkDetectorName[iDet]) != 0)
940 loadAlObjsListOfDets += fgkDetectorName[iDet];
941 loadAlObjsListOfDets += " ";
943 } // end loop over detectors
945 if(AliGeomManager::GetNalignable("GRP") != 0)
946 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
947 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
949 // Check if the array with alignment objects was
950 // provided by the user. If yes, apply the objects
951 // to the present TGeo geometry
952 if (fAlignObjArray) {
953 if (gGeoManager && gGeoManager->IsClosed()) {
954 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
955 AliError("The misalignment of one or more volumes failed!"
956 "Compare the list of simulated detectors and the list of detector alignment data!");
961 AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
967 if (fAlignObjArray) {
968 fAlignObjArray->Delete();
969 delete fAlignObjArray; fAlignObjArray=NULL;
975 //_____________________________________________________________________________
976 void AliReconstruction::SetGAliceFile(const char* fileName)
978 // set the name of the galice file
980 fGAliceFileName = fileName;
983 //_____________________________________________________________________________
984 void AliReconstruction::SetInput(const char* input)
986 // In case the input string starts with 'mem://', we run in an online mode
987 // and AliRawReaderDateOnline object is created. In all other cases a raw-data
988 // file is assumed. One can give as an input:
989 // mem://: - events taken from DAQ monitoring libs online
991 // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
992 if (input) fRawInput = input;
995 //_____________________________________________________________________________
996 void AliReconstruction::SetOutput(const char* output)
998 // Set the output ESD filename
999 // 'output' is a normalt ROOT url
1000 // The method is used in case of raw-data reco with PROOF
1001 if (output) fESDOutput = output;
1004 //_____________________________________________________________________________
1005 void AliReconstruction::SetOption(const char* detector, const char* option)
1007 // set options for the reconstruction of a detector
1009 TObject* obj = fOptions.FindObject(detector);
1010 if (obj) fOptions.Remove(obj);
1011 fOptions.Add(new TNamed(detector, option));
1014 //_____________________________________________________________________________
1015 void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam *par)
1017 // Set custom reconstruction parameters for a given detector
1018 // Single set of parameters for all the events
1020 // First check if the reco-params are global
1021 if(!strcmp(detector, "GRP")) {
1022 par->SetAsDefault();
1023 fRecoParam.AddDetRecoParam(kNDetectors,par);
1027 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1028 if(!strcmp(detector, fgkDetectorName[iDet])) {
1029 par->SetAsDefault();
1030 fRecoParam.AddDetRecoParam(iDet,par);
1037 //_____________________________________________________________________________
1038 Bool_t AliReconstruction::InitGRP() {
1039 //------------------------------------
1040 // Initialization of the GRP entry
1041 //------------------------------------
1042 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
1046 TMap* m = dynamic_cast<TMap*>(entry->GetObject()); // old GRP entry
1049 AliInfo("Found a TMap in GRP/GRP/Data, converting it into an AliGRPObject");
1051 fGRPData = new AliGRPObject();
1052 fGRPData->ReadValuesFromMap(m);
1056 AliInfo("Found an AliGRPObject in GRP/GRP/Data, reading it");
1057 fGRPData = dynamic_cast<AliGRPObject*>(entry->GetObject()); // new GRP entry
1061 // FIX ME: The unloading of GRP entry is temporarily disabled
1062 // because ZDC and VZERO are using it in order to initialize
1063 // their reconstructor objects. In the future one has to think
1064 // of propagating AliRunInfo to the reconstructors.
1065 // AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
1069 AliError("No GRP entry found in OCDB!");
1073 TString lhcState = fGRPData->GetLHCState();
1074 if (lhcState==AliGRPObject::GetInvalidString()) {
1075 AliError("GRP/GRP/Data entry: missing value for the LHC state ! Using UNKNOWN");
1076 lhcState = "UNKNOWN";
1079 TString beamType = fGRPData->GetBeamType();
1080 if (beamType==AliGRPObject::GetInvalidString()) {
1081 AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN");
1082 beamType = "UNKNOWN";
1085 Float_t beamEnergy = fGRPData->GetBeamEnergy();
1086 if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
1087 AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
1091 TString runType = fGRPData->GetRunType();
1092 if (runType==AliGRPObject::GetInvalidString()) {
1093 AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN");
1094 runType = "UNKNOWN";
1097 Int_t activeDetectors = fGRPData->GetDetectorMask();
1098 if (activeDetectors==AliGRPObject::GetInvalidUInt()) {
1099 AliError("GRP/GRP/Data entry: missing value for the detector mask ! Using 1074790399");
1100 activeDetectors = 1074790399;
1102 AliDebug(1, Form("activeDetectors = %d", activeDetectors));
1104 fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
1108 // Process the list of active detectors
1109 if (activeDetectors) {
1110 UInt_t detMask = activeDetectors;
1111 AliDebug(1, Form("Detector List = %s", fRunLocalReconstruction.Data()));
1112 fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
1113 AliDebug(1, Form("Detector List = %s", fRunLocalReconstruction.Data()));
1114 fRunTracking = MatchDetectorList(fRunTracking,detMask);
1115 fFillESD = MatchDetectorList(fFillESD,detMask);
1116 fQADetectors = MatchDetectorList(fQADetectors,detMask);
1117 fDeleteRecPoints = MatchDetectorList(fDeleteRecPoints,detMask);
1118 fDeleteDigits = MatchDetectorList(fDeleteDigits,detMask);
1119 fLoadCDB.Form("%s %s %s %s",
1120 fRunLocalReconstruction.Data(),
1121 fRunTracking.Data(),
1123 fQADetectors.Data());
1124 fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
1125 if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1) &&
1126 !((detMask >> AliDAQ::DetectorID("ITSSDD")) & 0x1) &&
1127 !((detMask >> AliDAQ::DetectorID("ITSSSD")) & 0x1) ) {
1128 // switch off the vertexer
1129 AliInfo("SPD,SDD,SSD is not in the list of active detectors. Vertexer and Trackleter are switched off.");
1130 fRunVertexFinder = kFALSE;
1131 fRunMultFinder = kFALSE;
1133 if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) {
1134 // switch off the reading of CTP raw-data payload
1135 if (fFillTriggerESD) {
1136 AliInfo("CTP is not in the list of active detectors. CTP data reading switched off.");
1137 fFillTriggerESD = kFALSE;
1142 AliInfo("===================================================================================");
1143 AliInfo(Form("Running local reconstruction for detectors: %s",fRunLocalReconstruction.Data()));
1144 AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data()));
1145 AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data()));
1146 AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data()));
1147 AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data()));
1148 AliInfo("===================================================================================");
1150 //*** Dealing with the magnetic field map
1151 if ( TGeoGlobalMagField::Instance()->IsLocked() ) {
1152 if (TGeoGlobalMagField::Instance()->GetField()->TestBit(AliMagF::kOverrideGRP)) {
1153 AliInfo("ExpertMode!!! GRP information will be ignored !");
1154 AliInfo("ExpertMode!!! Running with the externally locked B field !");
1157 AliInfo("Destroying existing B field instance!");
1158 delete TGeoGlobalMagField::Instance();
1161 if ( !TGeoGlobalMagField::Instance()->IsLocked() ) {
1162 // Construct the field map out of the information retrieved from GRP.
1165 Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0);
1166 if (l3Current == AliGRPObject::GetInvalidFloat()) {
1167 AliError("GRP/GRP/Data entry: missing value for the L3 current !");
1171 Char_t l3Polarity = fGRPData->GetL3Polarity();
1172 if (l3Polarity == AliGRPObject::GetInvalidChar()) {
1173 AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
1178 Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0);
1179 if (diCurrent == AliGRPObject::GetInvalidFloat()) {
1180 AliError("GRP/GRP/Data entry: missing value for the dipole current !");
1184 Char_t diPolarity = fGRPData->GetDipolePolarity();
1185 if (diPolarity == AliGRPObject::GetInvalidChar()) {
1186 AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
1190 // read special bits for the polarity convention and map type
1191 Int_t polConvention = fGRPData->IsPolarityConventionLHC() ? AliMagF::kConvLHC : AliMagF::kConvDCS2008;
1192 Bool_t uniformB = fGRPData->IsUniformBMap();
1195 AliMagF* fld = AliMagF::CreateFieldMap(TMath::Abs(l3Current) * (l3Polarity ? -1:1),
1196 TMath::Abs(diCurrent) * (diPolarity ? -1:1),
1197 polConvention,uniformB,beamEnergy, beamType.Data());
1199 TGeoGlobalMagField::Instance()->SetField( fld );
1200 TGeoGlobalMagField::Instance()->Lock();
1201 AliInfo("Running with the B field constructed out of GRP !");
1203 else AliFatal("Failed to create a B field map !");
1205 else AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
1208 //*** Get the diamond profiles from OCDB
1209 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1211 fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
1213 AliError("No SPD diamond profile found in OCDB!");
1216 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1218 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
1220 AliError("No diamond profile found in OCDB!");
1223 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1225 fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
1227 AliError("No TPC diamond profile found in OCDB!");
1230 entry = AliCDBManager::Instance()->Get("GRP/Calib/CosmicTriggers");
1232 fListOfCosmicTriggers = dynamic_cast<THashTable*>(entry->GetObject());
1236 if (!fListOfCosmicTriggers) {
1237 AliWarning("Can not get list of cosmic triggers from OCDB! Cosmic event specie will be effectively disabled!");
1243 //_____________________________________________________________________________
1244 Bool_t AliReconstruction::LoadCDB()
1246 // Load CDB entries for all active detectors.
1247 // By default we load all the entries in <det>/Calib
1250 AliCodeTimerAuto("",0);
1252 AliCDBManager::Instance()->Get("GRP/CTP/Config");
1254 AliCDBManager::Instance()->Get("GRP/Calib/LHCClockPhase");
1256 TString detStr = fLoadCDB;
1257 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1258 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1259 AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
1260 AliCDBManager::Instance()->GetAll(Form("%s/Trigger/*",fgkDetectorName[iDet]));
1263 // Temporary fix - one has to define the correct policy in order
1264 // to load the trigger OCDB entries only for the detectors that
1265 // in the trigger or that are needed in order to put correct
1266 // information in ESD
1267 AliCDBManager::Instance()->GetAll("TRIGGER/*/*");
1271 //_____________________________________________________________________________
1272 Bool_t AliReconstruction::LoadTriggerScalersCDB()
1274 // Load CTP scalers from OCDB.
1275 // The scalers are checked for consistency.
1277 AliCodeTimerAuto("",0);
1279 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/Scalers");
1283 AliInfo("Found an AliTriggerRunScalers in GRP/CTP/Scalers, reading it");
1284 fRunScalers = dynamic_cast<AliTriggerRunScalers*> (entry->GetObject());
1286 if (fRunScalers && (fRunScalers->CorrectScalersOverflow() == 0)) AliInfo("32bit Trigger counters corrected for overflow");
1291 //_____________________________________________________________________________
1292 Bool_t AliReconstruction::LoadCTPTimeParamsCDB()
1294 // Load CTP timing information (alignment)
1297 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
1298 if (!entry) return kFALSE;
1300 AliInfo("Found an AliCTPTimeParams in GRP/CTP/CTPtiming, reading it");
1301 fCTPTimeParams = dynamic_cast<AliCTPTimeParams*> (entry->GetObject());
1304 AliCDBEntry* entry2 = AliCDBManager::Instance()->Get("GRP/CTP/TimeAlign");
1305 if (!entry2) return kFALSE;
1307 AliInfo("Found an AliCTPTimeParams in GRP/CTP/TimeAlign, reading it");
1308 fCTPTimeAlign = dynamic_cast<AliCTPTimeParams*> (entry2->GetObject());
1309 entry2->SetOwner(0);
1314 //_____________________________________________________________________________
1315 Bool_t AliReconstruction::ReadIntensityInfoCDB()
1317 // Load LHC DIP data
1318 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/LHCData");
1319 AliCDBEntry* entryCTP = AliCDBManager::Instance()->Get("GRP/CTP/Config");
1321 if (!entry || !entryCTP) {
1322 AliError(Form("Failed to extract CDB objects GRP/GRP/LHCData: %p or GRP/CTP/Config: %p",entry,entryCTP));
1326 enum {kA,kB,kC,kE,kNMasks};
1327 AliTriggerConfiguration* conf = (AliTriggerConfiguration*)entryCTP->GetObject();
1328 const TObjArray& clArr = conf->GetClasses();
1329 TObjArray masks(kNMasks);
1331 AliTriggerClass* trClass = 0;
1333 masks.SetOwner(kFALSE);
1335 while ( (trClass=(AliTriggerClass*)next()) ) {
1336 TString trName = trClass->GetName();
1337 int ind = trName.Index("-"); // prefix in front of A,B,C,E
1338 if (ind<1) continue; // anomaly
1340 trName = trName.Data() + ind;
1341 AliTriggerBCMask* bcMask = trClass->GetBCMask();
1342 if (!bcMask) continue;
1344 if (trName.BeginsWith("-A-")) which |= 0x1<<kA;
1345 else if (trName.BeginsWith("-B-")) which |= 0x1<<kB;
1346 else if (trName.BeginsWith("-C-")) which |= 0x1<<kC;
1347 else if (trName.BeginsWith("-E-")) which |= 0x1<<kE;
1348 else if (trName.BeginsWith("-AC-")) which |= (0x1<<kA) | (0x1<<kC);
1349 else if (trName.BeginsWith("-CA-")) which |= (0x1<<kA) | (0x1<<kC);
1350 else { AliWarning(Form("Unknown trigger type %s\n",trClass->GetName())); continue;}
1352 for (int ip=kNMasks;ip--;) {
1353 if ( !(which&(0x1<<ip)) || masks[ip] ) continue; // does not match or already done
1354 masks[ip] = (TObject*)bcMask;
1357 if (nFound==kNMasks) break;
1360 AliInfo("Reading mean bunch intensities from GRP/GRP/LHCData");
1361 AliLHCData* dipData = dynamic_cast<AliLHCData*> (entry->GetObject());
1363 for (int ib=2;ib--;) {
1365 if (dipData && (dipData->GetMeanIntensity(ib,intI,intNI,&masks)>=0)) {
1366 fBeamInt[ib][0] = intI;
1367 fBeamInt[ib][1] = intNI;
1368 AliInfo(Form("Mean intensity for beam %d: Interacting:%.2e Non-Interacting:%.2e",ib,intI,intNI));
1376 //_____________________________________________________________________________
1377 Bool_t AliReconstruction::Run(const char* input)
1380 AliCodeTimerAuto("",0);
1383 if (GetAbort() != TSelector::kContinue) return kFALSE;
1385 TChain *chain = NULL;
1386 if (fRawReader && (chain = fRawReader->GetChain())) {
1387 Long64_t nEntries = (fLastEvent < 0) ? (TChain::kBigNumber) : (fLastEvent - fFirstEvent + 1);
1390 // Temporary fix for long raw-data runs (until socket timeout handling in PROOF is revised)
1391 gProof->Exec("gEnv->SetValue(\"Proof.SocketActivityTimeout\",-1)", kTRUE);
1394 gProof->Exec("TGrid::Connect(\"alien://\")",kTRUE);
1396 TMessage::EnableSchemaEvolutionForAll(kTRUE);
1397 gProof->Exec("TMessage::EnableSchemaEvolutionForAll(kTRUE)",kTRUE);
1399 gProof->AddInput(this);
1401 if (!ParseOutput()) return kFALSE;
1403 gProof->SetParameter("PROOF_MaxSlavesPerNode", 9999);
1405 chain->Process("AliReconstruction","",nEntries,fFirstEvent);
1408 chain->Process(this,"",nEntries,fFirstEvent);
1413 if (GetAbort() != TSelector::kContinue) return kFALSE;
1415 if (GetAbort() != TSelector::kContinue) return kFALSE;
1416 //******* The loop over events
1417 AliInfo("Starting looping over events");
1419 while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
1420 (fRawReader && fRawReader->NextEvent())) {
1422 // check if process has enough resources
1423 if (!HasEnoughResources(iEvent)) break;
1424 if (!ProcessEvent(iEvent)) {
1425 Abort("ProcessEvent",TSelector::kAbortFile);
1431 if (GetAbort() != TSelector::kContinue) return kFALSE;
1433 if (GetAbort() != TSelector::kContinue) return kFALSE;
1439 //_____________________________________________________________________________
1440 void AliReconstruction::InitRawReader(const char* input)
1442 // Init raw-reader and
1443 // set the input in case of raw data
1445 AliCodeTimerAuto("",0);
1447 if (input) fRawInput = input;
1448 fRawReader = AliRawReader::Create(fRawInput.Data());
1450 if (fRawInput.IsNull()) {
1451 AliInfo("Reconstruction will run over digits");
1454 AliFatal("Can not create raw-data reader ! Exiting...");
1458 if (!fEquipIdMap.IsNull() && fRawReader)
1459 fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1461 if (!fUseHLTData.IsNull()) {
1462 // create the RawReaderHLT which performs redirection of HLT input data for
1463 // the specified detectors
1464 AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
1466 fParentRawReader=fRawReader;
1467 fRawReader=pRawReader;
1469 AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
1472 AliSysInfo::AddStamp("CreateRawReader");
1475 //_____________________________________________________________________________
1476 void AliReconstruction::InitRun(const char* input)
1478 // Initialization of raw-reader,
1479 // run number, CDB etc.
1480 AliCodeTimerAuto("",0);
1481 AliSysInfo::AddStamp("Start");
1483 // Initialize raw-reader if any
1484 InitRawReader(input);
1486 // Initialize the CDB storage
1489 // Set run number in CDBManager (if it is not already set by the user)
1490 if (!SetRunNumberFromData()) {
1491 Abort("SetRunNumberFromData", TSelector::kAbortProcess);
1495 if(fFromCDBSnapshot){
1496 AliDebug(2,"Initializing from a CDB snapshot");
1497 if(!AliCDBManager::Instance()->InitFromSnapshot(fSnapshotFileName.Data()))
1498 AliFatal("Was not able to initialize from the snapshot!");
1500 // Set CDB lock: from now on it is forbidden to reset the run number
1501 // or the default storage or to activate any further storage!
1506 //_____________________________________________________________________________
1507 void AliReconstruction::Begin(TTree *)
1509 // Initialize AlReconstruction before
1510 // going into the event loop
1511 // Should follow the TSelector convention
1512 // i.e. initialize only the object on the client side
1513 AliCodeTimerAuto("",0);
1515 AliReconstruction *reco = NULL;
1517 if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
1520 AliSysInfo::AddStamp("ReadInputInBegin");
1523 // Import ideal TGeo geometry and apply misalignment
1525 TString geom(gSystem->DirName(fGAliceFileName));
1526 geom += "/geometry.root";
1527 AliGeomManager::LoadGeometry(geom.Data());
1529 Abort("LoadGeometry", TSelector::kAbortProcess);
1532 AliSysInfo::AddStamp("LoadGeom");
1533 TString detsToCheck=fRunLocalReconstruction;
1534 if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) {
1535 Abort("CheckSymNamesLUT", TSelector::kAbortProcess);
1538 AliSysInfo::AddStamp("CheckGeom");
1541 Bool_t toCDBSnapshot=kFALSE;
1542 TString snapshotFileOut(""); // we could use fSnapshotFileName if we are not interested
1543 // in reading from and writing to a snapshot file at the same time
1544 if(TString(gSystem->Getenv("OCDB_SNAPSHOT_CREATE")) == TString("kTRUE")){
1545 toCDBSnapshot=kTRUE;
1546 //fFromCDBSnapshot=kFALSE;
1547 TString snapshotFile(gSystem->Getenv("OCDB_SNAPSHOT_FILENAME"));
1548 if(!(snapshotFile.IsNull() || snapshotFile.IsWhitespace()))
1549 snapshotFileOut = snapshotFile;
1551 snapshotFileOut="OCDB.root";
1554 if (!MisalignGeometry(fLoadAlignData)) {
1555 Abort("MisalignGeometry", TSelector::kAbortProcess);
1558 AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
1559 if(!toCDBSnapshot) AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
1560 AliSysInfo::AddStamp("MisalignGeom");
1563 Abort("InitGRP", TSelector::kAbortProcess);
1566 AliSysInfo::AddStamp("InitGRP");
1567 if(!toCDBSnapshot) AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
1569 if(!fFromCDBSnapshot){
1571 Abort("LoadCDB", TSelector::kAbortProcess);
1574 AliSysInfo::AddStamp("LoadCDB");
1577 if (!LoadTriggerScalersCDB()) {
1578 Abort("LoadTriggerScalersCDB", TSelector::kAbortProcess);
1581 AliSysInfo::AddStamp("LoadTriggerScalersCDB");
1583 if (!LoadCTPTimeParamsCDB()) {
1584 Abort("LoadCTPTimeParamsCDB", TSelector::kAbortProcess);
1587 AliSysInfo::AddStamp("LoadCTPTimeParamsCDB");
1589 if (!ReadIntensityInfoCDB()) {
1590 Abort("ReadIntensityInfoCDB", TSelector::kAbortProcess);
1593 AliSysInfo::AddStamp("ReadIntensityInfoCDB");
1595 // Read the reconstruction parameters from OCDB
1596 if (!InitRecoParams()) {
1597 AliWarning("Not all detectors have correct RecoParam objects initialized");
1599 AliSysInfo::AddStamp("InitRecoParams");
1602 AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data(),kFALSE);
1603 AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
1604 AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
1606 if (fInput && gProof) {
1607 if (reco) *reco = *this;
1609 gGeoManager->SetName("Geometry");
1610 gProof->AddInputData(gGeoManager,kTRUE);
1612 gProof->AddInputData(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()),kTRUE);
1613 fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
1614 AliMagF *magFieldMap = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
1615 magFieldMap->SetName("MagneticFieldMap");
1616 gProof->AddInputData(magFieldMap,kTRUE);
1618 fAnalysis->SetName("Analysis");
1619 gProof->AddInputData(fAnalysis,kTRUE);
1625 //_____________________________________________________________________________
1626 void AliReconstruction::SlaveBegin(TTree*)
1628 // Initialization related to run-loader,
1629 // vertexer, trackers, recontructors
1630 // In proof mode it is executed on the slave
1631 AliCodeTimerAuto("",0);
1633 TProofOutputFile *outProofFile = NULL;
1635 if (AliDebugLevel() > 0) fInput->Print();
1636 if (AliDebugLevel() > 10) fInput->Dump();
1637 if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
1640 if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) {
1642 AliGeomManager::SetGeometry(tgeo);
1644 if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) {
1645 Int_t runNumber = -1;
1646 if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) {
1647 AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber);
1648 man->SetCacheFlag(kTRUE);
1649 man->SetLock(kTRUE);
1653 if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
1654 AliMagF *newMap = new AliMagF(*map);
1655 if (!newMap->LoadParameterization()) {
1656 Abort("AliMagF::LoadParameterization", TSelector::kAbortProcess);
1659 TGeoGlobalMagField::Instance()->SetField(newMap);
1660 TGeoGlobalMagField::Instance()->Lock();
1663 // Attempt to get the analysis manager from the input list
1664 fAnalysis = (AliAnalysisManager*)fInput->FindObject("Analysis");
1665 if (fAnalysis) AliInfo("==== Analysis manager retrieved from input list ====");
1667 if (TNamed *outputFileName = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE"))
1668 fProofOutputFileName = outputFileName->GetTitle();
1669 if (TNamed *outputLocation = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_LOCATION"))
1670 fProofOutputLocation = outputLocation->GetTitle();
1671 if (fInput->FindObject("PROOF_OUTPUTFILE_DATASET"))
1672 fProofOutputDataset = kTRUE;
1673 if (TNamed *archiveList = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_ARCHIVE"))
1674 fProofOutputArchive = archiveList->GetTitle();
1675 if (!fProofOutputFileName.IsNull() &&
1676 !fProofOutputLocation.IsNull() &&
1677 fProofOutputArchive.IsNull()) {
1678 if (!fProofOutputDataset) {
1679 outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"M");
1680 outProofFile->SetOutputFileName(Form("%s%s",fProofOutputLocation.Data(),fProofOutputFileName.Data()));
1683 outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"DROV",fProofOutputLocation.Data());
1685 if (AliDebugLevel() > 0) outProofFile->Dump();
1686 fOutput->Add(outProofFile);
1688 AliSysInfo::AddStamp("ReadInputInSlaveBegin");
1690 // Check if analysis was requested in the reconstruction event loop
1692 // Attempt to connect in-memory singleton
1693 fAnalysis = AliAnalysisManager::GetAnalysisManager();
1694 if (fAnalysis) AliInfo(Form("==== Analysis manager <%s> found in memory ====", fAnalysis->GetName()));
1695 // Check if an analysis macro was specified
1696 if (!fAnalysis && !fAnalysisMacro.IsNull()) {
1697 // Run specified analysis macro
1698 gROOT->ProcessLine(Form(".x %s",fAnalysisMacro.Data()));
1699 fAnalysis = AliAnalysisManager::GetAnalysisManager();
1700 if (!fAnalysis) AliError(Form("No analysis manager produced by analysis macro %s", fAnalysisMacro.Data()));
1701 else AliInfo(Form("==== Analysis manager <%s> produced by analysis macro <%s> ====",
1702 fAnalysis->GetName(), fAnalysisMacro.Data()));
1706 // get the run loader
1707 if (!InitRunLoader()) {
1708 Abort("InitRunLoader", TSelector::kAbortProcess);
1711 AliSysInfo::AddStamp("LoadLoader");
1713 ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
1716 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
1717 Abort("CreateTrackers", TSelector::kAbortProcess);
1720 AliSysInfo::AddStamp("CreateTrackers");
1722 // create the ESD output file and tree
1723 if (!outProofFile) {
1724 ffile = TFile::Open("AliESDs.root", "RECREATE");
1725 ffile->SetCompressionLevel(2);
1726 if (!ffile->IsOpen()) {
1727 Abort("OpenESDFile", TSelector::kAbortProcess);
1732 AliInfo(Form("Opening output PROOF file: %s/%s",
1733 outProofFile->GetDir(), outProofFile->GetFileName()));
1734 if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
1735 Abort(Form("Problems opening output PROOF file: %s/%s",
1736 outProofFile->GetDir(), outProofFile->GetFileName()),
1737 TSelector::kAbortProcess);
1742 ftree = new TTree("esdTree", "Tree with ESD objects");
1743 fesd = new AliESDEvent();
1744 fesd->CreateStdContent();
1745 // add a so far non-std object to the ESD, this will
1746 // become part of the std content
1747 fesd->AddObject(new AliESDHLTDecision);
1749 fesd->WriteToTree(ftree);
1750 if (fWriteESDfriend) {
1751 ffileF = TFile::Open("AliESDfriends.root", "RECREATE");
1752 ftreeF = new TTree("esdFriendTree", "Tree with ESD Friend objects");
1753 fesdf = new AliESDfriend();
1754 ftreeF->Branch("ESDfriend.","AliESDfriend", &fesdf);
1755 fesd->AddObject(fesdf);
1758 ftree->GetUserInfo()->Add(fesd);
1760 fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
1761 fhltesd = new AliESDEvent();
1762 fhltesd->CreateStdContent();
1763 // read the ESD template from CDB
1764 // HLT is allowed to put non-std content to its ESD, the non-std
1765 // objects need to be created before invocation of WriteToTree in
1766 // order to create all branches. Initialization is done from an
1767 // ESD layout template in CDB
1768 AliCDBManager* man = AliCDBManager::Instance();
1769 AliCDBPath hltESDConfigPath("HLT/ConfigHLT/esdLayout");
1770 AliCDBEntry* hltESDConfig=NULL;
1771 if (man->GetId(hltESDConfigPath)!=NULL &&
1772 (hltESDConfig=man->Get(hltESDConfigPath))!=NULL) {
1773 AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
1775 // init all internal variables from the list of objects
1776 pESDLayout->GetStdContent();
1778 // copy content and create non-std objects
1779 *fhltesd=*pESDLayout;
1782 AliError(Form("error setting hltEsd layout from %s: invalid object type",
1783 hltESDConfigPath.GetPath().Data()));
1787 fhltesd->WriteToTree(fhlttree);
1788 fhlttree->GetUserInfo()->Add(fhltesd);
1790 ProcInfo_t procInfo;
1791 gSystem->GetProcInfo(&procInfo);
1792 AliInfo(Form("Current memory usage %ld %ld", procInfo.fMemResident, procInfo.fMemVirtual));
1795 //Initialize the QA and start of cycle
1796 if (fRunQA || fRunGlobalQA)
1799 //Initialize the Plane Efficiency framework
1800 if (fRunPlaneEff && !InitPlaneEff()) {
1801 Abort("InitPlaneEff", TSelector::kAbortProcess);
1805 if (strcmp(gProgName,"alieve") == 0)
1806 fRunAliEVE = InitAliEVE();
1807 // If we have an analysis manager, connect the AliRecoInputHandler here
1809 if (!dynamic_cast<AliRecoInputHandler*>(fAnalysis->GetInputEventHandler())) {
1810 AliError("Analysis manager used in reconstruction should use AliRecoInputHandler - \
1811 \n ->Replacing with AliRecoInputHandler instance.");
1812 delete fAnalysis->GetInputEventHandler();
1814 // Set the event and other data pointers
1815 fRecoHandler = new AliRecoInputHandler();
1816 fRecoHandler->Init(ftree, "LOCAL");
1817 fRecoHandler->SetEvent(fesd);
1818 fRecoHandler->SetESDfriend(fesdf);
1819 fRecoHandler->SetHLTEvent(fhltesd);
1820 fRecoHandler->SetHLTTree(fhlttree);
1821 fAnalysis->SetInputEventHandler(fRecoHandler);
1822 // Enter external loop mode
1823 fAnalysis->SetExternalLoop(kTRUE);
1824 // Initialize analysis
1825 fAnalysis->StartAnalysis("local", (TTree*)0);
1826 // Connect ESD tree with the input container
1827 fAnalysis->GetCommonInputContainer()->SetData(ftree);
1832 //_____________________________________________________________________________
1833 Bool_t AliReconstruction::Process(Long64_t entry)
1835 // run the reconstruction over a single entry
1836 // from the chain with raw data
1837 AliCodeTimerAuto("",0);
1839 TTree *currTree = fChain->GetTree();
1840 AliRawVEvent *event = NULL;
1841 currTree->SetBranchAddress("rawevent",&event);
1842 currTree->GetEntry(entry);
1843 fRawReader = new AliRawReaderRoot(event);
1844 // check if process has enough resources
1845 if (!HasEnoughResources(entry)) return kFALSE;
1846 fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
1854 //_____________________________________________________________________________
1855 void AliReconstruction::Init(TTree *tree)
1857 // Implementation of TSelector::Init()
1860 AliError("The input tree is not found!");
1866 //_____________________________________________________________________________
1867 Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
1869 // run the reconstruction over a single event
1870 // The event loop is steered in Run method
1873 static Long_t oldMres=0;
1874 static Long_t oldMvir=0;
1875 static Float_t oldCPU=0;
1876 static Long_t aveDMres=0;
1877 static Long_t aveDMvir=0;
1878 static Float_t aveDCPU=0;
1880 AliCodeTimerAuto("",0);
1884 AliSysInfo::AddStamp(Form("StartEv_%d",iEvent), 0,0,iEvent);
1886 if (iEvent >= fRunLoader->GetNumberOfEvents()) {
1887 fRunLoader->SetEventNumber(iEvent);
1889 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
1891 fRunLoader->TreeE()->Fill();
1893 if (fRawReader && fRawReader->UseAutoSaveESD())
1894 fRunLoader->TreeE()->AutoSave("SaveSelf");
1897 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
1902 fRunLoader->GetEvent(iEvent);
1904 // Fill Event-info object
1906 fRecoParam.SetEventSpecie(fRunInfo,fEventInfo,fListOfCosmicTriggers);
1908 ProcInfo_t procInfo;
1909 if(iEvent==fFirstEvent) {
1910 gSystem->GetProcInfo(&procInfo);
1911 oldMres=procInfo.fMemResident;
1912 oldMvir=procInfo.fMemVirtual;
1913 oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
1915 AliInfo(Form("================================= Processing event %d of type %-10s ==================================", iEvent,fRecoParam.PrintEventSpecie()));
1917 AliSysInfo::AddStamp(Form("StartReco_%d",iEvent), 0,0,iEvent);
1919 // Set the reco-params
1921 TString detStr = fLoadCDB;
1922 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1923 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1924 AliReconstructor *reconstructor = GetReconstructor(iDet);
1925 if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
1926 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
1927 reconstructor->SetRecoParam(par);
1928 reconstructor->GetPidSettings(&pid);
1929 reconstructor->SetEventInfo(&fEventInfo);
1931 AliQAManager::QAManager()->SetEventInfo(&fEventInfo) ;
1932 AliQAManager::QAManager()->SetRecoParam(iDet, par) ;
1933 if (par) AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
1938 if (fRunQA || fRunGlobalQA) AliQADataMaker::SetEventTrigClasses(fEventInfo.GetTriggerClasses()); // RS: select which histo clones are to be filled
1941 const AliDetectorRecoParam *grppar = fRecoParam.GetDetRecoParam(kNDetectors);
1942 AliQAManager::QAManager()->SetRecoParam(AliQAv1::kGLOBAL, grppar) ;
1943 AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(grppar->GetEventSpecie())) ;
1948 if (fRunQA && IsInTasks(AliQAv1::kRAWS)) {
1949 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1950 AliQAManager::QAManager()->RunOneEvent(fRawReader) ;
1951 AliSysInfo::AddStamp(Form("RawQA_%d",iEvent), 0,0,iEvent);
1953 // local single event reconstruction
1954 if (!fRunLocalReconstruction.IsNull()) {
1955 TString detectors=fRunLocalReconstruction;
1956 // run HLT event reconstruction first
1957 // ;-( IsSelected changes the string
1958 if (IsSelected("HLT", detectors) &&
1959 !RunLocalEventReconstruction("HLT")) {
1960 if (fStopOnError) {CleanUp(); return kFALSE;}
1962 detectors=fRunLocalReconstruction;
1963 detectors.ReplaceAll("HLT", "");
1964 if (!RunLocalEventReconstruction(detectors)) {
1973 // fill Event header information from the RawEventHeader
1974 if (fRawReader){FillRawEventHeaderESD(fesd);}
1975 if (fRawReader){FillRawEventHeaderESD(fhltesd);}
1977 fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1978 fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1980 ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
1981 ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
1982 ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
1983 ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
1985 fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1986 fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1988 fesd->SetEventSpecie(fRecoParam.GetEventSpecie());
1989 fhltesd->SetEventSpecie(fRecoParam.GetEventSpecie());
1991 // Set magnetic field from the tracker
1992 fesd->SetMagneticField(AliTracker::GetBz());
1993 fhltesd->SetMagneticField(AliTracker::GetBz());
1995 AliESDRun *esdRun,*esdRunH;
1996 esdRun = (AliESDRun*)fesd->GetESDRun();
1997 esdRunH = (AliESDRun*)fhltesd->GetESDRun();
1998 esdRun->SetBeamEnergyIsSqrtSHalfGeV();
1999 esdRunH->SetBeamEnergyIsSqrtSHalfGeV();
2001 for (int ib=2;ib--;) for (int it=2;it--;) {
2002 esdRun->SetMeanIntensity(ib,it, fBeamInt[ib][it]);
2003 esdRunH->SetMeanIntensity(ib,it, fBeamInt[ib][it]);
2006 fesd->SetBeamEnergy(fGRPData->GetBeamEnergy());
2007 fesd->SetBeamType(fGRPData->GetBeamType().Data());
2008 fesd->SetBeamParticle(fGRPData->GetSingleBeamType(0).Atoi(),0);
2009 fesd->SetBeamParticle(fGRPData->GetSingleBeamType(1).Atoi(),1);
2010 fhltesd->SetBeamEnergy(fGRPData->GetBeamEnergy());
2011 fhltesd->SetBeamType(fGRPData->GetBeamType().Data());
2012 fhltesd->SetBeamParticle(fGRPData->GetSingleBeamType(0).Atoi(),0);
2013 fhltesd->SetBeamParticle(fGRPData->GetSingleBeamType(1).Atoi(),1);
2015 AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
2016 if (fld) { // set info needed for field initialization
2017 fesd->SetCurrentL3(fld->GetCurrentSol());
2018 fesd->SetCurrentDip(fld->GetCurrentDip());
2019 fesd->SetUniformBMap(fld->IsUniform());
2020 fesd->SetBInfoStored();
2022 fhltesd->SetCurrentL3(fld->GetCurrentSol());
2023 fhltesd->SetCurrentDip(fld->GetCurrentDip());
2024 fhltesd->SetUniformBMap(fld->IsUniform());
2025 fhltesd->SetBInfoStored();
2028 // Set most probable pt, for B=0 tracking
2029 // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
2030 const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
2031 if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
2033 // Fill raw-data error log into the ESD
2034 if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
2036 AliSysInfo::AddStamp(Form("FillHeadErrs_%d",iEvent), 0,0,iEvent);
2039 if (fRunVertexFinder) {
2040 if (!RunVertexFinder(fesd)) {
2041 if (fStopOnError) {CleanUp(); return kFALSE;}
2043 AliSysInfo::AddStamp(Form("VtxFinder_%d",iEvent), 0,0,iEvent);
2046 // For Plane Efficiency: run the SPD trackleter
2047 if (fRunPlaneEff && fSPDTrackleter) {
2048 if (!RunSPDTrackleting(fesd)) {
2049 if (fStopOnError) {CleanUp(); return kFALSE;}
2051 AliSysInfo::AddStamp(Form("TrackletEff_%d",iEvent), 0,0,iEvent);
2055 if (!fRunTracking.IsNull()) {
2056 if (fRunMuonTracking) {
2057 if (!RunMuonTracking(fesd)) {
2058 if (fStopOnError) {CleanUp(); return kFALSE;}
2061 AliSysInfo::AddStamp(Form("TrackingMUON_%d",iEvent), 0,0,iEvent);
2065 if (!fRunTracking.IsNull()) {
2066 if (!RunTracking(fesd,pid)) {
2067 if (fStopOnError) {CleanUp(); return kFALSE;}
2072 if (!fFillESD.IsNull()) {
2073 TString detectors=fFillESD;
2074 // run HLT first and on hltesd
2075 // ;-( IsSelected changes the string
2076 if (IsSelected("HLT", detectors) &&
2077 !FillESD(fhltesd, "HLT")) {
2078 if (fStopOnError) {CleanUp(); return kFALSE;}
2081 // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
2082 if (detectors.Contains("ALL")) {
2084 for (Int_t idet=0; idet<kNDetectors; ++idet){
2085 detectors += fgkDetectorName[idet];
2089 detectors.ReplaceAll("HLT", "");
2090 if (!FillESD(fesd, detectors)) {
2091 if (fStopOnError) {CleanUp(); return kFALSE;}
2099 // Propagate track to the beam pipe (if not already done by ITS)
2101 const Int_t ntracks = fesd->GetNumberOfTracks();
2102 const Double_t kRadius = 2.8; //something less than the beam pipe radius
2105 UShort_t selectedIdx[ntracks];
2107 for (Int_t itrack=0; itrack<ntracks; itrack++){
2108 const Double_t kMaxStep = 1; //max step over the material
2111 AliESDtrack *track = fesd->GetTrack(itrack);
2112 if (!track) continue;
2114 AliExternalTrackParam *tpcTrack =
2115 (AliExternalTrackParam *)track->GetTPCInnerParam();
2119 PropagateTrackToBxByBz(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
2122 Int_t n=trkArray.GetEntriesFast();
2123 selectedIdx[n]=track->GetID();
2124 trkArray.AddLast(tpcTrack);
2127 //Tracks refitted by ITS should already be at the SPD vertex
2128 if (track->IsOn(AliESDtrack::kITSrefit)) continue;
2131 PropagateTrackToBxByBz(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
2132 Double_t x[3]; track->GetXYZ(x);
2133 Double_t b[3]; AliTracker::GetBxByBz(x,b);
2134 track->RelateToVertexBxByBz(fesd->GetPrimaryVertexSPD(), b, kVeryBig);
2137 AliSysInfo::AddStamp(Form("RelToSPDVtx_%d",iEvent), 0,0,iEvent);
2139 // Improve the reconstructed primary vertex position using the tracks
2141 Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
2142 if(fesd->GetPrimaryVertexSPD()) {
2143 TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
2144 if(vtitle.Contains("cosmics")) {
2145 runVertexFinderTracks=kFALSE;
2149 if (runVertexFinderTracks) {
2150 // TPC + ITS primary vertex
2151 ftVertexer->SetITSMode();
2152 ftVertexer->SetConstraintOff();
2153 // get cuts for vertexer from AliGRPRecoParam
2154 Bool_t constrSPD=kFALSE;
2156 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
2157 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
2158 grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer,nCutsVertexer);
2159 ftVertexer->SetCuts(cutsVertexer,nCutsVertexer);
2160 delete [] cutsVertexer; cutsVertexer = NULL;
2161 if(grpRecoParam->GetVertexerTracksConstraintITS()) {
2162 if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius){
2163 ftVertexer->SetVtxStart(fDiamondProfile); // apply constraint only if sigmax is smaller than the beam pipe radius
2165 if(fDiamondProfileSPD && fDiamondProfileSPD->GetXRes()<kRadius){
2166 ftVertexer->SetVtxStart(fDiamondProfileSPD);
2172 AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
2175 TString title=pvtx->GetTitle();
2176 title.Append("SPD");
2177 pvtx->SetTitle(title);
2179 if (pvtx->GetStatus()) {
2180 fesd->SetPrimaryVertexTracks(pvtx);
2181 for (Int_t i=0; i<ntracks; i++) {
2182 AliESDtrack *t = fesd->GetTrack(i);
2183 Double_t x[3]; t->GetXYZ(x);
2184 Double_t b[3]; AliTracker::GetBxByBz(x,b);
2185 t->RelateToVertexBxByBz(pvtx, b, kVeryBig);
2188 delete pvtx; pvtx=NULL;
2190 AliSysInfo::AddStamp(Form("VtxTrk_%d",iEvent), 0,0,iEvent);
2192 // TPC-only primary vertex
2193 ftVertexer->SetTPCMode();
2194 ftVertexer->SetConstraintOff();
2195 // get cuts for vertexer from AliGRPRecoParam
2197 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
2198 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
2199 grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer,nCutsVertexer);
2200 ftVertexer->SetCuts(cutsVertexer,nCutsVertexer);
2201 delete [] cutsVertexer; cutsVertexer = NULL;
2202 if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC()) {
2203 if(fDiamondProfileTPC->GetXRes()<kRadius) ftVertexer->SetVtxStart(fDiamondProfileTPC); // apply constraint only if sigmax is smaller than the beam pipe radius
2206 pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
2208 if (pvtx->GetStatus()) {
2209 fesd->SetPrimaryVertexTPC(pvtx);
2210 for (Int_t i=0; i<ntracks; i++) {
2211 AliESDtrack *t = fesd->GetTrack(i);
2212 Double_t x[3]; t->GetXYZ(x);
2213 Double_t b[3]; AliTracker::GetBxByBz(x,b);
2214 t->RelateToVertexTPCBxByBz(pvtx, b, kVeryBig);
2217 delete pvtx; pvtx=NULL;
2219 AliSysInfo::AddStamp(Form("VtxTPC_%d",iEvent), 0,0,iEvent);
2223 if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius) fesd->SetDiamond(fDiamondProfile);
2224 else fesd->SetDiamond(fDiamondProfileSPD);
2228 AliV0vertexer vtxer;
2229 // get cuts for V0vertexer from AliGRPRecoParam
2231 Int_t nCutsV0vertexer = grpRecoParam->GetVertexerV0NCuts();
2232 Double_t cutsV0vertexer[nCutsV0vertexer];
2233 grpRecoParam->GetVertexerV0Cuts(cutsV0vertexer);
2234 vtxer.SetCuts(cutsV0vertexer);
2236 vtxer.Tracks2V0vertices(fesd);
2237 AliSysInfo::AddStamp(Form("V0Finder_%d",iEvent), 0,0,iEvent);
2239 if (fRunCascadeFinder) {
2241 AliCascadeVertexer cvtxer;
2242 // get cuts for CascadeVertexer from AliGRPRecoParam
2244 Int_t nCutsCascadeVertexer = grpRecoParam->GetVertexerCascadeNCuts();
2245 Double_t cutsCascadeVertexer[nCutsCascadeVertexer];
2246 grpRecoParam->GetVertexerCascadeCuts(cutsCascadeVertexer);
2247 cvtxer.SetCuts(cutsCascadeVertexer);
2249 cvtxer.V0sTracks2CascadeVertices(fesd);
2250 AliSysInfo::AddStamp(Form("CascadeFinder_%d",iEvent), 0,0,iEvent);
2255 if (fReconstructor[3])
2256 GetReconstructor(3)->FillEventTimeWithTOF(fesd,&pid);
2261 if (fFillTriggerESD) {
2262 if (!FillTriggerESD(fesd)) {
2263 if (fStopOnError) {CleanUp(); return kFALSE;}
2266 // Always fill scalers
2267 if (!FillTriggerScalers(fesd)) {
2268 if (fStopOnError) {CleanUp(); return kFALSE;}
2271 AliSysInfo::AddStamp(Form("FillVaria_%d",iEvent), 0,0,iEvent);
2276 AliSysInfo::AddStamp(Form("CleanESD_%d",iEvent), 0,0,iEvent);
2279 // RS run updated trackleter: since we want to mark the clusters used by tracks and also mark the
2280 // tracks interpreted as primary, this step should be done in the very end, when full
2281 // ESD info is available (particulalry, V0s)
2283 if (fRunMultFinder) {
2284 if (!RunMultFinder(fesd)) {
2285 if (fStopOnError) {CleanUp(); return kFALSE;}
2287 AliSysInfo::AddStamp(Form("MultFinder_%d",iEvent), 0,0,iEvent);
2290 if (fRunQA && IsInTasks(AliQAv1::kESDS)) {
2291 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2292 AliQAManager::QAManager()->RunOneEvent(fesd, fhltesd) ;
2293 AliSysInfo::AddStamp(Form("RunQA_%d",iEvent), 0,0,iEvent);
2296 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2298 qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2299 if (qadm && IsInTasks(AliQAv1::kESDS))
2300 qadm->Exec(AliQAv1::kESDS, fesd);
2301 AliSysInfo::AddStamp(Form("RunGlobQA_%d",iEvent), 0,0,iEvent);
2304 // copy HLT decision from HLTesd to esd
2305 // the most relevant information is stored in a reduced container in the esd,
2306 // while the full information can be found in the HLTesd
2307 TObject* pHLTSrc=fhltesd->FindListObject(AliESDHLTDecision::Name());
2308 TObject* pHLTTgt=fesd->FindListObject(AliESDHLTDecision::Name());
2309 if (pHLTSrc && pHLTTgt) {
2310 pHLTSrc->Copy(*pHLTTgt);
2313 // Perform analysis of this event if requested
2314 // RS: Should be done before WriteESDfriend, since the latter may clean the esdfriend
2316 fRecoHandler->BeginEvent(iEvent);
2317 fAnalysis->ExecAnalysis();
2318 fRecoHandler->FinishEvent();
2319 AliSysInfo::AddStamp(Form("Analysis_%d",iEvent), 0,0,iEvent);
2322 if (fWriteESDfriend) {
2323 fesd->GetESDfriend(fesdf);
2324 AliSysInfo::AddStamp(Form("CreateFriend_%d",iEvent), 0,0,iEvent);
2329 AliSysInfo::AddStamp(Form("ESDFill_%d",iEvent), 0,0,iEvent);
2331 if (fWriteESDfriend) {
2333 AliSysInfo::AddStamp(Form("WriteFriend_%d",iEvent), 0,0,iEvent);
2337 // Auto-save the ESD tree in case of prompt reco @P2
2338 if (fRawReader && fRawReader->UseAutoSaveESD()) {
2339 ftree->AutoSave("SaveSelf");
2340 if (fWriteESDfriend) ftreeF->AutoSave("SaveSelf");
2346 if (fRunAliEVE) RunAliEVE();
2350 if (fWriteESDfriend) {
2351 fesdf->~AliESDfriend();
2352 new (fesdf) AliESDfriend(); // Reset...
2355 gSystem->GetProcInfo(&procInfo);
2356 Long_t dMres=(procInfo.fMemResident-oldMres)/1024;
2357 Long_t dMvir=(procInfo.fMemVirtual-oldMvir)/1024;
2358 Float_t dCPU=procInfo.fCpuUser+procInfo.fCpuSys-oldCPU;
2359 aveDMres+=(dMres-aveDMres)/(iEvent-fFirstEvent+1);
2360 aveDMvir+=(dMvir-aveDMvir)/(iEvent-fFirstEvent+1);
2361 aveDCPU+=(dCPU-aveDCPU)/(iEvent-fFirstEvent+1);
2362 AliInfo(Form("======================= End Event %d: Res %ld(%3ld <%3ld>) Vir %ld(%3ld <%3ld>) CPU %5.2f <%5.2f> ===================",
2363 iEvent, procInfo.fMemResident/1024, dMres, aveDMres, procInfo.fMemVirtual/1024, dMvir, aveDMvir, dCPU, aveDCPU));
2364 oldMres=procInfo.fMemResident;
2365 oldMvir=procInfo.fMemVirtual;
2366 oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
2369 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2370 if (fReconstructor[iDet]) {
2371 fReconstructor[iDet]->SetRecoParam(NULL);
2372 fReconstructor[iDet]->SetEventInfo(NULL);
2374 if (fTracker[iDet]) fTracker[iDet]->SetEventInfo(NULL);
2377 if (fRunQA || fRunGlobalQA)
2378 AliQAManager::QAManager()->Increment() ;
2380 DeleteRecPoints(fDeleteRecPoints);
2381 DeleteDigits(fDeleteDigits);
2386 //_____________________________________________________________________________
2387 void AliReconstruction::SlaveTerminate()
2389 // Finalize the run on the slave side
2390 // Called after the exit
2391 // from the event loop
2392 AliCodeTimerAuto("",0);
2393 // If analysis was done during reconstruction, we need to call SlaveTerminate for it
2395 fAnalysis->PackOutput(fOutput);
2396 fAnalysis->SetSkipTerminate(kTRUE);
2397 fAnalysis->Terminate();
2400 if (fIsNewRunLoader) { // galice.root didn't exist
2401 fRunLoader->WriteHeader("OVERWRITE");
2402 fRunLoader->WriteTrigger("OVERWRITE");
2403 fRunLoader->CdGAFile();
2404 fRunLoader->Write(0, TObject::kOverwrite);
2407 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
2408 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
2410 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
2411 cdbMapCopy->SetOwner(1);
2412 cdbMapCopy->SetName("cdbMap");
2413 TIter iter(cdbMap->GetTable());
2416 while((pair = dynamic_cast<TPair*> (iter.Next()))){
2417 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
2418 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
2419 if (keyStr && valStr)
2420 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
2423 TList *cdbListCopy = new TList();
2424 cdbListCopy->SetOwner(1);
2425 cdbListCopy->SetName("cdbList");
2427 TIter iter2(cdbList);
2430 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
2431 cdbListCopy->Add(new TObjString(id->ToString().Data()));
2434 ftree->GetUserInfo()->Add(cdbMapCopy);
2435 ftree->GetUserInfo()->Add(cdbListCopy);
2437 // Add the AliRoot version that created this file
2438 TString sVersion("aliroot ");
2439 sVersion += ALIROOT_SVN_BRANCH;
2441 sVersion += ALIROOT_SVN_REVISION;
2442 sVersion += "; root ";
2443 sVersion += ROOT_SVN_BRANCH;
2445 sVersion += ROOT_SVN_REVISION;
2446 sVersion += "; metadata ";
2447 sVersion += gSystem->Getenv("PRODUCTION_METADATA");
2450 TNamed * alirootVersion = new TNamed("alirootVersion",sVersion.Data());
2451 ftree->GetUserInfo()->Add(alirootVersion); // The list becomes owner of alirootVersion
2455 // we want to have only one tree version number
2456 ftree->Write(ftree->GetName(),TObject::kOverwrite);
2457 fhlttree->Write(fhlttree->GetName(),TObject::kOverwrite);
2459 if (fWriteESDfriend) {
2461 ftreeF->Write(ftreeF->GetName(),TObject::kOverwrite);
2464 // Finish with Plane Efficiency evaluation: before of CleanUp !!!
2465 if (fRunPlaneEff && !FinishPlaneEff()) {
2466 AliWarning("Finish PlaneEff evaluation failed");
2469 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2470 if (fReconstructor[iDet]) fReconstructor[iDet]->Terminate();
2472 // End of cycle for the in-loop
2474 if (fRunQA || fRunGlobalQA) {
2475 AliQAManager::QAManager()->EndOfCycle() ;
2477 !fProofOutputLocation.IsNull() &&
2478 fProofOutputArchive.IsNull() &&
2479 !fProofOutputDataset) {
2480 TString qaOutputFile(Form("%sMerged.%s.Data.root",
2481 fProofOutputLocation.Data(),
2482 AliQAv1::GetQADataFileName()));
2483 TProofOutputFile *qaProofFile = new TProofOutputFile(Form("Merged.%s.Data.root",
2484 AliQAv1::GetQADataFileName()));
2485 qaProofFile->SetOutputFileName(qaOutputFile.Data());
2486 if (AliDebugLevel() > 0) qaProofFile->Dump();
2487 fOutput->Add(qaProofFile);
2488 MergeQA(qaProofFile->GetFileName());
2499 if (!fProofOutputFileName.IsNull() &&
2500 !fProofOutputLocation.IsNull() &&
2501 fProofOutputDataset &&
2502 !fProofOutputArchive.IsNull()) {
2503 TProofOutputFile *zipProofFile = new TProofOutputFile(fProofOutputFileName.Data(),
2505 fProofOutputLocation.Data());
2506 if (AliDebugLevel() > 0) zipProofFile->Dump();
2507 fOutput->Add(zipProofFile);
2508 TString fileList(fProofOutputArchive.Data());
2509 fileList.ReplaceAll(","," ");
2511 #if ROOT_SVN_REVISION >= 30174
2512 command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(kTRUE),zipProofFile->GetFileName(),fileList.Data());
2514 command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(),zipProofFile->GetFileName(),fileList.Data());
2516 AliInfo(Form("Executing: %s",command.Data()));
2517 gSystem->Exec(command.Data());
2522 //_____________________________________________________________________________
2523 void AliReconstruction::Terminate()
2525 // Create tags for the events in the ESD tree (the ESD tree is always present)
2526 // In case of empty events the tags will contain dummy values
2527 AliCodeTimerAuto("",0);
2529 // Do not call the ESD tag creator in case of PROOF-based reconstruction
2531 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
2532 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
2533 delete esdtagCreator;
2536 // Cleanup of CDB manager: cache and active storages!
2537 AliCDBManager::Instance()->ClearCache();
2540 //_____________________________________________________________________________
2541 Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
2543 // run the local reconstruction
2545 static Int_t eventNr=0;
2546 AliCodeTimerAuto("",0)
2548 TString detStr = detectors;
2549 // execute HLT reconstruction first since other detector reconstruction
2550 // might depend on HLT data
2551 // key 'HLT' is removed from detStr by IsSelected
2552 if (!IsSelected("HLT", detStr)) {
2553 AliReconstructor* reconstructor = GetReconstructor(kNDetectors-1);
2554 if (reconstructor) {
2555 // there is no AliLoader for HLT, see
2556 // https://savannah.cern.ch/bugs/?35473
2557 AliInfo("running reconstruction for HLT");
2559 AliInfo("reconstructor->Reconstruct(fRawReader, NULL)");
2560 reconstructor->Reconstruct(fRawReader, NULL);
2563 AliInfo("reconstructor->Reconstruct(dummy, NULL)");
2565 reconstructor->Reconstruct(dummy, NULL);
2568 AliSysInfo::AddStamp(Form("LRecHLT_%d",eventNr), -1,1,eventNr);
2571 AliInfo(Form("kNDetectors = %d",kNDetectors));
2573 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2574 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2575 AliDebug(1, Form("Detector: %s", fgkDetectorName[iDet]));
2576 AliReconstructor* reconstructor = GetReconstructor(iDet);
2577 if (!reconstructor) continue;
2578 AliLoader* loader = fLoader[iDet];
2580 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
2583 // conversion of digits
2584 if (fRawReader && reconstructor->HasDigitConversion()) {
2585 AliInfo(Form("converting raw data digits into root objects for %s",
2586 fgkDetectorName[iDet]));
2587 // AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
2588 // fgkDetectorName[iDet]),0);
2589 loader->LoadDigits("update");
2590 loader->CleanDigits();
2591 loader->MakeDigitsContainer();
2592 TTree* digitsTree = loader->TreeD();
2593 reconstructor->ConvertDigits(fRawReader, digitsTree);
2594 loader->WriteDigits("OVERWRITE");
2595 loader->UnloadDigits();
2597 // local reconstruction
2598 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
2599 //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]),0);
2600 AliDebug(1, "Loading Rec Points");
2601 loader->LoadRecPoints("update");
2602 AliDebug(1, "Cleaning Rec Points");
2603 loader->CleanRecPoints();
2604 AliDebug(1, "Making Rec Points Container");
2605 loader->MakeRecPointsContainer();
2606 TTree* clustersTree = loader->TreeR();
2607 if (fRawReader && !reconstructor->HasDigitConversion()) {
2608 reconstructor->Reconstruct(fRawReader, clustersTree);
2611 AliDebug(1, "Loading Digits");
2612 loader->LoadDigits("read");
2613 TTree* digitsTree = loader->TreeD();
2614 AliDebug(1, Form("Digits Tree = %p",digitsTree));
2616 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
2621 AliDebug(1, "Digits -> Clusters");
2622 reconstructor->Reconstruct(digitsTree, clustersTree);
2623 if (fRunQA && IsInTasks(AliQAv1::kDIGITSR)) {
2624 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2625 AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, digitsTree) ;
2628 loader->UnloadDigits();
2630 if (fRunQA && IsInTasks(AliQAv1::kRECPOINTS)) {
2631 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2632 AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, clustersTree) ;
2634 loader->WriteRecPoints("OVERWRITE");
2635 loader->UnloadRecPoints();
2636 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
2638 if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
2639 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2640 AliError(Form("the following detectors were not found: %s",
2648 //_____________________________________________________________________________
2649 Bool_t AliReconstruction::RunSPDTrackleting(AliESDEvent*& esd)
2651 // run the SPD trackleting (for SPD efficiency purpouses)
2653 AliCodeTimerAuto("",0)
2655 Double_t vtxPos[3] = {0, 0, 0};
2656 Double_t vtxErr[3] = {0.0, 0.0, 0.0};
2662 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
2663 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
2664 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
2667 const AliESDVertex *vertex = esd->GetVertex();
2669 AliWarning("Vertex not found");
2672 vertex->GetXYZ(vtxPos);
2673 vertex->GetSigmaXYZ(vtxErr);
2674 if (fSPDTrackleter) {
2675 AliInfo("running the SPD Trackleter for Plane Efficiency Evaluation");
2678 fLoader[0]->LoadRecPoints("read");
2679 TTree* tree = fLoader[0]->TreeR();
2681 AliError("Can't get the ITS cluster tree");
2684 fSPDTrackleter->LoadClusters(tree);
2685 fSPDTrackleter->SetVertex(vtxPos, vtxErr);
2687 if (fSPDTrackleter->Clusters2Tracks(esd) != 0) {
2688 AliWarning("AliITSTrackleterSPDEff Clusters2Tracks failed");
2689 // fLoader[0]->UnloadRecPoints();
2692 //fSPDTrackleter->UnloadRecPoints();
2694 AliWarning("SPDTrackleter not available");
2700 //_____________________________________________________________________________
2701 Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
2703 // run the barrel tracking
2705 AliCodeTimerAuto("",0)
2707 AliVertexer *vertexer = CreateVertexer();
2708 if (!vertexer) return kFALSE;
2710 AliInfo(Form("running the ITS vertex finder: %s",vertexer->ClassName()));
2711 AliESDVertex* vertex = NULL;
2713 fLoader[0]->LoadRecPoints();
2714 TTree* cltree = fLoader[0]->TreeR();
2716 if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
2717 vertex = vertexer->FindVertexForCurrentEvent(cltree);
2720 AliError("Can't get the ITS cluster tree");
2722 fLoader[0]->UnloadRecPoints();
2725 AliError("Can't get the ITS loader");
2728 AliWarning("Vertex not found");
2729 vertex = new AliESDVertex();
2730 vertex->SetName("default");
2733 vertex->SetName("reconstructed");
2738 vertex->GetXYZ(vtxPos);
2739 vertex->GetSigmaXYZ(vtxErr);
2741 esd->SetPrimaryVertexSPD(vertex);
2742 AliESDVertex *vpileup = NULL;
2743 Int_t novertices = 0;
2744 vpileup = vertexer->GetAllVertices(novertices);
2746 for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
2749 // if SPD multiplicity has been determined, it is stored in the ESD
2750 AliMultiplicity *mult = vertexer->GetMultiplicity();
2751 if(mult)esd->SetMultiplicity(mult);
2753 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2754 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
2763 //_____________________________________________________________________________
2764 Bool_t AliReconstruction::RunMultFinder(AliESDEvent*& esd)
2766 // run the trackleter for multiplicity study
2768 AliCodeTimerAuto("",0)
2770 AliTrackleter *trackleter = CreateMultFinder();
2771 if (!trackleter) return kFALSE;
2773 AliInfo(Form("running the ITS multiplicity finder: %s",trackleter->ClassName()));
2776 fLoader[0]->LoadRecPoints();
2777 TTree* cltree = fLoader[0]->TreeR();
2779 trackleter->Reconstruct(esd,cltree);
2780 AliMultiplicity *mult = trackleter->GetMultiplicity();
2781 if(mult) esd->SetMultiplicity(mult);
2784 AliError("Can't get the ITS cluster tree");
2786 fLoader[0]->UnloadRecPoints();
2789 AliError("Can't get the ITS loader");
2797 //_____________________________________________________________________________
2798 Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
2800 // run the HLT barrel tracking
2802 AliCodeTimerAuto("",0)
2805 AliError("Missing runLoader!");
2809 AliInfo("running HLT tracking");
2811 // Get a pointer to the HLT reconstructor
2812 AliReconstructor *reconstructor = GetReconstructor(kNDetectors-1);
2813 if (!reconstructor) return kFALSE;
2816 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2817 TString detName = fgkDetectorName[iDet];
2818 AliDebug(1, Form("%s HLT tracking", detName.Data()));
2819 reconstructor->SetOption(detName.Data());
2820 AliTracker *tracker = reconstructor->CreateTracker();
2822 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
2823 if (fStopOnError) return kFALSE;
2827 Double_t vtxErr[3]={0.005,0.005,0.010};
2828 const AliESDVertex *vertex = esd->GetVertex();
2829 vertex->GetXYZ(vtxPos);
2830 tracker->SetVertex(vtxPos,vtxErr);
2832 fLoader[iDet]->LoadRecPoints("read");
2833 TTree* tree = fLoader[iDet]->TreeR();
2835 AliError(Form("Can't get the %s cluster tree", detName.Data()));
2838 tracker->LoadClusters(tree);
2840 if (tracker->Clusters2Tracks(esd) != 0) {
2841 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
2845 tracker->UnloadClusters();
2853 //_____________________________________________________________________________
2854 Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
2856 // run the muon spectrometer tracking
2858 AliCodeTimerAuto("",0)
2861 AliError("Missing runLoader!");
2864 Int_t iDet = GetDetIndex("MUON"); // for MUON
2866 // Get a pointer to the MUON reconstructor
2867 AliReconstructor *reconstructor = GetReconstructor(iDet);
2868 if (!reconstructor) return kFALSE;
2871 TString detName = fgkDetectorName[iDet];
2872 AliDebug(1, Form("%s tracking", detName.Data()));
2873 AliTracker *tracker = reconstructor->CreateTracker();
2875 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2880 fLoader[iDet]->LoadRecPoints("read");
2882 tracker->LoadClusters(fLoader[iDet]->TreeR());
2884 Int_t rv = tracker->Clusters2Tracks(esd);
2886 fLoader[iDet]->UnloadRecPoints();
2888 tracker->UnloadClusters();
2892 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2900 //_____________________________________________________________________________
2901 Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
2903 // run the barrel tracking
2904 static Int_t eventNr=0;
2905 AliCodeTimerAuto("",0)
2907 AliInfo("running tracking");
2909 // Set the event info which is used
2910 // by the trackers in order to obtain
2911 // information about read-out detectors,
2913 AliDebug(1, "Setting event info");
2914 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2915 if (!fTracker[iDet]) continue;
2916 fTracker[iDet]->SetEventInfo(&fEventInfo);
2919 //Fill the ESD with the T0 info (will be used by the TOF)
2920 if (fReconstructor[11] && fLoader[11]) {
2921 fLoader[11]->LoadRecPoints("READ");
2922 TTree *treeR = fLoader[11]->TreeR();
2924 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
2928 // pass 1: TPC + ITS inwards
2929 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2930 if (!fTracker[iDet]) continue;
2931 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
2934 fLoader[iDet]->LoadRecPoints("read");
2935 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
2936 TTree* tree = fLoader[iDet]->TreeR();
2938 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2941 fTracker[iDet]->LoadClusters(tree);
2942 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
2944 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
2945 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2948 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
2949 // preliminary PID in TPC needed by the ITS tracker
2951 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2952 PID.MakePID(esd,kTRUE);
2953 AliSysInfo::AddStamp(Form("MakePID0%s_%d",fgkDetectorName[iDet],eventNr), iDet,4,eventNr);
2957 // pass 2: ALL backwards
2959 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2960 if (!fTracker[iDet]) continue;
2961 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
2964 if (iDet > 1) { // all except ITS, TPC
2966 fLoader[iDet]->LoadRecPoints("read");
2967 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
2968 tree = fLoader[iDet]->TreeR();
2970 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2973 fTracker[iDet]->LoadClusters(tree);
2974 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
2978 if (iDet>1) // start filling residuals for the "outer" detectors
2980 AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2981 TObjArray ** arr = AliTracker::GetResidualsArray() ;
2983 AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
2984 TObjArray * elem = arr[AliRecoParam::AConvert(es)];
2985 if ( elem && (! elem->At(0)) ) {
2986 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2987 if (qadm) qadm->InitRecPointsForTracker() ;
2990 // AliSysInfo::AddStamp(Form("QAInitResid%s_%d",fgkDetectorName[iDet],eventNr), iDet,0, eventNr);
2992 if (fTracker[iDet]->PropagateBack(esd) != 0) {
2993 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
2996 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
2999 if (iDet > 3) { // all except ITS, TPC, TRD and TOF
3000 fTracker[iDet]->UnloadClusters();
3001 fLoader[iDet]->UnloadRecPoints();
3003 // updated PID in TPC needed by the ITS tracker -MI
3005 //GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
3006 //AliESDpid::MakePID(esd);
3007 PID.MakePID(esd,kTRUE);
3008 AliSysInfo::AddStamp(Form("MakePID1%s_%d",fgkDetectorName[iDet],eventNr), iDet,4,eventNr);
3012 //stop filling residuals for the "outer" detectors
3013 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
3015 // pass 3: TRD + TPC + ITS refit inwards
3017 for (Int_t iDet = 2; iDet >= 0; iDet--) {
3018 if (!fTracker[iDet]) continue;
3019 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
3022 if (iDet<2) // start filling residuals for TPC and ITS
3024 AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
3025 TObjArray ** arr = AliTracker::GetResidualsArray() ;
3027 AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
3028 TObjArray * elem = arr[AliRecoParam::AConvert(es)];
3029 if ( elem && (! elem->At(0)) ) {
3030 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
3031 if (qadm) qadm->InitRecPointsForTracker() ;
3036 if (fTracker[iDet]->RefitInward(esd) != 0) {
3037 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
3040 // run postprocessing
3041 if (fTracker[iDet]->PostProcess(esd) != 0) {
3042 AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
3045 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
3048 // write space-points to the ESD in case alignment data output
3050 if (fWriteAlignmentData) {
3051 WriteAlignmentData(esd);
3052 AliSysInfo::AddStamp(Form("WrtAlignData_%d",eventNr), 0,0, eventNr);
3055 for (Int_t iDet = 3; iDet >= 0; iDet--) {
3056 if (!fTracker[iDet]) continue;
3058 fTracker[iDet]->UnloadClusters();
3059 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
3060 fLoader[iDet]->UnloadRecPoints();
3061 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
3063 // stop filling residuals for TPC and ITS
3064 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
3070 //_____________________________________________________________________________
3071 Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
3073 // Remove the data which are not needed for the physics analysis.
3076 Int_t nTracks=esd->GetNumberOfTracks();
3077 Int_t nV0s=esd->GetNumberOfV0s();
3079 (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
3081 Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
3082 Bool_t rc=esd->Clean(cleanPars);
3084 nTracks=esd->GetNumberOfTracks();
3085 nV0s=esd->GetNumberOfV0s();
3087 (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
3092 //_____________________________________________________________________________
3093 Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
3095 // fill the event summary data
3097 AliCodeTimerAuto("",0)
3098 static Int_t eventNr=0;
3099 TString detStr = detectors;
3101 AliSysInfo::AddStamp(Form("FillESDb%d",eventNr), -19,-19, eventNr);
3102 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3103 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3104 AliReconstructor* reconstructor = GetReconstructor(iDet);
3105 if (!reconstructor) continue;
3106 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
3107 TTree* clustersTree = NULL;
3108 if (fLoader[iDet]) {
3109 fLoader[iDet]->LoadRecPoints("read");
3110 clustersTree = fLoader[iDet]->TreeR();
3111 if (!clustersTree) {
3112 AliError(Form("Can't get the %s clusters tree",
3113 fgkDetectorName[iDet]));
3114 if (fStopOnError) return kFALSE;
3117 if (fRawReader && !reconstructor->HasDigitConversion()) {
3118 reconstructor->FillESD(fRawReader, clustersTree, esd);
3120 TTree* digitsTree = NULL;
3121 if (fLoader[iDet]) {
3122 fLoader[iDet]->LoadDigits("read");
3123 digitsTree = fLoader[iDet]->TreeD();
3125 AliError(Form("Can't get the %s digits tree",
3126 fgkDetectorName[iDet]));
3127 if (fStopOnError) return kFALSE;
3130 reconstructor->FillESD(digitsTree, clustersTree, esd);
3131 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
3133 if (fLoader[iDet]) {
3134 fLoader[iDet]->UnloadRecPoints();
3138 if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
3139 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
3140 AliError(Form("the following detectors were not found: %s",
3142 if (fStopOnError) return kFALSE;
3144 AliSysInfo::AddStamp(Form("FillESDe%d",eventNr), -20,-20, eventNr);
3149 //_____________________________________________________________________________
3150 Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
3152 // Reads the trigger decision which is
3153 // stored in Trigger.root file and fills
3154 // the corresponding esd entries
3156 AliCodeTimerAuto("",0)
3158 AliInfo("Filling trigger information into the ESD");
3161 AliCTPRawStream input(fRawReader);
3162 if (!input.Next()) {
3163 AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
3166 if (esd->GetTriggerMask() != input.GetClassMask())
3167 AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
3168 input.GetClassMask(),esd->GetTriggerMask()));
3169 if (esd->GetOrbitNumber() != input.GetOrbitID())
3170 AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
3171 input.GetOrbitID(),esd->GetOrbitNumber()));
3172 if (esd->GetBunchCrossNumber() != input.GetBCID())
3173 AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
3174 input.GetBCID(),esd->GetBunchCrossNumber()));
3175 AliESDHeader* esdheader = esd->GetHeader();
3176 esdheader->SetL0TriggerInputs(input.GetL0Inputs());
3177 esdheader->SetL1TriggerInputs(input.GetL1Inputs());
3178 esdheader->SetL2TriggerInputs(input.GetL2Inputs());
3180 // UInt_t orbit=input.GetOrbitID();
3181 for(Int_t i=0 ; i<input.GetNIRs() ; i++ ) {
3182 esdheader->AddTriggerIR(input.GetIR(i));
3184 AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
3186 rlCTP->SetL0TriggerInputs(input.GetL0Inputs());
3187 rlCTP->SetL1TriggerInputs(input.GetL1Inputs());
3188 rlCTP->SetL2TriggerInputs(input.GetL2Inputs());
3191 if (fIsNewRunLoader) fRunLoader->TreeCT()->Fill();
3195 //_____________________________________________________________________________
3196 Bool_t AliReconstruction::FillTriggerScalers(AliESDEvent*& esd)
3199 //fRunScalers->Print();
3200 if(fRunScalers && fRunScalers->CheckRunScalers()){
3201 AliTimeStamp* timestamp = new AliTimeStamp(esd->GetOrbitNumber(), esd->GetPeriodNumber(), esd->GetBunchCrossNumber());
3202 //AliTimeStamp* timestamp = new AliTimeStamp(10308000, 0, (ULong64_t)486238);
3203 AliESDHeader* esdheader = fesd->GetHeader();
3204 for(Int_t i=0;i<50;i++){
3205 if((1ull<<i) & esd->GetTriggerMask()){
3206 AliTriggerScalersESD* scalesd = fRunScalers->GetScalersForEventClass( timestamp, i+1);
3207 if(scalesd)esdheader->SetTriggerScalersRecord(scalesd);
3210 const AliTriggerScalersRecordESD* scalrecEvent = fRunScalers->GetScalersDeltaForEvent( timestamp);
3211 const AliTriggerScalersRecordESD* scalrecRun = fRunScalers->GetScalersDeltaForRun();
3212 if (scalrecEvent) esdheader->SetTriggerScalersDeltaEvent(scalrecEvent);
3213 if (scalrecRun) esdheader->SetTriggerScalersDeltaRun(scalrecRun);
3217 //_____________________________________________________________________________
3218 Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
3221 // Filling information from RawReader Header
3224 if (!fRawReader) return kFALSE;
3226 AliInfo("Filling information from RawReader Header");
3228 esd->SetBunchCrossNumber(fRawReader->GetBCID());
3229 esd->SetOrbitNumber(fRawReader->GetOrbitID());
3230 esd->SetPeriodNumber(fRawReader->GetPeriod());
3232 esd->SetTimeStamp(fRawReader->GetTimestamp());
3233 esd->SetEventType(fRawReader->GetType());
3239 //_____________________________________________________________________________
3240 Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
3242 // check whether detName is contained in detectors
3243 // if yes, it is removed from detectors
3245 // check if all detectors are selected
3246 if ((detectors.CompareTo("ALL") == 0) ||
3247 detectors.BeginsWith("ALL ") ||
3248 detectors.EndsWith(" ALL") ||
3249 detectors.Contains(" ALL ")) {
3254 // search for the given detector
3255 Bool_t result = kFALSE;
3256 if ((detectors.CompareTo(detName) == 0) ||
3257 detectors.BeginsWith(detName+" ") ||
3258 detectors.EndsWith(" "+detName) ||
3259 detectors.Contains(" "+detName+" ")) {
3260 detectors.ReplaceAll(detName, "");
3264 // clean up the detectors string
3265 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
3266 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
3267 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
3272 //_____________________________________________________________________________
3273 Bool_t AliReconstruction::InitRunLoader()
3275 // get or create the run loader
3277 if (gAlice) delete gAlice;
3280 TFile *gafile = TFile::Open(fGAliceFileName.Data());
3281 // if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
3282 if (gafile) { // galice.root exists
3286 // load all base libraries to get the loader classes
3287 TString libs = gSystem->GetLibraries();
3288 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3289 TString detName = fgkDetectorName[iDet];
3290 if (detName == "HLT") continue;
3291 if (libs.Contains("lib" + detName + "base.so")) continue;
3292 gSystem->Load("lib" + detName + "base.so");
3294 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
3296 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
3301 fRunLoader->CdGAFile();
3302 fRunLoader->LoadgAlice();
3304 //PH This is a temporary fix to give access to the kinematics
3305 //PH that is needed for the labels of ITS clusters
3306 fRunLoader->LoadHeader();
3307 fRunLoader->LoadKinematics();
3309 } else { // galice.root does not exist
3311 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
3313 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
3314 AliConfig::GetDefaultEventFolderName(),
3317 AliError(Form("could not create run loader in file %s",
3318 fGAliceFileName.Data()));
3322 fIsNewRunLoader = kTRUE;
3323 fRunLoader->MakeTree("E");
3324 fRunLoader->MakeTree("GG");
3326 if (fNumberOfEventsPerFile > 0)
3327 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
3329 fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
3335 //_____________________________________________________________________________
3336 AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
3338 // get the reconstructor object and the loader for a detector
3340 if (fReconstructor[iDet]) {
3341 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
3342 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
3343 fReconstructor[iDet]->SetRecoParam(par);
3344 fReconstructor[iDet]->SetRunInfo(fRunInfo);
3346 return fReconstructor[iDet];
3349 // load the reconstructor object
3350 TPluginManager* pluginManager = gROOT->GetPluginManager();
3351 TString detName = fgkDetectorName[iDet];
3352 TString recName = "Ali" + detName + "Reconstructor";
3354 if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
3356 AliReconstructor* reconstructor = NULL;
3357 // first check if a plugin is defined for the reconstructor
3358 TPluginHandler* pluginHandler =
3359 pluginManager->FindHandler("AliReconstructor", detName);
3360 // if not, add a plugin for it
3361 if (!pluginHandler) {
3362 AliDebug(1, Form("defining plugin for %s", recName.Data()));
3363 TString libs = gSystem->GetLibraries();
3364 if (libs.Contains("lib" + detName + "base.so") ||
3365 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
3366 pluginManager->AddHandler("AliReconstructor", detName,
3367 recName, detName + "rec", recName + "()");
3369 pluginManager->AddHandler("AliReconstructor", detName,
3370 recName, detName, recName + "()");
3372 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
3374 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
3375 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
3378 // check if the upgrade reconstructor should be used instead of the standard one
3379 if(fUpgradeMask[iDet]) {
3380 if(reconstructor) delete reconstructor;
3381 TClass *cl = new TClass(Form("Ali%sUpgradeReconstructor",fgkDetectorName[iDet]));
3382 reconstructor = (AliReconstructor*)(cl->New());
3385 if (reconstructor) {
3386 TObject* obj = fOptions.FindObject(detName.Data());
3387 if (obj) reconstructor->SetOption(obj->GetTitle());
3388 reconstructor->SetRunInfo(fRunInfo);
3389 reconstructor->Init();
3390 fReconstructor[iDet] = reconstructor;
3393 // get or create the loader
3394 if (detName != "HLT") {
3395 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
3396 if (!fLoader[iDet]) {
3397 AliConfig::Instance()
3398 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
3400 // first check if a plugin is defined for the loader
3402 pluginManager->FindHandler("AliLoader", detName);
3403 // if not, add a plugin for it
3404 if (!pluginHandler) {
3405 TString loaderName = "Ali" + detName + "Loader";
3406 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
3407 pluginManager->AddHandler("AliLoader", detName,
3408 loaderName, detName + "base",
3409 loaderName + "(const char*, TFolder*)");
3410 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
3412 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
3414 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
3415 fRunLoader->GetEventFolder());
3417 if (!fLoader[iDet]) { // use default loader
3418 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
3420 if (!fLoader[iDet]) {
3421 AliWarning(Form("couldn't get loader for %s", detName.Data()));
3422 if (fStopOnError) return NULL;
3424 fRunLoader->AddLoader(fLoader[iDet]);
3425 fRunLoader->CdGAFile();
3426 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
3427 fRunLoader->Write(0, TObject::kOverwrite);
3432 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
3433 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
3434 if (reconstructor) {
3435 reconstructor->SetRecoParam(par);
3436 reconstructor->SetRunInfo(fRunInfo);
3439 return reconstructor;
3442 //_____________________________________________________________________________
3443 AliVertexer* AliReconstruction::CreateVertexer()
3445 // create the vertexer
3446 // Please note that the caller is the owner of the
3449 AliVertexer* vertexer = NULL;
3450 AliReconstructor* itsReconstructor = GetReconstructor(0);
3451 if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) ||
3452 fRunTracking.Contains("ITS") || fFillESD.Contains("ITS") )) {
3453 vertexer = itsReconstructor->CreateVertexer();
3456 AliWarning("couldn't create a vertexer for ITS");
3462 //_____________________________________________________________________________
3463 AliTrackleter* AliReconstruction::CreateMultFinder()
3465 // create the ITS trackleter for mult. estimation
3466 // Please note that the caller is the owner of the
3469 AliTrackleter* trackleter = NULL;
3470 AliReconstructor* itsReconstructor = GetReconstructor(0);
3471 if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) ||
3472 fRunTracking.Contains("ITS") || fFillESD.Contains("ITS") )) {
3473 trackleter = itsReconstructor->CreateMultFinder();
3476 AliWarning("ITS is not in reconstruction, switching off RunMultFinder");
3477 fRunMultFinder = kFALSE;
3483 //_____________________________________________________________________________
3484 Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
3486 // create the trackers
3487 AliInfo("Creating trackers");
3489 TString detStr = detectors;
3490 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3491 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3492 AliReconstructor* reconstructor = GetReconstructor(iDet);
3493 if (!reconstructor) continue;
3494 TString detName = fgkDetectorName[iDet];
3495 if (detName == "HLT") {
3496 fRunHLTTracking = kTRUE;
3499 if (detName == "MUON") {
3500 fRunMuonTracking = kTRUE;
3504 fTracker[iDet] = reconstructor->CreateTracker();
3505 if (!fTracker[iDet] && (iDet < 7)) {
3506 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
3507 if (fStopOnError) return kFALSE;
3509 AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
3515 //_____________________________________________________________________________
3516 void AliReconstruction::CleanUp()
3518 // delete trackers and the run loader and close and delete the file
3520 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3521 delete fReconstructor[iDet];
3522 fReconstructor[iDet] = NULL;
3523 fLoader[iDet] = NULL;
3524 delete fTracker[iDet];
3525 fTracker[iDet] = NULL;
3532 delete fSPDTrackleter;
3533 fSPDTrackleter = NULL;
3542 delete fParentRawReader;
3543 fParentRawReader=NULL;
3551 if (AliQAManager::QAManager())
3552 AliQAManager::QAManager()->ShowQA() ;
3553 // AliQAManager::Destroy() ;
3558 void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
3560 // Write space-points which are then used in the alignment procedures
3561 // For the moment only ITS, TPC, TRD and TOF
3563 Int_t ntracks = esd->GetNumberOfTracks();
3564 for (Int_t itrack = 0; itrack < ntracks; itrack++)
3566 AliESDtrack *track = esd->GetTrack(itrack);
3569 for (Int_t i=0; i<200; ++i) idx[i] = -1; //PH avoid uninitialized values
3570 for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
3571 nsp += (iDet==GetDetIndex("TRD")) ? track->GetTRDntracklets():track->GetNcls(iDet);
3573 if (iDet==GetDetIndex("ITS")) { // ITS "extra" clusters
3574 track->GetClusters(iDet,idx);
3575 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++;
3580 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
3581 track->SetTrackPointArray(sp);
3583 for (Int_t iDet = 5; iDet >= 0; iDet--) {
3584 AliTracker *tracker = fTracker[iDet];
3585 if (!tracker) continue;
3586 Int_t nspdet = (iDet==GetDetIndex("TRD")) ? track->GetTRDtracklets(idx):track->GetClusters(iDet,idx);
3588 if (iDet==GetDetIndex("ITS")) // ITS "extra" clusters
3589 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++;
3591 if (nspdet <= 0) continue;
3595 while (isp2 < nspdet) {
3596 Bool_t isvalid=kTRUE;
3598 Int_t index=idx[isp++];
3599 if (index < 0) continue;
3601 TString dets = fgkDetectorName[iDet];
3602 if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
3603 fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
3604 fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
3605 fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
3606 isvalid = tracker->GetTrackPointTrackingError(index,p,track);
3608 isvalid = tracker->GetTrackPoint(index,p);
3611 if (!isvalid) continue;
3612 if (iDet==GetDetIndex("ITS") && (isp-1)>=6) p.SetExtra();
3613 sp->AddPoint(isptrack,&p); isptrack++;
3620 //_____________________________________________________________________________
3621 void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
3623 // The method reads the raw-data error log
3624 // accumulated within the rawReader.
3625 // It extracts the raw-data errors related to
3626 // the current event and stores them into
3627 // a TClonesArray inside the esd object.
3629 if (!fRawReader) return;
3631 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
3633 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
3635 if (iEvent != log->GetEventNumber()) continue;
3637 esd->AddRawDataErrorLog(log);
3642 //_____________________________________________________________________________
3643 // void AliReconstruction::CheckQA()
3645 // check the QA of SIM for this run and remove the detectors
3646 // with status Fatal
3648 // TString newRunLocalReconstruction ;
3649 // TString newRunTracking ;
3650 // TString newFillESD ;
3652 // for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
3653 // TString detName(AliQAv1::GetDetName(iDet)) ;
3654 // AliQAv1 * qa = AliQAv1::Instance(AliQAv1::DETECTORINDEX_t(iDet)) ;
3655 // if ( qa->IsSet(AliQAv1::DETECTORINDEX_t(iDet), AliQAv1::kSIM, specie, AliQAv1::kFATAL)) {
3656 // AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed",
3657 // detName.Data(), AliRecoParam::GetEventSpecieName(es))) ;
3659 // if ( fRunLocalReconstruction.Contains(AliQAv1::GetDetName(iDet)) ||
3660 // fRunLocalReconstruction.Contains("ALL") ) {
3661 // newRunLocalReconstruction += detName ;
3662 // newRunLocalReconstruction += " " ;
3664 // if ( fRunTracking.Contains(AliQAv1::GetDetName(iDet)) ||
3665 // fRunTracking.Contains("ALL") ) {
3666 // newRunTracking += detName ;
3667 // newRunTracking += " " ;
3669 // if ( fFillESD.Contains(AliQAv1::GetDetName(iDet)) ||
3670 // fFillESD.Contains("ALL") ) {
3671 // newFillESD += detName ;
3672 // newFillESD += " " ;
3676 // fRunLocalReconstruction = newRunLocalReconstruction ;
3677 // fRunTracking = newRunTracking ;
3678 // fFillESD = newFillESD ;
3681 //_____________________________________________________________________________
3682 Int_t AliReconstruction::GetDetIndex(const char* detector)
3684 // return the detector index corresponding to detector
3686 for (index = 0; index < kNDetectors ; index++) {
3687 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
3692 //_____________________________________________________________________________
3693 Bool_t AliReconstruction::FinishPlaneEff() {
3695 // Here execute all the necessary operationis, at the end of the tracking phase,
3696 // in case that evaluation of PlaneEfficiencies was required for some detector.
3697 // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
3699 // This Preliminary version works only FOR ITS !!!!!
3700 // other detectors (TOF,TRD, etc. have to develop their specific codes)
3703 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
3706 TString detStr = fLoadCDB;
3707 //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
3708 for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
3709 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3710 if(fTracker[iDet] && fTracker[iDet]->GetPlaneEff()) {
3711 AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
3712 TString name=planeeff->GetName();
3714 TFile* pefile = TFile::Open(name, "RECREATE");
3715 ret=(Bool_t)planeeff->Write();
3717 if(planeeff->GetCreateHistos()) {
3718 TString hname=planeeff->GetName();
3719 hname+="Histo.root";
3720 ret*=planeeff->WriteHistosToFile(hname,"RECREATE");
3723 if(fSPDTrackleter) {
3724 AliPlaneEff *planeeff=fSPDTrackleter->GetPlaneEff();
3725 TString name="AliITSPlaneEffSPDtracklet.root";
3726 TFile* pefile = TFile::Open(name, "RECREATE");
3727 ret=(Bool_t)planeeff->Write();
3729 AliESDEvent *dummy=NULL;
3730 ret=(Bool_t)fSPDTrackleter->PostProcess(dummy); // take care of writing other files
3735 //_____________________________________________________________________________
3736 Bool_t AliReconstruction::InitPlaneEff() {
3738 // Here execute all the necessary operations, before of the tracking phase,
3739 // for the evaluation of PlaneEfficiencies, in case required for some detectors.
3740 // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
3741 // which should be updated/recalculated.
3743 // This Preliminary version will work only FOR ITS !!!!!
3744 // other detectors (TOF,TRD, etc. have to develop their specific codes)
3747 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
3750 fSPDTrackleter = NULL;
3751 TString detStr = fLoadCDB;
3752 if (IsSelected(fgkDetectorName[0], detStr)) {
3753 AliReconstructor* itsReconstructor = GetReconstructor(0);
3754 if (itsReconstructor) {
3755 fSPDTrackleter = itsReconstructor->CreateTrackleter(); // this is NULL unless required in RecoParam
3757 if (fSPDTrackleter) {
3758 AliInfo("Trackleter for SPD has been created");
3764 //_____________________________________________________________________________
3765 Bool_t AliReconstruction::InitAliEVE()
3767 // This method should be called only in case
3768 // AliReconstruction is run
3769 // within the alieve environment.
3770 // It will initialize AliEVE in a way
3771 // so that it can visualize event processed
3772 // by AliReconstruction.
3773 // The return flag shows whenever the
3774 // AliEVE initialization was successful or not.
3776 TString macroStr(gSystem->Getenv("ALIEVE_ONLINE_MACRO"));
3778 if (macroStr.IsNull())
3779 macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
3781 AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
3783 if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
3785 gROOT->ProcessLine("if (!AliEveEventManager::GetMaster()){new AliEveEventManager();AliEveEventManager::GetMaster()->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(AliEveEventManager::GetMaster());};");
3786 gROOT->ProcessLine("alieve_online_init()");
3791 //_____________________________________________________________________________
3792 void AliReconstruction::RunAliEVE()
3794 // Runs AliEVE visualisation of
3795 // the current event.
3796 // Should be executed only after
3797 // successful initialization of AliEVE.
3799 AliInfo("Running AliEVE...");
3800 gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p,(AliESDfriend*)%p);",fRunLoader,fRawReader,fesd,fesdf));
3804 //_____________________________________________________________________________
3805 Bool_t AliReconstruction::SetRunQA(TString detAndAction)
3807 // Allows to run QA for a selected set of detectors
3808 // and a selected set of tasks among RAWS, DIGITSR, RECPOINTS and ESDS
3809 // all selected detectors run the same selected tasks
3811 if (!detAndAction.Contains(":")) {
3812 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
3816 Int_t colon = detAndAction.Index(":") ;
3817 fQADetectors = detAndAction(0, colon) ;
3818 fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
3819 if (fQATasks.Contains("ALL") ) {
3820 fQATasks = Form("%d %d %d %d", AliQAv1::kRAWS, AliQAv1::kDIGITSR, AliQAv1::kRECPOINTS, AliQAv1::kESDS) ;
3822 fQATasks.ToUpper() ;
3824 if ( fQATasks.Contains("RAW") )
3825 tempo = Form("%d ", AliQAv1::kRAWS) ;
3826 if ( fQATasks.Contains("DIGIT") )
3827 tempo += Form("%d ", AliQAv1::kDIGITSR) ;
3828 if ( fQATasks.Contains("RECPOINT") )
3829 tempo += Form("%d ", AliQAv1::kRECPOINTS) ;
3830 if ( fQATasks.Contains("ESD") )
3831 tempo += Form("%d ", AliQAv1::kESDS) ;
3833 if (fQATasks.IsNull()) {
3834 AliInfo("No QA requested\n") ;
3839 TString tempo(fQATasks) ;
3840 tempo.ReplaceAll(Form("%d", AliQAv1::kRAWS), AliQAv1::GetTaskName(AliQAv1::kRAWS)) ;
3841 tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITSR), AliQAv1::GetTaskName(AliQAv1::kDIGITSR)) ;
3842 tempo.ReplaceAll(Form("%d", AliQAv1::kRECPOINTS), AliQAv1::GetTaskName(AliQAv1::kRECPOINTS)) ;
3843 tempo.ReplaceAll(Form("%d", AliQAv1::kESDS), AliQAv1::GetTaskName(AliQAv1::kESDS)) ;
3844 AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
3849 //_____________________________________________________________________________
3850 Bool_t AliReconstruction::InitRecoParams()
3852 // The method accesses OCDB and retrieves all
3853 // the available reco-param objects from there.
3855 Bool_t isOK = kTRUE;
3857 if (fRecoParam.GetDetRecoParamArray(kNDetectors)) {
3858 AliInfo("Using custom GRP reconstruction parameters");
3861 AliInfo("Loading GRP reconstruction parameter objects");
3863 AliCDBPath path("GRP","Calib","RecoParam");
3864 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
3866 AliWarning("Couldn't find GRP RecoParam entry in OCDB");
3870 TObject *recoParamObj = entry->GetObject();
3871 if (dynamic_cast<TObjArray*>(recoParamObj)) {
3872 // GRP has a normal TobjArray of AliDetectorRecoParam objects
3873 // Registering them in AliRecoParam
3874 fRecoParam.AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
3876 else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
3877 // GRP has only onse set of reco parameters
3878 // Registering it in AliRecoParam
3879 AliInfo("Single set of GRP reconstruction parameters found");
3880 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
3881 fRecoParam.AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
3884 AliError("No valid GRP RecoParam object found in the OCDB");
3891 TString detStr = fLoadCDB;
3892 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3894 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3896 if (fRecoParam.GetDetRecoParamArray(iDet)) {
3897 AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
3901 AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]));
3903 AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
3904 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
3906 AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]));
3910 TObject *recoParamObj = entry->GetObject();
3911 if (dynamic_cast<TObjArray*>(recoParamObj)) {
3912 // The detector has a normal TobjArray of AliDetectorRecoParam objects
3913 // Registering them in AliRecoParam
3914 fRecoParam.AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
3916 else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
3917 // The detector has only onse set of reco parameters
3918 // Registering it in AliRecoParam
3919 AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]));
3920 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
3921 fRecoParam.AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
3924 AliError(Form("No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]));
3928 // FIX ME: We have to disable the unloading of reco-param CDB
3929 // entries because QA framework is using them. Has to be fix in
3930 // a way that the QA takes the objects already constructed in
3932 // AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
3936 if (AliDebugLevel() > 0) fRecoParam.Print();
3941 //_____________________________________________________________________________
3942 Bool_t AliReconstruction::GetEventInfo()
3944 // Fill the event info object
3946 AliCodeTimerAuto("",0)
3948 AliCentralTrigger *aCTP = NULL;
3950 fEventInfo.SetEventType(fRawReader->GetType());
3952 ULong64_t mask = fRawReader->GetClassMask();
3953 fEventInfo.SetTriggerMask(mask);
3954 UInt_t clmask = fRawReader->GetDetectorPattern()[0];
3955 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
3957 aCTP = new AliCentralTrigger();
3958 TString configstr("");
3959 if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
3960 AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
3964 aCTP->SetClassMask(mask);
3965 aCTP->SetClusterMask(clmask);
3967 AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
3969 rlCTP->SetClassMask(mask);
3970 rlCTP->SetClusterMask(clmask);
3974 fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
3976 if (fRunLoader && (!fRunLoader->LoadTrigger())) {
3977 aCTP = fRunLoader->GetTrigger();
3978 fEventInfo.SetTriggerMask(aCTP->GetClassMask());
3979 // get inputs from actp - just get
3980 AliESDHeader* esdheader = fesd->GetHeader();
3981 esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
3982 esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
3983 esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
3984 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
3987 AliWarning("No trigger can be loaded! The trigger information will not be used!");
3992 AliTriggerConfiguration *config = aCTP->GetConfiguration();
3994 AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
3995 if (fRawReader) delete aCTP;
3999 UChar_t clustmask = 0;
4001 ULong64_t trmask = fEventInfo.GetTriggerMask();
4002 const TObjArray& classesArray = config->GetClasses();
4003 Int_t nclasses = classesArray.GetEntriesFast();
4004 for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
4005 AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
4006 if (trclass && trclass->GetMask()>0) {
4007 Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
4008 fesd->SetTriggerClass(trclass->GetName(),trindex);
4009 if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
4010 if (trmask & (1ull << trindex)) {
4012 trclasses += trclass->GetName();
4014 clustmask |= trclass->GetCluster()->GetClusterMask();
4018 fEventInfo.SetTriggerClasses(trclasses);
4019 // Now put the declared trigger classes (not present in the run)
4020 // to 0/false in the event selection
4021 if (!fDeclTriggerClasses.IsNull()) {
4022 TObjArray *tokens = fDeclTriggerClasses.Tokenize(" ");
4023 Int_t ntokens = tokens->GetEntriesFast();
4024 for (Int_t itoken = 0; itoken < ntokens; ++itoken) {
4025 if (fRawReader) fRawReader->LoadTriggerClass((((TObjString*)tokens->At(itoken))->String()).Data(),-1);
4030 // Write names of active trigger inputs in ESD Header
4031 const TObjArray& inputsArray = config->GetInputs();
4032 Int_t ninputs = inputsArray.GetEntriesFast();
4033 for( Int_t iinput=0; iinput < ninputs; iinput++ ) {
4034 AliTriggerInput* trginput = (AliTriggerInput*)inputsArray.At(iinput);
4035 if (trginput && trginput->GetMask()>0) {
4036 Int_t inputIndex = (Int_t)TMath::Nint(TMath::Log2(trginput->GetMask()));
4037 AliESDHeader* headeresd = fesd->GetHeader();
4038 Int_t trglevel = (Int_t)trginput->GetLevel();
4039 if (trglevel == 0) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex);
4040 if (trglevel == 1) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+24);
4041 if (trglevel == 2) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+48);
4045 // Set the information in ESD
4046 fesd->SetTriggerMask(trmask);
4047 fesd->SetTriggerCluster(clustmask);
4049 if (!aCTP->CheckTriggeredDetectors()) {
4050 if (fRawReader) delete aCTP;
4054 if (fRawReader) delete aCTP;
4056 // We have to fill also the HLT decision here!!
4062 const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_t detectorMask)
4064 // Match the detector list found in the rec.C or the default 'ALL'
4065 // to the list found in the GRP (stored there by the shuttle PP which
4066 // gets the information from ECS)
4067 static TString resultList;
4068 TString detList = detectorList;
4072 for(Int_t iDet = 0; iDet < (AliDAQ::kNDetectors-1); iDet++) {
4073 if ((detectorMask >> iDet) & 0x1) {
4074 TString det = AliDAQ::OfflineModuleName(iDet);
4075 if ((detList.CompareTo("ALL") == 0) ||
4076 ((detList.BeginsWith("ALL ") ||
4077 detList.EndsWith(" ALL") ||
4078 detList.Contains(" ALL ")) &&
4079 !(detList.BeginsWith("-"+det+" ") ||
4080 detList.EndsWith(" -"+det) ||
4081 detList.Contains(" -"+det+" "))) ||
4082 (detList.CompareTo(det) == 0) ||
4083 detList.BeginsWith(det+" ") ||
4084 detList.EndsWith(" "+det) ||
4085 detList.Contains( " "+det+" " )) {
4086 if (!resultList.EndsWith(det + " ")) {
4095 if ((detectorMask >> AliDAQ::kHLTId) & 0x1) {
4096 TString hltDet = AliDAQ::OfflineModuleName(AliDAQ::kNDetectors-1);
4097 if ((detList.CompareTo("ALL") == 0) ||
4098 ((detList.BeginsWith("ALL ") ||
4099 detList.EndsWith(" ALL") ||
4100 detList.Contains(" ALL ")) &&
4101 !(detList.BeginsWith("-"+hltDet+" ") ||
4102 detList.EndsWith(" -"+hltDet) ||
4103 detList.Contains(" -"+hltDet+" "))) ||
4104 (detList.CompareTo(hltDet) == 0) ||
4105 detList.BeginsWith(hltDet+" ") ||
4106 detList.EndsWith(" "+hltDet) ||
4107 detList.Contains( " "+hltDet+" " )) {
4108 resultList += hltDet;
4112 return resultList.Data();
4116 //______________________________________________________________________________
4117 void AliReconstruction::Abort(const char *method, EAbort what)
4119 // Abort processing. If what = kAbortProcess, the Process() loop will be
4120 // aborted. If what = kAbortFile, the current file in a chain will be
4121 // aborted and the processing will continue with the next file, if there
4122 // is no next file then Process() will be aborted. Abort() can also be
4123 // called from Begin(), SlaveBegin(), Init() and Notify(). After abort
4124 // the SlaveTerminate() and Terminate() are always called. The abort flag
4125 // can be checked in these methods using GetAbort().
4127 // The method is overwritten in AliReconstruction for better handling of
4128 // reco specific errors
4130 if (!fStopOnError) return;
4134 TString whyMess = method;
4135 whyMess += " failed! Aborting...";
4137 AliError(whyMess.Data());
4140 TString mess = "Abort";
4141 if (fAbort == kAbortProcess)
4142 mess = "AbortProcess";
4143 else if (fAbort == kAbortFile)
4146 Info(mess.Data(), "%s", whyMess.Data());
4149 //______________________________________________________________________________
4150 Bool_t AliReconstruction::ProcessEvent(void* event)
4152 // Method that is used in case the event loop
4153 // is steered from outside, for example by AMORE
4154 // 'event' is a pointer to the DATE event in the memory
4156 if (fRawReader) delete fRawReader;
4157 fRawReader = new AliRawReaderDate(event);
4158 fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
4165 //______________________________________________________________________________
4166 Bool_t AliReconstruction::ParseOutput()
4168 // The method parses the output file
4169 // location string in order to steer
4170 // properly the selector
4172 TPMERegexp re1("(\\w+\\.zip#\\w+\\.root):([,*\\w+\\.root,*]+)@dataset://(\\w++)");
4173 TPMERegexp re2("(\\w+\\.root)?@?dataset://(\\w++)");
4175 if (re1.Match(fESDOutput) == 4) {
4176 // root archive with output files stored and regustered
4178 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",re1[1].Data()));
4179 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",re1[3].Data()));
4180 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_DATASET",""));
4181 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_ARCHIVE",re1[2].Data()));
4182 AliInfo(Form("%s files will be stored within %s in dataset %s",
4187 else if (re2.Match(fESDOutput) == 3) {
4188 // output file stored and registered
4190 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",(re2[1].IsNull()) ? "AliESDs.root" : re2[1].Data()));
4191 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",re2[2].Data()));
4192 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_DATASET",""));
4193 AliInfo(Form("%s will be stored in dataset %s",
4194 (re2[1].IsNull()) ? "AliESDs.root" : re2[1].Data(),
4198 if (fESDOutput.IsNull()) {
4199 // Output location not given.
4200 // Assuming xrootd has been already started and
4201 // the output file has to be sent back
4202 // to the client machine
4203 TString esdUrl(Form("root://%s/%s/",
4204 TUrl(gSystem->HostName()).GetHostFQDN(),
4206 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE","AliESDs.root"));
4207 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",esdUrl.Data()));
4208 AliInfo(Form("AliESDs.root will be stored in %s",
4212 // User specified an output location.
4213 // Ones has just to parse it here
4214 TUrl outputUrl(fESDOutput.Data());
4215 TString outputFile(gSystem->BaseName(outputUrl.GetFile()));
4216 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",outputFile.IsNull() ? "AliESDs.root" : outputFile.Data()));
4217 TString outputLocation(outputUrl.GetUrl());
4218 outputLocation.ReplaceAll(outputFile.Data(),"");
4219 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",outputLocation.Data()));
4220 AliInfo(Form("%s will be stored in %s",
4221 outputFile.IsNull() ? "AliESDs.root" : outputFile.Data(),
4222 outputLocation.Data()));
4229 //______________________________________________________________________________
4230 Bool_t AliReconstruction::IsHighPt() const {
4231 // Selection of events containing "high" pT tracks
4232 // If at least one track is found within 1.5 and 100 GeV (pT)
4233 // that was reconstructed by both ITS and TPC, the event is accepted
4236 const Double_t pTmin = 1.5;
4237 const Double_t pTmax = 100;
4239 mask |= (AliESDtrack::kITSrefit);
4240 mask |= (AliESDtrack::kTPCrefit);
4241 const Double_t pTminCosmic = 5.;
4242 const Double_t pTmaxCosmic = 100;
4243 ULong_t maskCosmic = 0;
4244 Int_t cosmicCount=0;
4245 maskCosmic |= (AliESDtrack::kTPCrefit);
4247 Bool_t isOK = kFALSE;
4249 if (fesd && fesd->GetEventType()==AliRawEventHeaderBase::kPhysicsEvent) {
4250 // Check if this ia a physics event (code 7)
4251 Int_t ntrk = fesd->GetNumberOfTracks();
4252 for (Int_t itrk=0; itrk<ntrk; ++itrk) {
4254 AliESDtrack * trk = fesd->GetTrack(itrk);
4256 && trk->Pt() > pTmin
4257 && trk->Pt() < pTmax
4258 && (trk->GetStatus() & mask) == mask ) {
4264 && trk->GetInnerParam()
4265 && trk->GetInnerParam()->Pt() > pTminCosmic
4266 && trk->GetInnerParam()->Pt() < pTmaxCosmic
4267 && (trk->GetStatus() & maskCosmic) == maskCosmic ) {
4273 if (cosmicCount>1) isOK=kTRUE;
4278 //______________________________________________________________________________
4279 Bool_t AliReconstruction::IsCosmicOrCalibSpecie() const {
4280 // Select cosmic or calibration events
4282 Bool_t isOK = kFALSE;
4284 if (fesd && fesd->GetEventType()==AliRawEventHeaderBase::kPhysicsEvent) {
4285 // Check if this ia a physics event (code 7)
4287 UInt_t specie = fesd->GetEventSpecie();
4288 if (specie==AliRecoParam::kCosmic || specie==AliRecoParam::kCalib) {
4295 //______________________________________________________________________________
4296 void AliReconstruction::WriteESDfriend() {
4297 // Fill the ESD friend in the tree. The required fraction of ESD friends is stored
4298 // in fFractionFriends. We select events where we store the ESD friends according
4299 // to the following algorithm:
4300 // 1. Store all Cosmic or Calibration events within the required fraction
4301 // 2. Sample "high Pt" events within the remaining fraction after step 1.
4302 // 3. Sample randomly events if we still have remaining slot
4305 Bool_t isSelected = kFALSE;
4307 // Store all friends for B field OFF
4308 if (TMath::Abs(AliTrackerBase::GetBz())<0.5) isSelected=kTRUE;
4310 if (IsCosmicOrCalibSpecie()) { // Selection of calib or cosmic events
4317 Double_t remainingFraction = fFractionFriends;
4318 remainingFraction -= ((Double_t)(fSspecie)/(Double_t)(fNall));
4320 if (IsHighPt()) { // Selection of "high Pt" events
4322 Double_t curentHighPtFraction = ((Double_t)(fNhighPt+1))/((Double_t)(fNall+1));
4323 // "Bayesian" estimate supposing that without events all the events are of the required type
4326 Double_t rnd = gRandom->Rndm()*curentHighPtFraction;
4327 if (rnd<remainingFraction) {
4333 remainingFraction -= ((Double_t)(fShighPt)/(Double_t)(fNall));
4335 // Random selection to fill the remaining fraction (if any)
4337 Double_t rnd = gRandom->Rndm();
4338 if (rnd<remainingFraction) {
4344 fesdf->~AliESDfriend();
4345 new (fesdf) AliESDfriend(); // Reset...
4346 fesdf->SetSkipBit(kTRUE);
4352 //_________________________________________________________________
4353 void AliReconstruction::DeleteDigits(const TString& detectors)
4355 // delete requested digit files produced at current event
4356 static int iEvent = 0;
4357 if (detectors.IsNull()) return;
4358 TString detStr = detectors;
4359 AliInfo(Form("Deleting Digits: %s",detectors.Data()));
4361 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
4362 gSystem->Exec(Form("if [ -e %s.Digits.root ]; then\nrm %s.Digits.root\nfi",
4363 fgkDetectorName[iDet],fgkDetectorName[iDet]));
4365 AliSysInfo::AddStamp(Form("DelDigits_%d",iEvent), 0,0,iEvent);
4369 //_________________________________________________________________
4370 void AliReconstruction::DeleteRecPoints(const TString& detectors)
4372 // delete requested recpoint files produced at current event
4373 static int iEvent = 0;
4374 if (detectors.IsNull()) return;
4375 TString detStr = detectors;
4376 AliInfo(Form("Deleting Recpoints: %s",detectors.Data()));
4378 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
4379 gSystem->Exec(Form("if [ -e %s.RecPoints.root ]; then\nrm %s.RecPoints.root\nfi",
4380 fgkDetectorName[iDet],fgkDetectorName[iDet]));
4382 AliSysInfo::AddStamp(Form("DelRecPoints_%d",iEvent), 0,0,iEvent);
4386 //_________________________________________________________________
4387 void AliReconstruction::SetStopOnResourcesExcess(Int_t vRSS,Int_t vVMEM)
4389 // require checking the resources left and stopping on excess
4390 // if 0 : no check is done
4391 // if >0 : stop reconstruction if exceeds this value
4392 // if <0 : use as margin to system limits
4394 const int kKB2MB = 1024;
4395 const int kInfMem = 9999999;
4398 int pgSize = getpagesize();
4402 AliInfo(Form("Setting max. RSS usage to user value %d MB",fMaxRSS));
4405 getrlimit(RLIMIT_RSS,&r);
4406 fMaxRSS = r.rlim_max==RLIM_INFINITY ? kInfMem : int(r.rlim_max*pgSize/kKB2MB/kKB2MB) + vRSS;
4407 AliInfo(Form("Setting max. RSS usage to system hard limit %d%s MB (%d margin)",fMaxRSS,r.rlim_max==RLIM_INFINITY ? "(inf)":"",-vRSS));
4409 else {AliInfo("No check on RSS memory usage will be applied");}
4413 AliInfo(Form("Setting max. VMEM usage to user value %d MB",fMaxVMEM));
4416 getrlimit(RLIMIT_AS,&r);
4417 fMaxVMEM = r.rlim_max==RLIM_INFINITY ? kInfMem : int(r.rlim_max*pgSize/kKB2MB/kKB2MB) + vVMEM;
4418 AliInfo(Form("Setting max. VMEM usage to system hard limit %d%s MB (%d margin)",fMaxVMEM,r.rlim_max==RLIM_INFINITY ? "(inf)":"",-vVMEM));
4420 else {AliInfo("No check on RSS memory usage will be applied");}
4424 //_________________________________________________________________
4425 Bool_t AliReconstruction::HasEnoughResources(int ev)
4427 // check if process consumed more than allowed resources
4428 const int kKB2MB = 1024;
4430 if (!fMaxRSS && !fMaxVMEM) return res;
4432 ProcInfo_t procInfo;
4433 gSystem->GetProcInfo(&procInfo);
4434 if (procInfo.fMemResident/kKB2MB > fMaxRSS) res = kFALSE;
4435 if (procInfo.fMemVirtual/kKB2MB > fMaxVMEM) res = kFALSE;
4438 AliInfo(Form("Job exceeded allowed limits: RSS:%d (%d) VMEM:%d (%d), will stop",
4439 int(procInfo.fMemResident/kKB2MB),fMaxRSS,
4440 int(procInfo.fMemVirtual/kKB2MB) ,fMaxVMEM));
4442 gSystem->Exec(Form("if [ -e %s ]; then\nrm %s\nfi\necho %d > %s",fgkStopEvFName,fgkStopEvFName,ev,fgkStopEvFName));