Primary Athena algorithm for ATLAS simulation. More...

#include <G4AtlasAlg.h>

Inheritance diagram for G4AtlasAlg:

Public Member Functions
	G4AtlasAlg (const std::string &name, ISvcLocator *pSvcLocator)
	Standard algorithm constructor.
virtual	~G4AtlasAlg ()
	Virtual destructor.
bool	isClonable () const override
	this Alg is Clonable (for AthenaMT)
StatusCode initialize	ATLAS_NOT_THREAD_SAFE () override
	Initialize the algorithm.
StatusCode	finalize () override
	Finalize the algorithm and invoke G4 run termination.
StatusCode	execute () override
	Simulate one Athena event.
void	initializeG4 ()
	Poorly named possibly unused method which sets some verbosities.
void	initializeOnce ()
	G4 initialization called only by the first alg instance.
void	finalizeOnce ()
	G4 finalization called only by the first alg instance.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	commandLog (int returnCode, const std::string &commandString) const
	This command prints a message about a G4Command depending on its returnCode.
void	releaseGeoModel ()
	Releases the GeoModel geometry from memory once it has been used to build the G4 geometry and is no-longer required.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
PublicToolHandleArray< G4UA::IUserActionTool >	m_actionTools {this, "UserActionTools", {}, "User action tools to be added to the G4 Action service."}
Gaudi::Property< std::string >	m_simplifiedGeoPath {this, "SimplifiedGeoPath", "", "Path to the simplified geometry file used to transport particles"}
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared
Configurable Properties
Gaudi::Property< bool >	m_killAbortedEvents {this, "KillAbortedEvents", false, ""}
Gaudi::Property< bool >	m_flagAbortedEvents {this, "FlagAbortedEvents", false, ""}
SG::ReadHandleKey< McEventCollection >	m_inputTruthCollectionKey {this, "InputTruthCollection", "BeamTruthEvent", "Input hard scatter collection"}
	input hard scatter collection
SG::WriteHandleKey< McEventCollection >	m_outputTruthCollectionKey {this, "OutputTruthCollection", "TruthEvent", "Output hard scatter truth collection"}
	output hard scatter truth collection
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey {this, "EventInfo", "EventInfo", "EventInfo key"}
ServiceHandle< ISF::ITruthSvc >	m_truthRecordSvc {this, "TruthRecordService", "ISF_TruthRecordSvc", ""}
	Central Truth Service.
ServiceHandle< ISF::IGeoIDSvc >	m_geoIDSvc {this, "GeoIDSvc", "ISF_GeoIDSvc", ""}
	Geo ID Service.
std::map< std::string, std::string >	m_verbosities
	Verbosity settings for Geant4.
Configurable Properties (common with TransportTool)
Gaudi::Property< std::string >	m_libList {this, "Dll", "", ""}
Gaudi::Property< std::string >	m_physList {this, "Physics", "", ""}
Gaudi::Property< std::string >	m_fieldMap {this, "FieldMap", "", ""}
Gaudi::Property< std::string >	m_rndmGen {this, "RandomGenerator", "athena", ""}
Gaudi::Property< bool >	m_releaseGeoModel {this, "ReleaseGeoModel", true, ""}
Gaudi::Property< bool >	m_recordFlux {this, "RecordFlux", false, ""}
Gaudi::Property< bool >	m_quietMode {this, "QuietMode", false, ""}
Gaudi::Property< std::vector< std::string > >	m_g4commands {this, "G4Commands", {}, "Commands to send to the G4UI"}
	Commands to send to the G4 UI.
Gaudi::Property< bool >	m_useMT {this,"MultiThreading", false, "Multi-threading specific settings"}
	Activate multi-threading configuration.
Gaudi::Property< bool >	m_activateParallelGeometries {this, "ActivateParallelWorlds", false, "Toggle on/off the G4 parallel geometry system"}
BooleanProperty	m_useShadowEvent {this, "UseShadowEvent", false, "New approach to selecting particles for simulation" }
ServiceHandle< IAthRNGSvc >	m_rndmGenSvc {this, "AtRndmGenSvc", "AthRNGSvc", ""}
	Random number service.
Gaudi::Property< std::string >	m_randomStreamName {this, "RandomStreamName", "Geant4", ""}
	Random Stream Name.
ServiceHandle< IUserLimitsSvc >	m_userLimitsSvc {this, "UserLimitsSvc", "UserLimitsSvc", ""}
ServiceHandle< G4UA::IUserActionSvc >	m_userActionSvc {this, "UserActionSvc", "G4UA::UserActionSvc", ""}
	User Action Service.
PublicToolHandle< IDetectorConstructionTool >	m_detConstruction {this, "DetectorConstruction", "", "Tool handle of the DetectorConstruction"}
PublicToolHandleArray< IPhysicsInitializationTool >	m_physicsInitializationTools {this, "PhysicsInitializationTools", {}, "Physics initialization happening after Geant4 initialization"}
ServiceHandle< Simulation::IZeroLifetimePatcher >	m_qspatcher {this, "QuasiStablePatcher", "", "Quasi-Stable Particle Simulation Patcher"}
	Quasi-Stable Particle Simulation Patcher.
ToolHandle< ISF::IGenEventFilter >	m_truthPreselectionTool {this, "TruthPreselectionTool", "", "Tool for filtering out quasi-stable particle daughters"}
ServiceHandle< ISF::IInputConverter >	m_inputConverter {this, "InputConverter", "ISF_InputConverter", ""}
	Service to convert ISF_Particles into a G4Event.
ServiceHandle< IPhysicsListSvc >	m_physListSvc {this, "PhysicsListSvc", "PhysicsListSvc", ""}
	Physics List Tool.
PublicToolHandle< ISensitiveDetectorMasterTool >	m_senDetTool {this, "SenDetMasterTool", "SensitiveDetectorMasterTool", ""}
	Sensitive Detector Master Tool.
PublicToolHandle< IFastSimulationMasterTool >	m_fastSimTool {this, "FastSimMasterTool", "FastSimulationMasterTool", ""}
	Fast Simulation Master Tool.

Detailed Description

Primary Athena algorithm for ATLAS simulation.

During initialization, this class sets up several things, including:

the ATLAS (master) run manager
physics list assignment to G4
detector construction (currently FADS::FadsDetectorConstruction)

During the event loop, it handles processing of the event by invoking the (worker) run manager.

Definition at line 53 of file G4AtlasAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ G4AtlasAlg()

G4AtlasAlg::G4AtlasAlg	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Standard algorithm constructor.

Definition at line 61 of file G4AtlasAlg.cxx.

  : AthAlgorithm(name, pSvcLocator)
{
  // Verbosities
  declareProperty("Verbosities", m_verbosities);
}

◆ ~G4AtlasAlg()

virtual G4AtlasAlg::~G4AtlasAlg ( )

inlinevirtual

Virtual destructor.

Definition at line 62 of file G4AtlasAlg.h.

62{ };

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

StatusCode initialize G4AtlasAlg::ATLAS_NOT_THREAD_SAFE ( )

override

Initialize the algorithm.

Here we setup several things for simulation, including:

force intialization of the UserActionSvc
apply custom G4 UI commands (like custom physics list)
configure the particle generator and random generator svc

◆ commandLog()

void G4AtlasAlg::commandLog	(	int	returnCode,
		const std::string &	commandString ) const

private

This command prints a message about a G4Command depending on its returnCode.

Definition at line 487 of file G4AtlasAlg.cxx.

{
  switch(returnCode) {
  case 0: { ATH_MSG_DEBUG("G4 Command: " << commandString << " - Command Succeeded"); } break;
  case 100: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Command Not Found!"); } break;
  case 200: {
    auto* stateManager = G4StateManager::GetStateManager();
    ATH_MSG_DEBUG("G4 Command: " << commandString << " - Illegal Application State (" <<
                    stateManager->GetStateString(stateManager->GetCurrentState()) << ")!");
  } break;
  case 300: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Parameter Out of Range!"); } break;
  case 400: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Parameter Unreadable!"); } break;
  case 500: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Parameter Out of Candidates!"); } break;
  case 600: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Alias Not Found!"); } break;
  default: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Unknown Status!"); } break;
  }
 
}

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

StatusCode G4AtlasAlg::execute ( )

override

Simulate one Athena event.

Definition at line 318 of file G4AtlasAlg.cxx.

{
  static std::atomic<unsigned int> n_Event=0;
  ATH_MSG_DEBUG("++++++++++++  G4AtlasAlg execute  ++++++++++++");
 
  n_Event += 1;
 
  if (n_Event<=10 || (n_Event%100) == 0) {
    ATH_MSG_ALWAYS("G4AtlasAlg: Event num. "  << n_Event << " start processing");
  }
 
  // Release GeoModel Geometry if necessary
  if (m_releaseGeoModel) {
    try {
      std::call_once(releaseGeoModelOnceFlag, &G4AtlasAlg::releaseGeoModel, this);
    }
    catch(const std::exception& e) {
      ATH_MSG_ERROR("Failure in G4AtlasAlg::releaseGeoModel: " << e.what());
      return StatusCode::FAILURE;
    }
  }
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  // Set the RNG to use for this event. We need to reset it for MT jobs
  // because of the mismatch between Gaudi slot-local and G4 thread-local RNG.
  ATHRNG::RNGWrapper* rngWrapper = m_rndmGenSvc->getEngine(this, m_randomStreamName);
  rngWrapper->setSeed( m_randomStreamName,  ctx);
  G4Random::setTheEngine(*rngWrapper);
 
  ATH_MSG_DEBUG("Calling SimulateG4Event");
 
  auto eventInfo = std::make_unique<AtlasG4EventUserInfo>(ctx);
  // get a shared pointer to the hit collection map because we will need it after the G4Event is destroyed
  std::shared_ptr<HitCollectionMap> hitCollections = eventInfo->GetHitCollectionMap();
 
  ATH_CHECK(m_senDetTool->BeginOfAthenaEvent(*hitCollections));
  ATH_CHECK(m_userActionSvc->BeginOfAthenaEvent(*hitCollections));
  ATH_CHECK(m_fastSimTool->BeginOfAthenaEvent());
 
  SG::ReadHandle<McEventCollection> inputTruthCollection(m_inputTruthCollectionKey);
  if (!inputTruthCollection.isValid()) {
    ATH_MSG_FATAL("Unable to read input GenEvent collection " << inputTruthCollection.name() << " in store " << inputTruthCollection.store());
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Found input GenEvent collection " << inputTruthCollection.name() << " in store " << inputTruthCollection.store());
  // create the output Truth collection
  SG::WriteHandle<McEventCollection> outputTruthCollection(m_outputTruthCollectionKey);
  std::unique_ptr<McEventCollection> shadowTruth{};
  if (m_useShadowEvent) {
    outputTruthCollection = std::make_unique<McEventCollection>();
    // copy input Evgen collection to shadow Truth collection
    shadowTruth = std::make_unique<McEventCollection>(*inputTruthCollection);
    for (HepMC::GenEvent* currentGenEvent : *shadowTruth ) {
      // Apply QS patch if required
      if ( not m_qspatcher.empty() ) {
        ATH_CHECK(m_qspatcher->applyWorkaround(*currentGenEvent));
      }
      // Copy GenEvent and remove daughters of quasi-stable particles to be simulated
      std::unique_ptr<HepMC::GenEvent> outputEvent = m_truthPreselectionTool->filterGenEvent(*currentGenEvent);
      outputTruthCollection->push_back(outputEvent.release());
    }
  }
  else {
    // copy input Evgen collection to output Truth collection
    outputTruthCollection = std::make_unique<McEventCollection>(*inputTruthCollection);
    // empty shadow Truth collection
    shadowTruth = std::make_unique<McEventCollection>();
    // Apply QS patch if required
    if ( not m_qspatcher.empty() ) {
      for (HepMC::GenEvent* currentGenEvent : *outputTruthCollection ) {
        ATH_CHECK(m_qspatcher->applyWorkaround(*currentGenEvent));
      }
    }
  }
 
  ATH_MSG_DEBUG("Recorded output GenEvent collection " << outputTruthCollection.name() << " in store " << outputTruthCollection.store());
 
  const int largestGeneratedParticleBC =  (outputTruthCollection->empty()) ? HepMC::UNDEFINED_ID
    : HepMC::maxGeneratedParticleBarcode(outputTruthCollection->at(0)); // TODO make this more robust
  const int largestGeneratedVertexBC =  (outputTruthCollection->empty()) ? HepMC::UNDEFINED_ID
    : HepMC::maxGeneratedVertexBarcode(outputTruthCollection->at(0)); // TODO make this more robust
  // tell TruthService we're starting a new event
  ATH_CHECK( m_truthRecordSvc->initializeTruthCollection(largestGeneratedParticleBC, largestGeneratedVertexBC) );
 
  bool abort = false;
 
  {
 
    auto inputEvent = std::make_unique<G4Event>(ctx.eventID().event_number());
    inputEvent->SetUserInformation(eventInfo.release());
 
    ATH_CHECK(m_inputConverter->convertHepMCToG4Event(
        *outputTruthCollection, *inputEvent, *shadowTruth));
    // Worker run manager
    // Custom class has custom method call: ProcessEvent.
    // So, grab custom singleton class directly, rather than base.
    // Maybe that should be changed! Then we can use a base pointer.
    if (m_useMT) {
#ifdef G4MULTITHREADED
      auto* workerRM = G4AtlasWorkerRunManager::GetG4AtlasWorkerRunManager();
      abort = workerRM->ProcessEvent(inputEvent.release());
#else
      ATH_MSG_ERROR("Trying to use multi-threading in non-MT build!");
      return StatusCode::FAILURE;
#endif
    } else {
      auto* workerRM ATLAS_THREAD_SAFE =  // single-threaded case
          G4AtlasRunManager::GetG4AtlasRunManager();
      abort = workerRM->ProcessEvent(inputEvent.release());
    }
 
    if (abort) {
      ATH_MSG_WARNING("Event was aborted !! ");
      ATH_MSG_WARNING("Simulation will now go on to the next event ");
      if (m_killAbortedEvents) {
        ATH_MSG_WARNING("setFilterPassed is now False");
        setFilterPassed(false);
      }
      if (m_flagAbortedEvents) {
        SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey, ctx);
        if (!eventInfo.isValid()) {
          ATH_MSG_FATAL(
              "Failed to retrieve xAOD::EventInfo while trying to update the "
              "error state!");
          return StatusCode::FAILURE;
        } else {
          eventInfo->updateErrorState(xAOD::EventInfo::Core,
                                      xAOD::EventInfo::Error);
          ATH_MSG_WARNING("Set error state in xAOD::EventInfo!");
        }
      }
    }
 
    ATH_CHECK(m_senDetTool->EndOfAthenaEvent(*hitCollections));
    ATH_CHECK(m_userActionSvc->EndOfAthenaEvent(*hitCollections));
    ATH_CHECK(m_fastSimTool->EndOfAthenaEvent());
 
    ATH_CHECK(m_truthRecordSvc->releaseEvent());
  }
  // Remove QS patch if required
  if(!m_qspatcher.empty()) {
    for (HepMC::GenEvent* currentGenEvent : *outputTruthCollection ) {
      ATH_CHECK(m_qspatcher->removeWorkaround(*currentGenEvent));
    }
  }
 
  return StatusCode::SUCCESS;
}

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

◆ finalize()

StatusCode G4AtlasAlg::finalize ( )

override

Finalize the algorithm and invoke G4 run termination.

Definition at line 291 of file G4AtlasAlg.cxx.

{
  ATH_MSG_DEBUG(std::endl<<std::endl<<std::endl);
  ATH_MSG_DEBUG("++++++++++++  G4AtlasAlg finalized  ++++++++++++" <<std::endl<<std::endl);
 
  // One time finalization
  try {
    std::call_once(finalizeOnceFlag, &G4AtlasAlg::finalizeOnce, this);
  }
  catch(const std::exception& e) {
    ATH_MSG_ERROR("Failure in G4AtlasAlg::finalizeOnce: " << e.what());
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

◆ finalizeOnce()

void G4AtlasAlg::finalizeOnce ( )

G4 finalization called only by the first alg instance.

This is done (for now) because we get multiple alg instances in hive.

Definition at line 309 of file G4AtlasAlg.cxx.

{
  ATH_MSG_DEBUG("\t terminating the current G4 run");
  auto runMgr = G4RunManager::GetRunManager();
  runMgr->RunTermination();
}

◆ initializeG4()

void G4AtlasAlg::initializeG4 ( )

Poorly named possibly unused method which sets some verbosities.

Definition at line 258 of file G4AtlasAlg.cxx.

{
  if (m_verbosities.size()>0) {
    G4TransportationManager *tm = G4TransportationManager::GetTransportationManager();
    G4RunManagerKernel *rmk = G4RunManagerKernel::GetRunManagerKernel();
    G4EventManager *em = G4EventManager::GetEventManager();
 
    auto itr = m_verbosities.end();
    if ((itr = m_verbosities.find("Navigator")) != m_verbosities.end()) {
      tm->GetNavigatorForTracking()->SetVerboseLevel( atof(itr->second.data()) );
    }
    if ((itr = m_verbosities.find("Propagator")) != m_verbosities.end()) {
      tm->GetPropagatorInField()->SetVerboseLevel( atof(itr->second.data()) );
    }
    if ((itr = m_verbosities.find("Tracking")) != m_verbosities.end()) {
      rmk->GetTrackingManager()->SetVerboseLevel( atof(itr->second.data()) );
    }
    if ((itr = m_verbosities.find("Stepping")) != m_verbosities.end()) {
      rmk->GetTrackingManager()->GetSteppingManager()->
        SetVerboseLevel( atof(itr->second.data()) );
    }
    if ((itr = m_verbosities.find("Stacking")) != m_verbosities.end()) {
      rmk->GetStackManager()->SetVerboseLevel( atof(itr->second.data()) );
    }
    if ((itr = m_verbosities.find("Event")) != m_verbosities.end()) {
      em->SetVerboseLevel( atof(itr->second.data()) );
    }
  } // End of the setting of verbosities
 
}

◆ initializeOnce()

void G4AtlasAlg::initializeOnce ( )

G4 initialization called only by the first alg instance.

This is done (for now) because we get multiple alg instances in hive.

Definition at line 136 of file G4AtlasAlg.cxx.

{
  // Assign physics list
  if(m_physListSvc.retrieve().isFailure()) {
    throw std::runtime_error("Could not initialize ATLAS PhysicsListSvc!");
  }
  for (const auto& action_tool : m_actionTools) {
    if (m_userActionSvc->addActionTool(action_tool).isFailure()) {
      throw std::runtime_error("Failed to add action tool "+action_tool.name());
    }
  }
 
  ATH_MSG_INFO( "retrieving the Detector Construction tool" );
  if(m_detConstruction.retrieve().isFailure()) {
    throw std::runtime_error("Could not initialize ATLAS DetectorConstruction!");
  }
 
  // Create the (master) run manager
  if(m_useMT) {
#ifdef G4MULTITHREADED
    auto* runMgr ATLAS_THREAD_SAFE = // protected by std::call_once above
      G4AtlasMTRunManager::GetG4AtlasMTRunManager();
    m_physListSvc->SetPhysicsList();
    runMgr->SetDetConstructionTool( m_detConstruction.get() );
    runMgr->SetPhysListSvc( m_physListSvc.typeAndName() );
    runMgr->SetQuietMode( m_quietMode );
    // Worker Thread initialization used to create worker run manager on demand.
    std::unique_ptr<G4AtlasUserWorkerThreadInitialization> workerInit =
      std::make_unique<G4AtlasUserWorkerThreadInitialization>();
    workerInit->SetQuietMode( m_quietMode );
    runMgr->SetUserInitialization( workerInit.release() );
    std::unique_ptr<G4AtlasActionInitialization> actionInitialization =
      std::make_unique<G4AtlasActionInitialization>(m_userActionSvc.get());
    runMgr->SetUserInitialization(actionInitialization.release());
#else
    throw std::runtime_error("Trying to use multi-threading in non-MT build!");
#endif
  }
  // Single-threaded run manager
  else {
    auto* runMgr ATLAS_THREAD_SAFE = // safe because single-threaded
      G4AtlasRunManager::GetG4AtlasRunManager();
    m_physListSvc->SetPhysicsList();
    runMgr->SetRecordFlux( m_recordFlux, std::make_unique<G4AtlasFluxRecorder>() );
    runMgr->SetLogLevel( int(msg().level()) ); // Synch log levels
    runMgr->SetDetConstructionTool( m_detConstruction.get() );
    runMgr->SetPhysListSvc(m_physListSvc.typeAndName() );
    runMgr->SetQuietMode( m_quietMode );
    std::unique_ptr<G4AtlasActionInitialization> actionInitialization =
      std::make_unique<G4AtlasActionInitialization>(m_userActionSvc.get());
    runMgr->SetUserInitialization(actionInitialization.release());
  }
 
  // G4 user interface commands
  G4UImanager *ui = G4UImanager::GetUIpointer();
 
  // Load custom libraries
  if (!m_libList.empty()) {
    ATH_MSG_INFO("G4AtlasAlg specific libraries requested ");
    std::string temp="/load "+m_libList;
    ui->ApplyCommand(temp);
  }
  // Load custom physics
  if (!m_physList.empty()) {
    ATH_MSG_INFO("requesting a specific physics list "<< m_physList);
    std::string temp="/Physics/GetPhysicsList "+m_physList;
    ui->ApplyCommand(temp);
  }
  // Load custom magnetic field
  if (!m_fieldMap.empty()) {
    ATH_MSG_INFO("requesting a specific field map "<< m_fieldMap);
    ATH_MSG_INFO("the field is initialized straight away");
    std::string temp="/MagneticField/Select "+m_fieldMap;
    ui->ApplyCommand(temp);
    ui->ApplyCommand("/MagneticField/Initialize");
  }
 
  // Send UI commands
  ATH_MSG_DEBUG("G4 Command: Trying at the end of initializeOnce()");
  for (const auto& g4command : m_g4commands) {
    int returnCode = ui->ApplyCommand( g4command );
    commandLog(returnCode, g4command);
  }
 
  // Code from G4AtlasSvc
  auto* rm = G4RunManager::GetRunManager();
  if(!rm) {
    throw std::runtime_error("Run manager retrieval has failed");
  }
  rm->Initialize();     // Initialization differs slightly in multi-threading.
  // TODO: add more details about why this is here.
  if(!m_useMT && rm->ConfirmBeamOnCondition()) {
    rm->RunInitialization();
  }
 
  ATH_MSG_INFO("Initializing " << m_physicsInitializationTools.size() << " physics initialization tools");
  for(auto& physicsTool : m_physicsInitializationTools) {
    if (physicsTool->initializePhysics().isFailure()) {
      throw std::runtime_error("Failed to initialize physics with tool " + physicsTool.name());
    }
  }
 
  if(m_userLimitsSvc.retrieve().isFailure()) {
    throw std::runtime_error("Could not initialize ATLAS UserLimitsSvc!");
  }
 
  if (m_activateParallelGeometries) {
    G4VModularPhysicsList* thePhysicsList=dynamic_cast<G4VModularPhysicsList*>(m_physListSvc->GetPhysicsList());
    if (!thePhysicsList) {
      throw std::runtime_error("Failed dynamic_cast!! this is not a G4VModularPhysicsList!");
    }
#if G4VERSION_NUMBER >= 1010
    std::vector<std::string>& parallelWorldNames=m_detConstruction->GetParallelWorldNames();
    for (auto& it: parallelWorldNames) {
      thePhysicsList->RegisterPhysics(new G4ParallelWorldPhysics(it,true));
    }
#endif
  }
 
  return;
}

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isClonable()

bool G4AtlasAlg::isClonable ( ) const

inlineoverride

this Alg is Clonable (for AthenaMT)

Definition at line 65 of file G4AtlasAlg.h.

65{ return true; }

◆ msg()

MsgStream & AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ releaseGeoModel()

void G4AtlasAlg::releaseGeoModel ( )

private

Releases the GeoModel geometry from memory once it has been used to build the G4 geometry and is no-longer required.

Definition at line 469 of file G4AtlasAlg.cxx.

{
  SmartIF<IGeoModelSvc> geoModel{Gaudi::svcLocator()->service("GeoModelSvc")};
  if (!geoModel) {
    ATH_MSG_WARNING( " ----> Unable to retrieve GeoModelSvc" );
  }
  else {
    if (geoModel->clear().isFailure()) {
      ATH_MSG_WARNING( " ----> GeoModelSvc::clear() failed" );
    }
    else {
      ATH_MSG_INFO( " ----> GeoModelSvc::clear() succeeded " );
    }
  }
  m_releaseGeoModel=false; // Don't do that again...
  return;
}

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

◆ m_actionTools

PublicToolHandleArray<G4UA::IUserActionTool> G4AtlasAlg::m_actionTools {this, "UserActionTools", {}, "User action tools to be added to the G4 Action service."}

private

Definition at line 159 of file G4AtlasAlg.h.

159{this, "UserActionTools", {}, "User action tools to be added to the G4 Action service."};

◆ m_activateParallelGeometries

Gaudi::Property<bool> G4AtlasAlg::m_activateParallelGeometries {this, "ActivateParallelWorlds", false, "Toggle on/off the G4 parallel geometry system"}

private

Definition at line 131 of file G4AtlasAlg.h.

131{this, "ActivateParallelWorlds", false, "Toggle on/off the G4 parallel geometry system"};

◆ m_detConstruction

PublicToolHandle<IDetectorConstructionTool> G4AtlasAlg::m_detConstruction {this, "DetectorConstruction", "", "Tool handle of the DetectorConstruction"}

private

Definition at line 142 of file G4AtlasAlg.h.

142{this, "DetectorConstruction", "", "Tool handle of the DetectorConstruction"};

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> G4AtlasAlg::m_eventInfoKey {this, "EventInfo", "EventInfo", "EventInfo key"}

private

Definition at line 107 of file G4AtlasAlg.h.

107{this, "EventInfo", "EventInfo", "EventInfo key"};

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_fastSimTool

PublicToolHandle<IFastSimulationMasterTool> G4AtlasAlg::m_fastSimTool {this, "FastSimMasterTool", "FastSimulationMasterTool", ""}

private

Fast Simulation Master Tool.

Definition at line 157 of file G4AtlasAlg.h.

157{this, "FastSimMasterTool", "FastSimulationMasterTool", ""};

◆ m_fieldMap

Gaudi::Property<std::string> G4AtlasAlg::m_fieldMap {this, "FieldMap", "", ""}

private

Definition at line 122 of file G4AtlasAlg.h.

122{this, "FieldMap", "", ""};

◆ m_flagAbortedEvents

Gaudi::Property<bool> G4AtlasAlg::m_flagAbortedEvents {this, "FlagAbortedEvents", false, ""}

private

Definition at line 104 of file G4AtlasAlg.h.

104{this, "FlagAbortedEvents", false, ""};

◆ m_g4commands

Gaudi::Property<std::vector<std::string> > G4AtlasAlg::m_g4commands {this, "G4Commands", {}, "Commands to send to the G4UI"}

private

Commands to send to the G4 UI.

Definition at line 128 of file G4AtlasAlg.h.

128{this, "G4Commands", {}, "Commands to send to the G4UI"};

◆ m_geoIDSvc

ServiceHandle<ISF::IGeoIDSvc> G4AtlasAlg::m_geoIDSvc {this, "GeoIDSvc", "ISF_GeoIDSvc", ""}

private

Geo ID Service.

Definition at line 112 of file G4AtlasAlg.h.

112{this, "GeoIDSvc", "ISF_GeoIDSvc", ""};

◆ m_inputConverter

ServiceHandle<ISF::IInputConverter> G4AtlasAlg::m_inputConverter {this, "InputConverter", "ISF_InputConverter", ""}

private

Service to convert ISF_Particles into a G4Event.

Definition at line 151 of file G4AtlasAlg.h.

151{this, "InputConverter", "ISF_InputConverter", ""};

◆ m_inputTruthCollectionKey

SG::ReadHandleKey<McEventCollection> G4AtlasAlg::m_inputTruthCollectionKey {this, "InputTruthCollection", "BeamTruthEvent", "Input hard scatter collection"}

private

input hard scatter collection

Definition at line 105 of file G4AtlasAlg.h.

105{this, "InputTruthCollection", "BeamTruthEvent", "Input hard scatter collection"};

◆ m_killAbortedEvents

Gaudi::Property<bool> G4AtlasAlg::m_killAbortedEvents {this, "KillAbortedEvents", false, ""}

private

Definition at line 103 of file G4AtlasAlg.h.

103{this, "KillAbortedEvents", false, ""};

◆ m_libList

Gaudi::Property<std::string> G4AtlasAlg::m_libList {this, "Dll", "", ""}

private

Definition at line 120 of file G4AtlasAlg.h.

120{this, "Dll", "", ""};

◆ m_outputTruthCollectionKey

SG::WriteHandleKey<McEventCollection> G4AtlasAlg::m_outputTruthCollectionKey {this, "OutputTruthCollection", "TruthEvent", "Output hard scatter truth collection"}

private

output hard scatter truth collection

Definition at line 106 of file G4AtlasAlg.h.

106{this, "OutputTruthCollection", "TruthEvent", "Output hard scatter truth collection"};

◆ m_physicsInitializationTools

PublicToolHandleArray<IPhysicsInitializationTool> G4AtlasAlg::m_physicsInitializationTools {this, "PhysicsInitializationTools", {}, "Physics initialization happening after Geant4 initialization"}

private

Definition at line 143 of file G4AtlasAlg.h.

143{this, "PhysicsInitializationTools", {}, "Physics initialization happening after Geant4 initialization"};

◆ m_physList

Gaudi::Property<std::string> G4AtlasAlg::m_physList {this, "Physics", "", ""}

private

Definition at line 121 of file G4AtlasAlg.h.

121{this, "Physics", "", ""};

◆ m_physListSvc

ServiceHandle<IPhysicsListSvc> G4AtlasAlg::m_physListSvc {this, "PhysicsListSvc", "PhysicsListSvc", ""}

private

Physics List Tool.

Definition at line 153 of file G4AtlasAlg.h.

153{this, "PhysicsListSvc", "PhysicsListSvc", ""};

◆ m_qspatcher

ServiceHandle<Simulation::IZeroLifetimePatcher> G4AtlasAlg::m_qspatcher {this, "QuasiStablePatcher", "", "Quasi-Stable Particle Simulation Patcher"}

private

Quasi-Stable Particle Simulation Patcher.

Definition at line 146 of file G4AtlasAlg.h.

146{this, "QuasiStablePatcher", "", "Quasi-Stable Particle Simulation Patcher"};

◆ m_quietMode

Gaudi::Property<bool> G4AtlasAlg::m_quietMode {this, "QuietMode", false, ""}

private

Definition at line 126 of file G4AtlasAlg.h.

126{this, "QuietMode", false, ""};

◆ m_randomStreamName

Gaudi::Property<std::string> G4AtlasAlg::m_randomStreamName {this, "RandomStreamName", "Geant4", ""}

private

Random Stream Name.

Definition at line 136 of file G4AtlasAlg.h.

136{this, "RandomStreamName", "Geant4", ""};

◆ m_recordFlux

Gaudi::Property<bool> G4AtlasAlg::m_recordFlux {this, "RecordFlux", false, ""}

private

Definition at line 125 of file G4AtlasAlg.h.

125{this, "RecordFlux", false, ""};

◆ m_releaseGeoModel

Gaudi::Property<bool> G4AtlasAlg::m_releaseGeoModel {this, "ReleaseGeoModel", true, ""}

private

Definition at line 124 of file G4AtlasAlg.h.

124{this, "ReleaseGeoModel", true, ""};

◆ m_rndmGen

Gaudi::Property<std::string> G4AtlasAlg::m_rndmGen {this, "RandomGenerator", "athena", ""}

private

Definition at line 123 of file G4AtlasAlg.h.

123{this, "RandomGenerator", "athena", ""};

◆ m_rndmGenSvc

ServiceHandle<IAthRNGSvc> G4AtlasAlg::m_rndmGenSvc {this, "AtRndmGenSvc", "AthRNGSvc", ""}

private

Random number service.

Definition at line 134 of file G4AtlasAlg.h.

134{this, "AtRndmGenSvc", "AthRNGSvc", ""}; // TODO rename property

◆ m_senDetTool

PublicToolHandle<ISensitiveDetectorMasterTool> G4AtlasAlg::m_senDetTool {this, "SenDetMasterTool", "SensitiveDetectorMasterTool", ""}

private

Sensitive Detector Master Tool.

Definition at line 155 of file G4AtlasAlg.h.

155{this, "SenDetMasterTool", "SensitiveDetectorMasterTool", ""};

◆ m_simplifiedGeoPath

Gaudi::Property<std::string> G4AtlasAlg::m_simplifiedGeoPath {this, "SimplifiedGeoPath", "", "Path to the simplified geometry file used to transport particles"}

private

Definition at line 161 of file G4AtlasAlg.h.

161{this, "SimplifiedGeoPath", "", "Path to the simplified geometry file used to transport particles"};

◆ m_truthPreselectionTool

ToolHandle<ISF::IGenEventFilter> G4AtlasAlg::m_truthPreselectionTool {this, "TruthPreselectionTool", "", "Tool for filtering out quasi-stable particle daughters"}

private

Definition at line 148 of file G4AtlasAlg.h.

148{this, "TruthPreselectionTool", "", "Tool for filtering out quasi-stable particle daughters"};

◆ m_truthRecordSvc

ServiceHandle<ISF::ITruthSvc> G4AtlasAlg::m_truthRecordSvc {this, "TruthRecordService", "ISF_TruthRecordSvc", ""}

private

Central Truth Service.

Definition at line 110 of file G4AtlasAlg.h.

110{this, "TruthRecordService", "ISF_TruthRecordSvc", ""};

◆ m_useMT

Gaudi::Property<bool> G4AtlasAlg::m_useMT {this,"MultiThreading", false, "Multi-threading specific settings"}

private

Activate multi-threading configuration.

Definition at line 130 of file G4AtlasAlg.h.

130{this,"MultiThreading", false, "Multi-threading specific settings"};

◆ m_userActionSvc

ServiceHandle<G4UA::IUserActionSvc> G4AtlasAlg::m_userActionSvc {this, "UserActionSvc", "G4UA::UserActionSvc", ""}

private

User Action Service.

Definition at line 140 of file G4AtlasAlg.h.

140{this, "UserActionSvc", "G4UA::UserActionSvc", ""};

◆ m_userLimitsSvc

ServiceHandle<IUserLimitsSvc> G4AtlasAlg::m_userLimitsSvc {this, "UserLimitsSvc", "UserLimitsSvc", ""}

private

Definition at line 138 of file G4AtlasAlg.h.

138{this, "UserLimitsSvc", "UserLimitsSvc", ""};

◆ m_useShadowEvent

BooleanProperty G4AtlasAlg::m_useShadowEvent {this, "UseShadowEvent", false, "New approach to selecting particles for simulation" }

private

Definition at line 132 of file G4AtlasAlg.h.

132{this, "UseShadowEvent", false, "New approach to selecting particles for simulation" };

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_verbosities

std::map<std::string,std::string> G4AtlasAlg::m_verbosities

private

Verbosity settings for Geant4.

Definition at line 115 of file G4AtlasAlg.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ G4AtlasAlg()

◆ ~G4AtlasAlg()

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

◆ commandLog()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ finalizeOnce()

◆ initializeG4()

◆ initializeOnce()

◆ inputHandles()

◆ isClonable()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ releaseGeoModel()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_actionTools

◆ m_activateParallelGeometries

◆ m_detConstruction

◆ m_detStore

◆ m_eventInfoKey

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_fastSimTool

◆ m_fieldMap

◆ m_flagAbortedEvents

◆ m_g4commands

◆ m_geoIDSvc

◆ m_inputConverter

◆ m_inputTruthCollectionKey

◆ m_killAbortedEvents

◆ m_libList

◆ m_outputTruthCollectionKey

◆ m_physicsInitializationTools

◆ m_physList

◆ m_physListSvc

◆ m_qspatcher

◆ m_quietMode

◆ m_randomStreamName

◆ m_recordFlux

◆ m_releaseGeoModel

◆ m_rndmGen

◆ m_rndmGenSvc

◆ m_senDetTool

◆ m_simplifiedGeoPath

◆ m_truthPreselectionTool

◆ m_truthRecordSvc

◆ m_useMT

◆ m_userActionSvc

◆ m_userLimitsSvc

◆ m_useShadowEvent

◆ m_varHandleArraysDeclared

◆ m_verbosities

◆ m_vhka