G4AtlasAlg Class Reference

Primary Athena algorithm for ATLAS simulation. More...

#include <G4AtlasAlg.h>

Inheritance diagram for G4AtlasAlg:

Collaboration diagram for G4AtlasAlg:

Public Member Functions
	G4AtlasAlg (const std::string &name, ISvcLocator *pSvcLocator)
	Standard algorithm constructor. More...
virtual	~G4AtlasAlg ()
	Virtual destructor. More...
bool	isClonable () const override
	this Alg is Clonable (for AthenaMT) More...
StatusCode initialize	ATLAS_NOT_THREAD_SAFE () override
	Initialize the algorithm. More...
StatusCode	finalize () override
	Finalize the algorithm and invoke G4 run termination. More...
StatusCode	execute () override
	Simulate one Athena event. More...
void	initializeG4 ()
	Poorly named possibly unused method which sets some verbosities. More...
void	initializeOnce ()
	G4 initialization called only by the first alg instance. More...
void	finalizeOnce ()
	G4 finalization called only by the first alg instance. More...
virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	commandLog (int returnCode, const std::string &commandString) const
	This command prints a message about a G4Command depending on its returnCode. More...
void	releaseGeoModel ()
	Releases the GeoModel geometry from memory once it has been used to build the G4 geometry and is no-longer required. More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
PublicToolHandleArray< G4UA::IUserActionTool >	m_actionTools {this, "UserActionTools", {}, "User action tools to be added to the G4 Action service."}
Gaudi::Property< std::string >	m_simplifiedGeoPath {this, "SimplifiedGeoPath", "", "Path to the simplified geometry file used to transport particles"}
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared
Configurable Properties
Gaudi::Property< bool >	m_killAbortedEvents {this, "KillAbortedEvents", false, ""}
Gaudi::Property< bool >	m_flagAbortedEvents {this, "FlagAbortedEvents", false, ""}
SG::ReadHandleKey< McEventCollection >	m_inputTruthCollectionKey {this, "InputTruthCollection", "BeamTruthEvent", "Input hard scatter collection"}
	input hard scatter collection More...
SG::WriteHandleKey< McEventCollection >	m_outputTruthCollectionKey {this, "OutputTruthCollection", "TruthEvent", "Output hard scatter truth collection"}
	output hard scatter truth collection More...
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey {this, "EventInfo", "EventInfo", "EventInfo key"}
ServiceHandle< ISF::ITruthSvc >	m_truthRecordSvc {this, "TruthRecordService", "ISF_TruthRecordSvc", ""}
	Central Truth Service. More...
ServiceHandle< ISF::IGeoIDSvc >	m_geoIDSvc {this, "GeoIDSvc", "ISF_GeoIDSvc", ""}
	Geo ID Service. More...
std::map< std::string, std::string >	m_verbosities
	Verbosity settings for Geant4. More...
Configurable Properties (common with TransportTool)
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::string >	m_rndmGen {this, "RandomGenerator", "athena", ""}
Gaudi::Property< bool >	m_releaseGeoModel {this, "ReleaseGeoModel", true, ""}
Gaudi::Property< bool >	m_recordFlux {this, "RecordFlux", false, ""}
Gaudi::Property< bool >	m_quietMode {this, "QuietMode", false, ""}
Gaudi::Property< std::vector< std::string > >	m_g4commands {this, "G4Commands", {}, "Commands to send to the G4UI"}
	Commands to send to the G4 UI. More...
Gaudi::Property< bool >	m_useMT {this,"MultiThreading", false, "Multi-threading specific settings"}
	Activate multi-threading configuration. More...
Gaudi::Property< bool >	m_activateParallelGeometries {this, "ActivateParallelWorlds", false, "Toggle on/off the G4 parallel geometry system"}
BooleanProperty	m_useShadowEvent {this, "UseShadowEvent", false, "New approach to selecting particles for simulation" }
ServiceHandle< IAthRNGSvc >	m_rndmGenSvc {this, "AtRndmGenSvc", "AthRNGSvc", ""}
	Random number service. More...
Gaudi::Property< std::string >	m_randomStreamName {this, "RandomStreamName", "Geant4", ""}
	Random Stream Name. More...
ServiceHandle< IUserLimitsSvc >	m_userLimitsSvc {this, "UserLimitsSvc", "UserLimitsSvc", ""}
ServiceHandle< G4UA::IUserActionSvc >	m_userActionSvc {this, "UserActionSvc", "G4UA::UserActionSvc", ""}
	User Action Service. More...
ServiceHandle< IDetectorGeometrySvc >	m_detGeoSvc {this, "DetGeoSvc", "DetectorGeometrySvc", ""}
	Detector Geometry Service (builds G4 Geometry) More...
ServiceHandle< Simulation::IZeroLifetimePatcher >	m_qspatcher {this, "QuasiStablePatcher", "", "Quasi-Stable Particle Simulation Patcher"}
	Quasi-Stable Particle Simulation Patcher. More...
ToolHandle< ISF::IGenEventFilter >	m_truthPreselectionTool {this, "TruthPreselectionTool", "", "Tool for filtering out quasi-stable particle daughters"}
ServiceHandle< ISF::IInputConverter >	m_inputConverter {this, "InputConverter", "ISF_InputConverter", ""}
	Service to convert ISF_Particles into a G4Event. More...
ServiceHandle< IPhysicsListSvc >	m_physListSvc {this, "PhysicsListSvc", "PhysicsListSvc", ""}
	Physics List Tool. More...
PublicToolHandle< ISensitiveDetectorMasterTool >	m_senDetTool {this, "SenDetMasterTool", "SensitiveDetectorMasterTool", ""}
	Sensitive Detector Master Tool. More...
PublicToolHandle< IFastSimulationMasterTool >	m_fastSimTool {this, "FastSimMasterTool", "FastSimulationMasterTool", ""}
	Fast Simulation Master Tool. More...

Detailed Description

Primary Athena algorithm for ATLAS simulation.

During initialization, this class sets up several things, including:

• the ATLAS (master) run manager
• physics list assignment to G4
• detector construction (currently FADS::FadsDetectorConstruction)

During the event loop, it handles processing of the event by invoking the (worker) run manager.

Definition at line 52 of file G4AtlasAlg.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

G4AtlasAlg()

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

Standard algorithm constructor.

Definition at line 57 of file G4AtlasAlg.cxx.

  : AthAlgorithm(name, pSvcLocator)
{
  // Verbosities
  declareProperty("Verbosities", m_verbosities);
}

~G4AtlasAlg()

virtual G4AtlasAlg::~G4AtlasAlg ( )

inlinevirtual

Virtual destructor.

Definition at line 61 of file G4AtlasAlg.h.

{  };

Member Function Documentation

ATLAS_NOT_THREAD_SAFE()

StatusCode initialize G4AtlasAlg::ATLAS_NOT_THREAD_SAFE ( )

override

Initialize the algorithm.

Here we setup several things for simulation, including:

• force intialization of the UserActionSvc
• apply custom G4 UI commands (like custom physics list)
• configure the particle generator and random generator svc

commandLog()

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

private

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

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

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                 {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode G4AtlasAlg::execute ( )

override

Simulate one Athena event.

Definition at line 312 of file G4AtlasAlg.cxx.

{
  static std::atomic<unsigned int> n_Event=0;
  ATH_MSG_DEBUG("++++++++++++  G4AtlasAlg execute  ++++++++++++");
 
#ifdef G4MULTITHREADED
  // In some rare cases, TBB may create more physical worker threads than
  // were requested via the pool size.  This can happen at any time.
  // In that case, those extra threads will not have had the thread-local
  // initialization done, leading to a crash.  Try to detect that and do
  // the initialization now if needed.
  if (G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking()->GetWorldVolume() == nullptr)
  {
    ToolHandle<IThreadInitTool> ti ("G4ThreadInitTool", nullptr);
    ATH_CHECK( ti.retrieve() );
    ti->initThread();
  }
#endif
 
  n_Event += 1;
 
  if (n_Event<=10 || (n_Event%100) == 0) {
    ATH_MSG_ALWAYS("G4AtlasAlg: Event num. "  << n_Event << " start processing");
  }
 
  // Release GeoModel Geometry if necessary
  if (m_releaseGeoModel) {
    try {
      std::call_once(releaseGeoModelOnceFlag, &G4AtlasAlg::releaseGeoModel, this);
    }
    catch(const std::exception& e) {
      ATH_MSG_ERROR("Failure in G4AtlasAlg::releaseGeoModel: " << e.what());
      return StatusCode::FAILURE;
    }
  }
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  // Set the RNG to use for this event. We need to reset it for MT jobs
  // because of the mismatch between Gaudi slot-local and G4 thread-local RNG.
  ATHRNG::RNGWrapper* rngWrapper = m_rndmGenSvc->getEngine(this, m_randomStreamName);
  rngWrapper->setSeed( m_randomStreamName,  ctx);
  G4Random::setTheEngine(*rngWrapper);
 
  ATH_MSG_DEBUG("Calling SimulateG4Event");
 
  ATH_CHECK(m_senDetTool->BeginOfAthenaEvent());
  ATH_CHECK(m_fastSimTool->BeginOfAthenaEvent());
 
  SG::ReadHandle<McEventCollection> inputTruthCollection(m_inputTruthCollectionKey);
  if (!inputTruthCollection.isValid()) {
    ATH_MSG_FATAL("Unable to read input GenEvent collection " << inputTruthCollection.name() << " in store " << inputTruthCollection.store());
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Found input GenEvent collection " << inputTruthCollection.name() << " in store " << inputTruthCollection.store());
  // create the output Truth collection
  SG::WriteHandle<McEventCollection> outputTruthCollection(m_outputTruthCollectionKey);
  std::unique_ptr<McEventCollection> shadowTruth{};
  if (m_useShadowEvent) {
    outputTruthCollection = std::make_unique<McEventCollection>();
    // copy input Evgen collection to shadow Truth collection
    shadowTruth = std::make_unique<McEventCollection>(*inputTruthCollection);
    for (HepMC::GenEvent* currentGenEvent : *shadowTruth ) {
      // Apply QS patch if required
      if ( not m_qspatcher.empty() ) {
        ATH_CHECK(m_qspatcher->applyWorkaround(*currentGenEvent));
      }
      // Copy GenEvent and remove daughters of quasi-stable particles to be simulated
      std::unique_ptr<HepMC::GenEvent> outputEvent = m_truthPreselectionTool->filterGenEvent(*currentGenEvent);
      outputTruthCollection->push_back(outputEvent.release());
    }
  }
  else {
    // copy input Evgen collection to output Truth collection
    outputTruthCollection = std::make_unique<McEventCollection>(*inputTruthCollection);
    // empty shadow Truth collection
    shadowTruth = std::make_unique<McEventCollection>();
    // Apply QS patch if required
    if ( not m_qspatcher.empty() ) {
      for (HepMC::GenEvent* currentGenEvent : *outputTruthCollection ) {
        ATH_CHECK(m_qspatcher->applyWorkaround(*currentGenEvent));
      }
    }
  }
 
  ATH_MSG_DEBUG("Recorded output GenEvent collection " << outputTruthCollection.name() << " in store " << outputTruthCollection.store());
 
  const int largestGeneratedParticleBC =  (outputTruthCollection->empty()) ? HepMC::UNDEFINED_ID
    : HepMC::maxGeneratedParticleBarcode(outputTruthCollection->at(0)); // TODO make this more robust
  const int largestGeneratedVertexBC =  (outputTruthCollection->empty()) ? HepMC::UNDEFINED_ID
    : HepMC::maxGeneratedVertexBarcode(outputTruthCollection->at(0)); // TODO make this more robust
  // tell TruthService we're starting a new event
  ATH_CHECK( m_truthRecordSvc->initializeTruthCollection(largestGeneratedParticleBC, largestGeneratedVertexBC) );
 
  G4Event *inputEvent{};
  ATH_CHECK( m_inputConverter->convertHepMCToG4Event(ctx, *outputTruthCollection, inputEvent, *shadowTruth) );
 
  bool abort = false;
  // Worker run manager
  // Custom class has custom method call: ProcessEvent.
  // So, grab custom singleton class directly, rather than base.
  // Maybe that should be changed! Then we can use a base pointer.
  if(m_useMT) {
#ifdef G4MULTITHREADED
    auto* workerRM = G4AtlasWorkerRunManager::GetG4AtlasWorkerRunManager();
    abort = workerRM->ProcessEvent(inputEvent);
#else
    ATH_MSG_ERROR("Trying to use multi-threading in non-MT build!");
    return StatusCode::FAILURE;
#endif
  }
  else {
    auto* workerRM ATLAS_THREAD_SAFE = // single-threaded case
      G4AtlasRunManager::GetG4AtlasRunManager();
    abort = workerRM->ProcessEvent(inputEvent);
  }
  if (abort) {
    ATH_MSG_WARNING("Event was aborted !! ");
    ATH_MSG_WARNING("Simulation will now go on to the next event ");
    if (m_killAbortedEvents) {
      ATH_MSG_WARNING("setFilterPassed is now False");
      setFilterPassed(false);
    }
    if (m_flagAbortedEvents) {
      SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey, ctx);
      if (!eventInfo.isValid()) {
        ATH_MSG_FATAL( "Failed to retrieve xAOD::EventInfo while trying to update the error state!" );
        return StatusCode::FAILURE;
      }
      else {
        eventInfo->updateErrorState(xAOD::EventInfo::Core,xAOD::EventInfo::Error);
        ATH_MSG_WARNING( "Set error state in xAOD::EventInfo!" );
      }
    }
  }
 
  // Register all of the collections if there are any new-style SDs
  ATH_CHECK(m_senDetTool->EndOfAthenaEvent());
  ATH_CHECK(m_fastSimTool->EndOfAthenaEvent());
 
  ATH_CHECK( m_truthRecordSvc->releaseEvent() );
 
  // Remove QS patch if required
  if(!m_qspatcher.empty()) {
    for (HepMC::GenEvent* currentGenEvent : *outputTruthCollection ) {
      ATH_CHECK(m_qspatcher->removeWorkaround(*currentGenEvent));
    }
  }
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

finalize()

StatusCode G4AtlasAlg::finalize ( )

override

Finalize the algorithm and invoke G4 run termination.

Definition at line 285 of file G4AtlasAlg.cxx.

{
  ATH_MSG_DEBUG(std::endl<<std::endl<<std::endl);
  ATH_MSG_DEBUG("++++++++++++  G4AtlasAlg finalized  ++++++++++++" <<std::endl<<std::endl);
 
  // One time finalization
  try {
    std::call_once(finalizeOnceFlag, &G4AtlasAlg::finalizeOnce, this);
  }
  catch(const std::exception& e) {
    ATH_MSG_ERROR("Failure in G4AtlasAlg::finalizeOnce: " << e.what());
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

finalizeOnce()

void G4AtlasAlg::finalizeOnce

(

)

G4 finalization called only by the first alg instance.

This is done (for now) because we get multiple alg instances in hive.

Definition at line 303 of file G4AtlasAlg.cxx.

{
  ATH_MSG_DEBUG("\t terminating the current G4 run");
  auto runMgr = G4RunManager::GetRunManager();
  runMgr->RunTermination();
}

initializeG4()

void G4AtlasAlg::initializeG4

(

)

Poorly named possibly unused method which sets some verbosities.

Definition at line 252 of file G4AtlasAlg.cxx.

{
  if (m_verbosities.size()>0) {
    G4TransportationManager *tm = G4TransportationManager::GetTransportationManager();
    G4RunManagerKernel *rmk = G4RunManagerKernel::GetRunManagerKernel();
    G4EventManager *em = G4EventManager::GetEventManager();
 
    auto itr = m_verbosities.end();
    if ((itr = m_verbosities.find("Navigator")) != m_verbosities.end()) {
      tm->GetNavigatorForTracking()->SetVerboseLevel( atof(itr->second.data()) );
    }
    if ((itr = m_verbosities.find("Propagator")) != m_verbosities.end()) {
      tm->GetPropagatorInField()->SetVerboseLevel( atof(itr->second.data()) );
    }
    if ((itr = m_verbosities.find("Tracking")) != m_verbosities.end()) {
      rmk->GetTrackingManager()->SetVerboseLevel( atof(itr->second.data()) );
    }
    if ((itr = m_verbosities.find("Stepping")) != m_verbosities.end()) {
      rmk->GetTrackingManager()->GetSteppingManager()->
        SetVerboseLevel( atof(itr->second.data()) );
    }
    if ((itr = m_verbosities.find("Stacking")) != m_verbosities.end()) {
      rmk->GetStackManager()->SetVerboseLevel( atof(itr->second.data()) );
    }
    if ((itr = m_verbosities.find("Event")) != m_verbosities.end()) {
      em->SetVerboseLevel( atof(itr->second.data()) );
    }
  } // End of the setting of verbosities
 
}

initializeOnce()

void G4AtlasAlg::initializeOnce

(

)

G4 initialization called only by the first alg instance.

This is done (for now) because we get multiple alg instances in hive.

Definition at line 133 of file G4AtlasAlg.cxx.

{
  // Assign physics list
  if(m_physListSvc.retrieve().isFailure()) {
    throw std::runtime_error("Could not initialize ATLAS PhysicsListSvc!");
  }
  for (const auto& action_tool : m_actionTools) {
    if (m_userActionSvc->addActionTool(action_tool).isFailure()) {
      throw std::runtime_error("Failed to add action tool "+action_tool.name());
    }
  }
 
  // Create the (master) run manager
  if(m_useMT) {
#ifdef G4MULTITHREADED
    auto* runMgr ATLAS_THREAD_SAFE = // protected by std::call_once above
      G4AtlasMTRunManager::GetG4AtlasMTRunManager();
    m_physListSvc->SetPhysicsList();
    runMgr->SetDetGeoSvc( m_detGeoSvc.typeAndName() );
    runMgr->SetFastSimMasterTool(m_fastSimTool.typeAndName() );
    runMgr->SetPhysListSvc( m_physListSvc.typeAndName() );
    runMgr->SetQuietMode( m_quietMode );
    // Worker Thread initialization used to create worker run manager on demand.
    std::unique_ptr<G4AtlasUserWorkerThreadInitialization> workerInit =
      std::make_unique<G4AtlasUserWorkerThreadInitialization>();
    workerInit->SetDetGeoSvc( m_detGeoSvc.typeAndName() );
    workerInit->SetFastSimMasterTool( m_fastSimTool.typeAndName() );
    workerInit->SetQuietMode( m_quietMode );
    runMgr->SetUserInitialization( workerInit.release() );
    std::unique_ptr<G4AtlasActionInitialization> actionInitialization =
      std::make_unique<G4AtlasActionInitialization>(m_userActionSvc.get());
    runMgr->SetUserInitialization(actionInitialization.release());
#else
    throw std::runtime_error("Trying to use multi-threading in non-MT build!");
#endif
  }
  // Single-threaded run manager
  else {
    auto* runMgr ATLAS_THREAD_SAFE = // safe because single-threaded
      G4AtlasRunManager::GetG4AtlasRunManager();
    m_physListSvc->SetPhysicsList();
    runMgr->SetRecordFlux( m_recordFlux, std::make_unique<G4AtlasFluxRecorder>() );
    runMgr->SetLogLevel( int(msg().level()) ); // Synch log levels
    runMgr->SetDetGeoSvc( m_detGeoSvc.typeAndName() );
    runMgr->SetFastSimMasterTool(m_fastSimTool.typeAndName() );
    runMgr->SetPhysListSvc(m_physListSvc.typeAndName() );
    runMgr->SetQuietMode( m_quietMode );
    std::unique_ptr<G4AtlasActionInitialization> actionInitialization =
      std::make_unique<G4AtlasActionInitialization>(m_userActionSvc.get());
    runMgr->SetUserInitialization(actionInitialization.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);
  }
 
  // Code from G4AtlasSvc
  auto* rm = G4RunManager::GetRunManager();
  if(!rm) {
    throw std::runtime_error("Run manager retrieval has failed");
  }
  rm->Initialize();     // Initialization differs slightly in multi-threading.
  // TODO: add more details about why this is here.
  if(!m_useMT && rm->ConfirmBeamOnCondition()) {
    rm->RunInitialization();
  }
 
  ATH_MSG_INFO( "retireving the Detector Geometry Service" );
  if(m_detGeoSvc.retrieve().isFailure()) {
    throw std::runtime_error("Could not initialize ATLAS DetectorGeometrySvc!");
  }
 
  if(m_userLimitsSvc.retrieve().isFailure()) {
    throw std::runtime_error("Could not initialize ATLAS UserLimitsSvc!");
  }
 
  if (m_activateParallelGeometries) {
    G4VModularPhysicsList* thePhysicsList=dynamic_cast<G4VModularPhysicsList*>(m_physListSvc->GetPhysicsList());
    if (!thePhysicsList) {
      throw std::runtime_error("Failed dynamic_cast!! this is not a G4VModularPhysicsList!");
    }
#if G4VERSION_NUMBER >= 1010
    std::vector<std::string>& parallelWorldNames=m_detGeoSvc->GetParallelWorldNames();
    for (auto& it: parallelWorldNames) {
      thePhysicsList->RegisterPhysics(new G4ParallelWorldPhysics(it,true));
    }
#endif
  }
 
  return;
}

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isClonable()

bool G4AtlasAlg::isClonable ( ) const

inlineoverride

this Alg is Clonable (for AthenaMT)

Definition at line 64 of file G4AtlasAlg.h.

{ return true; }

msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

releaseGeoModel()

void G4AtlasAlg::releaseGeoModel ( )

private

Releases the GeoModel geometry from memory once it has been used to build the G4 geometry and is no-longer required.

Definition at line 465 of file G4AtlasAlg.cxx.

{
  SmartIF<IGeoModelSvc> geoModel{Gaudi::svcLocator()->service("GeoModelSvc")};
  if (!geoModel) {
    ATH_MSG_WARNING( " ----> Unable to retrieve GeoModelSvc" );
  }
  else {
    if (geoModel->clear().isFailure()) {
      ATH_MSG_WARNING( " ----> GeoModelSvc::clear() failed" );
    }
    else {
      ATH_MSG_INFO( " ----> GeoModelSvc::clear() succeeded " );
    }
  }
  m_releaseGeoModel=false; // Don't do that again...
  return;
}

renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_actionTools

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

private

Definition at line 157 of file G4AtlasAlg.h.

m_activateParallelGeometries

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

private

Definition at line 130 of file G4AtlasAlg.h.

m_detGeoSvc

ServiceHandle<IDetectorGeometrySvc> G4AtlasAlg::m_detGeoSvc {this, "DetGeoSvc", "DetectorGeometrySvc", ""}

private

Detector Geometry Service (builds G4 Geometry)

Definition at line 141 of file G4AtlasAlg.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> G4AtlasAlg::m_eventInfoKey {this, "EventInfo", "EventInfo", "EventInfo key"}

private

Definition at line 106 of file G4AtlasAlg.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_fastSimTool

PublicToolHandle<IFastSimulationMasterTool> G4AtlasAlg::m_fastSimTool {this, "FastSimMasterTool", "FastSimulationMasterTool", ""}

private

Fast Simulation Master Tool.

Definition at line 155 of file G4AtlasAlg.h.

m_fieldMap

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

private

Definition at line 121 of file G4AtlasAlg.h.

m_flagAbortedEvents

Gaudi::Property<bool> G4AtlasAlg::m_flagAbortedEvents {this, "FlagAbortedEvents", false, ""}

private

Definition at line 103 of file G4AtlasAlg.h.

m_g4commands

Gaudi::Property<std::vector<std::string> > G4AtlasAlg::m_g4commands {this, "G4Commands", {}, "Commands to send to the G4UI"}

private

Commands to send to the G4 UI.

Definition at line 127 of file G4AtlasAlg.h.

m_geoIDSvc

ServiceHandle<ISF::IGeoIDSvc> G4AtlasAlg::m_geoIDSvc {this, "GeoIDSvc", "ISF_GeoIDSvc", ""}

private

Geo ID Service.

Definition at line 111 of file G4AtlasAlg.h.

m_inputConverter

ServiceHandle<ISF::IInputConverter> G4AtlasAlg::m_inputConverter {this, "InputConverter", "ISF_InputConverter", ""}

private

Service to convert ISF_Particles into a G4Event.

Definition at line 149 of file G4AtlasAlg.h.

m_inputTruthCollectionKey

SG::ReadHandleKey<McEventCollection> G4AtlasAlg::m_inputTruthCollectionKey {this, "InputTruthCollection", "BeamTruthEvent", "Input hard scatter collection"}

private

input hard scatter collection

Definition at line 104 of file G4AtlasAlg.h.

m_killAbortedEvents

Gaudi::Property<bool> G4AtlasAlg::m_killAbortedEvents {this, "KillAbortedEvents", false, ""}

private

Definition at line 102 of file G4AtlasAlg.h.

m_libList

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

private

Definition at line 119 of file G4AtlasAlg.h.

m_outputTruthCollectionKey

SG::WriteHandleKey<McEventCollection> G4AtlasAlg::m_outputTruthCollectionKey {this, "OutputTruthCollection", "TruthEvent", "Output hard scatter truth collection"}

private

output hard scatter truth collection

Definition at line 105 of file G4AtlasAlg.h.

m_physList

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

private

Definition at line 120 of file G4AtlasAlg.h.

m_physListSvc

ServiceHandle<IPhysicsListSvc> G4AtlasAlg::m_physListSvc {this, "PhysicsListSvc", "PhysicsListSvc", ""}

private

Physics List Tool.

Definition at line 151 of file G4AtlasAlg.h.

m_qspatcher

ServiceHandle<Simulation::IZeroLifetimePatcher> G4AtlasAlg::m_qspatcher {this, "QuasiStablePatcher", "", "Quasi-Stable Particle Simulation Patcher"}

private

Quasi-Stable Particle Simulation Patcher.

Definition at line 144 of file G4AtlasAlg.h.

m_quietMode

Gaudi::Property<bool> G4AtlasAlg::m_quietMode {this, "QuietMode", false, ""}

private

Definition at line 125 of file G4AtlasAlg.h.

m_randomStreamName

Gaudi::Property<std::string> G4AtlasAlg::m_randomStreamName {this, "RandomStreamName", "Geant4", ""}

private

Random Stream Name.

Definition at line 135 of file G4AtlasAlg.h.

m_recordFlux

Gaudi::Property<bool> G4AtlasAlg::m_recordFlux {this, "RecordFlux", false, ""}

private

Definition at line 124 of file G4AtlasAlg.h.

m_releaseGeoModel

Gaudi::Property<bool> G4AtlasAlg::m_releaseGeoModel {this, "ReleaseGeoModel", true, ""}

private

Definition at line 123 of file G4AtlasAlg.h.

m_rndmGen

Gaudi::Property<std::string> G4AtlasAlg::m_rndmGen {this, "RandomGenerator", "athena", ""}

private

Definition at line 122 of file G4AtlasAlg.h.

m_rndmGenSvc

ServiceHandle<IAthRNGSvc> G4AtlasAlg::m_rndmGenSvc {this, "AtRndmGenSvc", "AthRNGSvc", ""}

private

Random number service.

Definition at line 133 of file G4AtlasAlg.h.

m_senDetTool

PublicToolHandle<ISensitiveDetectorMasterTool> G4AtlasAlg::m_senDetTool {this, "SenDetMasterTool", "SensitiveDetectorMasterTool", ""}

private

Sensitive Detector Master Tool.

Definition at line 153 of file G4AtlasAlg.h.

m_simplifiedGeoPath

Gaudi::Property<std::string> G4AtlasAlg::m_simplifiedGeoPath {this, "SimplifiedGeoPath", "", "Path to the simplified geometry file used to transport particles"}

private

Definition at line 159 of file G4AtlasAlg.h.

m_truthPreselectionTool

ToolHandle<ISF::IGenEventFilter> G4AtlasAlg::m_truthPreselectionTool {this, "TruthPreselectionTool", "", "Tool for filtering out quasi-stable particle daughters"}

private

Definition at line 146 of file G4AtlasAlg.h.

m_truthRecordSvc

ServiceHandle<ISF::ITruthSvc> G4AtlasAlg::m_truthRecordSvc {this, "TruthRecordService", "ISF_TruthRecordSvc", ""}

private

Central Truth Service.

Definition at line 109 of file G4AtlasAlg.h.

m_useMT

Gaudi::Property<bool> G4AtlasAlg::m_useMT {this,"MultiThreading", false, "Multi-threading specific settings"}

private

Activate multi-threading configuration.

Definition at line 129 of file G4AtlasAlg.h.

m_userActionSvc

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

private

User Action Service.

Definition at line 139 of file G4AtlasAlg.h.

m_userLimitsSvc

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

private

Definition at line 137 of file G4AtlasAlg.h.

m_useShadowEvent

BooleanProperty G4AtlasAlg::m_useShadowEvent {this, "UseShadowEvent", false, "New approach to selecting particles for simulation" }

private

Definition at line 131 of file G4AtlasAlg.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_verbosities

std::map<std::string,std::string> G4AtlasAlg::m_verbosities

private

Verbosity settings for Geant4.

Definition at line 114 of file G4AtlasAlg.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• G4AtlasAlg.h
• G4AtlasAlg.cxx