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	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< 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 35 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 178 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 67 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()->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 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;
  }

Member Data Documentation

m_eventActions

ThreadActionHolder<G4AtlasEventAction> G4UA::UserActionSvc::m_eventActions

private

Thread-local event action.

Definition at line 68 of file UserActionSvc.h.

m_runActions

ThreadActionHolder<G4AtlasRunAction> G4UA::UserActionSvc::m_runActions

private

Thread-local run action.

Definition at line 66 of file UserActionSvc.h.

m_stackingActions

ThreadActionHolder<G4AtlasStackingAction> G4UA::UserActionSvc::m_stackingActions

private

Thread-local stacking action.

Definition at line 70 of file UserActionSvc.h.

m_steppingActions

ThreadActionHolder<G4AtlasSteppingAction> G4UA::UserActionSvc::m_steppingActions

private

Thread-local stepping action.

Definition at line 74 of file UserActionSvc.h.

m_trackingActions

ThreadActionHolder<G4AtlasTrackingAction> G4UA::UserActionSvc::m_trackingActions

private

Thread-local tracking action.

Definition at line 72 of file UserActionSvc.h.

m_userActionTools

ToolHandleArray<IUserActionTool> G4UA::UserActionSvc::m_userActionTools

private

User action tools.

Definition at line 58 of file UserActionSvc.h.

---

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

• UserActionSvc.h
• UserActionSvc.cxx