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:

Classes
struct	EventQueueSynchronization
struct	StateSynchronization

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 void	WaitBeginRun () override
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 ()
	Geant4 main thread function, this is executed in a separate thread and blocks on BeamOn.
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
StateSynchronization	m_statusSync
EventQueueSynchronization	m_eventQueueSync

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 235 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 41 of file G4RunTool.cxx.

                              {
  // Signal finalization to G4 threads
  m_statusSync.SetStatus(StateSynchronization::Status::AthenaFinalize);
  
  // G4 worker threads should be waiting for the next event to simulate at this state
  // Pushing empty event, will cause one worker thread to realize we are done and call AbortRun for G4
  for(int i = 0; i < m_nG4threads; ++i) {
    PushEvent(nullptr);
  }
 
  if (m_thread) {
    try {
      if(m_thread->joinable()) m_thread->join();
    }  
    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 ( )

private

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

Definition at line 124 of file G4RunTool.cxx.

                           {
 
  ATH_MSG_INFO("Geant4 main thread starts with id " << std::this_thread::get_id());
  
  // Construct the default run manager
  auto runManager = std::make_unique<G4MTRunManager>();
 
  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");
    return;
  }
 
  if(m_physicsListSvc.retrieve().isFailure()) {
    ATH_MSG_ERROR("Failed to retrieve PhysicsListService");
    return;
  }
 
  if(m_userActionSvc.retrieve().isFailure()) {
    ATH_MSG_ERROR("Failed to retrieve UserActionService");
    return;
  }
 
  if(m_actionTools.retrieve().isFailure()) {
    ATH_MSG_ERROR("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());
 
  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();
 
  m_physicsListSvc->SetPhysicsOptions();
 
  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.m_status != StateSynchronization::Status::AthenaFinalize) {
    runManager->BeamOn(m_nG4eventsPerRun);
  }
 
  // Clean up geometry
  G4GeometryManager::GetInstance()->OpenGeometry();
  G4PhysicalVolumeStore::GetInstance()->Clean();
  ATH_MSG_INFO("Geant4 main thread ended");
}

GetEvent()

auto G4RunTool::GetEvent ( )

overridevirtual

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

Definition at line 110 of file G4RunTool.cxx.

                                    {
 
  std::unique_lock lk(m_eventQueueSync.m_mutex);
  m_eventQueueSync.m_cv.wait(lk, [this]{ return m_eventQueueSync.m_events.size() > 0; });
  UPEvent ev = std::move(m_eventQueueSync.m_events.front());
  m_eventQueueSync.m_events.pop();
  return ev;
}

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 24 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 68 of file G4RunTool.cxx.

                               {
  m_statusSync.SetStatus(StateSynchronization::Status::BeginRun);
}

PushEvent()

void G4RunTool::PushEvent ( UPEvent ev )

overridevirtual

Definition at line 101 of file G4RunTool.cxx.

                                    {
  {
    std::scoped_lock lk(m_eventQueueSync.m_mutex);
    m_eventQueueSync.m_events.push(std::move(ev));
  }
  m_eventQueueSync.m_cv.notify_one();
}

Size()

size_t G4RunTool::Size ( ) const

overridevirtual

Definition at line 95 of file G4RunTool.cxx.

                             {
  std::scoped_lock lk(m_eventQueueSync.m_mutex);
  return m_eventQueueSync.m_events.size();
}

WaitBeginRun()

void G4RunTool::WaitBeginRun ( )

overridevirtual

Definition at line 73 of file G4RunTool.cxx.

                             {
  m_statusSync.WaitStatus(StateSynchronization::Status::BeginRun);
}

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 79 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 82 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 78 of file G4RunTool.h.

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

m_eventQueueSync

EventQueueSynchronization G4RunTool::m_eventQueueSync

private

Definition at line 121 of file G4RunTool.h.

m_fieldMap

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

private

Definition at line 86 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 87 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 84 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 90 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 89 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 80 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 74 of file G4RunTool.h.

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

m_physList

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

private

Definition at line 85 of file G4RunTool.h.

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

m_statusSync

StateSynchronization G4RunTool::m_statusSync

private

Definition at line 118 of file G4RunTool.h.

m_thread

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

private

Definition at line 115 of file G4RunTool.h.

m_userActionSvc

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

private

Definition at line 76 of file G4RunTool.h.

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

m_userLimitsSvc

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

private

Definition at line 75 of file G4RunTool.h.

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

---

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

• G4RunTool.h
• G4RunTool.cxx