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>
205 ClassImp(AliReconstruction)
207 //_____________________________________________________________________________
208 const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE"
209 // #ifdef MFT_UPGRADE
216 //_____________________________________________________________________________
217 AliReconstruction::AliReconstruction(const char* gAliceFilename) :
219 fRunVertexFinder(kTRUE),
220 fRunVertexFinderTracks(kTRUE),
221 fRunHLTTracking(kFALSE),
222 fRunMuonTracking(kFALSE),
224 fRunCascadeFinder(kTRUE),
225 fRunMultFinder(kTRUE),
227 fWriteAlignmentData(kFALSE),
228 fWriteESDfriend(kFALSE),
229 fFillTriggerESD(kTRUE),
237 fRunLocalReconstruction("ALL"),
241 fUseTrackingErrorsForAlignment(""),
242 fGAliceFileName(gAliceFilename),
245 fProofOutputFileName(""),
246 fProofOutputLocation(""),
247 fProofOutputDataset(kFALSE),
248 fProofOutputArchive(""),
252 fNumberOfEventsPerFile((UInt_t)-1),
253 fFractionFriends(0.04),
255 fLoadAlignFromCDB(kTRUE),
256 fLoadAlignData("ALL"),
261 fCTPTimeParams(NULL),
266 fParentRawReader(NULL),
270 fSPDTrackleter(NULL),
272 fDiamondProfileSPD(NULL),
273 fDiamondProfile(NULL),
274 fDiamondProfileTPC(NULL),
275 fListOfCosmicTriggers(NULL),
279 fAlignObjArray(NULL),
283 fInitCDBCalled(kFALSE),
284 fFromCDBSnapshot(kFALSE),
285 fSnapshotFileName(""),
286 fSetRunNumberFromDataCalled(kFALSE),
291 fSameQACycle(kFALSE),
292 fInitQACalled(kFALSE),
293 fWriteQAExpertData(kTRUE),
294 fRunPlaneEff(kFALSE),
305 fIsNewRunLoader(kFALSE),
318 // create reconstruction object with default parameters
321 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
322 fReconstructor[iDet] = NULL;
323 fUpgradeMask[iDet]=kFALSE;
324 fLoader[iDet] = NULL;
325 fTracker[iDet] = NULL;
327 for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
328 fQACycles[iDet] = 999999 ;
329 fQAWriteExpert[iDet] = kFALSE ;
331 fBeamInt[0][0]=fBeamInt[0][1]=fBeamInt[1][0]=fBeamInt[1][1] = -1;
336 //_____________________________________________________________________________
337 AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
339 fRunVertexFinder(rec.fRunVertexFinder),
340 fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
341 fRunHLTTracking(rec.fRunHLTTracking),
342 fRunMuonTracking(rec.fRunMuonTracking),
343 fRunV0Finder(rec.fRunV0Finder),
344 fRunCascadeFinder(rec.fRunCascadeFinder),
345 fRunMultFinder(rec.fRunMultFinder),
346 fStopOnError(rec.fStopOnError),
347 fWriteAlignmentData(rec.fWriteAlignmentData),
348 fWriteESDfriend(rec.fWriteESDfriend),
349 fFillTriggerESD(rec.fFillTriggerESD),
351 fCleanESD(rec.fCleanESD),
352 fV0DCAmax(rec.fV0DCAmax),
353 fV0CsPmin(rec.fV0CsPmin),
357 fRunLocalReconstruction(rec.fRunLocalReconstruction),
358 fRunTracking(rec.fRunTracking),
359 fFillESD(rec.fFillESD),
360 fLoadCDB(rec.fLoadCDB),
361 fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
362 fGAliceFileName(rec.fGAliceFileName),
363 fRawInput(rec.fRawInput),
364 fESDOutput(rec.fESDOutput),
365 fProofOutputFileName(rec.fProofOutputFileName),
366 fProofOutputLocation(rec.fProofOutputLocation),
367 fProofOutputDataset(rec.fProofOutputDataset),
368 fProofOutputArchive(rec.fProofOutputArchive),
369 fEquipIdMap(rec.fEquipIdMap),
370 fFirstEvent(rec.fFirstEvent),
371 fLastEvent(rec.fLastEvent),
372 fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
373 fFractionFriends(rec.fFractionFriends),
375 fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
376 fLoadAlignData(rec.fLoadAlignData),
377 fUseHLTData(rec.fUseHLTData),
381 fCTPTimeParams(NULL),
386 fParentRawReader(NULL),
388 fRecoParam(rec.fRecoParam),
390 fSPDTrackleter(NULL),
392 fDiamondProfileSPD(rec.fDiamondProfileSPD),
393 fDiamondProfile(rec.fDiamondProfile),
394 fDiamondProfileTPC(rec.fDiamondProfileTPC),
395 fListOfCosmicTriggers(NULL),
399 fAlignObjArray(rec.fAlignObjArray),
400 fCDBUri(rec.fCDBUri),
401 fQARefUri(rec.fQARefUri),
403 fInitCDBCalled(rec.fInitCDBCalled),
404 fFromCDBSnapshot(rec.fFromCDBSnapshot),
405 fSnapshotFileName(rec.fSnapshotFileName),
406 fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
407 fQADetectors(rec.fQADetectors),
408 fQATasks(rec.fQATasks),
410 fRunGlobalQA(rec.fRunGlobalQA),
411 fSameQACycle(rec.fSameQACycle),
412 fInitQACalled(rec.fInitQACalled),
413 fWriteQAExpertData(rec.fWriteQAExpertData),
414 fRunPlaneEff(rec.fRunPlaneEff),
425 fIsNewRunLoader(rec.fIsNewRunLoader),
434 fAnalysisMacro(rec.fAnalysisMacro),
440 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
441 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
443 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
444 fReconstructor[iDet] = NULL;
445 fUpgradeMask[iDet] = kFALSE;
446 fLoader[iDet] = NULL;
447 fTracker[iDet] = NULL;
450 for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
451 fQACycles[iDet] = rec.fQACycles[iDet];
452 fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
455 for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
456 if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
459 for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
463 //_____________________________________________________________________________
464 AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
466 // assignment operator
467 // Used in PROOF mode
468 // Be very careful while modifing it!
469 // Simple rules to follow:
470 // for persistent data members - use their assignment operators
471 // for non-persistent ones - do nothing or take the default values from constructor
472 // TSelector members should not be touched
473 if(&rec == this) return *this;
475 fRunVertexFinder = rec.fRunVertexFinder;
476 fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
477 fRunHLTTracking = rec.fRunHLTTracking;
478 fRunMuonTracking = rec.fRunMuonTracking;
479 fRunV0Finder = rec.fRunV0Finder;
480 fRunCascadeFinder = rec.fRunCascadeFinder;
481 fRunMultFinder = rec.fRunMultFinder;
482 fStopOnError = rec.fStopOnError;
483 fWriteAlignmentData = rec.fWriteAlignmentData;
484 fWriteESDfriend = rec.fWriteESDfriend;
485 fFillTriggerESD = rec.fFillTriggerESD;
487 fCleanESD = rec.fCleanESD;
488 fV0DCAmax = rec.fV0DCAmax;
489 fV0CsPmin = rec.fV0CsPmin;
493 fRunLocalReconstruction = rec.fRunLocalReconstruction;
494 fRunTracking = rec.fRunTracking;
495 fFillESD = rec.fFillESD;
496 fLoadCDB = rec.fLoadCDB;
497 fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
498 fGAliceFileName = rec.fGAliceFileName;
499 fRawInput = rec.fRawInput;
500 fESDOutput = rec.fESDOutput;
501 fProofOutputFileName = rec.fProofOutputFileName;
502 fProofOutputLocation = rec.fProofOutputLocation;
503 fProofOutputDataset = rec.fProofOutputDataset;
504 fProofOutputArchive = rec.fProofOutputArchive;
505 fEquipIdMap = rec.fEquipIdMap;
506 fFirstEvent = rec.fFirstEvent;
507 fLastEvent = rec.fLastEvent;
508 fNumberOfEventsPerFile = rec.fNumberOfEventsPerFile;
509 fFractionFriends = rec.fFractionFriends;
511 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
512 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
515 fLoadAlignFromCDB = rec.fLoadAlignFromCDB;
516 fLoadAlignData = rec.fLoadAlignData;
517 fUseHLTData = rec.fUseHLTData;
519 delete fRunInfo; fRunInfo = NULL;
520 if (rec.fRunInfo) fRunInfo = new AliRunInfo(*rec.fRunInfo);
522 fEventInfo = rec.fEventInfo;
524 delete fRunScalers; fRunScalers = NULL;
525 if (rec.fRunScalers) fRunScalers = new AliTriggerRunScalers(*rec.fRunScalers);
527 delete fCTPTimeParams; fCTPTimeParams = NULL;
528 if (rec.fCTPTimeParams) fCTPTimeParams = new AliCTPTimeParams(*rec.fCTPTimeParams);
529 delete fCTPTimeAlign; fCTPTimeAlign = NULL;
530 if (rec.fCTPTimeAlign) fCTPTimeAlign = new AliCTPTimeParams(*rec.fCTPTimeAlign);
534 fParentRawReader = NULL;
536 fRecoParam = rec.fRecoParam;
538 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
539 fUpgradeMask[iDet] = kFALSE;
540 delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
541 delete fLoader[iDet]; fLoader[iDet] = NULL;
542 delete fTracker[iDet]; fTracker[iDet] = NULL;
545 for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
546 fQACycles[iDet] = rec.fQACycles[iDet];
547 fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
550 delete fSPDTrackleter; fSPDTrackleter = NULL;
552 delete fDiamondProfileSPD; fDiamondProfileSPD = NULL;
553 if (rec.fDiamondProfileSPD) fDiamondProfileSPD = new AliESDVertex(*rec.fDiamondProfileSPD);
554 delete fDiamondProfile; fDiamondProfile = NULL;
555 if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile);
556 delete fDiamondProfileTPC; fDiamondProfileTPC = NULL;
557 if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC);
559 delete fListOfCosmicTriggers; fListOfCosmicTriggers = NULL;
560 if (rec.fListOfCosmicTriggers) fListOfCosmicTriggers = (THashTable*)((rec.fListOfCosmicTriggers)->Clone());
562 delete fGRPData; fGRPData = NULL;
563 // if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
564 if (rec.fGRPData) fGRPData = (AliGRPObject*)((rec.fGRPData)->Clone());
566 delete fAlignObjArray; fAlignObjArray = NULL;
569 fQARefUri = rec.fQARefUri;
570 fSpecCDBUri.Delete();
571 fInitCDBCalled = rec.fInitCDBCalled;
572 fFromCDBSnapshot = rec.fFromCDBSnapshot;
573 fSnapshotFileName = rec.fSnapshotFileName;
574 fSetRunNumberFromDataCalled = rec.fSetRunNumberFromDataCalled;
575 fQADetectors = rec.fQADetectors;
576 fQATasks = rec.fQATasks;
578 fRunGlobalQA = rec.fRunGlobalQA;
579 fSameQACycle = rec.fSameQACycle;
580 fInitQACalled = rec.fInitQACalled;
581 fWriteQAExpertData = rec.fWriteQAExpertData;
582 fRunPlaneEff = rec.fRunPlaneEff;
583 for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
593 fIsNewRunLoader = rec.fIsNewRunLoader;
602 fAnalysisMacro = rec.fAnalysisMacro;
609 //_____________________________________________________________________________
610 AliReconstruction::~AliReconstruction()
615 if (fListOfCosmicTriggers) {
616 fListOfCosmicTriggers->Delete();
617 delete fListOfCosmicTriggers;
621 delete fCTPTimeParams;
622 delete fCTPTimeAlign;
624 if (fAlignObjArray) {
625 fAlignObjArray->Delete();
626 delete fAlignObjArray;
628 fSpecCDBUri.Delete();
630 AliCodeTimer::Instance()->Print();
633 //_____________________________________________________________________________
634 void AliReconstruction::InitQA()
636 //Initialize the QA and start of cycle
637 AliCodeTimerAuto("",0);
639 if (fInitQACalled) return;
640 fInitQACalled = kTRUE;
642 if (fGRPData) AliQADataMaker::SetCloningRequest( fGRPData->GetQATrigClasses(), fGRPData->GetQACloningRequest());
645 AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kRECMODE) ;
646 if (fWriteQAExpertData)
647 qam->SetWriteExpert() ;
649 if (qam->IsDefaultStorageSet()) {
650 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
651 AliWarning("Default QA reference storage has been already set !");
652 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fQARefUri.Data()));
653 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
654 fQARefUri = qam->GetDefaultStorage()->GetURI();
656 if (fQARefUri.Length() > 0) {
657 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
658 AliDebug(2, Form("Default QA reference storage is set to: %s", fQARefUri.Data()));
659 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
661 fQARefUri="local://$ALICE_ROOT/QAref";
662 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
663 AliWarning("Default QA refeference storage not yet set !!!!");
664 AliWarning(Form("Setting it now to: %s", fQARefUri.Data()));
665 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
668 qam->SetDefaultStorage(fQARefUri);
672 qam->SetActiveDetectors(fQADetectors) ;
673 for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) {
674 qam->SetCycleLength(AliQAv1::DETECTORINDEX_t(det), fQACycles[det]) ;
675 qam->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
677 if (!fRawReader && !fInput && IsInTasks(AliQAv1::kRAWS))
678 fQATasks.ReplaceAll(Form("%d",AliQAv1::kRAWS), "") ;
679 qam->SetTasks(fQATasks) ;
680 qam->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ;
683 Bool_t sameCycle = kFALSE ;
684 AliQADataMaker *qadm = qam->GetQADataMaker(AliQAv1::kGLOBAL);
685 AliInfo(Form("Initializing the global QA data maker"));
686 if (IsInTasks(AliQAv1::kRECPOINTS)) {
687 qadm->StartOfCycle(AliQAv1::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
688 TObjArray **arr=qadm->Init(AliQAv1::kRECPOINTS);
689 AliTracker::SetResidualsArray(arr);
692 if (IsInTasks(AliQAv1::kESDS)) {
693 qadm->StartOfCycle(AliQAv1::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
694 qadm->Init(AliQAv1::kESDS);
697 AliSysInfo::AddStamp("InitQA") ;
700 //_____________________________________________________________________________
701 void AliReconstruction::MergeQA(const char *fileName)
703 //Initialize the QA and start of cycle
704 AliCodeTimerAuto("",0) ;
705 AliQAManager::QAManager()->Merge(AliCDBManager::Instance()->GetRun(),fileName) ;
706 AliSysInfo::AddStamp("MergeQA") ;
709 //_____________________________________________________________________________
710 void AliReconstruction::InitCDB()
712 // activate a default CDB storage
713 // First check if we have any CDB storage set, because it is used
714 // to retrieve the calibration and alignment constants
715 AliCodeTimerAuto("",0);
717 if (fInitCDBCalled) return;
718 fInitCDBCalled = kTRUE;
720 AliCDBManager* man = AliCDBManager::Instance();
721 if (man->IsDefaultStorageSet())
723 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
724 AliWarning("Default CDB storage has been already set !");
725 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
726 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
727 fCDBUri = man->GetDefaultStorage()->GetURI();
730 if (fCDBUri.Length() > 0)
732 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
733 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
734 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
735 man->SetDefaultStorage(fCDBUri);
737 else if (!man->GetRaw()){
738 fCDBUri="local://$ALICE_ROOT/OCDB";
739 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
740 AliWarning("Default CDB storage not yet set !!!!");
741 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
742 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
743 man->SetDefaultStorage(fCDBUri);
746 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
747 AliWarning("Default storage will be set after setting the Run Number!!!");
748 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
752 // Now activate the detector specific CDB storage locations
753 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
754 TObject* obj = fSpecCDBUri[i];
756 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
757 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
758 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
759 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
761 AliSysInfo::AddStamp("InitCDB");
764 //_____________________________________________________________________________
765 void AliReconstruction::SetDefaultStorage(const char* uri) {
766 // Store the desired default CDB storage location
767 // Activate it later within the Run() method
773 //_____________________________________________________________________________
774 void AliReconstruction::SetQARefDefaultStorage(const char* uri) {
775 // Store the desired default CDB storage location
776 // Activate it later within the Run() method
779 AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
782 //_____________________________________________________________________________
783 void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
784 // Store a detector-specific CDB storage location
785 // Activate it later within the Run() method
787 AliCDBPath aPath(calibType);
788 if(!aPath.IsValid()){
789 // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
790 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
791 if(!strcmp(calibType, fgkDetectorName[iDet])) {
792 aPath.SetPath(Form("%s/*", calibType));
793 AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
797 if(!aPath.IsValid()){
798 AliError(Form("Not a valid path or detector: %s", calibType));
803 // // check that calibType refers to a "valid" detector name
804 // Bool_t isDetector = kFALSE;
805 // for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
806 // TString detName = fgkDetectorName[iDet];
807 // if(aPath.GetLevel0() == detName) {
808 // isDetector = kTRUE;
814 // AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
818 TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
819 if (obj) fSpecCDBUri.Remove(obj);
820 fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
824 //_____________________________________________________________________________
825 Bool_t AliReconstruction::SetRunNumberFromData()
827 // The method is called in Run() in order
828 // to set a correct run number.
829 // In case of raw data reconstruction the
830 // run number is taken from the raw data header
832 if (fSetRunNumberFromDataCalled) return kTRUE;
833 fSetRunNumberFromDataCalled = kTRUE;
835 AliCDBManager* man = AliCDBManager::Instance();
838 if(fRawReader->NextEvent()) {
839 if(man->GetRun() > 0) {
840 AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
842 man->SetRun(fRawReader->GetRunNumber());
843 fRawReader->RewindEvents();
846 if(man->GetRun() > 0) {
847 AliWarning("No raw-data events are found ! Using settings in AliCDBManager !");
850 AliWarning("Neither raw events nor settings in AliCDBManager are found !");
856 AliRunLoader *rl = AliRunLoader::Open(fGAliceFileName.Data());
858 AliError(Form("No run loader found in file %s", fGAliceFileName.Data()));
863 // read run number from gAlice
864 if(rl->GetHeader()) {
865 man->SetRun(rl->GetHeader()->GetRun());
870 AliError("Neither run-loader header nor RawReader objects are found !");
882 //_____________________________________________________________________________
883 void AliReconstruction::SetCDBLock() {
884 // Set CDB lock: from now on it is forbidden to reset the run number
885 // or the default storage or to activate any further storage!
887 AliCDBManager::Instance()->SetLock(1);
890 //_____________________________________________________________________________
891 void AliReconstruction::MatchUpgradeDetector() {
892 // Translates detector name in a boolean.
893 // The boolean is used in GetReconstructor to load the
894 // upgrade reconstructor instead of the standard one.
895 for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
896 if(fUpgradeModule.Contains(fgkDetectorName[iDet])) fUpgradeMask[iDet]=kTRUE;
899 //_____________________________________________________________________________
900 Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
902 // Read the alignment objects from CDB.
903 // Each detector is supposed to have the
904 // alignment objects in DET/Align/Data CDB path.
905 // All the detector objects are then collected,
906 // sorted by geometry level (starting from ALIC) and
907 // then applied to the TGeo geometry.
908 // Finally an overlaps check is performed.
910 // Load alignment data from CDB and fill fAlignObjArray
911 if(fLoadAlignFromCDB){
913 TString detStr = detectors;
914 TString loadAlObjsListOfDets = "";
916 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
917 if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
918 if(!strcmp(fgkDetectorName[iDet],"HLT")) continue;
920 if(AliGeomManager::GetNalignable(fgkDetectorName[iDet]) != 0)
922 loadAlObjsListOfDets += fgkDetectorName[iDet];
923 loadAlObjsListOfDets += " ";
925 } // end loop over detectors
927 if(AliGeomManager::GetNalignable("GRP") != 0)
928 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
929 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
930 AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
932 // Check if the array with alignment objects was
933 // provided by the user. If yes, apply the objects
934 // to the present TGeo geometry
935 if (fAlignObjArray) {
936 if (gGeoManager && gGeoManager->IsClosed()) {
937 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
938 AliError("The misalignment of one or more volumes failed!"
939 "Compare the list of simulated detectors and the list of detector alignment data!");
944 AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
950 if (fAlignObjArray) {
951 fAlignObjArray->Delete();
952 delete fAlignObjArray; fAlignObjArray=NULL;
958 //_____________________________________________________________________________
959 void AliReconstruction::SetGAliceFile(const char* fileName)
961 // set the name of the galice file
963 fGAliceFileName = fileName;
966 //_____________________________________________________________________________
967 void AliReconstruction::SetInput(const char* input)
969 // In case the input string starts with 'mem://', we run in an online mode
970 // and AliRawReaderDateOnline object is created. In all other cases a raw-data
971 // file is assumed. One can give as an input:
972 // mem://: - events taken from DAQ monitoring libs online
974 // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
975 if (input) fRawInput = input;
978 //_____________________________________________________________________________
979 void AliReconstruction::SetOutput(const char* output)
981 // Set the output ESD filename
982 // 'output' is a normalt ROOT url
983 // The method is used in case of raw-data reco with PROOF
984 if (output) fESDOutput = output;
987 //_____________________________________________________________________________
988 void AliReconstruction::SetOption(const char* detector, const char* option)
990 // set options for the reconstruction of a detector
992 TObject* obj = fOptions.FindObject(detector);
993 if (obj) fOptions.Remove(obj);
994 fOptions.Add(new TNamed(detector, option));
997 //_____________________________________________________________________________
998 void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam *par)
1000 // Set custom reconstruction parameters for a given detector
1001 // Single set of parameters for all the events
1003 // First check if the reco-params are global
1004 if(!strcmp(detector, "GRP")) {
1005 par->SetAsDefault();
1006 fRecoParam.AddDetRecoParam(kNDetectors,par);
1010 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1011 if(!strcmp(detector, fgkDetectorName[iDet])) {
1012 par->SetAsDefault();
1013 fRecoParam.AddDetRecoParam(iDet,par);
1020 //_____________________________________________________________________________
1021 Bool_t AliReconstruction::InitGRP() {
1022 //------------------------------------
1023 // Initialization of the GRP entry
1024 //------------------------------------
1025 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
1029 TMap* m = dynamic_cast<TMap*>(entry->GetObject()); // old GRP entry
1032 AliInfo("Found a TMap in GRP/GRP/Data, converting it into an AliGRPObject");
1034 fGRPData = new AliGRPObject();
1035 fGRPData->ReadValuesFromMap(m);
1039 AliInfo("Found an AliGRPObject in GRP/GRP/Data, reading it");
1040 fGRPData = dynamic_cast<AliGRPObject*>(entry->GetObject()); // new GRP entry
1044 // FIX ME: The unloading of GRP entry is temporarily disabled
1045 // because ZDC and VZERO are using it in order to initialize
1046 // their reconstructor objects. In the future one has to think
1047 // of propagating AliRunInfo to the reconstructors.
1048 // AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
1052 AliError("No GRP entry found in OCDB!");
1056 TString lhcState = fGRPData->GetLHCState();
1057 if (lhcState==AliGRPObject::GetInvalidString()) {
1058 AliError("GRP/GRP/Data entry: missing value for the LHC state ! Using UNKNOWN");
1059 lhcState = "UNKNOWN";
1062 TString beamType = fGRPData->GetBeamType();
1063 if (beamType==AliGRPObject::GetInvalidString()) {
1064 AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN");
1065 beamType = "UNKNOWN";
1068 Float_t beamEnergy = fGRPData->GetBeamEnergy();
1069 if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
1070 AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
1074 TString runType = fGRPData->GetRunType();
1075 if (runType==AliGRPObject::GetInvalidString()) {
1076 AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN");
1077 runType = "UNKNOWN";
1080 Int_t activeDetectors = fGRPData->GetDetectorMask();
1081 if (activeDetectors==AliGRPObject::GetInvalidUInt()) {
1082 AliError("GRP/GRP/Data entry: missing value for the detector mask ! Using 1074790399");
1083 activeDetectors = 1074790399;
1085 AliDebug(1, Form("activeDetectors = %d", activeDetectors));
1087 fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
1091 // Process the list of active detectors
1092 if (activeDetectors) {
1093 UInt_t detMask = activeDetectors;
1094 AliDebug(1, Form("Detector List = %s", fRunLocalReconstruction.Data()));
1095 fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
1096 AliDebug(1, Form("Detector List = %s", fRunLocalReconstruction.Data()));
1097 fRunTracking = MatchDetectorList(fRunTracking,detMask);
1098 fFillESD = MatchDetectorList(fFillESD,detMask);
1099 fQADetectors = MatchDetectorList(fQADetectors,detMask);
1100 fLoadCDB.Form("%s %s %s %s",
1101 fRunLocalReconstruction.Data(),
1102 fRunTracking.Data(),
1104 fQADetectors.Data());
1105 fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
1106 if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1) &&
1107 !((detMask >> AliDAQ::DetectorID("ITSSDD")) & 0x1) &&
1108 !((detMask >> AliDAQ::DetectorID("ITSSSD")) & 0x1) ) {
1109 // switch off the vertexer
1110 AliInfo("SPD,SDD,SSD is not in the list of active detectors. Vertexer and Trackleter are switched off.");
1111 fRunVertexFinder = kFALSE;
1112 fRunMultFinder = kFALSE;
1114 if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) {
1115 // switch off the reading of CTP raw-data payload
1116 if (fFillTriggerESD) {
1117 AliInfo("CTP is not in the list of active detectors. CTP data reading switched off.");
1118 fFillTriggerESD = kFALSE;
1123 AliInfo("===================================================================================");
1124 AliInfo(Form("Running local reconstruction for detectors: %s",fRunLocalReconstruction.Data()));
1125 AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data()));
1126 AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data()));
1127 AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data()));
1128 AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data()));
1129 AliInfo("===================================================================================");
1131 //*** Dealing with the magnetic field map
1132 if ( TGeoGlobalMagField::Instance()->IsLocked() ) {
1133 if (TGeoGlobalMagField::Instance()->GetField()->TestBit(AliMagF::kOverrideGRP)) {
1134 AliInfo("ExpertMode!!! GRP information will be ignored !");
1135 AliInfo("ExpertMode!!! Running with the externally locked B field !");
1138 AliInfo("Destroying existing B field instance!");
1139 delete TGeoGlobalMagField::Instance();
1142 if ( !TGeoGlobalMagField::Instance()->IsLocked() ) {
1143 // Construct the field map out of the information retrieved from GRP.
1146 Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0);
1147 if (l3Current == AliGRPObject::GetInvalidFloat()) {
1148 AliError("GRP/GRP/Data entry: missing value for the L3 current !");
1152 Char_t l3Polarity = fGRPData->GetL3Polarity();
1153 if (l3Polarity == AliGRPObject::GetInvalidChar()) {
1154 AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
1159 Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0);
1160 if (diCurrent == AliGRPObject::GetInvalidFloat()) {
1161 AliError("GRP/GRP/Data entry: missing value for the dipole current !");
1165 Char_t diPolarity = fGRPData->GetDipolePolarity();
1166 if (diPolarity == AliGRPObject::GetInvalidChar()) {
1167 AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
1171 // read special bits for the polarity convention and map type
1172 Int_t polConvention = fGRPData->IsPolarityConventionLHC() ? AliMagF::kConvLHC : AliMagF::kConvDCS2008;
1173 Bool_t uniformB = fGRPData->IsUniformBMap();
1176 AliMagF* fld = AliMagF::CreateFieldMap(TMath::Abs(l3Current) * (l3Polarity ? -1:1),
1177 TMath::Abs(diCurrent) * (diPolarity ? -1:1),
1178 polConvention,uniformB,beamEnergy, beamType.Data());
1180 TGeoGlobalMagField::Instance()->SetField( fld );
1181 TGeoGlobalMagField::Instance()->Lock();
1182 AliInfo("Running with the B field constructed out of GRP !");
1184 else AliFatal("Failed to create a B field map !");
1186 else AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
1189 //*** Get the diamond profiles from OCDB
1190 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1192 fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
1194 AliError("No SPD diamond profile found in OCDB!");
1197 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1199 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
1201 AliError("No diamond profile found in OCDB!");
1204 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1206 fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
1208 AliError("No TPC diamond profile found in OCDB!");
1211 entry = AliCDBManager::Instance()->Get("GRP/Calib/CosmicTriggers");
1213 fListOfCosmicTriggers = dynamic_cast<THashTable*>(entry->GetObject());
1215 AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
1218 if (!fListOfCosmicTriggers) {
1219 AliWarning("Can not get list of cosmic triggers from OCDB! Cosmic event specie will be effectively disabled!");
1225 //_____________________________________________________________________________
1226 Bool_t AliReconstruction::LoadCDB()
1228 // Load CDB entries for all active detectors.
1229 // By default we load all the entries in <det>/Calib
1232 AliCodeTimerAuto("",0);
1234 AliCDBManager::Instance()->Get("GRP/CTP/Config");
1236 AliCDBManager::Instance()->Get("GRP/Calib/LHCClockPhase");
1238 TString detStr = fLoadCDB;
1239 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1240 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1241 AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
1242 AliCDBManager::Instance()->GetAll(Form("%s/Trigger/*",fgkDetectorName[iDet]));
1245 // Temporary fix - one has to define the correct policy in order
1246 // to load the trigger OCDB entries only for the detectors that
1247 // in the trigger or that are needed in order to put correct
1248 // information in ESD
1249 AliCDBManager::Instance()->GetAll("TRIGGER/*/*");
1253 //_____________________________________________________________________________
1254 Bool_t AliReconstruction::LoadTriggerScalersCDB()
1256 // Load CTP scalers from OCDB.
1257 // The scalers are checked for consistency.
1259 AliCodeTimerAuto("",0);
1261 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/Scalers");
1265 AliInfo("Found an AliTriggerRunScalers in GRP/CTP/Scalers, reading it");
1266 fRunScalers = dynamic_cast<AliTriggerRunScalers*> (entry->GetObject());
1268 if (fRunScalers && (fRunScalers->CorrectScalersOverflow() == 0)) AliInfo("32bit Trigger counters corrected for overflow");
1273 //_____________________________________________________________________________
1274 Bool_t AliReconstruction::LoadCTPTimeParamsCDB()
1276 // Load CTP timing information (alignment)
1279 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
1280 if (!entry) return kFALSE;
1282 AliInfo("Found an AliCTPTimeParams in GRP/CTP/CTPtiming, reading it");
1283 fCTPTimeParams = dynamic_cast<AliCTPTimeParams*> (entry->GetObject());
1286 AliCDBEntry* entry2 = AliCDBManager::Instance()->Get("GRP/CTP/TimeAlign");
1287 if (!entry2) return kFALSE;
1289 AliInfo("Found an AliCTPTimeParams in GRP/CTP/TimeAlign, reading it");
1290 fCTPTimeAlign = dynamic_cast<AliCTPTimeParams*> (entry2->GetObject());
1291 entry2->SetOwner(0);
1296 //_____________________________________________________________________________
1297 Bool_t AliReconstruction::ReadIntensityInfoCDB()
1299 // Load LHC DIP data
1300 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/LHCData");
1301 AliCDBEntry* entryCTP = AliCDBManager::Instance()->Get("GRP/CTP/Config");
1303 if (!entry || !entryCTP) {
1304 AliError(Form("Failed to extract CDB objects GRP/GRP/LHCData: %p or GRP/CTP/Config: %p",entry,entryCTP));
1308 enum {kA,kB,kC,kE,kNMasks};
1309 AliTriggerConfiguration* conf = (AliTriggerConfiguration*)entryCTP->GetObject();
1310 const TObjArray& clArr = conf->GetClasses();
1311 TObjArray masks(kNMasks);
1313 AliTriggerClass* trClass = 0;
1315 masks.SetOwner(kFALSE);
1317 while ( (trClass=(AliTriggerClass*)next()) ) {
1318 TString trName = trClass->GetName();
1319 int ind = trName.Index("-"); // prefix in front of A,B,C,E
1320 if (ind<1) continue; // anomaly
1322 trName = trName.Data() + ind;
1323 AliTriggerBCMask* bcMask = trClass->GetBCMask();
1324 if (!bcMask) continue;
1326 if (trName.BeginsWith("-A-")) which |= 0x1<<kA;
1327 else if (trName.BeginsWith("-B-")) which |= 0x1<<kB;
1328 else if (trName.BeginsWith("-C-")) which |= 0x1<<kC;
1329 else if (trName.BeginsWith("-E-")) which |= 0x1<<kE;
1330 else if (trName.BeginsWith("-AC-")) which |= (0x1<<kA) | (0x1<<kC);
1331 else if (trName.BeginsWith("-CA-")) which |= (0x1<<kA) | (0x1<<kC);
1332 else { AliWarning(Form("Unknown trigger type %s\n",trClass->GetName())); continue;}
1334 for (int ip=kNMasks;ip--;) {
1335 if ( !(which&(0x1<<ip)) || masks[ip] ) continue; // does not match or already done
1336 masks[ip] = (TObject*)bcMask;
1339 if (nFound==kNMasks) break;
1342 AliInfo("Reading mean bunch intensities from GRP/GRP/LHCData");
1343 AliLHCData* dipData = dynamic_cast<AliLHCData*> (entry->GetObject());
1345 for (int ib=2;ib--;) {
1347 if (dipData && (dipData->GetMeanIntensity(ib,intI,intNI,&masks)>=0)) {
1348 fBeamInt[ib][0] = intI;
1349 fBeamInt[ib][1] = intNI;
1350 AliInfo(Form("Mean intensity for beam %d: Interacting:%.2e Non-Interacting:%.2e",ib,intI,intNI));
1358 //_____________________________________________________________________________
1359 Bool_t AliReconstruction::Run(const char* input)
1362 AliCodeTimerAuto("",0);
1365 if (GetAbort() != TSelector::kContinue) return kFALSE;
1367 TChain *chain = NULL;
1368 if (fRawReader && (chain = fRawReader->GetChain())) {
1369 Long64_t nEntries = (fLastEvent < 0) ? (TChain::kBigNumber) : (fLastEvent - fFirstEvent + 1);
1372 // Temporary fix for long raw-data runs (until socket timeout handling in PROOF is revised)
1373 gProof->Exec("gEnv->SetValue(\"Proof.SocketActivityTimeout\",-1)", kTRUE);
1376 gProof->Exec("TGrid::Connect(\"alien://\")",kTRUE);
1378 TMessage::EnableSchemaEvolutionForAll(kTRUE);
1379 gProof->Exec("TMessage::EnableSchemaEvolutionForAll(kTRUE)",kTRUE);
1381 gProof->AddInput(this);
1383 if (!ParseOutput()) return kFALSE;
1385 gProof->SetParameter("PROOF_MaxSlavesPerNode", 9999);
1387 chain->Process("AliReconstruction","",nEntries,fFirstEvent);
1390 chain->Process(this,"",nEntries,fFirstEvent);
1395 if (GetAbort() != TSelector::kContinue) return kFALSE;
1397 if (GetAbort() != TSelector::kContinue) return kFALSE;
1398 //******* The loop over events
1399 AliInfo("Starting looping over events");
1401 while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
1402 (fRawReader && fRawReader->NextEvent())) {
1403 if (!ProcessEvent(iEvent)) {
1404 Abort("ProcessEvent",TSelector::kAbortFile);
1410 if (GetAbort() != TSelector::kContinue) return kFALSE;
1412 if (GetAbort() != TSelector::kContinue) return kFALSE;
1418 //_____________________________________________________________________________
1419 void AliReconstruction::InitRawReader(const char* input)
1421 // Init raw-reader and
1422 // set the input in case of raw data
1424 AliCodeTimerAuto("",0);
1426 if (input) fRawInput = input;
1427 fRawReader = AliRawReader::Create(fRawInput.Data());
1429 if (fRawInput.IsNull()) {
1430 AliInfo("Reconstruction will run over digits");
1433 AliFatal("Can not create raw-data reader ! Exiting...");
1437 if (!fEquipIdMap.IsNull() && fRawReader)
1438 fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1440 if (!fUseHLTData.IsNull()) {
1441 // create the RawReaderHLT which performs redirection of HLT input data for
1442 // the specified detectors
1443 AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
1445 fParentRawReader=fRawReader;
1446 fRawReader=pRawReader;
1448 AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
1451 AliSysInfo::AddStamp("CreateRawReader");
1454 //_____________________________________________________________________________
1455 void AliReconstruction::InitRun(const char* input)
1457 // Initialization of raw-reader,
1458 // run number, CDB etc.
1459 AliCodeTimerAuto("",0);
1460 AliSysInfo::AddStamp("Start");
1462 // Initialize raw-reader if any
1463 InitRawReader(input);
1465 // Initialize the CDB storage
1468 // Set run number in CDBManager (if it is not already set by the user)
1469 if (!SetRunNumberFromData()) {
1470 Abort("SetRunNumberFromData", TSelector::kAbortProcess);
1474 // Set CDB lock: from now on it is forbidden to reset the run number
1475 // or the default storage or to activate any further storage!
1480 //_____________________________________________________________________________
1481 void AliReconstruction::Begin(TTree *)
1483 // Initialize AlReconstruction before
1484 // going into the event loop
1485 // Should follow the TSelector convention
1486 // i.e. initialize only the object on the client side
1487 AliCodeTimerAuto("",0);
1489 AliReconstruction *reco = NULL;
1491 if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
1494 AliSysInfo::AddStamp("ReadInputInBegin");
1497 // Import ideal TGeo geometry and apply misalignment
1499 TString geom(gSystem->DirName(fGAliceFileName));
1500 geom += "/geometry.root";
1501 AliGeomManager::LoadGeometry(geom.Data());
1503 Abort("LoadGeometry", TSelector::kAbortProcess);
1506 AliSysInfo::AddStamp("LoadGeom");
1507 TString detsToCheck=fRunLocalReconstruction;
1508 if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) {
1509 Abort("CheckSymNamesLUT", TSelector::kAbortProcess);
1512 AliSysInfo::AddStamp("CheckGeom");
1515 if(fFromCDBSnapshot){
1516 AliDebug(2,"Initializing from a CDB snapshot");
1517 if(!AliCDBManager::Instance()->InitFromSnapshot(fSnapshotFileName.Data())){
1518 Abort("InitFromSnapshot", TSelector::kAbortProcess);
1523 if (!MisalignGeometry(fLoadAlignData)) {
1524 Abort("MisalignGeometry", TSelector::kAbortProcess);
1527 AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
1528 AliSysInfo::AddStamp("MisalignGeom");
1531 Abort("InitGRP", TSelector::kAbortProcess);
1534 AliSysInfo::AddStamp("InitGRP");
1536 if(!fFromCDBSnapshot){
1538 Abort("LoadCDB", TSelector::kAbortProcess);
1541 AliSysInfo::AddStamp("LoadCDB");
1544 if (!LoadTriggerScalersCDB()) {
1545 Abort("LoadTriggerScalersCDB", TSelector::kAbortProcess);
1548 AliSysInfo::AddStamp("LoadTriggerScalersCDB");
1550 if (!LoadCTPTimeParamsCDB()) {
1551 Abort("LoadCTPTimeParamsCDB", TSelector::kAbortProcess);
1554 AliSysInfo::AddStamp("LoadCTPTimeParamsCDB");
1556 if (!ReadIntensityInfoCDB()) {
1557 Abort("ReadIntensityInfoCDB", TSelector::kAbortProcess);
1560 AliSysInfo::AddStamp("ReadIntensityInfoCDB");
1562 // Read the reconstruction parameters from OCDB
1563 if (!InitRecoParams()) {
1564 AliWarning("Not all detectors have correct RecoParam objects initialized");
1566 AliSysInfo::AddStamp("InitRecoParams");
1568 if (fInput && gProof) {
1569 if (reco) *reco = *this;
1571 gGeoManager->SetName("Geometry");
1572 gProof->AddInputData(gGeoManager,kTRUE);
1574 gProof->AddInputData(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()),kTRUE);
1575 fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
1576 AliMagF *magFieldMap = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
1577 magFieldMap->SetName("MagneticFieldMap");
1578 gProof->AddInputData(magFieldMap,kTRUE);
1580 fAnalysis->SetName("Analysis");
1581 gProof->AddInputData(fAnalysis,kTRUE);
1587 //_____________________________________________________________________________
1588 void AliReconstruction::SlaveBegin(TTree*)
1590 // Initialization related to run-loader,
1591 // vertexer, trackers, recontructors
1592 // In proof mode it is executed on the slave
1593 AliCodeTimerAuto("",0);
1595 TProofOutputFile *outProofFile = NULL;
1597 if (AliDebugLevel() > 0) fInput->Print();
1598 if (AliDebugLevel() > 10) fInput->Dump();
1599 if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
1602 if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) {
1604 AliGeomManager::SetGeometry(tgeo);
1606 if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) {
1607 Int_t runNumber = -1;
1608 if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) {
1609 AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber);
1610 man->SetCacheFlag(kTRUE);
1611 man->SetLock(kTRUE);
1615 if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
1616 AliMagF *newMap = new AliMagF(*map);
1617 if (!newMap->LoadParameterization()) {
1618 Abort("AliMagF::LoadParameterization", TSelector::kAbortProcess);
1621 TGeoGlobalMagField::Instance()->SetField(newMap);
1622 TGeoGlobalMagField::Instance()->Lock();
1625 // Attempt to get the analysis manager from the input list
1626 fAnalysis = (AliAnalysisManager*)fInput->FindObject("Analysis");
1627 if (fAnalysis) AliInfo("==== Analysis manager retrieved from input list ====");
1629 if (TNamed *outputFileName = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE"))
1630 fProofOutputFileName = outputFileName->GetTitle();
1631 if (TNamed *outputLocation = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_LOCATION"))
1632 fProofOutputLocation = outputLocation->GetTitle();
1633 if (fInput->FindObject("PROOF_OUTPUTFILE_DATASET"))
1634 fProofOutputDataset = kTRUE;
1635 if (TNamed *archiveList = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_ARCHIVE"))
1636 fProofOutputArchive = archiveList->GetTitle();
1637 if (!fProofOutputFileName.IsNull() &&
1638 !fProofOutputLocation.IsNull() &&
1639 fProofOutputArchive.IsNull()) {
1640 if (!fProofOutputDataset) {
1641 outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"M");
1642 outProofFile->SetOutputFileName(Form("%s%s",fProofOutputLocation.Data(),fProofOutputFileName.Data()));
1645 outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"DROV",fProofOutputLocation.Data());
1647 if (AliDebugLevel() > 0) outProofFile->Dump();
1648 fOutput->Add(outProofFile);
1650 AliSysInfo::AddStamp("ReadInputInSlaveBegin");
1652 // Check if analysis was requested in the reconstruction event loop
1654 // Attempt to connect in-memory singleton
1655 fAnalysis = AliAnalysisManager::GetAnalysisManager();
1656 if (fAnalysis) AliInfo(Form("==== Analysis manager <%s> found in memory ====", fAnalysis->GetName()));
1657 // Check if an analysis macro was specified
1658 if (!fAnalysis && !fAnalysisMacro.IsNull()) {
1659 // Run specified analysis macro
1660 gROOT->ProcessLine(Form(".x %s",fAnalysisMacro.Data()));
1661 fAnalysis = AliAnalysisManager::GetAnalysisManager();
1662 if (!fAnalysis) AliError(Form("No analysis manager produced by analysis macro %s", fAnalysisMacro.Data()));
1663 else AliInfo(Form("==== Analysis manager <%s> produced by analysis macro <%s> ====",
1664 fAnalysis->GetName(), fAnalysisMacro.Data()));
1668 // get the run loader
1669 if (!InitRunLoader()) {
1670 Abort("InitRunLoader", TSelector::kAbortProcess);
1673 AliSysInfo::AddStamp("LoadLoader");
1675 ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
1678 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
1679 Abort("CreateTrackers", TSelector::kAbortProcess);
1682 AliSysInfo::AddStamp("CreateTrackers");
1684 // create the ESD output file and tree
1685 if (!outProofFile) {
1686 ffile = TFile::Open("AliESDs.root", "RECREATE");
1687 ffile->SetCompressionLevel(2);
1688 if (!ffile->IsOpen()) {
1689 Abort("OpenESDFile", TSelector::kAbortProcess);
1694 AliInfo(Form("Opening output PROOF file: %s/%s",
1695 outProofFile->GetDir(), outProofFile->GetFileName()));
1696 if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
1697 Abort(Form("Problems opening output PROOF file: %s/%s",
1698 outProofFile->GetDir(), outProofFile->GetFileName()),
1699 TSelector::kAbortProcess);
1704 ftree = new TTree("esdTree", "Tree with ESD objects");
1705 fesd = new AliESDEvent();
1706 fesd->CreateStdContent();
1707 // add a so far non-std object to the ESD, this will
1708 // become part of the std content
1709 fesd->AddObject(new AliESDHLTDecision);
1711 fesd->WriteToTree(ftree);
1712 if (fWriteESDfriend) {
1713 ffileF = TFile::Open("AliESDfriends.root", "RECREATE");
1714 ftreeF = new TTree("esdFriendTree", "Tree with ESD Friend objects");
1715 fesdf = new AliESDfriend();
1716 ftreeF->Branch("ESDfriend.","AliESDfriend", &fesdf);
1717 fesd->AddObject(fesdf);
1720 ftree->GetUserInfo()->Add(fesd);
1722 fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
1723 fhltesd = new AliESDEvent();
1724 fhltesd->CreateStdContent();
1725 // read the ESD template from CDB
1726 // HLT is allowed to put non-std content to its ESD, the non-std
1727 // objects need to be created before invocation of WriteToTree in
1728 // order to create all branches. Initialization is done from an
1729 // ESD layout template in CDB
1730 AliCDBManager* man = AliCDBManager::Instance();
1731 AliCDBPath hltESDConfigPath("HLT/ConfigHLT/esdLayout");
1732 AliCDBEntry* hltESDConfig=NULL;
1733 if (man->GetId(hltESDConfigPath)!=NULL &&
1734 (hltESDConfig=man->Get(hltESDConfigPath))!=NULL) {
1735 AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
1737 // init all internal variables from the list of objects
1738 pESDLayout->GetStdContent();
1740 // copy content and create non-std objects
1741 *fhltesd=*pESDLayout;
1744 AliError(Form("error setting hltEsd layout from %s: invalid object type",
1745 hltESDConfigPath.GetPath().Data()));
1749 fhltesd->WriteToTree(fhlttree);
1750 fhlttree->GetUserInfo()->Add(fhltesd);
1752 ProcInfo_t procInfo;
1753 gSystem->GetProcInfo(&procInfo);
1754 AliInfo(Form("Current memory usage %ld %ld", procInfo.fMemResident, procInfo.fMemVirtual));
1757 //Initialize the QA and start of cycle
1758 if (fRunQA || fRunGlobalQA)
1761 //Initialize the Plane Efficiency framework
1762 if (fRunPlaneEff && !InitPlaneEff()) {
1763 Abort("InitPlaneEff", TSelector::kAbortProcess);
1767 if (strcmp(gProgName,"alieve") == 0)
1768 fRunAliEVE = InitAliEVE();
1769 // If we have an analysis manager, connect the AliRecoInputHandler here
1771 if (!dynamic_cast<AliRecoInputHandler*>(fAnalysis->GetInputEventHandler())) {
1772 AliError("Analysis manager used in reconstruction should use AliRecoInputHandler - \
1773 \n ->Replacing with AliRecoInputHandler instance.");
1774 delete fAnalysis->GetInputEventHandler();
1776 // Set the event and other data pointers
1777 fRecoHandler = new AliRecoInputHandler();
1778 fRecoHandler->Init(ftree, "LOCAL");
1779 fRecoHandler->SetEvent(fesd);
1780 fRecoHandler->SetESDfriend(fesdf);
1781 fRecoHandler->SetHLTEvent(fhltesd);
1782 fRecoHandler->SetHLTTree(fhlttree);
1783 fAnalysis->SetInputEventHandler(fRecoHandler);
1784 // Enter external loop mode
1785 fAnalysis->SetExternalLoop(kTRUE);
1786 // Initialize analysis
1787 fAnalysis->StartAnalysis("local", (TTree*)0);
1788 // Connect ESD tree with the input container
1789 fAnalysis->GetCommonInputContainer()->SetData(ftree);
1794 //_____________________________________________________________________________
1795 Bool_t AliReconstruction::Process(Long64_t entry)
1797 // run the reconstruction over a single entry
1798 // from the chain with raw data
1799 AliCodeTimerAuto("",0);
1801 TTree *currTree = fChain->GetTree();
1802 AliRawVEvent *event = NULL;
1803 currTree->SetBranchAddress("rawevent",&event);
1804 currTree->GetEntry(entry);
1805 fRawReader = new AliRawReaderRoot(event);
1806 fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
1814 //_____________________________________________________________________________
1815 void AliReconstruction::Init(TTree *tree)
1817 // Implementation of TSelector::Init()
1820 AliError("The input tree is not found!");
1826 //_____________________________________________________________________________
1827 Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
1829 // run the reconstruction over a single event
1830 // The event loop is steered in Run method
1833 static Long_t oldMres=0;
1834 static Long_t oldMvir=0;
1835 static Float_t oldCPU=0;
1836 static Long_t aveDMres=0;
1837 static Long_t aveDMvir=0;
1838 static Float_t aveDCPU=0;
1840 AliCodeTimerAuto("",0);
1844 if (iEvent >= fRunLoader->GetNumberOfEvents()) {
1845 fRunLoader->SetEventNumber(iEvent);
1847 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
1849 fRunLoader->TreeE()->Fill();
1851 if (fRawReader && fRawReader->UseAutoSaveESD())
1852 fRunLoader->TreeE()->AutoSave("SaveSelf");
1855 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
1860 fRunLoader->GetEvent(iEvent);
1862 // Fill Event-info object
1864 fRecoParam.SetEventSpecie(fRunInfo,fEventInfo,fListOfCosmicTriggers);
1866 ProcInfo_t procInfo;
1867 if(iEvent==fFirstEvent) {
1868 gSystem->GetProcInfo(&procInfo);
1869 oldMres=procInfo.fMemResident;
1870 oldMvir=procInfo.fMemVirtual;
1871 oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
1873 AliInfo(Form("================================= Processing event %d of type %-10s ==================================", iEvent,fRecoParam.PrintEventSpecie()));
1875 // Set the reco-params
1877 TString detStr = fLoadCDB;
1878 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1879 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1880 AliReconstructor *reconstructor = GetReconstructor(iDet);
1881 if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
1882 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
1883 reconstructor->SetRecoParam(par);
1884 reconstructor->GetPidSettings(&pid);
1885 reconstructor->SetEventInfo(&fEventInfo);
1887 AliQAManager::QAManager()->SetEventInfo(&fEventInfo) ;
1888 AliQAManager::QAManager()->SetRecoParam(iDet, par) ;
1889 if (par) AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
1894 if (fRunQA || fRunGlobalQA) AliQADataMaker::SetEventTrigClasses(fEventInfo.GetTriggerClasses()); // RS: select which histo clones are to be filled
1897 const AliDetectorRecoParam *grppar = fRecoParam.GetDetRecoParam(kNDetectors);
1898 AliQAManager::QAManager()->SetRecoParam(AliQAv1::kGLOBAL, grppar) ;
1899 AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(grppar->GetEventSpecie())) ;
1904 if (fRunQA && IsInTasks(AliQAv1::kRAWS)) {
1905 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1906 AliQAManager::QAManager()->RunOneEvent(fRawReader) ;
1908 // local single event reconstruction
1909 if (!fRunLocalReconstruction.IsNull()) {
1910 TString detectors=fRunLocalReconstruction;
1911 // run HLT event reconstruction first
1912 // ;-( IsSelected changes the string
1913 if (IsSelected("HLT", detectors) &&
1914 !RunLocalEventReconstruction("HLT")) {
1915 if (fStopOnError) {CleanUp(); return kFALSE;}
1917 detectors=fRunLocalReconstruction;
1918 detectors.ReplaceAll("HLT", "");
1919 if (!RunLocalEventReconstruction(detectors)) {
1928 // fill Event header information from the RawEventHeader
1929 if (fRawReader){FillRawEventHeaderESD(fesd);}
1930 if (fRawReader){FillRawEventHeaderESD(fhltesd);}
1932 fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1933 fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1935 ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
1936 ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
1937 ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
1938 ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
1940 fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1941 fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1943 fesd->SetEventSpecie(fRecoParam.GetEventSpecie());
1944 fhltesd->SetEventSpecie(fRecoParam.GetEventSpecie());
1946 // Set magnetic field from the tracker
1947 fesd->SetMagneticField(AliTracker::GetBz());
1948 fhltesd->SetMagneticField(AliTracker::GetBz());
1950 AliESDRun *esdRun,*esdRunH;
1951 esdRun = (AliESDRun*)fesd->GetESDRun();
1952 esdRunH = (AliESDRun*)fhltesd->GetESDRun();
1953 esdRun->SetBeamEnergyIsSqrtSHalfGeV();
1954 esdRunH->SetBeamEnergyIsSqrtSHalfGeV();
1956 for (int ib=2;ib--;) for (int it=2;it--;) {
1957 esdRun->SetMeanIntensity(ib,it, fBeamInt[ib][it]);
1958 esdRunH->SetMeanIntensity(ib,it, fBeamInt[ib][it]);
1961 AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
1962 if (fld) { // set info needed for field initialization
1963 fesd->SetCurrentL3(fld->GetCurrentSol());
1964 fesd->SetCurrentDip(fld->GetCurrentDip());
1965 fesd->SetBeamEnergy(fld->GetBeamEnergy());
1966 fesd->SetBeamType(fld->GetBeamTypeText());
1967 fesd->SetUniformBMap(fld->IsUniform());
1968 fesd->SetBInfoStored();
1970 fhltesd->SetCurrentL3(fld->GetCurrentSol());
1971 fhltesd->SetCurrentDip(fld->GetCurrentDip());
1972 fhltesd->SetBeamEnergy(fld->GetBeamEnergy());
1973 fhltesd->SetBeamType(fld->GetBeamTypeText());
1974 fhltesd->SetUniformBMap(fld->IsUniform());
1975 fhltesd->SetBInfoStored();
1978 // Set most probable pt, for B=0 tracking
1979 // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
1980 const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
1981 if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
1983 // Fill raw-data error log into the ESD
1984 if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
1987 if (fRunVertexFinder) {
1988 if (!RunVertexFinder(fesd)) {
1989 if (fStopOnError) {CleanUp(); return kFALSE;}
1993 // For Plane Efficiency: run the SPD trackleter
1994 if (fRunPlaneEff && fSPDTrackleter) {
1995 if (!RunSPDTrackleting(fesd)) {
1996 if (fStopOnError) {CleanUp(); return kFALSE;}
2001 if (!fRunTracking.IsNull()) {
2002 if (fRunMuonTracking) {
2003 if (!RunMuonTracking(fesd)) {
2004 if (fStopOnError) {CleanUp(); return kFALSE;}
2010 if (!fRunTracking.IsNull()) {
2011 if (!RunTracking(fesd,pid)) {
2012 if (fStopOnError) {CleanUp(); return kFALSE;}
2017 if (!fFillESD.IsNull()) {
2018 TString detectors=fFillESD;
2019 // run HLT first and on hltesd
2020 // ;-( IsSelected changes the string
2021 if (IsSelected("HLT", detectors) &&
2022 !FillESD(fhltesd, "HLT")) {
2023 if (fStopOnError) {CleanUp(); return kFALSE;}
2026 // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
2027 if (detectors.Contains("ALL")) {
2029 for (Int_t idet=0; idet<kNDetectors; ++idet){
2030 detectors += fgkDetectorName[idet];
2034 detectors.ReplaceAll("HLT", "");
2035 if (!FillESD(fesd, detectors)) {
2036 if (fStopOnError) {CleanUp(); return kFALSE;}
2044 // Propagate track to the beam pipe (if not already done by ITS)
2046 const Int_t ntracks = fesd->GetNumberOfTracks();
2047 const Double_t kRadius = 2.8; //something less than the beam pipe radius
2050 UShort_t *selectedIdx=new UShort_t[ntracks];
2052 for (Int_t itrack=0; itrack<ntracks; itrack++){
2053 const Double_t kMaxStep = 1; //max step over the material
2056 AliESDtrack *track = fesd->GetTrack(itrack);
2057 if (!track) continue;
2059 AliExternalTrackParam *tpcTrack =
2060 (AliExternalTrackParam *)track->GetTPCInnerParam();
2064 PropagateTrackToBxByBz(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
2067 Int_t n=trkArray.GetEntriesFast();
2068 selectedIdx[n]=track->GetID();
2069 trkArray.AddLast(tpcTrack);
2072 //Tracks refitted by ITS should already be at the SPD vertex
2073 if (track->IsOn(AliESDtrack::kITSrefit)) continue;
2076 PropagateTrackToBxByBz(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
2077 Double_t x[3]; track->GetXYZ(x);
2078 Double_t b[3]; AliTracker::GetBxByBz(x,b);
2079 track->RelateToVertexBxByBz(fesd->GetPrimaryVertexSPD(), b, kVeryBig);
2084 // Improve the reconstructed primary vertex position using the tracks
2086 Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
2087 if(fesd->GetPrimaryVertexSPD()) {
2088 TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
2089 if(vtitle.Contains("cosmics")) {
2090 runVertexFinderTracks=kFALSE;
2094 if (runVertexFinderTracks) {
2095 // TPC + ITS primary vertex
2096 ftVertexer->SetITSMode();
2097 ftVertexer->SetConstraintOff();
2098 // get cuts for vertexer from AliGRPRecoParam
2099 Bool_t constrSPD=kFALSE;
2101 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
2102 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
2103 grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer,nCutsVertexer);
2104 ftVertexer->SetCuts(cutsVertexer,nCutsVertexer);
2105 delete [] cutsVertexer; cutsVertexer = NULL;
2106 if(grpRecoParam->GetVertexerTracksConstraintITS()) {
2107 if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius){
2108 ftVertexer->SetVtxStart(fDiamondProfile); // apply constraint only if sigmax is smaller than the beam pipe radius
2110 if(fDiamondProfileSPD && fDiamondProfileSPD->GetXRes()<kRadius){
2111 ftVertexer->SetVtxStart(fDiamondProfileSPD);
2117 AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
2120 TString title=pvtx->GetTitle();
2121 title.Append("SPD");
2122 pvtx->SetTitle(title);
2124 if (pvtx->GetStatus()) {
2125 fesd->SetPrimaryVertexTracks(pvtx);
2126 for (Int_t i=0; i<ntracks; i++) {
2127 AliESDtrack *t = fesd->GetTrack(i);
2128 Double_t x[3]; t->GetXYZ(x);
2129 Double_t b[3]; AliTracker::GetBxByBz(x,b);
2130 t->RelateToVertexBxByBz(pvtx, b, kVeryBig);
2133 delete pvtx; pvtx=NULL;
2136 // TPC-only primary vertex
2137 ftVertexer->SetTPCMode();
2138 ftVertexer->SetConstraintOff();
2139 // get cuts for vertexer from AliGRPRecoParam
2141 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
2142 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
2143 grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer,nCutsVertexer);
2144 ftVertexer->SetCuts(cutsVertexer,nCutsVertexer);
2145 delete [] cutsVertexer; cutsVertexer = NULL;
2146 if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC()) {
2147 if(fDiamondProfileTPC->GetXRes()<kRadius) ftVertexer->SetVtxStart(fDiamondProfileTPC); // apply constraint only if sigmax is smaller than the beam pipe radius
2150 pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
2152 if (pvtx->GetStatus()) {
2153 fesd->SetPrimaryVertexTPC(pvtx);
2154 for (Int_t i=0; i<ntracks; i++) {
2155 AliESDtrack *t = fesd->GetTrack(i);
2156 Double_t x[3]; t->GetXYZ(x);
2157 Double_t b[3]; AliTracker::GetBxByBz(x,b);
2158 t->RelateToVertexTPCBxByBz(pvtx, b, kVeryBig);
2161 delete pvtx; pvtx=NULL;
2165 delete[] selectedIdx;
2167 if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius) fesd->SetDiamond(fDiamondProfile);
2168 else fesd->SetDiamond(fDiamondProfileSPD);
2172 AliV0vertexer vtxer;
2173 // get cuts for V0vertexer from AliGRPRecoParam
2175 Int_t nCutsV0vertexer = grpRecoParam->GetVertexerV0NCuts();
2176 Double_t *cutsV0vertexer = new Double_t[nCutsV0vertexer];
2177 grpRecoParam->GetVertexerV0Cuts(cutsV0vertexer);
2178 vtxer.SetCuts(cutsV0vertexer);
2179 delete [] cutsV0vertexer; cutsV0vertexer = NULL;
2181 vtxer.Tracks2V0vertices(fesd);
2183 if (fRunCascadeFinder) {
2185 AliCascadeVertexer cvtxer;
2186 // get cuts for CascadeVertexer from AliGRPRecoParam
2188 Int_t nCutsCascadeVertexer = grpRecoParam->GetVertexerCascadeNCuts();
2189 Double_t *cutsCascadeVertexer = new Double_t[nCutsCascadeVertexer];
2190 grpRecoParam->GetVertexerCascadeCuts(cutsCascadeVertexer);
2191 cvtxer.SetCuts(cutsCascadeVertexer);
2192 delete [] cutsCascadeVertexer; cutsCascadeVertexer = NULL;
2194 cvtxer.V0sTracks2CascadeVertices(fesd);
2199 if (fReconstructor[3])
2200 GetReconstructor(3)->FillEventTimeWithTOF(fesd,&pid);
2205 if (fFillTriggerESD) {
2206 if (!FillTriggerESD(fesd)) {
2207 if (fStopOnError) {CleanUp(); return kFALSE;}
2210 // Always fill scalers
2211 if (!FillTriggerScalers(fesd)) {
2212 if (fStopOnError) {CleanUp(); return kFALSE;}
2216 if (fCleanESD) CleanESD(fesd);
2218 // RS run updated trackleter: since we want to mark the clusters used by tracks and also mark the
2219 // tracks interpreted as primary, this step should be done in the very end, when full
2220 // ESD info is available (particulalry, V0s)
2222 if (fRunMultFinder) {
2223 if (!RunMultFinder(fesd)) {
2224 if (fStopOnError) {CleanUp(); return kFALSE;}
2228 if (fRunQA && IsInTasks(AliQAv1::kESDS)) {
2229 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2230 AliQAManager::QAManager()->RunOneEvent(fesd, fhltesd) ;
2233 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2235 qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2236 if (qadm && IsInTasks(AliQAv1::kESDS))
2237 qadm->Exec(AliQAv1::kESDS, fesd);
2240 // copy HLT decision from HLTesd to esd
2241 // the most relevant information is stored in a reduced container in the esd,
2242 // while the full information can be found in the HLTesd
2243 TObject* pHLTSrc=fhltesd->FindListObject(AliESDHLTDecision::Name());
2244 TObject* pHLTTgt=fesd->FindListObject(AliESDHLTDecision::Name());
2245 if (pHLTSrc && pHLTTgt) {
2246 pHLTSrc->Copy(*pHLTTgt);
2249 // Perform analysis of this event if requested
2250 // RS: Should be done before WriteESDfriend, since the latter may clean the esdfriend
2252 fRecoHandler->BeginEvent(iEvent);
2253 fAnalysis->ExecAnalysis();
2254 fRecoHandler->FinishEvent();
2257 if (fWriteESDfriend)
2258 fesd->GetESDfriend(fesdf);
2261 if (fWriteESDfriend) {
2264 // Auto-save the ESD tree in case of prompt reco @P2
2265 if (fRawReader && fRawReader->UseAutoSaveESD()) {
2266 ftree->AutoSave("SaveSelf");
2267 if (fWriteESDfriend) ftreeF->AutoSave("SaveSelf");
2274 if (fRunAliEVE) RunAliEVE();
2278 if (fWriteESDfriend) {
2279 fesdf->~AliESDfriend();
2280 new (fesdf) AliESDfriend(); // Reset...
2283 gSystem->GetProcInfo(&procInfo);
2284 Long_t dMres=(procInfo.fMemResident-oldMres)/1024;
2285 Long_t dMvir=(procInfo.fMemVirtual-oldMvir)/1024;
2286 Float_t dCPU=procInfo.fCpuUser+procInfo.fCpuSys-oldCPU;
2287 aveDMres+=(dMres-aveDMres)/(iEvent-fFirstEvent+1);
2288 aveDMvir+=(dMvir-aveDMvir)/(iEvent-fFirstEvent+1);
2289 aveDCPU+=(dCPU-aveDCPU)/(iEvent-fFirstEvent+1);
2290 AliInfo(Form("======================= End Event %d: Res %ld(%3ld <%3ld>) Vir %ld(%3ld <%3ld>) CPU %5.2f <%5.2f> ===================",
2291 iEvent, procInfo.fMemResident/1024, dMres, aveDMres, procInfo.fMemVirtual/1024, dMvir, aveDMvir, dCPU, aveDCPU));
2292 oldMres=procInfo.fMemResident;
2293 oldMvir=procInfo.fMemVirtual;
2294 oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
2297 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2298 if (fReconstructor[iDet]) {
2299 fReconstructor[iDet]->SetRecoParam(NULL);
2300 fReconstructor[iDet]->SetEventInfo(NULL);
2302 if (fTracker[iDet]) fTracker[iDet]->SetEventInfo(NULL);
2305 if (fRunQA || fRunGlobalQA)
2306 AliQAManager::QAManager()->Increment() ;
2311 //_____________________________________________________________________________
2312 void AliReconstruction::SlaveTerminate()
2314 // Finalize the run on the slave side
2315 // Called after the exit
2316 // from the event loop
2317 AliCodeTimerAuto("",0);
2318 // If analysis was done during reconstruction, we need to call SlaveTerminate for it
2320 fAnalysis->PackOutput(fOutput);
2321 fAnalysis->SetSkipTerminate(kTRUE);
2322 fAnalysis->Terminate();
2325 if (fIsNewRunLoader) { // galice.root didn't exist
2326 fRunLoader->WriteHeader("OVERWRITE");
2327 fRunLoader->WriteTrigger("OVERWRITE");
2328 fRunLoader->CdGAFile();
2329 fRunLoader->Write(0, TObject::kOverwrite);
2332 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
2333 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
2335 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
2336 cdbMapCopy->SetOwner(1);
2337 cdbMapCopy->SetName("cdbMap");
2338 TIter iter(cdbMap->GetTable());
2341 while((pair = dynamic_cast<TPair*> (iter.Next()))){
2342 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
2343 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
2344 if (keyStr && valStr)
2345 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
2348 TList *cdbListCopy = new TList();
2349 cdbListCopy->SetOwner(1);
2350 cdbListCopy->SetName("cdbList");
2352 TIter iter2(cdbList);
2355 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
2356 cdbListCopy->Add(new TObjString(id->ToString().Data()));
2359 ftree->GetUserInfo()->Add(cdbMapCopy);
2360 ftree->GetUserInfo()->Add(cdbListCopy);
2362 // Add the AliRoot version that created this file
2363 TString sVersion("aliroot ");
2364 sVersion += ALIROOT_SVN_BRANCH;
2366 sVersion += ALIROOT_SVN_REVISION;
2367 sVersion += "; root ";
2368 sVersion += ROOT_SVN_BRANCH;
2370 sVersion += ROOT_SVN_REVISION;
2371 sVersion += "; metadata ";
2372 sVersion += gSystem->Getenv("PRODUCTION_METADATA");
2375 TNamed * alirootVersion = new TNamed("alirootVersion",sVersion.Data());
2376 ftree->GetUserInfo()->Add(alirootVersion); // The list becomes owner of alirootVersion
2380 // we want to have only one tree version number
2381 ftree->Write(ftree->GetName(),TObject::kOverwrite);
2382 fhlttree->Write(fhlttree->GetName(),TObject::kOverwrite);
2384 if (fWriteESDfriend) {
2386 ftreeF->Write(ftreeF->GetName(),TObject::kOverwrite);
2389 // Finish with Plane Efficiency evaluation: before of CleanUp !!!
2390 if (fRunPlaneEff && !FinishPlaneEff()) {
2391 AliWarning("Finish PlaneEff evaluation failed");
2394 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2395 if (fReconstructor[iDet]) fReconstructor[iDet]->Terminate();
2397 // End of cycle for the in-loop
2399 if (fRunQA || fRunGlobalQA) {
2400 AliQAManager::QAManager()->EndOfCycle() ;
2402 !fProofOutputLocation.IsNull() &&
2403 fProofOutputArchive.IsNull() &&
2404 !fProofOutputDataset) {
2405 TString qaOutputFile(Form("%sMerged.%s.Data.root",
2406 fProofOutputLocation.Data(),
2407 AliQAv1::GetQADataFileName()));
2408 TProofOutputFile *qaProofFile = new TProofOutputFile(Form("Merged.%s.Data.root",
2409 AliQAv1::GetQADataFileName()));
2410 qaProofFile->SetOutputFileName(qaOutputFile.Data());
2411 if (AliDebugLevel() > 0) qaProofFile->Dump();
2412 fOutput->Add(qaProofFile);
2413 MergeQA(qaProofFile->GetFileName());
2424 if (!fProofOutputFileName.IsNull() &&
2425 !fProofOutputLocation.IsNull() &&
2426 fProofOutputDataset &&
2427 !fProofOutputArchive.IsNull()) {
2428 TProofOutputFile *zipProofFile = new TProofOutputFile(fProofOutputFileName.Data(),
2430 fProofOutputLocation.Data());
2431 if (AliDebugLevel() > 0) zipProofFile->Dump();
2432 fOutput->Add(zipProofFile);
2433 TString fileList(fProofOutputArchive.Data());
2434 fileList.ReplaceAll(","," ");
2436 #if ROOT_SVN_REVISION >= 30174
2437 command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(kTRUE),zipProofFile->GetFileName(),fileList.Data());
2439 command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(),zipProofFile->GetFileName(),fileList.Data());
2441 AliInfo(Form("Executing: %s",command.Data()));
2442 gSystem->Exec(command.Data());
2447 //_____________________________________________________________________________
2448 void AliReconstruction::Terminate()
2450 // Create tags for the events in the ESD tree (the ESD tree is always present)
2451 // In case of empty events the tags will contain dummy values
2452 AliCodeTimerAuto("",0);
2454 // Do not call the ESD tag creator in case of PROOF-based reconstruction
2456 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
2457 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
2458 delete esdtagCreator;
2461 // Cleanup of CDB manager: cache and active storages!
2462 AliCDBManager::Instance()->ClearCache();
2465 //_____________________________________________________________________________
2466 Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
2468 // run the local reconstruction
2470 static Int_t eventNr=0;
2471 AliCodeTimerAuto("",0)
2473 TString detStr = detectors;
2474 // execute HLT reconstruction first since other detector reconstruction
2475 // might depend on HLT data
2476 // key 'HLT' is removed from detStr by IsSelected
2477 if (!IsSelected("HLT", detStr)) {
2478 AliReconstructor* reconstructor = GetReconstructor(kNDetectors-1);
2479 if (reconstructor) {
2480 // there is no AliLoader for HLT, see
2481 // https://savannah.cern.ch/bugs/?35473
2482 AliInfo("running reconstruction for HLT");
2484 AliInfo("reconstructor->Reconstruct(fRawReader, NULL)");
2485 reconstructor->Reconstruct(fRawReader, NULL);
2488 AliInfo("reconstructor->Reconstruct(dummy, NULL)");
2490 reconstructor->Reconstruct(dummy, NULL);
2495 AliInfo(Form("kNDetectors = %d",kNDetectors));
2497 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2498 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2499 AliDebug(1, Form("Detector: %s", fgkDetectorName[iDet]));
2500 AliReconstructor* reconstructor = GetReconstructor(iDet);
2501 if (!reconstructor) continue;
2502 AliLoader* loader = fLoader[iDet];
2504 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
2507 // conversion of digits
2508 if (fRawReader && reconstructor->HasDigitConversion()) {
2509 AliInfo(Form("converting raw data digits into root objects for %s",
2510 fgkDetectorName[iDet]));
2511 // AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
2512 // fgkDetectorName[iDet]),0);
2513 loader->LoadDigits("update");
2514 loader->CleanDigits();
2515 loader->MakeDigitsContainer();
2516 TTree* digitsTree = loader->TreeD();
2517 reconstructor->ConvertDigits(fRawReader, digitsTree);
2518 loader->WriteDigits("OVERWRITE");
2519 loader->UnloadDigits();
2521 // local reconstruction
2522 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
2523 //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]),0);
2524 AliDebug(1, "Loading Rec Points");
2525 loader->LoadRecPoints("update");
2526 AliDebug(1, "Cleaning Rec Points");
2527 loader->CleanRecPoints();
2528 AliDebug(1, "Making Rec Points Container");
2529 loader->MakeRecPointsContainer();
2530 TTree* clustersTree = loader->TreeR();
2531 if (fRawReader && !reconstructor->HasDigitConversion()) {
2532 reconstructor->Reconstruct(fRawReader, clustersTree);
2535 AliDebug(1, "Loading Digits");
2536 loader->LoadDigits("read");
2537 TTree* digitsTree = loader->TreeD();
2538 AliDebug(1, Form("Digits Tree = %p",digitsTree));
2540 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
2545 AliDebug(1, "Digits -> Clusters");
2546 reconstructor->Reconstruct(digitsTree, clustersTree);
2547 if (fRunQA && IsInTasks(AliQAv1::kDIGITSR)) {
2548 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2549 AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, digitsTree) ;
2552 loader->UnloadDigits();
2554 if (fRunQA && IsInTasks(AliQAv1::kRECPOINTS)) {
2555 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2556 AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, clustersTree) ;
2558 loader->WriteRecPoints("OVERWRITE");
2559 loader->UnloadRecPoints();
2560 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
2562 if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
2563 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2564 AliError(Form("the following detectors were not found: %s",
2572 //_____________________________________________________________________________
2573 Bool_t AliReconstruction::RunSPDTrackleting(AliESDEvent*& esd)
2575 // run the SPD trackleting (for SPD efficiency purpouses)
2577 AliCodeTimerAuto("",0)
2579 Double_t vtxPos[3] = {0, 0, 0};
2580 Double_t vtxErr[3] = {0.0, 0.0, 0.0};
2586 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
2587 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
2588 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
2591 const AliESDVertex *vertex = esd->GetVertex();
2593 AliWarning("Vertex not found");
2596 vertex->GetXYZ(vtxPos);
2597 vertex->GetSigmaXYZ(vtxErr);
2598 if (fSPDTrackleter) {
2599 AliInfo("running the SPD Trackleter for Plane Efficiency Evaluation");
2602 fLoader[0]->LoadRecPoints("read");
2603 TTree* tree = fLoader[0]->TreeR();
2605 AliError("Can't get the ITS cluster tree");
2608 fSPDTrackleter->LoadClusters(tree);
2609 fSPDTrackleter->SetVertex(vtxPos, vtxErr);
2611 if (fSPDTrackleter->Clusters2Tracks(esd) != 0) {
2612 AliWarning("AliITSTrackleterSPDEff Clusters2Tracks failed");
2613 // fLoader[0]->UnloadRecPoints();
2616 //fSPDTrackleter->UnloadRecPoints();
2618 AliWarning("SPDTrackleter not available");
2624 //_____________________________________________________________________________
2625 Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
2627 // run the barrel tracking
2629 AliCodeTimerAuto("",0)
2631 AliVertexer *vertexer = CreateVertexer();
2632 if (!vertexer) return kFALSE;
2634 AliInfo(Form("running the ITS vertex finder: %s",vertexer->ClassName()));
2635 AliESDVertex* vertex = NULL;
2637 fLoader[0]->LoadRecPoints();
2638 TTree* cltree = fLoader[0]->TreeR();
2640 if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
2641 vertex = vertexer->FindVertexForCurrentEvent(cltree);
2644 AliError("Can't get the ITS cluster tree");
2646 fLoader[0]->UnloadRecPoints();
2649 AliError("Can't get the ITS loader");
2652 AliWarning("Vertex not found");
2653 vertex = new AliESDVertex();
2654 vertex->SetName("default");
2657 vertex->SetName("reconstructed");
2662 vertex->GetXYZ(vtxPos);
2663 vertex->GetSigmaXYZ(vtxErr);
2665 esd->SetPrimaryVertexSPD(vertex);
2666 AliESDVertex *vpileup = NULL;
2667 Int_t novertices = 0;
2668 vpileup = vertexer->GetAllVertices(novertices);
2670 for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
2673 // if SPD multiplicity has been determined, it is stored in the ESD
2674 AliMultiplicity *mult = vertexer->GetMultiplicity();
2675 if(mult)esd->SetMultiplicity(mult);
2677 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2678 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
2687 //_____________________________________________________________________________
2688 Bool_t AliReconstruction::RunMultFinder(AliESDEvent*& esd)
2690 // run the trackleter for multiplicity study
2692 AliCodeTimerAuto("",0)
2694 AliTrackleter *trackleter = CreateMultFinder();
2695 if (!trackleter) return kFALSE;
2697 AliInfo(Form("running the ITS multiplicity finder: %s",trackleter->ClassName()));
2700 fLoader[0]->LoadRecPoints();
2701 TTree* cltree = fLoader[0]->TreeR();
2703 trackleter->Reconstruct(esd,cltree);
2704 AliMultiplicity *mult = trackleter->GetMultiplicity();
2705 if(mult) esd->SetMultiplicity(mult);
2708 AliError("Can't get the ITS cluster tree");
2710 fLoader[0]->UnloadRecPoints();
2713 AliError("Can't get the ITS loader");
2721 //_____________________________________________________________________________
2722 Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
2724 // run the HLT barrel tracking
2726 AliCodeTimerAuto("",0)
2729 AliError("Missing runLoader!");
2733 AliInfo("running HLT tracking");
2735 // Get a pointer to the HLT reconstructor
2736 AliReconstructor *reconstructor = GetReconstructor(kNDetectors-1);
2737 if (!reconstructor) return kFALSE;
2740 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2741 TString detName = fgkDetectorName[iDet];
2742 AliDebug(1, Form("%s HLT tracking", detName.Data()));
2743 reconstructor->SetOption(detName.Data());
2744 AliTracker *tracker = reconstructor->CreateTracker();
2746 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
2747 if (fStopOnError) return kFALSE;
2751 Double_t vtxErr[3]={0.005,0.005,0.010};
2752 const AliESDVertex *vertex = esd->GetVertex();
2753 vertex->GetXYZ(vtxPos);
2754 tracker->SetVertex(vtxPos,vtxErr);
2756 fLoader[iDet]->LoadRecPoints("read");
2757 TTree* tree = fLoader[iDet]->TreeR();
2759 AliError(Form("Can't get the %s cluster tree", detName.Data()));
2762 tracker->LoadClusters(tree);
2764 if (tracker->Clusters2Tracks(esd) != 0) {
2765 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
2769 tracker->UnloadClusters();
2777 //_____________________________________________________________________________
2778 Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
2780 // run the muon spectrometer tracking
2782 AliCodeTimerAuto("",0)
2785 AliError("Missing runLoader!");
2788 Int_t iDet = GetDetIndex("MUON"); // for MUON
2790 // Get a pointer to the MUON reconstructor
2791 AliReconstructor *reconstructor = GetReconstructor(iDet);
2792 if (!reconstructor) return kFALSE;
2795 TString detName = fgkDetectorName[iDet];
2796 AliDebug(1, Form("%s tracking", detName.Data()));
2797 AliTracker *tracker = reconstructor->CreateTracker();
2799 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2804 fLoader[iDet]->LoadRecPoints("read");
2806 tracker->LoadClusters(fLoader[iDet]->TreeR());
2808 Int_t rv = tracker->Clusters2Tracks(esd);
2810 fLoader[iDet]->UnloadRecPoints();
2812 tracker->UnloadClusters();
2816 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2824 //_____________________________________________________________________________
2825 Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
2827 // run the barrel tracking
2828 static Int_t eventNr=0;
2829 AliCodeTimerAuto("",0)
2831 AliInfo("running tracking");
2833 // Set the event info which is used
2834 // by the trackers in order to obtain
2835 // information about read-out detectors,
2837 AliDebug(1, "Setting event info");
2838 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2839 if (!fTracker[iDet]) continue;
2840 fTracker[iDet]->SetEventInfo(&fEventInfo);
2843 //Fill the ESD with the T0 info (will be used by the TOF)
2844 if (fReconstructor[11] && fLoader[11]) {
2845 fLoader[11]->LoadRecPoints("READ");
2846 TTree *treeR = fLoader[11]->TreeR();
2848 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
2852 // pass 1: TPC + ITS inwards
2853 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2854 if (!fTracker[iDet]) continue;
2855 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
2858 fLoader[iDet]->LoadRecPoints("read");
2859 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
2860 TTree* tree = fLoader[iDet]->TreeR();
2862 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2865 fTracker[iDet]->LoadClusters(tree);
2866 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
2868 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
2869 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2872 // preliminary PID in TPC needed by the ITS tracker
2874 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2875 PID.MakePID(esd,kTRUE);
2877 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
2880 // pass 2: ALL backwards
2882 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2883 if (!fTracker[iDet]) continue;
2884 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
2887 if (iDet > 1) { // all except ITS, TPC
2889 fLoader[iDet]->LoadRecPoints("read");
2890 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
2891 tree = fLoader[iDet]->TreeR();
2893 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2896 fTracker[iDet]->LoadClusters(tree);
2897 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
2901 if (iDet>1) // start filling residuals for the "outer" detectors
2903 AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2904 TObjArray ** arr = AliTracker::GetResidualsArray() ;
2906 AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
2907 TObjArray * elem = arr[AliRecoParam::AConvert(es)];
2908 if ( elem && (! elem->At(0)) ) {
2909 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2910 if (qadm) qadm->InitRecPointsForTracker() ;
2914 if (fTracker[iDet]->PropagateBack(esd) != 0) {
2915 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
2920 if (iDet > 3) { // all except ITS, TPC, TRD and TOF
2921 fTracker[iDet]->UnloadClusters();
2922 fLoader[iDet]->UnloadRecPoints();
2924 // updated PID in TPC needed by the ITS tracker -MI
2926 //GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2927 //AliESDpid::MakePID(esd);
2928 PID.MakePID(esd,kTRUE);
2930 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
2932 //stop filling residuals for the "outer" detectors
2933 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
2935 // pass 3: TRD + TPC + ITS refit inwards
2937 for (Int_t iDet = 2; iDet >= 0; iDet--) {
2938 if (!fTracker[iDet]) continue;
2939 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
2942 if (iDet<2) // start filling residuals for TPC and ITS
2944 AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2945 TObjArray ** arr = AliTracker::GetResidualsArray() ;
2947 AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
2948 TObjArray * elem = arr[AliRecoParam::AConvert(es)];
2949 if ( elem && (! elem->At(0)) ) {
2950 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2951 if (qadm) qadm->InitRecPointsForTracker() ;
2956 if (fTracker[iDet]->RefitInward(esd) != 0) {
2957 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
2960 // run postprocessing
2961 if (fTracker[iDet]->PostProcess(esd) != 0) {
2962 AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
2965 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
2968 // write space-points to the ESD in case alignment data output
2970 if (fWriteAlignmentData)
2971 WriteAlignmentData(esd);
2973 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2974 if (!fTracker[iDet]) continue;
2976 fTracker[iDet]->UnloadClusters();
2977 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
2978 fLoader[iDet]->UnloadRecPoints();
2979 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
2981 // stop filling residuals for TPC and ITS
2982 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
2988 //_____________________________________________________________________________
2989 Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
2991 // Remove the data which are not needed for the physics analysis.
2994 Int_t nTracks=esd->GetNumberOfTracks();
2995 Int_t nV0s=esd->GetNumberOfV0s();
2997 (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
2999 Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
3000 Bool_t rc=esd->Clean(cleanPars);
3002 nTracks=esd->GetNumberOfTracks();
3003 nV0s=esd->GetNumberOfV0s();
3005 (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
3010 //_____________________________________________________________________________
3011 Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
3013 // fill the event summary data
3015 AliCodeTimerAuto("",0)
3016 static Int_t eventNr=0;
3017 TString detStr = detectors;
3019 AliSysInfo::AddStamp(Form("FillESDb%d",eventNr), -19,-19, eventNr);
3020 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3021 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3022 AliReconstructor* reconstructor = GetReconstructor(iDet);
3023 if (!reconstructor) continue;
3024 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
3025 TTree* clustersTree = NULL;
3026 if (fLoader[iDet]) {
3027 fLoader[iDet]->LoadRecPoints("read");
3028 clustersTree = fLoader[iDet]->TreeR();
3029 if (!clustersTree) {
3030 AliError(Form("Can't get the %s clusters tree",
3031 fgkDetectorName[iDet]));
3032 if (fStopOnError) return kFALSE;
3035 if (fRawReader && !reconstructor->HasDigitConversion()) {
3036 reconstructor->FillESD(fRawReader, clustersTree, esd);
3038 TTree* digitsTree = NULL;
3039 if (fLoader[iDet]) {
3040 fLoader[iDet]->LoadDigits("read");
3041 digitsTree = fLoader[iDet]->TreeD();
3043 AliError(Form("Can't get the %s digits tree",
3044 fgkDetectorName[iDet]));
3045 if (fStopOnError) return kFALSE;
3048 reconstructor->FillESD(digitsTree, clustersTree, esd);
3049 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
3051 if (fLoader[iDet]) {
3052 fLoader[iDet]->UnloadRecPoints();
3056 if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
3057 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
3058 AliError(Form("the following detectors were not found: %s",
3060 if (fStopOnError) return kFALSE;
3062 AliSysInfo::AddStamp(Form("FillESDe%d",eventNr), -20,-20, eventNr);
3067 //_____________________________________________________________________________
3068 Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
3070 // Reads the trigger decision which is
3071 // stored in Trigger.root file and fills
3072 // the corresponding esd entries
3074 AliCodeTimerAuto("",0)
3076 AliInfo("Filling trigger information into the ESD");
3079 AliCTPRawStream input(fRawReader);
3080 if (!input.Next()) {
3081 AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
3084 if (esd->GetTriggerMask() != input.GetClassMask())
3085 AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
3086 input.GetClassMask(),esd->GetTriggerMask()));
3087 if (esd->GetOrbitNumber() != input.GetOrbitID())
3088 AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
3089 input.GetOrbitID(),esd->GetOrbitNumber()));
3090 if (esd->GetBunchCrossNumber() != input.GetBCID())
3091 AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
3092 input.GetBCID(),esd->GetBunchCrossNumber()));
3093 AliESDHeader* esdheader = esd->GetHeader();
3094 esdheader->SetL0TriggerInputs(input.GetL0Inputs());
3095 esdheader->SetL1TriggerInputs(input.GetL1Inputs());
3096 esdheader->SetL2TriggerInputs(input.GetL2Inputs());
3098 UInt_t orbit=input.GetOrbitID();
3099 for(Int_t i=0 ; i<input.GetNIRs() ; i++ )
3100 if(TMath::Abs(Int_t(orbit-(input.GetIR(i))->GetOrbit()))<=1){
3101 esdheader->AddTriggerIR(input.GetIR(i));
3103 AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
3104 rlCTP->SetL0TriggerInputs(input.GetL0Inputs());
3105 rlCTP->SetL1TriggerInputs(input.GetL1Inputs());
3106 rlCTP->SetL2TriggerInputs(input.GetL2Inputs());
3108 if (fIsNewRunLoader) fRunLoader->TreeCT()->Fill();
3112 //_____________________________________________________________________________
3113 Bool_t AliReconstruction::FillTriggerScalers(AliESDEvent*& esd)
3116 //fRunScalers->Print();
3117 if(fRunScalers && fRunScalers->CheckRunScalers()){
3118 AliTimeStamp* timestamp = new AliTimeStamp(esd->GetOrbitNumber(), esd->GetPeriodNumber(), esd->GetBunchCrossNumber());
3119 //AliTimeStamp* timestamp = new AliTimeStamp(10308000, 0, (ULong64_t)486238);
3120 AliESDHeader* esdheader = fesd->GetHeader();
3121 for(Int_t i=0;i<50;i++){
3122 if((1ull<<i) & esd->GetTriggerMask()){
3123 AliTriggerScalersESD* scalesd = fRunScalers->GetScalersForEventClass( timestamp, i+1);
3124 if(scalesd)esdheader->SetTriggerScalersRecord(scalesd);
3127 const AliTriggerScalersRecordESD* scalrecEvent = fRunScalers->GetScalersDeltaForEvent( timestamp);
3128 const AliTriggerScalersRecordESD* scalrecRun = fRunScalers->GetScalersDeltaForRun();
3129 if (scalrecEvent) esdheader->SetTriggerScalersDeltaEvent(scalrecEvent);
3130 if (scalrecRun) esdheader->SetTriggerScalersDeltaRun(scalrecRun);
3134 //_____________________________________________________________________________
3135 Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
3138 // Filling information from RawReader Header
3141 if (!fRawReader) return kFALSE;
3143 AliInfo("Filling information from RawReader Header");
3145 esd->SetBunchCrossNumber(fRawReader->GetBCID());
3146 esd->SetOrbitNumber(fRawReader->GetOrbitID());
3147 esd->SetPeriodNumber(fRawReader->GetPeriod());
3149 esd->SetTimeStamp(fRawReader->GetTimestamp());
3150 esd->SetEventType(fRawReader->GetType());
3156 //_____________________________________________________________________________
3157 Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
3159 // check whether detName is contained in detectors
3160 // if yes, it is removed from detectors
3162 // check if all detectors are selected
3163 if ((detectors.CompareTo("ALL") == 0) ||
3164 detectors.BeginsWith("ALL ") ||
3165 detectors.EndsWith(" ALL") ||
3166 detectors.Contains(" ALL ")) {
3171 // search for the given detector
3172 Bool_t result = kFALSE;
3173 if ((detectors.CompareTo(detName) == 0) ||
3174 detectors.BeginsWith(detName+" ") ||
3175 detectors.EndsWith(" "+detName) ||
3176 detectors.Contains(" "+detName+" ")) {
3177 detectors.ReplaceAll(detName, "");
3181 // clean up the detectors string
3182 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
3183 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
3184 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
3189 //_____________________________________________________________________________
3190 Bool_t AliReconstruction::InitRunLoader()
3192 // get or create the run loader
3194 if (gAlice) delete gAlice;
3197 TFile *gafile = TFile::Open(fGAliceFileName.Data());
3198 // if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
3199 if (gafile) { // galice.root exists
3203 // load all base libraries to get the loader classes
3204 TString libs = gSystem->GetLibraries();
3205 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3206 TString detName = fgkDetectorName[iDet];
3207 if (detName == "HLT") continue;
3208 if (libs.Contains("lib" + detName + "base.so")) continue;
3209 gSystem->Load("lib" + detName + "base.so");
3211 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
3213 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
3218 fRunLoader->CdGAFile();
3219 fRunLoader->LoadgAlice();
3221 //PH This is a temporary fix to give access to the kinematics
3222 //PH that is needed for the labels of ITS clusters
3223 fRunLoader->LoadHeader();
3224 fRunLoader->LoadKinematics();
3226 } else { // galice.root does not exist
3228 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
3230 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
3231 AliConfig::GetDefaultEventFolderName(),
3234 AliError(Form("could not create run loader in file %s",
3235 fGAliceFileName.Data()));
3239 fIsNewRunLoader = kTRUE;
3240 fRunLoader->MakeTree("E");
3241 fRunLoader->MakeTree("GG");
3243 if (fNumberOfEventsPerFile > 0)
3244 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
3246 fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
3252 //_____________________________________________________________________________
3253 AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
3255 // get the reconstructor object and the loader for a detector
3257 if (fReconstructor[iDet]) {
3258 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
3259 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
3260 fReconstructor[iDet]->SetRecoParam(par);
3261 fReconstructor[iDet]->SetRunInfo(fRunInfo);
3263 return fReconstructor[iDet];
3266 // load the reconstructor object
3267 TPluginManager* pluginManager = gROOT->GetPluginManager();
3268 TString detName = fgkDetectorName[iDet];
3269 TString recName = "Ali" + detName + "Reconstructor";
3271 if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
3273 AliReconstructor* reconstructor = NULL;
3274 // first check if a plugin is defined for the reconstructor
3275 TPluginHandler* pluginHandler =
3276 pluginManager->FindHandler("AliReconstructor", detName);
3277 // if not, add a plugin for it
3278 if (!pluginHandler) {
3279 AliDebug(1, Form("defining plugin for %s", recName.Data()));
3280 TString libs = gSystem->GetLibraries();
3281 if (libs.Contains("lib" + detName + "base.so") ||
3282 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
3283 pluginManager->AddHandler("AliReconstructor", detName,
3284 recName, detName + "rec", recName + "()");
3286 pluginManager->AddHandler("AliReconstructor", detName,
3287 recName, detName, recName + "()");
3289 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
3291 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
3292 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
3295 // check if the upgrade reconstructor should be used instead of the standard one
3296 if(fUpgradeMask[iDet]) {
3297 if(reconstructor) delete reconstructor;
3298 TClass *cl = new TClass(Form("Ali%sUpgradeReconstructor",fgkDetectorName[iDet]));
3299 reconstructor = (AliReconstructor*)(cl->New());
3302 if (reconstructor) {
3303 TObject* obj = fOptions.FindObject(detName.Data());
3304 if (obj) reconstructor->SetOption(obj->GetTitle());
3305 reconstructor->SetRunInfo(fRunInfo);
3306 reconstructor->Init();
3307 fReconstructor[iDet] = reconstructor;
3310 // get or create the loader
3311 if (detName != "HLT") {
3312 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
3313 if (!fLoader[iDet]) {
3314 AliConfig::Instance()
3315 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
3317 // first check if a plugin is defined for the loader
3319 pluginManager->FindHandler("AliLoader", detName);
3320 // if not, add a plugin for it
3321 if (!pluginHandler) {
3322 TString loaderName = "Ali" + detName + "Loader";
3323 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
3324 pluginManager->AddHandler("AliLoader", detName,
3325 loaderName, detName + "base",
3326 loaderName + "(const char*, TFolder*)");
3327 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
3329 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
3331 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
3332 fRunLoader->GetEventFolder());
3334 if (!fLoader[iDet]) { // use default loader
3335 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
3337 if (!fLoader[iDet]) {
3338 AliWarning(Form("couldn't get loader for %s", detName.Data()));
3339 if (fStopOnError) return NULL;
3341 fRunLoader->AddLoader(fLoader[iDet]);
3342 fRunLoader->CdGAFile();
3343 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
3344 fRunLoader->Write(0, TObject::kOverwrite);
3349 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
3350 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
3351 if (reconstructor) {
3352 reconstructor->SetRecoParam(par);
3353 reconstructor->SetRunInfo(fRunInfo);
3356 return reconstructor;
3359 //_____________________________________________________________________________
3360 AliVertexer* AliReconstruction::CreateVertexer()
3362 // create the vertexer
3363 // Please note that the caller is the owner of the
3366 AliVertexer* vertexer = NULL;
3367 AliReconstructor* itsReconstructor = GetReconstructor(0);
3368 if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) ||
3369 fRunTracking.Contains("ITS") || fFillESD.Contains("ITS") )) {
3370 vertexer = itsReconstructor->CreateVertexer();
3373 AliWarning("couldn't create a vertexer for ITS");
3379 //_____________________________________________________________________________
3380 AliTrackleter* AliReconstruction::CreateMultFinder()
3382 // create the ITS trackleter for mult. estimation
3383 // Please note that the caller is the owner of the
3386 AliTrackleter* trackleter = NULL;
3387 AliReconstructor* itsReconstructor = GetReconstructor(0);
3388 if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) ||
3389 fRunTracking.Contains("ITS") || fFillESD.Contains("ITS") )) {
3390 trackleter = itsReconstructor->CreateMultFinder();
3393 AliWarning("ITS is not in reconstruction, switching off RunMultFinder");
3394 fRunMultFinder = kFALSE;
3400 //_____________________________________________________________________________
3401 Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
3403 // create the trackers
3404 AliInfo("Creating trackers");
3406 TString detStr = detectors;
3407 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3408 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3409 AliReconstructor* reconstructor = GetReconstructor(iDet);
3410 if (!reconstructor) continue;
3411 TString detName = fgkDetectorName[iDet];
3412 if (detName == "HLT") {
3413 fRunHLTTracking = kTRUE;
3416 if (detName == "MUON") {
3417 fRunMuonTracking = kTRUE;
3421 fTracker[iDet] = reconstructor->CreateTracker();
3422 if (!fTracker[iDet] && (iDet < 7)) {
3423 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
3424 if (fStopOnError) return kFALSE;
3426 AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
3432 //_____________________________________________________________________________
3433 void AliReconstruction::CleanUp()
3435 // delete trackers and the run loader and close and delete the file
3437 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3438 delete fReconstructor[iDet];
3439 fReconstructor[iDet] = NULL;
3440 fLoader[iDet] = NULL;
3441 delete fTracker[iDet];
3442 fTracker[iDet] = NULL;
3449 delete fSPDTrackleter;
3450 fSPDTrackleter = NULL;
3459 delete fParentRawReader;
3460 fParentRawReader=NULL;
3468 if (AliQAManager::QAManager())
3469 AliQAManager::QAManager()->ShowQA() ;
3470 // AliQAManager::Destroy() ;
3475 void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
3477 // Write space-points which are then used in the alignment procedures
3478 // For the moment only ITS, TPC, TRD and TOF
3480 Int_t ntracks = esd->GetNumberOfTracks();
3481 for (Int_t itrack = 0; itrack < ntracks; itrack++)
3483 AliESDtrack *track = esd->GetTrack(itrack);
3486 for (Int_t i=0; i<200; ++i) idx[i] = -1; //PH avoid uninitialized values
3487 for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
3488 nsp += (iDet==GetDetIndex("TRD")) ? track->GetTRDntracklets():track->GetNcls(iDet);
3490 if (iDet==GetDetIndex("ITS")) { // ITS "extra" clusters
3491 track->GetClusters(iDet,idx);
3492 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++;
3497 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
3498 track->SetTrackPointArray(sp);
3500 for (Int_t iDet = 5; iDet >= 0; iDet--) {
3501 AliTracker *tracker = fTracker[iDet];
3502 if (!tracker) continue;
3503 Int_t nspdet = (iDet==GetDetIndex("TRD")) ? track->GetTRDtracklets(idx):track->GetClusters(iDet,idx);
3505 if (iDet==GetDetIndex("ITS")) // ITS "extra" clusters
3506 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++;
3508 if (nspdet <= 0) continue;
3512 while (isp2 < nspdet) {
3513 Bool_t isvalid=kTRUE;
3515 Int_t index=idx[isp++];
3516 if (index < 0) continue;
3518 TString dets = fgkDetectorName[iDet];
3519 if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
3520 fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
3521 fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
3522 fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
3523 isvalid = tracker->GetTrackPointTrackingError(index,p,track);
3525 isvalid = tracker->GetTrackPoint(index,p);
3528 if (!isvalid) continue;
3529 if (iDet==GetDetIndex("ITS") && (isp-1)>=6) p.SetExtra();
3530 sp->AddPoint(isptrack,&p); isptrack++;
3537 //_____________________________________________________________________________
3538 void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
3540 // The method reads the raw-data error log
3541 // accumulated within the rawReader.
3542 // It extracts the raw-data errors related to
3543 // the current event and stores them into
3544 // a TClonesArray inside the esd object.
3546 if (!fRawReader) return;
3548 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
3550 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
3552 if (iEvent != log->GetEventNumber()) continue;
3554 esd->AddRawDataErrorLog(log);
3559 //_____________________________________________________________________________
3560 // void AliReconstruction::CheckQA()
3562 // check the QA of SIM for this run and remove the detectors
3563 // with status Fatal
3565 // TString newRunLocalReconstruction ;
3566 // TString newRunTracking ;
3567 // TString newFillESD ;
3569 // for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
3570 // TString detName(AliQAv1::GetDetName(iDet)) ;
3571 // AliQAv1 * qa = AliQAv1::Instance(AliQAv1::DETECTORINDEX_t(iDet)) ;
3572 // if ( qa->IsSet(AliQAv1::DETECTORINDEX_t(iDet), AliQAv1::kSIM, specie, AliQAv1::kFATAL)) {
3573 // AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed",
3574 // detName.Data(), AliRecoParam::GetEventSpecieName(es))) ;
3576 // if ( fRunLocalReconstruction.Contains(AliQAv1::GetDetName(iDet)) ||
3577 // fRunLocalReconstruction.Contains("ALL") ) {
3578 // newRunLocalReconstruction += detName ;
3579 // newRunLocalReconstruction += " " ;
3581 // if ( fRunTracking.Contains(AliQAv1::GetDetName(iDet)) ||
3582 // fRunTracking.Contains("ALL") ) {
3583 // newRunTracking += detName ;
3584 // newRunTracking += " " ;
3586 // if ( fFillESD.Contains(AliQAv1::GetDetName(iDet)) ||
3587 // fFillESD.Contains("ALL") ) {
3588 // newFillESD += detName ;
3589 // newFillESD += " " ;
3593 // fRunLocalReconstruction = newRunLocalReconstruction ;
3594 // fRunTracking = newRunTracking ;
3595 // fFillESD = newFillESD ;
3598 //_____________________________________________________________________________
3599 Int_t AliReconstruction::GetDetIndex(const char* detector)
3601 // return the detector index corresponding to detector
3603 for (index = 0; index < kNDetectors ; index++) {
3604 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
3609 //_____________________________________________________________________________
3610 Bool_t AliReconstruction::FinishPlaneEff() {
3612 // Here execute all the necessary operationis, at the end of the tracking phase,
3613 // in case that evaluation of PlaneEfficiencies was required for some detector.
3614 // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
3616 // This Preliminary version works only FOR ITS !!!!!
3617 // other detectors (TOF,TRD, etc. have to develop their specific codes)
3620 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
3623 TString detStr = fLoadCDB;
3624 //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
3625 for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
3626 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3627 if(fTracker[iDet] && fTracker[iDet]->GetPlaneEff()) {
3628 AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
3629 TString name=planeeff->GetName();
3631 TFile* pefile = TFile::Open(name, "RECREATE");
3632 ret=(Bool_t)planeeff->Write();
3634 if(planeeff->GetCreateHistos()) {
3635 TString hname=planeeff->GetName();
3636 hname+="Histo.root";
3637 ret*=planeeff->WriteHistosToFile(hname,"RECREATE");
3640 if(fSPDTrackleter) {
3641 AliPlaneEff *planeeff=fSPDTrackleter->GetPlaneEff();
3642 TString name="AliITSPlaneEffSPDtracklet.root";
3643 TFile* pefile = TFile::Open(name, "RECREATE");
3644 ret=(Bool_t)planeeff->Write();
3646 AliESDEvent *dummy=NULL;
3647 ret=(Bool_t)fSPDTrackleter->PostProcess(dummy); // take care of writing other files
3652 //_____________________________________________________________________________
3653 Bool_t AliReconstruction::InitPlaneEff() {
3655 // Here execute all the necessary operations, before of the tracking phase,
3656 // for the evaluation of PlaneEfficiencies, in case required for some detectors.
3657 // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
3658 // which should be updated/recalculated.
3660 // This Preliminary version will work only FOR ITS !!!!!
3661 // other detectors (TOF,TRD, etc. have to develop their specific codes)
3664 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
3667 fSPDTrackleter = NULL;
3668 TString detStr = fLoadCDB;
3669 if (IsSelected(fgkDetectorName[0], detStr)) {
3670 AliReconstructor* itsReconstructor = GetReconstructor(0);
3671 if (itsReconstructor) {
3672 fSPDTrackleter = itsReconstructor->CreateTrackleter(); // this is NULL unless required in RecoParam
3674 if (fSPDTrackleter) {
3675 AliInfo("Trackleter for SPD has been created");
3681 //_____________________________________________________________________________
3682 Bool_t AliReconstruction::InitAliEVE()
3684 // This method should be called only in case
3685 // AliReconstruction is run
3686 // within the alieve environment.
3687 // It will initialize AliEVE in a way
3688 // so that it can visualize event processed
3689 // by AliReconstruction.
3690 // The return flag shows whenever the
3691 // AliEVE initialization was successful or not.
3693 TString macroStr(gSystem->Getenv("ALIEVE_ONLINE_MACRO"));
3695 if (macroStr.IsNull())
3696 macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
3698 AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
3700 if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
3702 gROOT->ProcessLine("if (!AliEveEventManager::GetMaster()){new AliEveEventManager();AliEveEventManager::GetMaster()->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(AliEveEventManager::GetMaster());};");
3703 gROOT->ProcessLine("alieve_online_init()");
3708 //_____________________________________________________________________________
3709 void AliReconstruction::RunAliEVE()
3711 // Runs AliEVE visualisation of
3712 // the current event.
3713 // Should be executed only after
3714 // successful initialization of AliEVE.
3716 AliInfo("Running AliEVE...");
3717 gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p,(AliESDfriend*)%p);",fRunLoader,fRawReader,fesd,fesdf));
3721 //_____________________________________________________________________________
3722 Bool_t AliReconstruction::SetRunQA(TString detAndAction)
3724 // Allows to run QA for a selected set of detectors
3725 // and a selected set of tasks among RAWS, DIGITSR, RECPOINTS and ESDS
3726 // all selected detectors run the same selected tasks
3728 if (!detAndAction.Contains(":")) {
3729 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
3733 Int_t colon = detAndAction.Index(":") ;
3734 fQADetectors = detAndAction(0, colon) ;
3735 fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
3736 if (fQATasks.Contains("ALL") ) {
3737 fQATasks = Form("%d %d %d %d", AliQAv1::kRAWS, AliQAv1::kDIGITSR, AliQAv1::kRECPOINTS, AliQAv1::kESDS) ;
3739 fQATasks.ToUpper() ;
3741 if ( fQATasks.Contains("RAW") )
3742 tempo = Form("%d ", AliQAv1::kRAWS) ;
3743 if ( fQATasks.Contains("DIGIT") )
3744 tempo += Form("%d ", AliQAv1::kDIGITSR) ;
3745 if ( fQATasks.Contains("RECPOINT") )
3746 tempo += Form("%d ", AliQAv1::kRECPOINTS) ;
3747 if ( fQATasks.Contains("ESD") )
3748 tempo += Form("%d ", AliQAv1::kESDS) ;
3750 if (fQATasks.IsNull()) {
3751 AliInfo("No QA requested\n") ;
3756 TString tempo(fQATasks) ;
3757 tempo.ReplaceAll(Form("%d", AliQAv1::kRAWS), AliQAv1::GetTaskName(AliQAv1::kRAWS)) ;
3758 tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITSR), AliQAv1::GetTaskName(AliQAv1::kDIGITSR)) ;
3759 tempo.ReplaceAll(Form("%d", AliQAv1::kRECPOINTS), AliQAv1::GetTaskName(AliQAv1::kRECPOINTS)) ;
3760 tempo.ReplaceAll(Form("%d", AliQAv1::kESDS), AliQAv1::GetTaskName(AliQAv1::kESDS)) ;
3761 AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
3766 //_____________________________________________________________________________
3767 Bool_t AliReconstruction::InitRecoParams()
3769 // The method accesses OCDB and retrieves all
3770 // the available reco-param objects from there.
3772 Bool_t isOK = kTRUE;
3774 if (fRecoParam.GetDetRecoParamArray(kNDetectors)) {
3775 AliInfo("Using custom GRP reconstruction parameters");
3778 AliInfo("Loading GRP reconstruction parameter objects");
3780 AliCDBPath path("GRP","Calib","RecoParam");
3781 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
3783 AliWarning("Couldn't find GRP RecoParam entry in OCDB");
3787 TObject *recoParamObj = entry->GetObject();
3788 if (dynamic_cast<TObjArray*>(recoParamObj)) {
3789 // GRP has a normal TobjArray of AliDetectorRecoParam objects
3790 // Registering them in AliRecoParam
3791 fRecoParam.AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
3793 else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
3794 // GRP has only onse set of reco parameters
3795 // Registering it in AliRecoParam
3796 AliInfo("Single set of GRP reconstruction parameters found");
3797 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
3798 fRecoParam.AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
3801 AliError("No valid GRP RecoParam object found in the OCDB");
3808 TString detStr = fLoadCDB;
3809 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3811 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3813 if (fRecoParam.GetDetRecoParamArray(iDet)) {
3814 AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
3818 AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]));
3820 AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
3821 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
3823 AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]));
3827 TObject *recoParamObj = entry->GetObject();
3828 if (dynamic_cast<TObjArray*>(recoParamObj)) {
3829 // The detector has a normal TobjArray of AliDetectorRecoParam objects
3830 // Registering them in AliRecoParam
3831 fRecoParam.AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
3833 else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
3834 // The detector has only onse set of reco parameters
3835 // Registering it in AliRecoParam
3836 AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]));
3837 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
3838 fRecoParam.AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
3841 AliError(Form("No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]));
3845 // FIX ME: We have to disable the unloading of reco-param CDB
3846 // entries because QA framework is using them. Has to be fix in
3847 // a way that the QA takes the objects already constructed in
3849 // AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
3853 if (AliDebugLevel() > 0) fRecoParam.Print();
3858 //_____________________________________________________________________________
3859 Bool_t AliReconstruction::GetEventInfo()
3861 // Fill the event info object
3863 AliCodeTimerAuto("",0)
3865 AliCentralTrigger *aCTP = NULL;
3867 fEventInfo.SetEventType(fRawReader->GetType());
3869 ULong64_t mask = fRawReader->GetClassMask();
3870 fEventInfo.SetTriggerMask(mask);
3871 UInt_t clmask = fRawReader->GetDetectorPattern()[0];
3872 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
3874 aCTP = new AliCentralTrigger();
3875 TString configstr("");
3876 if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
3877 AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
3881 aCTP->SetClassMask(mask);
3882 aCTP->SetClusterMask(clmask);
3884 AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
3885 rlCTP->SetClassMask(mask);
3886 rlCTP->SetClusterMask(clmask);
3889 fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
3891 if (fRunLoader && (!fRunLoader->LoadTrigger())) {
3892 aCTP = fRunLoader->GetTrigger();
3893 fEventInfo.SetTriggerMask(aCTP->GetClassMask());
3894 // get inputs from actp - just get
3895 AliESDHeader* esdheader = fesd->GetHeader();
3896 esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
3897 esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
3898 esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
3899 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
3902 AliWarning("No trigger can be loaded! The trigger information will not be used!");
3907 AliTriggerConfiguration *config = aCTP->GetConfiguration();
3909 AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
3910 if (fRawReader) delete aCTP;
3914 UChar_t clustmask = 0;
3916 ULong64_t trmask = fEventInfo.GetTriggerMask();
3917 const TObjArray& classesArray = config->GetClasses();
3918 Int_t nclasses = classesArray.GetEntriesFast();
3919 for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
3920 AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
3921 if (trclass && trclass->GetMask()>0) {
3922 Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
3923 fesd->SetTriggerClass(trclass->GetName(),trindex);
3924 if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
3925 if (trmask & (1ull << trindex)) {
3927 trclasses += trclass->GetName();
3929 clustmask |= trclass->GetCluster()->GetClusterMask();
3933 fEventInfo.SetTriggerClasses(trclasses);
3935 // Write names of active trigger inputs in ESD Header
3936 const TObjArray& inputsArray = config->GetInputs();
3937 Int_t ninputs = inputsArray.GetEntriesFast();
3938 for( Int_t iinput=0; iinput < ninputs; iinput++ ) {
3939 AliTriggerInput* trginput = (AliTriggerInput*)inputsArray.At(iinput);
3940 if (trginput && trginput->GetMask()>0) {
3941 Int_t inputIndex = (Int_t)TMath::Nint(TMath::Log2(trginput->GetMask()));
3942 AliESDHeader* headeresd = fesd->GetHeader();
3943 Int_t trglevel = (Int_t)trginput->GetLevel();
3944 if (trglevel == 0) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex);
3945 if (trglevel == 1) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+24);
3946 if (trglevel == 2) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+48);
3950 // Set the information in ESD
3951 fesd->SetTriggerMask(trmask);
3952 fesd->SetTriggerCluster(clustmask);
3954 if (!aCTP->CheckTriggeredDetectors()) {
3955 if (fRawReader) delete aCTP;
3959 if (fRawReader) delete aCTP;
3961 // We have to fill also the HLT decision here!!
3967 const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_t detectorMask)
3969 // Match the detector list found in the rec.C or the default 'ALL'
3970 // to the list found in the GRP (stored there by the shuttle PP which
3971 // gets the information from ECS)
3972 static TString resultList;
3973 TString detList = detectorList;
3977 for(Int_t iDet = 0; iDet < (AliDAQ::kNDetectors-1); iDet++) {
3978 if ((detectorMask >> iDet) & 0x1) {
3979 TString det = AliDAQ::OfflineModuleName(iDet);
3980 if ((detList.CompareTo("ALL") == 0) ||
3981 ((detList.BeginsWith("ALL ") ||
3982 detList.EndsWith(" ALL") ||
3983 detList.Contains(" ALL ")) &&
3984 !(detList.BeginsWith("-"+det+" ") ||
3985 detList.EndsWith(" -"+det) ||
3986 detList.Contains(" -"+det+" "))) ||
3987 (detList.CompareTo(det) == 0) ||
3988 detList.BeginsWith(det+" ") ||
3989 detList.EndsWith(" "+det) ||
3990 detList.Contains( " "+det+" " )) {
3991 if (!resultList.EndsWith(det + " ")) {
4000 if ((detectorMask >> AliDAQ::kHLTId) & 0x1) {
4001 TString hltDet = AliDAQ::OfflineModuleName(AliDAQ::kNDetectors-1);
4002 if ((detList.CompareTo("ALL") == 0) ||
4003 ((detList.BeginsWith("ALL ") ||
4004 detList.EndsWith(" ALL") ||
4005 detList.Contains(" ALL ")) &&
4006 !(detList.BeginsWith("-"+hltDet+" ") ||
4007 detList.EndsWith(" -"+hltDet) ||
4008 detList.Contains(" -"+hltDet+" "))) ||
4009 (detList.CompareTo(hltDet) == 0) ||
4010 detList.BeginsWith(hltDet+" ") ||
4011 detList.EndsWith(" "+hltDet) ||
4012 detList.Contains( " "+hltDet+" " )) {
4013 resultList += hltDet;
4017 return resultList.Data();
4021 //______________________________________________________________________________
4022 void AliReconstruction::Abort(const char *method, EAbort what)
4024 // Abort processing. If what = kAbortProcess, the Process() loop will be
4025 // aborted. If what = kAbortFile, the current file in a chain will be
4026 // aborted and the processing will continue with the next file, if there
4027 // is no next file then Process() will be aborted. Abort() can also be
4028 // called from Begin(), SlaveBegin(), Init() and Notify(). After abort
4029 // the SlaveTerminate() and Terminate() are always called. The abort flag
4030 // can be checked in these methods using GetAbort().
4032 // The method is overwritten in AliReconstruction for better handling of
4033 // reco specific errors
4035 if (!fStopOnError) return;
4039 TString whyMess = method;
4040 whyMess += " failed! Aborting...";
4042 AliError(whyMess.Data());
4045 TString mess = "Abort";
4046 if (fAbort == kAbortProcess)
4047 mess = "AbortProcess";
4048 else if (fAbort == kAbortFile)
4051 Info(mess, whyMess.Data());
4054 //______________________________________________________________________________
4055 Bool_t AliReconstruction::ProcessEvent(void* event)
4057 // Method that is used in case the event loop
4058 // is steered from outside, for example by AMORE
4059 // 'event' is a pointer to the DATE event in the memory
4061 if (fRawReader) delete fRawReader;
4062 fRawReader = new AliRawReaderDate(event);
4063 fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
4070 //______________________________________________________________________________
4071 Bool_t AliReconstruction::ParseOutput()
4073 // The method parses the output file
4074 // location string in order to steer
4075 // properly the selector
4077 TPMERegexp re1("(\\w+\\.zip#\\w+\\.root):([,*\\w+\\.root,*]+)@dataset://(\\w++)");
4078 TPMERegexp re2("(\\w+\\.root)?@?dataset://(\\w++)");
4080 if (re1.Match(fESDOutput) == 4) {
4081 // root archive with output files stored and regustered
4083 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",re1[1].Data()));
4084 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",re1[3].Data()));
4085 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_DATASET",""));
4086 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_ARCHIVE",re1[2].Data()));
4087 AliInfo(Form("%s files will be stored within %s in dataset %s",
4092 else if (re2.Match(fESDOutput) == 3) {
4093 // output file stored and registered
4095 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",(re2[1].IsNull()) ? "AliESDs.root" : re2[1].Data()));
4096 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",re2[2].Data()));
4097 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_DATASET",""));
4098 AliInfo(Form("%s will be stored in dataset %s",
4099 (re2[1].IsNull()) ? "AliESDs.root" : re2[1].Data(),
4103 if (fESDOutput.IsNull()) {
4104 // Output location not given.
4105 // Assuming xrootd has been already started and
4106 // the output file has to be sent back
4107 // to the client machine
4108 TString esdUrl(Form("root://%s/%s/",
4109 TUrl(gSystem->HostName()).GetHostFQDN(),
4111 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE","AliESDs.root"));
4112 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",esdUrl.Data()));
4113 AliInfo(Form("AliESDs.root will be stored in %s",
4117 // User specified an output location.
4118 // Ones has just to parse it here
4119 TUrl outputUrl(fESDOutput.Data());
4120 TString outputFile(gSystem->BaseName(outputUrl.GetFile()));
4121 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",outputFile.IsNull() ? "AliESDs.root" : outputFile.Data()));
4122 TString outputLocation(outputUrl.GetUrl());
4123 outputLocation.ReplaceAll(outputFile.Data(),"");
4124 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",outputLocation.Data()));
4125 AliInfo(Form("%s will be stored in %s",
4126 outputFile.IsNull() ? "AliESDs.root" : outputFile.Data(),
4127 outputLocation.Data()));
4134 //______________________________________________________________________________
4135 Bool_t AliReconstruction::IsHighPt() const {
4136 // Selection of events containing "high" pT tracks
4137 // If at least one track is found within 1.5 and 100 GeV (pT)
4138 // that was reconstructed by both ITS and TPC, the event is accepted
4141 const Double_t pTmin = 1.5;
4142 const Double_t pTmax = 100;
4144 mask |= (AliESDtrack::kITSrefit);
4145 mask |= (AliESDtrack::kTPCrefit);
4146 const Double_t pTminCosmic = 5.;
4147 const Double_t pTmaxCosmic = 100;
4148 ULong_t maskCosmic = 0;
4149 Int_t cosmicCount=0;
4150 maskCosmic |= (AliESDtrack::kTPCrefit);
4152 Bool_t isOK = kFALSE;
4154 if (fesd && fesd->GetEventType()==AliRawEventHeaderBase::kPhysicsEvent) {
4155 // Check if this ia a physics event (code 7)
4156 Int_t ntrk = fesd->GetNumberOfTracks();
4157 for (Int_t itrk=0; itrk<ntrk; ++itrk) {
4159 AliESDtrack * trk = fesd->GetTrack(itrk);
4161 && trk->Pt() > pTmin
4162 && trk->Pt() < pTmax
4163 && (trk->GetStatus() & mask) == mask ) {
4169 && trk->GetInnerParam()
4170 && trk->GetInnerParam()->Pt() > pTminCosmic
4171 && trk->GetInnerParam()->Pt() < pTmaxCosmic
4172 && (trk->GetStatus() & maskCosmic) == maskCosmic ) {
4178 if (cosmicCount>1) isOK=kTRUE;
4183 //______________________________________________________________________________
4184 Bool_t AliReconstruction::IsCosmicOrCalibSpecie() const {
4185 // Select cosmic or calibration events
4187 Bool_t isOK = kFALSE;
4189 if (fesd && fesd->GetEventType()==AliRawEventHeaderBase::kPhysicsEvent) {
4190 // Check if this ia a physics event (code 7)
4192 UInt_t specie = fesd->GetEventSpecie();
4193 if (specie==AliRecoParam::kCosmic || specie==AliRecoParam::kCalib) {
4200 //______________________________________________________________________________
4201 void AliReconstruction::WriteESDfriend() {
4202 // Fill the ESD friend in the tree. The required fraction of ESD friends is stored
4203 // in fFractionFriends. We select events where we store the ESD friends according
4204 // to the following algorithm:
4205 // 1. Store all Cosmic or Calibration events within the required fraction
4206 // 2. Sample "high Pt" events within the remaining fraction after step 1.
4207 // 3. Sample randomly events if we still have remaining slot
4210 Bool_t isSelected = kFALSE;
4212 // Store all friends for B field OFF
4213 if (TMath::Abs(AliTrackerBase::GetBz())<0.5) isSelected=kTRUE;
4215 if (IsCosmicOrCalibSpecie()) { // Selection of calib or cosmic events
4222 Double_t remainingFraction = fFractionFriends;
4223 remainingFraction -= ((Double_t)(fSspecie)/(Double_t)(fNall));
4225 if (IsHighPt()) { // Selection of "high Pt" events
4227 Double_t curentHighPtFraction = ((Double_t)(fNhighPt+1))/((Double_t)(fNall+1));
4228 // "Bayesian" estimate supposing that without events all the events are of the required type
4231 Double_t rnd = gRandom->Rndm()*curentHighPtFraction;
4232 if (rnd<remainingFraction) {
4238 remainingFraction -= ((Double_t)(fShighPt)/(Double_t)(fNall));
4240 // Random selection to fill the remaining fraction (if any)
4242 Double_t rnd = gRandom->Rndm();
4243 if (rnd<remainingFraction) {
4249 fesdf->~AliESDfriend();
4250 new (fesdf) AliESDfriend(); // Reset...
4251 fesdf->SetSkipBit(kTRUE);