G4RunAlg Class Reference

Primary Athena algorithm for ATLAS simulation. More...

#include <G4RunAlg.h>

Inheritance diagram for G4RunAlg:

Public Member Functions
virtual bool	isClonable () const override
	this Alg is Clonable (for AthenaMT)
virtual StatusCode initialize	ATLAS_NOT_THREAD_SAFE () override
	Initialize the algorithm.
virtual StatusCode	execute () override
	Simulate one Athena event.
	AthAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
	Standard algorithm constructor.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	releaseGeoModel ()
	Releases the GeoModel geometry from memory once it has been used to build the G4 geometry and is no-longer required.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared
Configurable Properties
Gaudi::Property< bool >	m_flagAbortedEvents {this, "FlagAbortedEvents", false, ""}
Gaudi::Property< bool >	m_killAbortedEvents {this, "KillAbortedEvents", false, ""}
Gaudi::Property< bool >	m_releaseGeoModel {this, "ReleaseGeoModel", true, ""}
Gaudi::Property< bool >	m_useShadowEvent {this, "UseShadowEvent", false, "New approach to selecting particles for simulation"}
Gaudi::Property< std::string >	m_randomStreamName {this, "RandomStreamName", "Geant4", ""}
Gaudi::Property< std::string >	m_simplifiedGeoPath {this, "SimplifiedGeoPath", "", "Path to the simplified geometry file"}
Gaudi::Property< std::map< std::string, std::string > >	m_verbosities {this, "Verbosities", {}, "Map of G4 Verbosities to set for the simulation"}
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey {this, "EventInfo", "EventInfo", "EventInfo key"}
SG::ReadHandleKey< McEventCollection >	m_inputTruthCollectionKey {this, "InputTruthCollection", "BeamTruthEvent", "Input hard scatter collection"}
SG::WriteHandleKey< McEventCollection >	m_outputTruthCollectionKey {this, "OutputTruthCollection", "TruthEvent", "Output hard scatter truth collection"}
ServiceHandle< ISF::IGeoIDSvc >	m_geoIDSvc {this, "GeoIDSvc", "ISF_GeoIDSvc", ""}
	Geo ID Service.
ServiceHandle< ISF::IInputConverter >	m_inputConverter {this, "InputConverter", "ISF_InputConverter", ""}
	Service to convert ISF_Particles into a G4Event.
ServiceHandle< ISF::ITruthSvc >	m_truthRecordSvc {this, "TruthRecordService", "ISF_TruthRecordSvc", ""}
	Central Truth Service.
ServiceHandle< Simulation::IZeroLifetimePatcher >	m_qspatcher {this, "QuasiStablePatcher", "", "Quasi-Stable Particle Simulation Patcher"}
	Quasi-Stable Particle Simulation Patcher.
ServiceHandle< IAthRNGSvc >	m_rndmGenSvc {this, "AtRndmGenSvc", "AthRNGSvc", ""}
	Random number service.
ServiceHandle< G4UA::IUserActionSvc >	m_userActionSvc {this, "UserActionSvc", "G4UA::UserActionSvc", ""}
	User Action Service.
PublicToolHandle< IFastSimulationMasterTool >	m_fastSimTool {this, "FastSimMasterTool", "FastSimulationMasterTool", ""}
	Fast Simulation Master Tool.
PublicToolHandle< IG4RunTool >	m_g4RunTool {this, "G4RunTool", "G4RunTool", ""}
	G4Atlas Tool for thread management and data interface.
PublicToolHandle< ISensitiveDetectorMasterTool >	m_senDetTool {this, "SenDetMasterTool", "SensitiveDetectorMasterTool", ""}
	Sensitive Detector Master Tool.
ToolHandle< ISF::IGenEventFilter >	m_truthPreselectionTool {this, "TruthPreselectionTool", "", "Tool for filtering out quasi-stable particle daughters"}
	Tool for filtering out quasi-stable particle daughters.

Detailed Description

Primary Athena algorithm for ATLAS simulation.

This algorithm setup a Geant Run (through G4RunTool) which executes in a separate thread pool managed by the G4RunManager.

In contrast to G4AtlasAlg, in which execute() runs the actual transport loop of the event, G4RunAlg will only prepare the event, and push it to the G4 worker using a shared queue. Condition variables are used to synchronize the Athena worker thread with the G4 worker thread in execute.

Definition at line 50 of file G4RunAlg.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

AthAlgorithm()

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

Standard algorithm constructor.

Definition at line 51 of file AthAlgorithm.cxx.

                                                       :
  ::AthCommonDataStore<AthCommonMsg<Algorithm>>   ( name, pSvcLocator )
{
  // Set up to run AthAlgorithmDHUpdate in sysInitialize before
  // merging dependency lists.  This extends the output dependency
  // list with any symlinks implied by inheritance relations.
  m_updateDataHandles =
    std::make_unique<AthenaBaseComps::AthAlgorithmDHUpdate>
    (m_extendedExtraObjects,
     std::move (m_updateDataHandles));
}

ATLAS_NOT_THREAD_SAFE()

virtual StatusCode initialize G4RunAlg::ATLAS_NOT_THREAD_SAFE ( )

overridevirtual

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

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & 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());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & 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()

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; }

execute()

StatusCode G4RunAlg::execute ( )

overridevirtual

Simulate one Athena event.

Definition at line 96 of file G4RunAlg.cxx.

{
  static std::atomic<unsigned int> n_Event=0;
  ATH_MSG_DEBUG("++++++++++++  G4RunAlg execute  ++++++++++++");
 
  n_Event += 1;
 
  if (n_Event<=10 || (n_Event%100) == 0) {
    ATH_MSG_ALWAYS("Event num. "  << n_Event << " start processing");
  }
 
  // Release GeoModel Geometry if necessary
  // TODO: should be moved to Geant4 main thread after run initialization
  if (m_releaseGeoModel) {
    try {
      std::call_once(releaseGeoModelOnceFlag, &G4RunAlg::releaseGeoModel, this);
    }
    catch(const std::exception& e) {
      ATH_MSG_ERROR("Failure in G4RunAlg::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);
 
  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
  {
 
    // called by the Geant4 PrimaryGeneratorAction because primary vertices must be instantiated by Geant4 threads
    auto prepare_event = [this, &outputTruthCollection, &shadowTruth, largestGeneratedParticleBC, largestGeneratedVertexBC](G4Event& event, std::unique_ptr<AtlasG4SyncEventUserInfo> g4eventInfo) -> StatusCode {
      // tell TruthService we're starting a new event
      ATH_CHECK( m_truthRecordSvc->initializeTruthCollection(largestGeneratedParticleBC, largestGeneratedVertexBC) );
      event.SetEventID(g4eventInfo->AthenaEventID());
      event.SetUserInformation(g4eventInfo.release());
      ATH_CHECK(m_inputConverter->convertHepMCToG4Event(
          *outputTruthCollection, event, *shadowTruth));
      return StatusCode::SUCCESS;
    };
    
    auto eventInfo = std::make_unique<AtlasG4SyncEventUserInfo>(rngWrapper->getEngine(ctx), std::move(prepare_event), ctx);
 
    // get a shared pointer to the hit collection map because we will need it after the G4Event is destroyed
    std::shared_ptr<HitCollectionMap> hitCollections = eventInfo->GetHitCollectionMap();
 
    ATH_CHECK(m_senDetTool->BeginOfAthenaEvent(*hitCollections));
    ATH_CHECK(m_userActionSvc->BeginOfAthenaEvent(*hitCollections));
    ATH_CHECK(m_fastSimTool->BeginOfAthenaEvent());
 
    auto syncInterface = eventInfo->SyncInterface();
 
    ATH_MSG_DEBUG("Pushing Athena event " << ctx.eventID().event_number() << " onto event buffer");
    m_g4RunTool->PushEvent(std::move(eventInfo));
    ATH_MSG_DEBUG("Buffer size=" << m_g4RunTool->Size() << ", waiting for event to finish");
    //G4 should tell Athena in an EndOfEventAction that the simulation of the event is done
    syncInterface->WaitStatusDone();
 
    if (syncInterface->EventAborted()) {
      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!");
        }
      }
    }
 
    ATH_CHECK(m_senDetTool->EndOfAthenaEvent(*hitCollections));
    ATH_CHECK(m_userActionSvc->EndOfAthenaEvent(*hitCollections));
    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();
}

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()

virtual bool G4RunAlg::isClonable ( ) const

inlineoverridevirtual

this Alg is Clonable (for AthenaMT)

Definition at line 58 of file G4RunAlg.h.

{ return true; }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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 G4RunAlg::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 237 of file G4RunAlg.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, AthHistogramAlgorithm, and PyAthena::Alg.

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_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> G4RunAlg::m_eventInfoKey {this, "EventInfo", "EventInfo", "EventInfo key"}

private

Definition at line 86 of file G4RunAlg.h.

{this, "EventInfo", "EventInfo", "EventInfo key"};

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> G4RunAlg::m_fastSimTool {this, "FastSimMasterTool", "FastSimulationMasterTool", ""}

private

Fast Simulation Master Tool.

Definition at line 104 of file G4RunAlg.h.

{this, "FastSimMasterTool", "FastSimulationMasterTool", ""};

m_flagAbortedEvents

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

private

Definition at line 78 of file G4RunAlg.h.

{this, "FlagAbortedEvents", false, ""};

m_g4RunTool

PublicToolHandle<IG4RunTool> G4RunAlg::m_g4RunTool {this, "G4RunTool", "G4RunTool", ""}

private

G4Atlas Tool for thread management and data interface.

Definition at line 106 of file G4RunAlg.h.

{this, "G4RunTool", "G4RunTool", ""};

m_geoIDSvc

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

private

Geo ID Service.

Definition at line 91 of file G4RunAlg.h.

{this, "GeoIDSvc", "ISF_GeoIDSvc", ""};

m_inputConverter

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

private

Service to convert ISF_Particles into a G4Event.

Definition at line 93 of file G4RunAlg.h.

{this, "InputConverter", "ISF_InputConverter", ""};

m_inputTruthCollectionKey

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

private

Definition at line 87 of file G4RunAlg.h.

{this, "InputTruthCollection", "BeamTruthEvent", "Input hard scatter collection"};

m_killAbortedEvents

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

private

Definition at line 79 of file G4RunAlg.h.

{this, "KillAbortedEvents", false, ""};

m_outputTruthCollectionKey

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

private

Definition at line 88 of file G4RunAlg.h.

{this, "OutputTruthCollection", "TruthEvent", "Output hard scatter truth collection"};

m_qspatcher

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

private

Quasi-Stable Particle Simulation Patcher.

Definition at line 97 of file G4RunAlg.h.

{this, "QuasiStablePatcher", "", "Quasi-Stable Particle Simulation Patcher"};

m_randomStreamName

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

private

Definition at line 82 of file G4RunAlg.h.

{this, "RandomStreamName", "Geant4", ""};

m_releaseGeoModel

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

private

Definition at line 80 of file G4RunAlg.h.

{this, "ReleaseGeoModel", true, ""};

m_rndmGenSvc

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

private

Random number service.

Definition at line 99 of file G4RunAlg.h.

{this, "AtRndmGenSvc", "AthRNGSvc", ""};

m_senDetTool

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

private

Sensitive Detector Master Tool.

Definition at line 108 of file G4RunAlg.h.

{this, "SenDetMasterTool", "SensitiveDetectorMasterTool", ""};

m_simplifiedGeoPath

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

private

Definition at line 83 of file G4RunAlg.h.

{this, "SimplifiedGeoPath", "", "Path to the simplified geometry file"};

m_truthPreselectionTool

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

private

Tool for filtering out quasi-stable particle daughters.

Definition at line 110 of file G4RunAlg.h.

{this, "TruthPreselectionTool", "", "Tool for filtering out quasi-stable particle daughters"};

m_truthRecordSvc

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

private

Central Truth Service.

Definition at line 95 of file G4RunAlg.h.

{this, "TruthRecordService", "ISF_TruthRecordSvc", ""};

m_userActionSvc

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

private

User Action Service.

Definition at line 101 of file G4RunAlg.h.

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

m_useShadowEvent

Gaudi::Property<bool> G4RunAlg::m_useShadowEvent {this, "UseShadowEvent", false, "New approach to selecting particles for simulation"}

private

Definition at line 81 of file G4RunAlg.h.

{this, "UseShadowEvent", false, "New approach to selecting particles for simulation"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_verbosities

Gaudi::Property<std::map<std::string, std::string> > G4RunAlg::m_verbosities {this, "Verbosities", {}, "Map of G4 Verbosities to set for the simulation"}

private

Definition at line 84 of file G4RunAlg.h.

{this, "Verbosities", {}, "Map of G4 Verbosities to set for the simulation"};

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:

• G4RunAlg.h
• G4RunAlg.cxx