ATLAS Offline Software
G4AtlasAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // Local includes
6 #include "G4AtlasAlg.h"
7 #include "G4AtlasFluxRecorder.h"
9 
12 
13 // Can we safely include all of these?
18 
19 // Geant4 includes
20 #include <G4Event.hh>
21 
22 #include "G4EventManager.hh"
23 #include "G4GDMLParser.hh"
24 #include "G4Navigator.hh"
25 #include "G4ParallelWorldPhysics.hh"
26 #include "G4PropagatorInField.hh"
27 #include "G4RunManagerKernel.hh"
28 #include "G4ScoringManager.hh"
29 #include "G4StackManager.hh"
30 #include "G4StateManager.hh"
31 #include "G4TrackingManager.hh"
32 #include "G4TransportationManager.hh"
33 #include "G4UImanager.hh"
34 #include "G4VModularPhysicsList.hh"
35 #include "G4VUserPhysicsList.hh"
36 
37 // CLHEP includes
38 #include "CLHEP/Random/RandomEngine.h"
39 
40 // Athena includes
41 #include "GaudiKernel/IThreadInitTool.h"
48 #include "StoreGate/ReadHandle.h"
49 #include "StoreGate/WriteHandle.h"
50 
51 // standard library
52 #include <memory>
53 #include <mutex>
54 static std::once_flag initializeOnceFlag;
55 static std::once_flag finalizeOnceFlag;
56 static std::once_flag releaseGeoModelOnceFlag;
57 
59 
60 
61 G4AtlasAlg::G4AtlasAlg(const std::string& name, ISvcLocator* pSvcLocator)
62  : AthAlgorithm(name, pSvcLocator)
63 {
64  // Verbosities
65  declareProperty("Verbosities", m_verbosities);
66 }
67 
68 
69 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
70 
72 {
73  ATH_MSG_DEBUG("Start of initialize()");
74 
75  // Read the simplified geometry for FastCaloSim track transportation if requested
76  if(!m_simplifiedGeoPath.empty()) {
77  std::string geoFile = PathResolverFindCalibFile(m_simplifiedGeoPath);
78 
79  if (geoFile.empty()) {
80  ATH_MSG_FATAL("Could not find simplified geometry file: " << m_simplifiedGeoPath);
81  return StatusCode::FAILURE;
82  }
83 
84  G4GDMLParser parser;
85  parser.Read(geoFile, false);
86  }
87 
88  // Create the scoring manager if requested
89  if (m_recordFlux) G4ScoringManager::GetScoringManager();
90 
91  ATH_CHECK( m_userActionSvc.retrieve() );
92  // One-time initialization
93  try {
94  std::call_once(initializeOnceFlag, &G4AtlasAlg::initializeOnce, this);
95  }
96  catch(const std::exception& e) {
97  ATH_MSG_ERROR("Failure in G4AtlasAlg::initializeOnce: " << e.what());
98  return StatusCode::FAILURE;
99  }
100 
101  ATH_CHECK( m_rndmGenSvc.retrieve() );
102  ATH_CHECK(m_actionTools.retrieve());
103 
104  ATH_CHECK(m_senDetTool.retrieve());
105  ATH_CHECK(m_fastSimTool.retrieve());
106 
107  // Truth
108  ATH_CHECK( m_truthRecordSvc.retrieve() );
109  ATH_MSG_INFO( "- Using ISF TruthRecordSvc : " << m_truthRecordSvc.typeAndName() );
110  ATH_CHECK( m_geoIDSvc.retrieve() );
111  ATH_MSG_INFO( "- Using ISF GeoIDSvc : " << m_geoIDSvc.typeAndName() );
112 
113  TruthStrategyManager& sManager = TruthStrategyManager::GetStrategyManager_nc();
114  sManager.SetISFTruthSvc( &(*m_truthRecordSvc) );
115  sManager.SetISFGeoIDSvc( &(*m_geoIDSvc) );
116 
117  // I/O
118  ATH_CHECK( m_inputTruthCollectionKey.initialize());
119  ATH_CHECK( m_outputTruthCollectionKey.initialize());
120  ATH_CHECK( m_eventInfoKey.initialize() );
121 
122  ATH_CHECK(m_inputConverter.retrieve());
123  if ( not m_truthPreselectionTool.empty() ) {
124  ATH_CHECK(m_truthPreselectionTool.retrieve());
125  }
126 
127  if ( not m_qspatcher.empty() ) {
128  ATH_CHECK( m_qspatcher.retrieve() );
129  }
130 
131  ATH_MSG_DEBUG("End of initialize()");
132  return StatusCode::SUCCESS;
133 }
134 
135 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
137 {
138  // Assign physics list
139  if(m_physListSvc.retrieve().isFailure()) {
140  throw std::runtime_error("Could not initialize ATLAS PhysicsListSvc!");
141  }
142  for (const auto& action_tool : m_actionTools) {
143  if (m_userActionSvc->addActionTool(action_tool).isFailure()) {
144  throw std::runtime_error("Failed to add action tool "+action_tool.name());
145  }
146  }
147 
148  ATH_MSG_INFO( "retrieving the Detector Construction tool" );
149  if(m_detConstruction.retrieve().isFailure()) {
150  throw std::runtime_error("Could not initialize ATLAS DetectorConstruction!");
151  }
152 
153  // Create the (master) run manager
154  if(m_useMT) {
155 #ifdef G4MULTITHREADED
156  auto* runMgr ATLAS_THREAD_SAFE = // protected by std::call_once above
157  G4AtlasMTRunManager::GetG4AtlasMTRunManager();
158  m_physListSvc->SetPhysicsList();
159  runMgr->SetDetConstructionTool( m_detConstruction.get() );
160  runMgr->SetPhysListSvc( m_physListSvc.typeAndName() );
161  runMgr->SetQuietMode( m_quietMode );
162  // Worker Thread initialization used to create worker run manager on demand.
163  std::unique_ptr<G4AtlasUserWorkerThreadInitialization> workerInit =
164  std::make_unique<G4AtlasUserWorkerThreadInitialization>();
165  workerInit->SetQuietMode( m_quietMode );
166  runMgr->SetUserInitialization( workerInit.release() );
167  std::unique_ptr<G4AtlasActionInitialization> actionInitialization =
168  std::make_unique<G4AtlasActionInitialization>(m_userActionSvc.get());
169  runMgr->SetUserInitialization(actionInitialization.release());
170 #else
171  throw std::runtime_error("Trying to use multi-threading in non-MT build!");
172 #endif
173  }
174  // Single-threaded run manager
175  else {
176  auto* runMgr ATLAS_THREAD_SAFE = // safe because single-threaded
177  G4AtlasRunManager::GetG4AtlasRunManager();
178  m_physListSvc->SetPhysicsList();
179  runMgr->SetRecordFlux( m_recordFlux, std::make_unique<G4AtlasFluxRecorder>() );
180  runMgr->SetLogLevel( int(msg().level()) ); // Synch log levels
181  runMgr->SetDetConstructionTool( m_detConstruction.get() );
182  runMgr->SetPhysListSvc(m_physListSvc.typeAndName() );
183  runMgr->SetQuietMode( m_quietMode );
184  std::unique_ptr<G4AtlasActionInitialization> actionInitialization =
185  std::make_unique<G4AtlasActionInitialization>(m_userActionSvc.get());
186  runMgr->SetUserInitialization(actionInitialization.release());
187  }
188 
189  // G4 user interface commands
190  G4UImanager *ui = G4UImanager::GetUIpointer();
191 
192  // Load custom libraries
193  if (!m_libList.empty()) {
194  ATH_MSG_INFO("G4AtlasAlg specific libraries requested ");
195  std::string temp="/load "+m_libList;
196  ui->ApplyCommand(temp);
197  }
198  // Load custom physics
199  if (!m_physList.empty()) {
200  ATH_MSG_INFO("requesting a specific physics list "<< m_physList);
201  std::string temp="/Physics/GetPhysicsList "+m_physList;
202  ui->ApplyCommand(temp);
203  }
204  // Load custom magnetic field
205  if (!m_fieldMap.empty()) {
206  ATH_MSG_INFO("requesting a specific field map "<< m_fieldMap);
207  ATH_MSG_INFO("the field is initialized straight away");
208  std::string temp="/MagneticField/Select "+m_fieldMap;
209  ui->ApplyCommand(temp);
210  ui->ApplyCommand("/MagneticField/Initialize");
211  }
212 
213  // Send UI commands
214  ATH_MSG_DEBUG("G4 Command: Trying at the end of initializeOnce()");
215  for (const auto& g4command : m_g4commands) {
216  int returnCode = ui->ApplyCommand( g4command );
217  commandLog(returnCode, g4command);
218  }
219 
220  // Code from G4AtlasSvc
221  auto* rm = G4RunManager::GetRunManager();
222  if(!rm) {
223  throw std::runtime_error("Run manager retrieval has failed");
224  }
225  rm->Initialize(); // Initialization differs slightly in multi-threading.
226  // TODO: add more details about why this is here.
227  if(!m_useMT && rm->ConfirmBeamOnCondition()) {
228  rm->RunInitialization();
229  }
230 
231  ATH_MSG_INFO("Initializing " << m_physicsInitializationTools.size() << " physics initialization tools");
232  for(auto& physicsTool : m_physicsInitializationTools) {
233  if (physicsTool->initializePhysics().isFailure()) {
234  throw std::runtime_error("Failed to initialize physics with tool " + physicsTool.name());
235  }
236  }
237 
238  if(m_userLimitsSvc.retrieve().isFailure()) {
239  throw std::runtime_error("Could not initialize ATLAS UserLimitsSvc!");
240  }
241 
243  G4VModularPhysicsList* thePhysicsList=dynamic_cast<G4VModularPhysicsList*>(m_physListSvc->GetPhysicsList());
244  if (!thePhysicsList) {
245  throw std::runtime_error("Failed dynamic_cast!! this is not a G4VModularPhysicsList!");
246  }
247 #if G4VERSION_NUMBER >= 1010
248  std::vector<std::string>& parallelWorldNames=m_detConstruction->GetParallelWorldNames();
249  for (auto& it: parallelWorldNames) {
250  thePhysicsList->RegisterPhysics(new G4ParallelWorldPhysics(it,true));
251  }
252 #endif
253  }
254 
255  return;
256 }
257 
259 {
260  if (m_verbosities.size()>0) {
261  G4TransportationManager *tm = G4TransportationManager::GetTransportationManager();
262  G4RunManagerKernel *rmk = G4RunManagerKernel::GetRunManagerKernel();
263  G4EventManager *em = G4EventManager::GetEventManager();
264 
265  auto itr = m_verbosities.end();
266  if ((itr = m_verbosities.find("Navigator")) != m_verbosities.end()) {
267  tm->GetNavigatorForTracking()->SetVerboseLevel( atof(itr->second.data()) );
268  }
269  if ((itr = m_verbosities.find("Propagator")) != m_verbosities.end()) {
270  tm->GetPropagatorInField()->SetVerboseLevel( atof(itr->second.data()) );
271  }
272  if ((itr = m_verbosities.find("Tracking")) != m_verbosities.end()) {
273  rmk->GetTrackingManager()->SetVerboseLevel( atof(itr->second.data()) );
274  }
275  if ((itr = m_verbosities.find("Stepping")) != m_verbosities.end()) {
276  rmk->GetTrackingManager()->GetSteppingManager()->
277  SetVerboseLevel( atof(itr->second.data()) );
278  }
279  if ((itr = m_verbosities.find("Stacking")) != m_verbosities.end()) {
280  rmk->GetStackManager()->SetVerboseLevel( atof(itr->second.data()) );
281  }
282  if ((itr = m_verbosities.find("Event")) != m_verbosities.end()) {
283  em->SetVerboseLevel( atof(itr->second.data()) );
284  }
285  } // End of the setting of verbosities
286 
287 }
288 
289 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
290 
292 {
293  ATH_MSG_DEBUG(std::endl<<std::endl<<std::endl);
294  ATH_MSG_DEBUG("++++++++++++ G4AtlasAlg finalized ++++++++++++" <<std::endl<<std::endl);
295 
296  // One time finalization
297  try {
298  std::call_once(finalizeOnceFlag, &G4AtlasAlg::finalizeOnce, this);
299  }
300  catch(const std::exception& e) {
301  ATH_MSG_ERROR("Failure in G4AtlasAlg::finalizeOnce: " << e.what());
302  return StatusCode::FAILURE;
303  }
304 
305  return StatusCode::SUCCESS;
306 }
307 
308 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
310 {
311  ATH_MSG_DEBUG("\t terminating the current G4 run");
312  auto runMgr = G4RunManager::GetRunManager();
313  runMgr->RunTermination();
314 }
315 
316 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
317 
319 {
320  static std::atomic<unsigned int> n_Event=0;
321  ATH_MSG_DEBUG("++++++++++++ G4AtlasAlg execute ++++++++++++");
322 
323  n_Event += 1;
324 
325  if (n_Event<=10 || (n_Event%100) == 0) {
326  ATH_MSG_ALWAYS("G4AtlasAlg: Event num. " << n_Event << " start processing");
327  }
328 
329  // Release GeoModel Geometry if necessary
330  if (m_releaseGeoModel) {
331  try {
332  std::call_once(releaseGeoModelOnceFlag, &G4AtlasAlg::releaseGeoModel, this);
333  }
334  catch(const std::exception& e) {
335  ATH_MSG_ERROR("Failure in G4AtlasAlg::releaseGeoModel: " << e.what());
336  return StatusCode::FAILURE;
337  }
338  }
339 
340  const EventContext& ctx = Gaudi::Hive::currentContext();
341  // Set the RNG to use for this event. We need to reset it for MT jobs
342  // because of the mismatch between Gaudi slot-local and G4 thread-local RNG.
343  ATHRNG::RNGWrapper* rngWrapper = m_rndmGenSvc->getEngine(this, m_randomStreamName);
344  rngWrapper->setSeed( m_randomStreamName, ctx);
345  G4Random::setTheEngine(*rngWrapper);
346 
347  ATH_MSG_DEBUG("Calling SimulateG4Event");
348 
349  auto eventInfo = std::make_unique<AtlasG4EventUserInfo>();
350  // get a shared pointer to the hit collection map because we will need it after the G4Event is destroyed
351  std::shared_ptr<HitCollectionMap> hitCollections = eventInfo->GetHitCollectionMap();
352 
353  ATH_CHECK(m_senDetTool->BeginOfAthenaEvent(*hitCollections));
354  ATH_CHECK(m_fastSimTool->BeginOfAthenaEvent());
355 
357  if (!inputTruthCollection.isValid()) {
358  ATH_MSG_FATAL("Unable to read input GenEvent collection " << inputTruthCollection.name() << " in store " << inputTruthCollection.store());
359  return StatusCode::FAILURE;
360  }
361  ATH_MSG_DEBUG("Found input GenEvent collection " << inputTruthCollection.name() << " in store " << inputTruthCollection.store());
362  // create the output Truth collection
364  std::unique_ptr<McEventCollection> shadowTruth{};
365  if (m_useShadowEvent) {
366  outputTruthCollection = std::make_unique<McEventCollection>();
367  // copy input Evgen collection to shadow Truth collection
368  shadowTruth = std::make_unique<McEventCollection>(*inputTruthCollection);
369  for (HepMC::GenEvent* currentGenEvent : *shadowTruth ) {
370  // Apply QS patch if required
371  if ( not m_qspatcher.empty() ) {
372  ATH_CHECK(m_qspatcher->applyWorkaround(*currentGenEvent));
373  }
374  // Copy GenEvent and remove daughters of quasi-stable particles to be simulated
375  std::unique_ptr<HepMC::GenEvent> outputEvent = m_truthPreselectionTool->filterGenEvent(*currentGenEvent);
376  outputTruthCollection->push_back(outputEvent.release());
377  }
378  }
379  else {
380  // copy input Evgen collection to output Truth collection
381  outputTruthCollection = std::make_unique<McEventCollection>(*inputTruthCollection);
382  // empty shadow Truth collection
383  shadowTruth = std::make_unique<McEventCollection>();
384  // Apply QS patch if required
385  if ( not m_qspatcher.empty() ) {
386  for (HepMC::GenEvent* currentGenEvent : *outputTruthCollection ) {
387  ATH_CHECK(m_qspatcher->applyWorkaround(*currentGenEvent));
388  }
389  }
390  }
391 
392  ATH_MSG_DEBUG("Recorded output GenEvent collection " << outputTruthCollection.name() << " in store " << outputTruthCollection.store());
393 
394  const int largestGeneratedParticleBC = (outputTruthCollection->empty()) ? HepMC::UNDEFINED_ID
395  : HepMC::maxGeneratedParticleBarcode(outputTruthCollection->at(0)); // TODO make this more robust
396  const int largestGeneratedVertexBC = (outputTruthCollection->empty()) ? HepMC::UNDEFINED_ID
397  : HepMC::maxGeneratedVertexBarcode(outputTruthCollection->at(0)); // TODO make this more robust
398  // tell TruthService we're starting a new event
399  ATH_CHECK( m_truthRecordSvc->initializeTruthCollection(largestGeneratedParticleBC, largestGeneratedVertexBC) );
400 
401  bool abort = false;
402 
403  {
404 
405  auto inputEvent = std::make_unique<G4Event>(ctx.eventID().event_number());
406  inputEvent->SetUserInformation(eventInfo.release());
407 
408  ATH_CHECK(m_inputConverter->convertHepMCToG4Event(
409  *outputTruthCollection, *inputEvent, *shadowTruth));
410  // Worker run manager
411  // Custom class has custom method call: ProcessEvent.
412  // So, grab custom singleton class directly, rather than base.
413  // Maybe that should be changed! Then we can use a base pointer.
414  if (m_useMT) {
415 #ifdef G4MULTITHREADED
416  auto* workerRM = G4AtlasWorkerRunManager::GetG4AtlasWorkerRunManager();
417  abort = workerRM->ProcessEvent(inputEvent.release());
418 #else
419  ATH_MSG_ERROR("Trying to use multi-threading in non-MT build!");
420  return StatusCode::FAILURE;
421 #endif
422  } else {
423  auto* workerRM ATLAS_THREAD_SAFE = // single-threaded case
424  G4AtlasRunManager::GetG4AtlasRunManager();
425  abort = workerRM->ProcessEvent(inputEvent.release());
426  }
427 
428  if (abort) {
429  ATH_MSG_WARNING("Event was aborted !! ");
430  ATH_MSG_WARNING("Simulation will now go on to the next event ");
431  if (m_killAbortedEvents) {
432  ATH_MSG_WARNING("setFilterPassed is now False");
433  setFilterPassed(false);
434  }
435  if (m_flagAbortedEvents) {
437  if (!eventInfo.isValid()) {
439  "Failed to retrieve xAOD::EventInfo while trying to update the "
440  "error state!");
441  return StatusCode::FAILURE;
442  } else {
445  ATH_MSG_WARNING("Set error state in xAOD::EventInfo!");
446  }
447  }
448  }
449 
450  ATH_CHECK(m_senDetTool->EndOfAthenaEvent(*hitCollections));
451  ATH_CHECK(m_fastSimTool->EndOfAthenaEvent());
452 
453  ATH_CHECK(m_truthRecordSvc->releaseEvent());
454  }
455  // Remove QS patch if required
456  if(!m_qspatcher.empty()) {
457  for (HepMC::GenEvent* currentGenEvent : *outputTruthCollection ) {
458  ATH_CHECK(m_qspatcher->removeWorkaround(*currentGenEvent));
459  }
460  }
461 
462  return StatusCode::SUCCESS;
463 }
464 
465 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
466 
468 {
469  SmartIF<IGeoModelSvc> geoModel{Gaudi::svcLocator()->service("GeoModelSvc")};
470  if (!geoModel) {
471  ATH_MSG_WARNING( " ----> Unable to retrieve GeoModelSvc" );
472  }
473  else {
474  if (geoModel->clear().isFailure()) {
475  ATH_MSG_WARNING( " ----> GeoModelSvc::clear() failed" );
476  }
477  else {
478  ATH_MSG_INFO( " ----> GeoModelSvc::clear() succeeded " );
479  }
480  }
481  m_releaseGeoModel=false; // Don't do that again...
482  return;
483 }
484 
485 void G4AtlasAlg::commandLog(int returnCode, const std::string& commandString) const
486 {
487  switch(returnCode) {
488  case 0: { ATH_MSG_DEBUG("G4 Command: " << commandString << " - Command Succeeded"); } break;
489  case 100: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Command Not Found!"); } break;
490  case 200: {
491  auto* stateManager = G4StateManager::GetStateManager();
492  ATH_MSG_DEBUG("G4 Command: " << commandString << " - Illegal Application State (" <<
493  stateManager->GetStateString(stateManager->GetCurrentState()) << ")!");
494  } break;
495  case 300: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Parameter Out of Range!"); } break;
496  case 400: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Parameter Unreadable!"); } break;
497  case 500: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Parameter Out of Candidates!"); } break;
498  case 600: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Alias Not Found!"); } break;
499  default: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Unknown Status!"); } break;
500  }
501 
502 }
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
ATHRNG::RNGWrapper::setSeed
void setSeed(const std::string &algName, const EventContext &ctx)
Set the random seed using a string (e.g.
Definition: RNGWrapper.h:169
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
G4AtlasAlg::m_flagAbortedEvents
Gaudi::Property< bool > m_flagAbortedEvents
Definition: G4AtlasAlg.h:104
HitCollectionMap.h
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
G4AtlasAlg::m_detConstruction
PublicToolHandle< IDetectorConstructionTool > m_detConstruction
Definition: G4AtlasAlg.h:142
G4AtlasAlg::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: G4AtlasAlg.h:107
G4AtlasMTRunManager.h
TruthStrategyManager::SetISFTruthSvc
void SetISFTruthSvc(ISF::ITruthSvc *truthSvc)
Define which ISF TruthService to use.
Definition: TruthStrategyManager.cxx:53
SG::ReadHandle< McEventCollection >
SG::VarHandleBase::name
const std::string & name() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx:75
G4AtlasAlg::finalize
StatusCode finalize() override
Finalize the algorithm and invoke G4 run termination.
Definition: G4AtlasAlg.cxx:291
initialize
void initialize()
Definition: run_EoverP.cxx:894
G4AtlasActionInitialization.h
G4AtlasAlg::m_senDetTool
PublicToolHandle< ISensitiveDetectorMasterTool > m_senDetTool
Sensitive Detector Master Tool.
Definition: G4AtlasAlg.h:155
ATLAS_NOT_THREAD_SAFE
StatusCode G4AtlasAlg::initialize ATLAS_NOT_THREAD_SAFE()
Install fatal handler with default options.
Definition: G4AtlasAlg.cxx:71
G4AtlasAlg::m_fieldMap
Gaudi::Property< std::string > m_fieldMap
Definition: G4AtlasAlg.h:122
skel.it
it
Definition: skel.GENtoEVGEN.py:407
HepMC::maxGeneratedVertexBarcode
int maxGeneratedVertexBarcode(const HepMC::GenEvent *genEvent)
Get the maximal absolute value of barcode of vertex present in the event. Returns a negative number.
Definition: MagicNumbers.h:444
G4AtlasAlg::m_recordFlux
Gaudi::Property< bool > m_recordFlux
Definition: G4AtlasAlg.h:125
TruthStrategyManager.h
G4AtlasAlg::m_releaseGeoModel
Gaudi::Property< bool > m_releaseGeoModel
Definition: G4AtlasAlg.h:124
G4AtlasAlg::m_physListSvc
ServiceHandle< IPhysicsListSvc > m_physListSvc
Physics List Tool.
Definition: G4AtlasAlg.h:153
G4AtlasAlg::m_randomStreamName
Gaudi::Property< std::string > m_randomStreamName
Random Stream Name.
Definition: G4AtlasAlg.h:136
G4AtlasUserWorkerThreadInitialization.h
G4AtlasAlg::commandLog
void commandLog(int returnCode, const std::string &commandString) const
This command prints a message about a G4Command depending on its returnCode.
Definition: G4AtlasAlg.cxx:485
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
xAOD::EventInfo_v1::Error
@ Error
The sub-detector issued an error.
Definition: EventInfo_v1.h:349
G4AtlasAlg::m_userLimitsSvc
ServiceHandle< IUserLimitsSvc > m_userLimitsSvc
Definition: G4AtlasAlg.h:138
python.CaloAddPedShiftConfig.parser
parser
Definition: CaloAddPedShiftConfig.py:41
G4AtlasRunManager.h
G4AtlasAlg::m_truthPreselectionTool
ToolHandle< ISF::IGenEventFilter > m_truthPreselectionTool
Definition: G4AtlasAlg.h:148
WriteHandle.h
Handle class for recording to StoreGate.
G4AtlasAlg::m_inputTruthCollectionKey
SG::ReadHandleKey< McEventCollection > m_inputTruthCollectionKey
input hard scatter collection
Definition: G4AtlasAlg.h:105
TruthStrategyManager::SetISFGeoIDSvc
void SetISFGeoIDSvc(ISF::IGeoIDSvc *geoIDSvc)
Define which ISF GeoIDSvc to use.
Definition: TruthStrategyManager.cxx:59
G4AtlasAlg::m_inputConverter
ServiceHandle< ISF::IInputConverter > m_inputConverter
Service to convert ISF_Particles into a G4Event.
Definition: G4AtlasAlg.h:151
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
G4AtlasAlg::m_fastSimTool
PublicToolHandle< IFastSimulationMasterTool > m_fastSimTool
Fast Simulation Master Tool.
Definition: G4AtlasAlg.h:157
G4AtlasAlg::finalizeOnce
void finalizeOnce()
G4 finalization called only by the first alg instance.
Definition: G4AtlasAlg.cxx:309
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
G4AtlasAlg::execute
StatusCode execute() override
Simulate one Athena event.
Definition: G4AtlasAlg.cxx:318
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
G4AtlasWorkerRunManager.h
G4AtlasAlg::m_useShadowEvent
BooleanProperty m_useShadowEvent
Definition: G4AtlasAlg.h:132
SG::VarHandleBase::store
std::string store() const
Return the name of the store holding the object we are proxying.
Definition: StoreGate/src/VarHandleBase.cxx:382
calibdata.exception
exception
Definition: calibdata.py:495
TruthStrategyManager
Singleton class for creating truth incidents.
Definition: TruthStrategyManager.h:23
G4AtlasAlg::initializeG4
void initializeG4()
Poorly named possibly unused method which sets some verbosities.
Definition: G4AtlasAlg.cxx:258
ATH_MSG_ALWAYS
#define ATH_MSG_ALWAYS(x)
Definition: AthMsgStreamMacros.h:35
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthAlgorithm
Definition: AthAlgorithm.h:47
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
CxxUtils::atof
double atof(std::string_view str)
Converts a string into a double / float.
Definition: Control/CxxUtils/Root/StringUtils.cxx:91
HepMC::UNDEFINED_ID
constexpr int UNDEFINED_ID
Definition: MagicNumbers.h:56
G4AtlasAlg::m_physicsInitializationTools
PublicToolHandleArray< IPhysicsInitializationTool > m_physicsInitializationTools
Definition: G4AtlasAlg.h:143
G4AtlasAlg::m_g4commands
Gaudi::Property< std::vector< std::string > > m_g4commands
Commands to send to the G4 UI.
Definition: G4AtlasAlg.h:128
PathResolver.h
G4AtlasAlg.h
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ATHRNG::RNGWrapper
A wrapper class for event-slot-local random engines.
Definition: RNGWrapper.h:56
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
G4AtlasAlg::releaseGeoModel
void releaseGeoModel()
Releases the GeoModel geometry from memory once it has been used to build the G4 geometry and is no-l...
Definition: G4AtlasAlg.cxx:467
G4AtlasAlg::m_physList
Gaudi::Property< std::string > m_physList
Definition: G4AtlasAlg.h:121
RNGWrapper.h
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:321
SG::WriteHandle< McEventCollection >
G4AtlasAlg::m_useMT
Gaudi::Property< bool > m_useMT
Activate multi-threading configuration.
Definition: G4AtlasAlg.h:130
G4AtlasAlg::m_truthRecordSvc
ServiceHandle< ISF::ITruthSvc > m_truthRecordSvc
Central Truth Service.
Definition: G4AtlasAlg.h:110
G4AtlasAlg::m_actionTools
PublicToolHandleArray< G4UA::IUserActionTool > m_actionTools
Definition: G4AtlasAlg.h:159
G4AtlasAlg::G4AtlasAlg
G4AtlasAlg(const std::string &name, ISvcLocator *pSvcLocator)
Standard algorithm constructor.
Definition: G4AtlasAlg.cxx:61
HepMC::maxGeneratedParticleBarcode
int maxGeneratedParticleBarcode(const HepMC::GenEvent *genEvent)
Get the maximal value of barcode of particle present in the event.
Definition: MagicNumbers.h:427
AtlasG4EventUserInfo.h
G4AtlasAlg::m_quietMode
Gaudi::Property< bool > m_quietMode
Definition: G4AtlasAlg.h:126
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
G4AtlasAlg::m_verbosities
std::map< std::string, std::string > m_verbosities
Verbosity settings for Geant4.
Definition: G4AtlasAlg.h:115
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
G4AtlasAlg::m_userActionSvc
ServiceHandle< G4UA::IUserActionSvc > m_userActionSvc
User Action Service.
Definition: G4AtlasAlg.h:140
G4AtlasAlg::m_qspatcher
ServiceHandle< Simulation::IZeroLifetimePatcher > m_qspatcher
Quasi-Stable Particle Simulation Patcher.
Definition: G4AtlasAlg.h:146
xAOD::EventInfo_v1::updateErrorState
bool updateErrorState(const EventFlagSubDet subDet, const EventFlagErrorState state) const
Update the error state for one particular sub-detector.
Definition: EventInfo_v1.cxx:856
G4AtlasAlg::m_killAbortedEvents
Gaudi::Property< bool > m_killAbortedEvents
Definition: G4AtlasAlg.h:103
ATLAS_THREAD_SAFE
#define ATLAS_THREAD_SAFE
Definition: checker_macros.h:211
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
ReadHandle.h
Handle class for reading from StoreGate.
G4AtlasAlg::m_rndmGenSvc
ServiceHandle< IAthRNGSvc > m_rndmGenSvc
Random number service.
Definition: G4AtlasAlg.h:134
G4AtlasAlg::m_libList
Gaudi::Property< std::string > m_libList
Definition: G4AtlasAlg.h:120
checker_macros.h
Define macros for attributes used to control the static checker.
IGeoModelSvc.h
G4AtlasAlg::m_outputTruthCollectionKey
SG::WriteHandleKey< McEventCollection > m_outputTruthCollectionKey
output hard scatter truth collection
Definition: G4AtlasAlg.h:106
xAOD::EventInfo_v1::Core
@ Core
Core flags describing the event.
Definition: EventInfo_v1.h:339
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
G4AtlasAlg::m_activateParallelGeometries
Gaudi::Property< bool > m_activateParallelGeometries
Definition: G4AtlasAlg.h:131
G4AtlasAlg::initializeOnce
void initializeOnce()
G4 initialization called only by the first alg instance.
Definition: G4AtlasAlg.cxx:136
G4AtlasFluxRecorder.h