G4UA::UserActionSvc Class Reference

A service which manages the user actions for G4 simulation. More...

#include <UserActionSvc.h>

Inheritance diagram for G4UA::UserActionSvc:

Collaboration diagram for G4UA::UserActionSvc:

Public Member Functions
	UserActionSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Standard constructor. More...
StatusCode	initialize () override
	Initialize the service. More...
StatusCode	initializeActionsMaster () override final
	Initialize the user run actions for the main thread. More...
StatusCode	initializeActions () override final
	Initialize the user actions for the current thread. More...
StatusCode	getSecondaryActions (std::vector< G4UserSteppingAction * > &actions) override final
StatusCode	addActionTool (const ToolHandle< IUserActionTool > &service_tool) override final

Private Attributes
Handles to ATLAS action tools
ToolHandleArray< IUserActionTool >	m_userActionTools
	User action tools. More...
ATLAS Geant4 user actions
ThreadActionHolder< G4AtlasRunAction >	m_runActions
	Thread-local run action. More...
ThreadActionHolder< G4AtlasPrimaryGeneratorAction >	m_primaryGeneratorActions
	Thread-local primary generator action. More...
ThreadActionHolder< G4AtlasEventAction >	m_eventActions
	Thread-local event action. More...
ThreadActionHolder< G4AtlasStackingAction >	m_stackingActions
	Thread-local stacking action. More...
ThreadActionHolder< G4AtlasTrackingAction >	m_trackingActions
	Thread-local tracking action. More...
ThreadActionHolder< G4AtlasSteppingAction >	m_steppingActions
	Thread-local stepping action. More...

Detailed Description

A service which manages the user actions for G4 simulation.

Author

Steve Farrell Steve.nosp@m.n.Fa.nosp@m.rrell.nosp@m.@cer.nosp@m.n.ch

Definition at line 36 of file UserActionSvc.h.

Constructor & Destructor Documentation

UserActionSvc()

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

Standard constructor.

Definition at line 23 of file UserActionSvc.cxx.

    : base_class(name, pSvcLocator)
    , m_userActionTools(this)
  {
    declareProperty("UserActionTools", m_userActionTools);
  }

Member Function Documentation

addActionTool()

StatusCode G4UA::UserActionSvc::addActionTool ( const ToolHandle< IUserActionTool > &  service_tool )

finaloverride

Definition at line 46 of file UserActionSvc.cxx.

                                                                                        {
    
    if (!service_tool.isPublic()){
        ATH_MSG_FATAL("Only public tools are allowed");
        return StatusCode::FAILURE;
    }
    if (service_tool.empty()) {
      ATH_MSG_FATAL("NO point in adding empty tool handles here.");
      return StatusCode::FAILURE;
    }
    ATH_MSG_INFO(" Add new tool "<<service_tool.name());
    m_userActionTools.push_back(service_tool);
    return StatusCode::SUCCESS;
  }

getSecondaryActions()

StatusCode G4UA::UserActionSvc::getSecondaryActions ( std::vector< G4UserSteppingAction * > &  actions )

finaloverride

Definition at line 211 of file UserActionSvc.cxx.

                                                                                             {
 
    // Only stepping actions can return secondaries? Maybe turn this into a templated method
    actions = m_steppingActions.get()->getActions();
 
    return StatusCode::SUCCESS;
  }

initialize()

StatusCode G4UA::UserActionSvc::initialize ( )

override

Initialize the service.

Definition at line 34 of file UserActionSvc.cxx.

  {
    ATH_MSG_INFO("Initializing " << m_userActionTools.size() << " user action tools.");
 
    for(const auto& action : m_userActionTools) {
      ATH_MSG_INFO( "      -> " << action.name() );
    }
 
    ATH_CHECK( m_userActionTools.retrieve() );
 
    return StatusCode::SUCCESS;
  }

initializeActions()

StatusCode G4UA::UserActionSvc::initializeActions ( )

finaloverride

Initialize the user actions for the current thread.

Definition at line 87 of file UserActionSvc.cxx.

  {
    // This method is called concurrently in AthenaMT during initialization.
    // We conservatively just lock the whole thing to protect MsgStream and
    // downstream code.
    static std::mutex userActionMutex;
    std::lock_guard<std::mutex> userActionLock(userActionMutex);
 
    ATH_MSG_DEBUG("initializeActions");
 
    // sanity check: this is to make sure there are no other instances of this
    // svc that have been already initialized, or that nobody else in some other
    // code has already been registering actions to the run manager, which would
    // be a major error in the configuration checking the run action is probably
    // enough fo multiple instances of this service, since all roles are usually
    // set at the same time. but other code may as well have registered just one
    // role, so it is safer to do all checks here.
 
    if( G4RunManager::GetRunManager()->GetUserRunAction() ||
        G4RunManager::GetRunManager()->GetUserPrimaryGeneratorAction() ||
        G4RunManager::GetRunManager()->GetUserEventAction() ||
        G4RunManager::GetRunManager()->GetUserStackingAction() ||
        G4RunManager::GetRunManager()->GetUserTrackingAction() ||
        G4RunManager::GetRunManager()->GetUserSteppingAction() )
    {
      ATH_MSG_FATAL("UserActionSvc has found that actions were already " <<
                    "registered to the G4RunManager. Check your code/configuration");
      return StatusCode::FAILURE;
    }
 
    // Retrieve the new user actions
    G4AtlasUserActions actions;
    for(auto& tool : m_userActionTools) {
      ATH_CHECK( tool->fillUserAction(actions) );
    }
 
    // Initialize the ATLAS run action.
    if(m_runActions.get()) {
      ATH_MSG_ERROR("Run action already exists for current thread!");
      return StatusCode::FAILURE;
    }
    auto runAction = std::make_unique<G4AtlasRunAction>();
    // Assign run plugins
    for(auto* action : actions.runActions)
      runAction->addRunAction(action);
    G4RunManager::GetRunManager()->SetUserAction( runAction.get() );
    m_runActions.set( std::move(runAction) );
 
    // Initialize the ATLAS primary generator action.
    if(m_primaryGeneratorActions.get()) {
      ATH_MSG_ERROR("Primary generator action already exists for current thread!");
      return StatusCode::FAILURE;
    }
    auto primaryGeneratorAction = std::make_unique<G4AtlasPrimaryGeneratorAction>();
    // Assign run plugins
    for(auto* action : actions.primaryGeneratorActions)
      primaryGeneratorAction->addPrimaryGeneratorAction(action);
    G4RunManager::GetRunManager()->SetUserAction( primaryGeneratorAction.get() );
    m_primaryGeneratorActions.set( std::move(primaryGeneratorAction) );
 
    // Initialize the ATLAS event action.
    if(m_eventActions.get()) {
      ATH_MSG_ERROR("Event action already exists for current thread!");
      return StatusCode::FAILURE;
    }
    auto eventAction = std::make_unique<G4AtlasEventAction>();
    // Assign event plugins
    for(auto* action : actions.eventActions) {
      eventAction->addEventAction(action);
      // set the event manager
      action->SetEventManager( G4EventManager::GetEventManager() );
    }
    G4RunManager::GetRunManager()->SetUserAction( eventAction.get() );
    m_eventActions.set( std::move(eventAction) );
 
    // Initialize the ATLAS stacking action.
    if(m_stackingActions.get()) {
      ATH_MSG_ERROR("Stacking action already exists for current thread!");
      return StatusCode::FAILURE;
    }
    auto stackAction = std::make_unique<G4AtlasStackingAction>();
    // Assign stacking plugins
    for(auto* action : actions.stackingActions) {
      stackAction->addAction(action);
      // set the stack manager
      action->SetStackManager( G4EventManager::GetEventManager()->GetStackManager() );
    }
    G4RunManager::GetRunManager()->SetUserAction( stackAction.get() );
    m_stackingActions.set( std::move(stackAction) );
 
    // Initialize the ATLAS tracking action.
    if(m_trackingActions.get()) {
      ATH_MSG_ERROR("Tracking action already exists for current thread!");
      return StatusCode::FAILURE;
    }
    auto trackAction = std::make_unique<G4AtlasTrackingAction>();
    // Assign tracking plugins
    for(auto* action : actions.trackingActions) {
      trackAction->addTrackAction(action);
      // set the tracking manager
      action->SetTrackingManagerPointer ( G4EventManager::GetEventManager()->GetTrackingManager() );
    }
    G4RunManager::GetRunManager()->SetUserAction( trackAction.get() );
    m_trackingActions.set( std::move(trackAction) );
 
    // Initialize the ATLAS stepping action.
    if(m_steppingActions.get()) {
      ATH_MSG_ERROR("Stepping action already exists for current thread!");
      return StatusCode::FAILURE;
    }
    auto stepAction = std::make_unique<G4AtlasSteppingAction>();
    // Assign stepping plugins
    for(auto* action : actions.steppingActions) {
      stepAction->addAction(action);
      // set the stepping manager
      action->SetSteppingManagerPointer( G4EventManager::GetEventManager()->GetTrackingManager()->GetSteppingManager() );
    }
    G4RunManager::GetRunManager()->SetUserAction( stepAction.get() );
    m_steppingActions.set( std::move(stepAction) );
 
    return StatusCode::SUCCESS;
  }

initializeActionsMaster()

StatusCode G4UA::UserActionSvc::initializeActionsMaster ( )

finaloverride

Initialize the user run actions for the main thread.

Definition at line 64 of file UserActionSvc.cxx.

  {
    // Retrieve the new user actions
    G4AtlasUserActions actions;
    for(auto& tool : m_userActionTools) {
      ATH_CHECK( tool->fillUserAction(actions) );
    }
    auto runAction = std::make_unique<G4AtlasRunAction>();
    // Assign run plugins
    for(auto* action : actions.runActionsMaster)
    {
        runAction->addRunAction(action);
    }
    G4RunManager::GetRunManager()->SetUserAction( runAction.release() );
    return StatusCode::SUCCESS;
  }

Member Data Documentation

m_eventActions

ThreadActionHolder<G4AtlasEventAction> G4UA::UserActionSvc::m_eventActions

private

Thread-local event action.

Definition at line 74 of file UserActionSvc.h.

m_primaryGeneratorActions

ThreadActionHolder<G4AtlasPrimaryGeneratorAction> G4UA::UserActionSvc::m_primaryGeneratorActions

private

Thread-local primary generator action.

Definition at line 72 of file UserActionSvc.h.

m_runActions

ThreadActionHolder<G4AtlasRunAction> G4UA::UserActionSvc::m_runActions

private

Thread-local run action.

Definition at line 70 of file UserActionSvc.h.

m_stackingActions

ThreadActionHolder<G4AtlasStackingAction> G4UA::UserActionSvc::m_stackingActions

private

Thread-local stacking action.

Definition at line 76 of file UserActionSvc.h.

m_steppingActions

ThreadActionHolder<G4AtlasSteppingAction> G4UA::UserActionSvc::m_steppingActions

private

Thread-local stepping action.

Definition at line 80 of file UserActionSvc.h.

m_trackingActions

ThreadActionHolder<G4AtlasTrackingAction> G4UA::UserActionSvc::m_trackingActions

private

Thread-local tracking action.

Definition at line 78 of file UserActionSvc.h.

m_userActionTools

ToolHandleArray<IUserActionTool> G4UA::UserActionSvc::m_userActionTools

private

User action tools.

Definition at line 62 of file UserActionSvc.h.

---

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

• UserActionSvc.h
• UserActionSvc.cxx