ATLAS custom singleton run manager. More...

#include <G4AtlasRunManager.h>

Inheritance diagram for G4AtlasRunManager:

Collaboration diagram for G4AtlasRunManager:

Public Member Functions
virtual	~G4AtlasRunManager ()

bool	ProcessEvent (G4Event *event)
	Does the work of simulating an ATLAS event. More...

void	RunTermination () override final
	G4 function called at end of run. More...

void	SetDetGeoSvc (const std::string &typeAndName)
	Configure the detector geometry service handle. More...

void	SetFastSimMasterTool (const std::string &typeAndName)
	Configure the Fast Simulation Master Tool handle. More...

void	SetPhysListSvc (const std::string &typeAndName)
	Configure the Physics List Tool handle. More...

void	SetRecordFlux (bool b, std::unique_ptr< IFluxRecorder > f)

void	SetLogLevel (int)

void	SetVolumeSmartlessLevel (const std::map< std::string, double > &nameAndValue)

void	SetQuietMode (bool quietMode)
	Configure the QuietMode option. More...

bool	msgLvl (const MSG::Level lvl) const
	Test the output level. More...

MsgStream &	msg () const
	The standard message stream. More...

MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream. More...

void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Static Public Member Functions
static G4AtlasRunManager *GetG4AtlasRunManager	ATLAS_NOT_THREAD_SAFE ()
	Retrieve the singleton instance. More...

Protected Member Functions
Overridden G4 init methods for customization
void	Initialize () override final

void	InitializeGeometry () override final

void	InitializePhysics () override final

Private Member Functions
	G4AtlasRunManager ()
	Pure singleton private constructor. More...

void	EndEvent ()

void	initMessaging () const
	Initialize our message level and MessageSvc. More...

Private Attributes
bool	m_recordFlux

ToolHandle< IFastSimulationMasterTool >	m_fastSimTool

ServiceHandle< IPhysicsListSvc >	m_physListSvc

ServiceHandle< IDetectorGeometrySvc >	m_detGeoSvc

std::unique_ptr< IFluxRecorder >	m_fluxRecorder
	Interface to flux recording. More...

std::map< std::string, double >	m_volumeSmartlessLevel

bool	m_quietMode {true}
	Quiet Mode for production. More...

std::string	m_nm
	Message source name. More...

boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...

std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...

std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...

std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

Detailed Description

ATLAS custom singleton run manager.

This is the run manager used for serial (not-MT) jobs.

Todo:: sync and reduce code duplication with MT run managers.

Definition at line 30 of file G4AtlasRunManager.h.

Constructor & Destructor Documentation

◆ ~G4AtlasRunManager()

virtual G4AtlasRunManager::~G4AtlasRunManager ( )

inlinevirtual

Definition at line 34 of file G4AtlasRunManager.h.

34 {}

◆ G4AtlasRunManager()

G4AtlasRunManager::G4AtlasRunManager ( )

private

Pure singleton private constructor.

Definition at line 22 of file G4AtlasRunManager.cxx.

   : G4RunManager()
   , AthMessaging("G4AtlasRunManager")
   , m_recordFlux(false)
   , m_fastSimTool("FastSimulationMasterTool")
   , m_physListSvc("PhysicsListSvc", "G4AtlasRunManager")
   , m_detGeoSvc("DetectorGeometrySvc", "G4AtlasRunManager")
   , m_volumeSmartlessLevel({})
 {  }

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

static G4AtlasRunManager* GetG4AtlasRunManager G4AtlasRunManager::ATLAS_NOT_THREAD_SAFE ( )

static

Retrieve the singleton instance.

◆ EndEvent()

void G4AtlasRunManager::EndEvent ( )

private

Definition at line 74 of file G4AtlasRunManager.cxx.

 {
   ATH_MSG_DEBUG( "G4AtlasRunManager::EndEvent" );
 }

◆ Initialize()

void G4AtlasRunManager::Initialize ( )

finaloverrideprotected

Definition at line 41 of file G4AtlasRunManager.cxx.

 {
   // ADA 11/28.2018: switch initialization order to meet ISF requirements
   // Call the base class Initialize method. This will call
   // InitializeGeometry and InitializePhysics.
   if (m_quietMode) { SetVerboseLevel(0); } // HACK
   G4RunManager::Initialize();
 }

◆ InitializeGeometry()

void G4AtlasRunManager::InitializeGeometry ( )

finaloverrideprotected

Definition at line 51 of file G4AtlasRunManager.cxx.

 {
   ATH_MSG_DEBUG( "InitializeGeometry()" );
   if (m_detGeoSvc.retrieve().isFailure()) {
     ATH_MSG_ERROR ( "Could not retrieve the DetectorGeometrySvc" );
     G4ExceptionDescription description;
     description << "InitializeGeometry: Failed to retrieve IDetectorGeometrySvc.";
     G4Exception("G4AtlasRunManager", "CouldNotRetrieveDetGeoSvc", FatalException, description);
     abort(); // to keep Coverity happy
   }
  
   // Create/assign detector construction
   G4RunManager::SetUserInitialization(m_detGeoSvc->GetDetectorConstruction());
   if (userDetector) {
     G4RunManager::InitializeGeometry();
   }
   else {
     ATH_MSG_WARNING( " User Detector not set!!! Geometry NOT initialized!!!" );
   }
   return;
 }

◆ InitializePhysics()

void G4AtlasRunManager::InitializePhysics ( )

finaloverrideprotected

Definition at line 80 of file G4AtlasRunManager.cxx.

 {
   ATH_MSG_INFO( "InitializePhysics()" );
   kernel->InitializePhysics();
   physicsInitialized = true;
  
   // Grab the physics list tool and set the extra options
   if (m_physListSvc.retrieve().isFailure()) {
     ATH_MSG_ERROR ( "Could not retrieve the physics list tool" );
     G4ExceptionDescription description;
     description << "InitializePhysics: Failed to retrieve IPhysicsListSvc.";
     G4Exception("G4AtlasRunManager", "CouldNotRetrievePLTool", FatalException, description);
     abort(); // to keep Coverity happy
   }
   m_physListSvc->SetPhysicsOptions();
  
   // Fast simulations last
   if (m_fastSimTool.retrieve().isFailure()) {
     ATH_MSG_ERROR ( "Could not retrieve the FastSim master tool" );
     G4ExceptionDescription description;
     description << "InitializePhysics: Failed to retrieve IFastSimulationMasterTool.";
     G4Exception("G4AtlasRunManager", "CouldNotRetrieveFastSimMaster", FatalException, description);
     abort(); // to keep Coverity happy
   }
   if(m_fastSimTool->initializeFastSims().isFailure()) {
     G4ExceptionDescription description;
     description << "InitializePhysics: Call to IFastSimulationMasterTool::initializeFastSims failed.";
     G4Exception("G4AtlasRunManager", "FailedToInitializeFastSims", FatalException, description);
     abort(); // to keep Coverity happy
   }
  
   if (m_recordFlux) {
     m_fluxRecorder->InitializeFluxRecording();
   }
  
   return;
 }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

 {
   m_imsg = Athena::getMessageSvc();
   m_lvl = m_imsg ?
     static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
     MSG::INFO;
 }

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 164 of file AthMessaging.h.

 {
   MsgStream* ms = m_msg_tls.get();
   if (!ms) {
     if (!m_initialized.test_and_set()) initMessaging();
     ms = new MsgStream(m_imsg,m_nm);
     m_msg_tls.reset( ms );
   }
  
   ms->setLevel (m_lvl);
   return *ms;
 }

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 179 of file AthMessaging.h.

180 { return msg() << lvl; }

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns: boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

 {
   if (!m_initialized.test_and_set()) initMessaging();
   if (m_lvl <= lvl) {
     msg() << lvl;
     return true;
   } else {
     return false;
   }
 }

◆ ProcessEvent()

bool G4AtlasRunManager::ProcessEvent ( G4Event * event )

Does the work of simulating an ATLAS event.

Definition at line 118 of file G4AtlasRunManager.cxx.

 {
  
   G4StateManager* stateManager = G4StateManager::GetStateManager();
   stateManager->SetNewState(G4State_GeomClosed);
  
   currentEvent = event;
  
   eventManager->ProcessOneEvent(currentEvent);
   if (currentEvent->IsAborted()) {
     ATH_MSG_WARNING( "G4AtlasRunManager::ProcessEvent: Event Aborted at Detector Simulation level" );
     currentEvent = nullptr;
     return true;
   }
  
   if (m_recordFlux) { m_fluxRecorder->RecordFlux(currentEvent); }
  
   this->StackPreviousEvent(currentEvent);
   bool abort = currentEvent->IsAborted();
   currentEvent = nullptr;
  
   return abort;
 }

◆ RunTermination()

void G4AtlasRunManager::RunTermination ( )

finaloverride

G4 function called at end of run.

Definition at line 142 of file G4AtlasRunManager.cxx.

 {
   ATH_MSG_DEBUG( " G4AtlasRunManager::RunTermination() " );
   if (m_recordFlux) {
     m_fluxRecorder->WriteFluxInformation();
   }
   
   this->CleanUpPreviousEvents();
   previousEvents->clear();
  
   if (userRunAction) {
     userRunAction->EndOfRunAction(currentRun);
   }
  
   delete currentRun;
   currentRun = nullptr;
   runIDCounter++;
  
   ATH_MSG_VERBOSE( "Changing the state..." );
   G4StateManager* stateManager = G4StateManager::GetStateManager();
   stateManager->SetNewState(G4State_Idle);
  
   ATH_MSG_VERBOSE( "Opening the geometry back up" );
   G4GeometryManager::GetInstance()->OpenGeometry();
  
   ATH_MSG_VERBOSE( "Terminating the run...  State is " << stateManager->GetStateString( stateManager->GetCurrentState() ) );
   kernel->RunTermination();
   ATH_MSG_VERBOSE( "All done..." );
  
   userRunAction = nullptr;
   userEventAction = nullptr;
   userSteppingAction = nullptr;
   userStackingAction = nullptr;
   userTrackingAction = nullptr;
   userDetector = nullptr;
   userPrimaryGeneratorAction = nullptr;
  
   return;
 }

◆ SetDetGeoSvc()

void G4AtlasRunManager::SetDetGeoSvc ( const std::string & typeAndName )

inline

Configure the detector geometry service handle.

Definition at line 46 of file G4AtlasRunManager.h.

                                                   {
     m_detGeoSvc.setTypeAndName(typeAndName);
   }

◆ SetFastSimMasterTool()

void G4AtlasRunManager::SetFastSimMasterTool ( const std::string & typeAndName )

inline

Configure the Fast Simulation Master Tool handle.

Definition at line 51 of file G4AtlasRunManager.h.

                                                           {
     m_fastSimTool.setTypeAndName(typeAndName);
   }

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

 {
   m_lvl = lvl;
 }

◆ SetLogLevel()

void G4AtlasRunManager::SetLogLevel ( int )

inline

Definition at line 61 of file G4AtlasRunManager.h.

61 { /* Not implemented */ }

◆ SetPhysListSvc()

void G4AtlasRunManager::SetPhysListSvc ( const std::string & typeAndName )

inline

Configure the Physics List Tool handle.

Definition at line 56 of file G4AtlasRunManager.h.

                                                     {
     m_physListSvc.setTypeAndName(typeAndName);
   }

◆ SetQuietMode()

void G4AtlasRunManager::SetQuietMode ( bool quietMode )

inline

Configure the QuietMode option.

Definition at line 68 of file G4AtlasRunManager.h.

                                     {
     m_quietMode = quietMode;
   }

◆ SetRecordFlux()

void G4AtlasRunManager::SetRecordFlux	(	bool	b,
		std::unique_ptr< IFluxRecorder >	f
	)

inline

Definition at line 60 of file G4AtlasRunManager.h.

60 { m_recordFlux = b; m_fluxRecorder=std::move(f);}

◆ SetVolumeSmartlessLevel()

void G4AtlasRunManager::SetVolumeSmartlessLevel ( const std::map< std::string, double > & nameAndValue )

inline

Definition at line 63 of file G4AtlasRunManager.h.

                                                                             {
     m_volumeSmartlessLevel = nameAndValue;
   }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_detGeoSvc

ServiceHandle<IDetectorGeometrySvc> G4AtlasRunManager::m_detGeoSvc

private

Definition at line 93 of file G4AtlasRunManager.h.

◆ m_fastSimTool

ToolHandle<IFastSimulationMasterTool> G4AtlasRunManager::m_fastSimTool

private

Definition at line 90 of file G4AtlasRunManager.h.

◆ m_fluxRecorder

std::unique_ptr<IFluxRecorder> G4AtlasRunManager::m_fluxRecorder

private

Interface to flux recording.

Definition at line 97 of file G4AtlasRunManager.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_physListSvc

ServiceHandle<IPhysicsListSvc> G4AtlasRunManager::m_physListSvc

private

Definition at line 91 of file G4AtlasRunManager.h.

◆ m_quietMode

bool G4AtlasRunManager::m_quietMode {true}

private

Quiet Mode for production.

Definition at line 104 of file G4AtlasRunManager.h.

◆ m_recordFlux

bool G4AtlasRunManager::m_recordFlux

private

Definition at line 88 of file G4AtlasRunManager.h.

◆ m_volumeSmartlessLevel

std::map<std::string, double> G4AtlasRunManager::m_volumeSmartlessLevel

private

Definition at line 101 of file G4AtlasRunManager.h.

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ~G4AtlasRunManager()

◆ G4AtlasRunManager()

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

◆ EndEvent()

◆ Initialize()

◆ InitializeGeometry()

◆ InitializePhysics()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ ProcessEvent()

◆ RunTermination()

◆ SetDetGeoSvc()

◆ SetFastSimMasterTool()

◆ setLevel()

◆ SetLogLevel()

◆ SetPhysListSvc()

◆ SetQuietMode()

◆ SetRecordFlux()

◆ SetVolumeSmartlessLevel()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_detGeoSvc

◆ m_fastSimTool

◆ m_fluxRecorder

◆ m_imsg

◆ m_lvl

◆ m_msg_tls

◆ m_nm

◆ m_physListSvc

◆ m_quietMode

◆ m_recordFlux

◆ m_volumeSmartlessLevel