G4RunTool Class Reference

Front-end service for initializing and interacting with the Geant4 run. More...

#include <G4RunTool.h>

Inheritance diagram for G4RunTool:

Collaboration diagram for G4RunTool:

Public Member Functions
virtual StatusCode	initialize () override final
	Initialize and start the Geant4 main thread, then wait until Geant4 is ready to start the run.
virtual StatusCode	finalize () override final
virtual void	NotifyBeginRun () override
	Notify Athena that Geant4 is ready to start a run.
virtual StatusCode	WaitBeginRun () override
	Wait for BeginOfRun, or return failure if the Geant4 thread stops first.
virtual size_t	Size () const override
virtual void	PushEvent (UPEvent ev) override
virtual UPEvent	GetEvent () override
	Get an event from the queue (called from Geant4 threads).

Private Member Functions
void	Geant4main () noexcept
	Geant4 main thread function, this is executed in a separate thread and blocks on BeamOn.
void	Geant4mainImpl (G4MTRunManager &runManager)
	Implementation called inside the Geant4 main thread exception boundary.
void	commandLog (int returnCode, const std::string &commandString) const
	This command prints a message about a G4Command depending on its returnCode.

Private Attributes
ServiceHandle< IPhysicsListSvc >	m_physicsListSvc {this, "PhysicsListSvc", "PhysicsListSvc"}
ServiceHandle< IUserLimitsSvc >	m_userLimitsSvc {this, "UserLimitsSvc", "UserLimitsSvc"}
ServiceHandle< G4UA::IUserActionSvc >	m_userActionSvc {this, "UserActionSvc", "G4UA::UserActionSvc"}
ToolHandle< IDetectorConstructionTool >	m_detConstruction {this, "DetectorConstruction", "", "Tool handle of the DetectorConstruction"}
ToolHandleArray< G4UA::IUserActionTool >	m_actionTools {this, "UserActionTools", {}, "User action tools to be added to the G4 Action service."}
PublicToolHandleArray< IPhysicsInitializationTool >	m_physicsInitializationTools {this, "PhysicsInitializationTools", {}, "Physics initialization happening after Geant4 initialization"}
Gaudi::Property< bool >	m_activateParallelGeometries {this, "ActivateParallelWorlds", false, "Toggle on/off the G4 parallel geometry system"}
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::vector< std::string > >	m_g4commands {this, "G4Commands", {}, "Commands to be sent to Geant4 UI at initialization"}
Gaudi::Property< int >	m_nG4threads {this, "NG4threads", 1, "Number of parallel G4 worker threads to launch"}
Gaudi::Property< int >	m_nG4eventsPerRun {this, "NG4eventsPerRun", 100000, "Number of G4 events foreseen for each Run"}
std::unique_ptr< std::thread >	m_thread
G4RunToolStateSynchronization	m_statusSync
G4RunToolEventQueue	m_eventQueue

Detailed Description

Front-end service for initializing and interacting with the Geant4 run.

This public tool will initialize Geant4 in a separate thread which will block until the end of the job. All the services constructing Geant4 objects (detector construction, physics list, etc.) are retrieved from the Geant4 main thread during initialize().

This tool's initialize() will spawn the Geant4 main thread, but doesn't wait for Geant4 to be initialized before returning. The reason is that the Geant4 main thread needs to initialize tools, and Gaudi tool initialization is protected by a recursive mutex, which would lead to a deadlock. Algorithms using this tool should call WaitBeginRun() in their initialize function to ensure Geant4 is ready.

Athena can push events to Geant4 using the PushEvent method, and Geant4 will retrieve them using GetEvent in the generator action.

Author

Julien Esseiva julie.nosp@m.n.es.nosp@m.seiva.nosp@m.@cer.nosp@m.n.ch

Definition at line 48 of file G4RunTool.h.

Member Function Documentation

commandLog()

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

private

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

Definition at line 252 of file G4RunTool.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;
  }
 
}

finalize()

StatusCode G4RunTool::finalize ( )

finaloverridevirtual

Definition at line 42 of file G4RunTool.cxx.

                              {
  // Signal finalization to G4 threads
  m_statusSync.RequestFinalize();
 
  // Wake every worker blocked waiting for an Athena event. GetEvent() returns
  // nullptr once the queue is closed, causing SyncEventAction to abort the run.
  m_eventQueue.Close();
 
  if (m_thread) {
    try {
      if(m_thread->joinable()) {
        m_thread->join();
        ATH_MSG_INFO("Geant4 main thread ended");
      }
 
    }  
    catch(const std::exception& e) {
      ATH_MSG_ERROR("Failure in G4RunTool::finalize, joining Geant4 main thread:" << e.what());
    }
  }
 
  return StatusCode::SUCCESS;
}

Geant4main()

void G4RunTool::Geant4main ( )

privatenoexcept

Geant4 main thread function, this is executed in a separate thread and blocks on BeamOn.

Definition at line 109 of file G4RunTool.cxx.

                                    {
  std::unique_ptr<G4MTRunManager> runManager;
  try {
    // Keep ownership outside the exception boundary. On failure, the event
    // queue must be closed before the run manager tries to join workers that
    // may still be blocked in GetEvent().
    runManager = std::make_unique<G4MTRunManager>();
    Geant4mainImpl(*runManager);
  }
  catch(const std::exception& error) {
    m_statusSync.Fail(error.what());
    ATH_MSG_ERROR("Exception in Geant4 main thread: " << error.what());
  }
  catch(...) {
    m_statusSync.Fail("Unknown exception in Geant4 main thread");
    ATH_MSG_ERROR("Unknown exception in Geant4 main thread");
  }
 
  // Teardown ordering is significant: wake blocked workers, join them while
  // destroying the run manager, publish the terminal lifecycle state, and
  // only then release Athena event waiters and their associated resources.
  m_eventQueue.Close();
  runManager.reset();
  m_statusSync.NotifyThreadExit();
  m_eventQueue.CompleteOutstandingEvents();
}

Geant4mainImpl()

void G4RunTool::Geant4mainImpl ( G4MTRunManager & runManager )

private

Implementation called inside the Geant4 main thread exception boundary.

Definition at line 136 of file G4RunTool.cxx.

                                                         {
 
  ATH_MSG_INFO("Geant4 main thread starts with id " << std::this_thread::get_id());
 
  runManager.SetNumberOfThreads(m_nG4threads);
  constexpr int seedFirstEventOnly = 1; // name the magic number
  // we will take care of reseeding each event, turn off Geant4 reseeding
  runManager.SetSeedOncePerCommunication(seedFirstEventOnly);
 
  if(m_detConstruction.retrieve().isFailure()) {
    ATH_MSG_ERROR("Failed to retrieve DetectorGeometryService");
    m_statusSync.Fail("Failed to retrieve DetectorGeometryService");
    return;
  }
 
  if(m_physicsListSvc.retrieve().isFailure()) {
    ATH_MSG_ERROR("Failed to retrieve PhysicsListService");
    m_statusSync.Fail("Failed to retrieve PhysicsListService");
    return;
  }
 
  if(m_userActionSvc.retrieve().isFailure()) {
    ATH_MSG_ERROR("Failed to retrieve UserActionService");
    m_statusSync.Fail("Failed to retrieve UserActionService");
    return;
  }
 
  if(m_actionTools.retrieve().isFailure()) {
    ATH_MSG_ERROR("Failed to retrieve ActionTools");
    m_statusSync.Fail("Failed to retrieve ActionTools");
    return;
  }
 
  // Initialize action tools for G4RunTool
  for (const auto& action_tool : m_actionTools) {
    ATH_MSG_INFO("retrieving action tool " + action_tool.name());
    if (m_userActionSvc->addActionTool(action_tool).isFailure()) {
      throw std::runtime_error("Failed to add action tool " + action_tool.name());
    }
  }
  // Set the user action service for the G4UA service
  // Having a ServiceHandle<IG4RunTool> would be a circular dependency which is not supported...
  m_userActionSvc->G4RunTool(this);
 
  // Many of the objects created here must be created in the same thread as the run manager
  runManager.SetUserInitialization(m_detConstruction->GetDetectorConstruction().release());
 
  // The actual physics list object must be created in the same thread as the run manager
  runManager.SetUserInitialization(m_physicsListSvc->GetPhysicsList());
 
  // Set global physics-list options as soon as the list has been created and
  // before any pre-initialization UI commands are applied.
  m_physicsListSvc->SetPhysicsListOptions();
 
  runManager.SetUserInitialization(
    std::make_unique<G4RunToolWorkerThreadInitialization>().release());
  runManager.SetUserInitialization(
    std::make_unique<G4AtlasActionInitialization>(m_userActionSvc.get()).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);
  }
 
  // Initialize run
  runManager.Initialize();
 
  // Process-specific UI commands require the processes to exist first. They
  // are forwarded to the workers with the command stack at the next BeamOn.
  m_physicsListSvc->SetPhysicsProcessOptions();
 
  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());
    }
  }
  // Retrieve core services needed for G4 main thread
  if(m_userLimitsSvc.retrieve().isFailure()) {
    throw std::runtime_error("Could not initialize ATLAS UserLimitsSvc!");
  }
 
  ATH_MSG_INFO("Geant4 initialization done, BeamOn...");
 
  // Repeat BeamOn as long as athena event loop is not finished
  while (!m_statusSync.StopRequested()) {
    runManager.BeamOn(m_nG4eventsPerRun);
  }
}

GetEvent()

auto G4RunTool::GetEvent ( )

overridevirtual

Get an event from the queue (called from Geant4 threads).

Definition at line 100 of file G4RunTool.cxx.

                                    {
  return m_eventQueue.GetEvent();
}

initialize()

StatusCode G4RunTool::initialize ( )

finaloverridevirtual

Initialize and start the Geant4 main thread, then wait until Geant4 is ready to start the run.

Definition at line 25 of file G4RunTool.cxx.

                                 {
 
  // Gaudi will automatically initialize child tools once this tool is initialized.
  // We want these child tools to be initialized in the Geant4 main thread,
  // disable() will tell Gaudi not to initialize them now.
  // Ideally we'd move the initialization that needs to happen in the Geant4 main thread out of initialize
  // and into a separate method called from Geant4main.
  m_detConstruction.disable();
  for(auto& tool : m_actionTools) {
    tool.disable();
  }
 
  m_thread = std::make_unique<std::thread>(&G4RunTool::Geant4main, this);
  ATH_MSG_DEBUG("Geant4main thread created, id=" << m_thread->get_id() << ", now waiting for G4 run manager");
  return StatusCode::SUCCESS;
}

NotifyBeginRun()

void G4RunTool::NotifyBeginRun ( )

overridevirtual

Notify Athena that Geant4 is ready to start a run.

Definition at line 71 of file G4RunTool.cxx.

                               {
  m_statusSync.NotifyBeginRun();
}

PushEvent()

void G4RunTool::PushEvent ( UPEvent ev )

overridevirtual

Definition at line 95 of file G4RunTool.cxx.

                                    {
  m_eventQueue.PushEvent(std::move(ev));
}

Size()

size_t G4RunTool::Size ( ) const

overridevirtual

Definition at line 90 of file G4RunTool.cxx.

                             {
  return m_eventQueue.Size();
}

WaitBeginRun()

StatusCode G4RunTool::WaitBeginRun ( )

overridevirtual

Wait for BeginOfRun, or return failure if the Geant4 thread stops first.

Definition at line 76 of file G4RunTool.cxx.

                                   {
  std::string failureMessage;
  if (!m_statusSync.WaitBeginRun(failureMessage)) {
    ATH_MSG_ERROR("Geant4 failed to start: " << failureMessage);
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_actionTools

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

private

Definition at line 82 of file G4RunTool.h.

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

m_activateParallelGeometries

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

private

Definition at line 85 of file G4RunTool.h.

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

m_detConstruction

ToolHandle<IDetectorConstructionTool> G4RunTool::m_detConstruction {this, "DetectorConstruction", "", "Tool handle of the DetectorConstruction"}

private

Definition at line 81 of file G4RunTool.h.

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

m_eventQueue

G4RunToolEventQueue G4RunTool::m_eventQueue

private

Definition at line 102 of file G4RunTool.h.

m_fieldMap

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

private

Definition at line 89 of file G4RunTool.h.

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

m_g4commands

Gaudi::Property<std::vector<std::string> > G4RunTool::m_g4commands {this, "G4Commands", {}, "Commands to be sent to Geant4 UI at initialization"}

private

Definition at line 90 of file G4RunTool.h.

{this, "G4Commands", {}, "Commands to be sent to Geant4 UI at initialization"};

m_libList

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

private

Definition at line 87 of file G4RunTool.h.

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

m_nG4eventsPerRun

Gaudi::Property<int> G4RunTool::m_nG4eventsPerRun {this, "NG4eventsPerRun", 100000, "Number of G4 events foreseen for each Run"}

private

Definition at line 93 of file G4RunTool.h.

{this, "NG4eventsPerRun", 100000, "Number of G4 events foreseen for each Run"};

m_nG4threads

Gaudi::Property<int> G4RunTool::m_nG4threads {this, "NG4threads", 1, "Number of parallel G4 worker threads to launch"}

private

Definition at line 92 of file G4RunTool.h.

{this, "NG4threads", 1, "Number of parallel G4 worker threads to launch"};

m_physicsInitializationTools

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

private

Definition at line 83 of file G4RunTool.h.

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

m_physicsListSvc

ServiceHandle<IPhysicsListSvc> G4RunTool::m_physicsListSvc {this, "PhysicsListSvc", "PhysicsListSvc"}

private

Definition at line 77 of file G4RunTool.h.

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

m_physList

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

private

Definition at line 88 of file G4RunTool.h.

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

m_statusSync

G4RunToolStateSynchronization G4RunTool::m_statusSync

private

Definition at line 99 of file G4RunTool.h.

m_thread

std::unique_ptr<std::thread> G4RunTool::m_thread

private

Definition at line 96 of file G4RunTool.h.

m_userActionSvc

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

private

Definition at line 79 of file G4RunTool.h.

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

m_userLimitsSvc

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

private

Definition at line 78 of file G4RunTool.h.

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

---

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

• G4RunTool.h
• G4RunTool.cxx