#include <TransportTool.h>

Inheritance diagram for iGeant4::G4TransportTool:

Collaboration diagram for iGeant4::G4TransportTool:

Public Member Functions
	G4TransportTool (const std::string &, const std::string &, const IInterface *)
	Constructor. More...

virtual	~G4TransportTool ()=default
	Destructor. More...

virtual StatusCode	initialize () override final
	AlgTool initialize method. More...

void initializeOnce	ATLAS_NOT_THREAD_SAFE ()
	G4 initialization called only by the first tool instance. More...

virtual StatusCode	finalize () override final
	AlgTool finalize method. More...

void	finalizeOnce ()
	G4 finalization called only by the first tool instance. More...

virtual StatusCode	simulate (const EventContext &ctx, ISF::ISFParticle &isp, ISF::ISFParticleContainer &secondaries, McEventCollection *mcEventCollection) override

virtual StatusCode	simulateVector (const EventContext &ctx, const ISF::ISFParticleVector &particles, ISF::ISFParticleContainer &secondaries, McEventCollection mcEventCollection, McEventCollection shadowTruth=nullptr) override
	Simulation call for vectors of particles. More...

virtual StatusCode	setupEvent (const EventContext &) override
	Setup Event chain - in case of a begin-of event action is needed. More...

virtual StatusCode	releaseEvent (const EventContext &) override
	Release Event chain - in case of an end-of event action is needed. More...

virtual ISF::SimulationFlavor	simFlavor () const override

virtual StatusCode	sysInitialize () override
	Gaudi sysInitialize() methods. More...

virtual StatusCode	setupEventST () override
	Setup Event chain - in case of a begin-of event action is needed (called by ISimulationSvc) More...

virtual StatusCode	releaseEventST () override
	Release Event chain - in case of an end-of event action is needed (called by ISimulationSvc) More...

const ChronoEntity *	chronoStart (const IChronoSvc::ChronoTag &tag)
	wrapper call to start chrono with given tag More...

const ChronoEntity *	chronoStop (const IChronoSvc::ChronoTag &tag)
	wrapper call to stop chrono with given tag More...

Protected Attributes
ServiceHandle< IChronoStatSvc >	m_chrono {this, "ChronoStatService", "ChronoStatSvc"}
	The timing service for general usage. More...

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...

HepMC::GenEvent *	genEvent (McEventCollection *mcEventCollection) const

Configurable Properties
using	passbackAction_t = G4UA::iGeant4::TrackProcessorUserActionBase

using	passbackActionMap_t = tbb::concurrent_unordered_map< std::thread::id, std::vector< passbackAction_t * >, std::hash< std::thread::id > >

Gaudi::Property< bool >	m_doTiming {this, "PrintTimingInfo", true, ""}

float	m_accumulatedEventTime {0.}

float	m_accumulatedEventTimeSq {0.}

unsigned int	m_nrOfEntries {0}

G4Timer *	m_runTimer {nullptr}

G4Timer *	m_eventTimer {nullptr}

passbackActionMap_t m_secondaryActions	ATLAS_THREAD_SAFE

Gaudi::Property< std::string >	m_mcEventCollectionName {this, "McEventCollection", "TruthEvent", ""}

Gaudi::Property< std::string >	m_libList {this, "Dll", "", ""}
	Helper Tool to provide G4RunManager. More...

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

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

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

ServiceHandle< IAthRNGSvc >	m_rndmGenSvc {this, "RandomNumberService", "AthRNGSvc", ""}

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", "", ""}
	user action service More...

ServiceHandle< IDetectorGeometrySvc >	m_detGeoSvc {this, "DetGeoSvc", "DetectorGeometrySvc", ""}
	Detector Geometry Service (builds G4 Geometry) More...

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 Service. 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

Geant4 AlgTool to create a ISFParticle at a volume entry/exit

universal transport tool

Author: Robert Harrington

Definition at line 66 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.h.

Member Typedef Documentation

◆ passbackAction_t

using iGeant4::G4TransportTool::passbackAction_t = G4UA::iGeant4::TrackProcessorUserActionBase

private

Definition at line 121 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.h.

◆ passbackActionMap_t

using iGeant4::G4TransportTool::passbackActionMap_t = tbb::concurrent_unordered_map< std::thread::id, std::vector< passbackAction_t* >, std::hash<std::thread::id> >

private

Definition at line 122 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.h.

Constructor & Destructor Documentation

◆ G4TransportTool()

iGeant4::G4TransportTool::G4TransportTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Constructor.

Definition at line 58 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.cxx.

   : ISF::BaseSimulatorTool(type, name, parent)
 {
   //declareProperty("KillAllNeutrinos",      m_KillAllNeutrinos=true);
   //declareProperty("KillLowEPhotons",       m_KillLowEPhotons=-1.);
 }

◆ ~G4TransportTool()

virtual iGeant4::G4TransportTool::~G4TransportTool ( )

virtualdefault

Destructor.

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

void initializeOnce iGeant4::G4TransportTool::ATLAS_NOT_THREAD_SAFE ( )

G4 initialization called only by the first tool instance.

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

◆ chronoStart()

const ChronoEntity* ISF::BaseSimulatorTool::chronoStart ( const IChronoSvc::ChronoTag & tag )

inlineinherited

wrapper call to start chrono with given tag

Definition at line 98 of file BaseSimulatorTool.h.

                                                                      {
       if (m_chrono) return m_chrono->chronoStart( tag);
       return nullptr;
     }

◆ chronoStop()

const ChronoEntity* ISF::BaseSimulatorTool::chronoStop ( const IChronoSvc::ChronoTag & tag )

inlineinherited

wrapper call to stop chrono with given tag

Definition at line 104 of file BaseSimulatorTool.h.

                                                                     {
       if (m_chrono) return m_chrono->chronoStop( tag);
       return nullptr;
     }

◆ commandLog()

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

private

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

Definition at line 474 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.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;
   }
  
 }

◆ finalize()

StatusCode iGeant4::G4TransportTool::finalize ( )

finaloverridevirtual

AlgTool finalize method.

Definition at line 218 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.cxx.

 {
   ATH_MSG_VERBOSE("++++++++++++  ISF G4 G4TransportTool finalized  ++++++++++++");
  
   // One time finalization
   try {
     std::call_once(finalizeOnceFlag, &iGeant4::G4TransportTool::finalizeOnce, this);
   }
   catch(const std::exception& e) {
     ATH_MSG_ERROR("Failure in iGeant4::G4TransportTool::finalizeOnce: " << e.what());
     return StatusCode::FAILURE;
   }
  
   if (m_doTiming) {
     m_runTimer->Stop();
     const float numEntriesFloat(m_nrOfEntries);
     const float runTime=m_runTimer->GetUserElapsed()+m_runTimer->GetSystemElapsed();
     const float avgTimePerEvent=(m_nrOfEntries>1) ? m_accumulatedEventTime/(numEntriesFloat-1.f) : runTime;
     const float avgTimeSqPerEvent=(m_nrOfEntries>1) ? m_accumulatedEventTimeSq/(numEntriesFloat-1.f) : runTime*runTime;
     const float sigma=(m_nrOfEntries>2) ? std::sqrt(std::abs(avgTimeSqPerEvent - avgTimePerEvent*avgTimePerEvent)/(numEntriesFloat-2.f)) : 0;
     ATH_MSG_INFO("*****************************************"<<endmsg<<
                  "**                                     **"<<endmsg<<
                  "    End of run - time spent is "<<std::setprecision(4) <<
                  runTime<<endmsg<<
                  "    Average time per event was "<<std::setprecision(4) <<
                  avgTimePerEvent <<" +- "<< std::setprecision(4) << sigma<<endmsg<<
                  "**                                     **"<<endmsg<<
                  "*****************************************");
   }
  
   return StatusCode::SUCCESS;
 }

◆ finalizeOnce()

void iGeant4::G4TransportTool::finalizeOnce ( )

G4 finalization called only by the first tool instance.

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

Definition at line 252 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.cxx.

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

◆ genEvent()

HepMC::GenEvent * iGeant4::G4TransportTool::genEvent ( McEventCollection * mcEventCollection ) const

private

Definition at line 452 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.cxx.

 {
  
   if(!mcEventCollection) {
     // retrieve McEventCollection from storegate
     if (evtStore()->contains<McEventCollection>(m_mcEventCollectionName)) {
       if (evtStore()->retrieve( mcEventCollection, m_mcEventCollectionName).isFailure()) {
         ATH_MSG_ERROR( "Unable to retrieve McEventCollection with name=" << m_mcEventCollectionName
                          << ".");
         return nullptr;
       }
       else {
         ATH_MSG_WARNING( "Fallback. Sucessfully retrieved McEventCollection with name=" << m_mcEventCollectionName);
       }
     }
     else { return nullptr; }
   }
   // collect last GenEvent from McEventCollection
   return mcEventCollection->back();
 }

◆ initialize()

StatusCode iGeant4::G4TransportTool::initialize ( )

finaloverridevirtual

AlgTool initialize method.

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 68 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.cxx.

 {
   ATH_MSG_VERBOSE("initialize");
  
   ATH_CHECK( ISF::BaseSimulatorTool::initialize() );
  
   // create G4Timers if enabled
   if (m_doTiming) {
     m_runTimer   = new G4Timer();
     m_eventTimer = new G4Timer();
     m_runTimer->Start();
   }
  
   // Create the scoring manager if requested
   if (m_recordFlux) G4ScoringManager::GetScoringManager();
  
   // One-time initialization
   try {
     std::call_once(initializeOnceFlag, &iGeant4::G4TransportTool::initializeOnce, this);
   }
   catch(const std::exception& e) {
     ATH_MSG_ERROR("Failure in iGeant4::G4TransportTool::initializeOnce: " << e.what());
     return StatusCode::FAILURE;
   }
  
   ATH_CHECK( m_rndmGenSvc.retrieve() );
   ATH_CHECK( m_userActionSvc.retrieve() );
  
   ATH_CHECK(m_senDetTool.retrieve());
   ATH_CHECK(m_fastSimTool.retrieve());
  
   ATH_CHECK(m_inputConverter.retrieve());
  
   return StatusCode::SUCCESS;
 }

◆ releaseEvent()

StatusCode iGeant4::G4TransportTool::releaseEvent ( const EventContext & )

overridevirtual

Release Event chain - in case of an end-of event action is needed.

Todo:: : strip hits of the tracks ...

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 406 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.cxx.

 {
   ATH_MSG_DEBUG ( "release Event" );
   /* todo: ELLI: the following is copied in from the PyG4AtlasAlg:
      -> this somehow needs to be moved into C++
      and put into releaseEvent() ( or setupEvent() ?)
  
      from ISF_Geant4Example import AtlasG4Eng
      from ISF_Geant4Example.ISF_SimFlags import simFlags
      if self.doFirstEventG4SeedsCheck :
      if simFlags.SeedsG4.statusOn:
      rnd = AtlasG4Eng.G4Eng.menu_G4RandomNrMenu()
      rnd.set_Seed(simFlags.SeedsG4.get_Value())
      self.doFirstEventG4SeedsCheck = False
      if self.RndG4Menu.SaveStatus:
      self.RndG4Menu.Menu.saveStatus('G4Seeds.txt')
   */
  
   // print per-event timing info if enabled
   if (m_doTiming) {
     m_eventTimer->Stop();
  
     const double eventTime=m_eventTimer->GetUserElapsed()+m_eventTimer->GetSystemElapsed();
     if (m_nrOfEntries>1) {
       m_accumulatedEventTime  +=eventTime;
       m_accumulatedEventTimeSq+=eventTime*eventTime;
     }
  
     const float numEntriesFloat(m_nrOfEntries);
     const float avgTimePerEvent=(m_nrOfEntries>1) ? m_accumulatedEventTime/(numEntriesFloat-1.f) : eventTime;
     const float avgTimeSqPerEvent=(m_nrOfEntries>1) ? m_accumulatedEventTimeSq/(numEntriesFloat-1.f) : eventTime*eventTime;
     const float sigma=(m_nrOfEntries>2) ? std::sqrt(std::abs(avgTimeSqPerEvent - avgTimePerEvent*avgTimePerEvent)/(numEntriesFloat-2.f)) : 0;
     ATH_MSG_INFO("\t Run:Event "<<ctx.eventID().run_number()<<":"<<ctx.eventID().event_number() << "\t ("<<m_nrOfEntries<<"th event for this worker) took " << std::setprecision(4) <<
                  eventTime << " s. New average " << std::setprecision(4) <<
                  avgTimePerEvent<<" +- "<<std::setprecision(4) << sigma);
   }
  
   ATH_CHECK(m_senDetTool->EndOfAthenaEvent());
   ATH_CHECK(m_fastSimTool->EndOfAthenaEvent());
  
   return StatusCode::SUCCESS;
 }

◆ releaseEventST()

virtual StatusCode ISF::BaseSimulatorTool::releaseEventST ( )

inlineoverridevirtualinherited

Release Event chain - in case of an end-of event action is needed (called by ISimulationSvc)

Reimplemented in ISF::FastCaloSimV2Tool.

Definition at line 94 of file BaseSimulatorTool.h.

95 { return releaseEvent(Gaudi::Hive::currentContext()); }

◆ setupEvent()

StatusCode iGeant4::G4TransportTool::setupEvent ( const EventContext & )

overridevirtual

Setup Event chain - in case of a begin-of event action is needed.

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 370 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.cxx.

 {
   ATH_MSG_DEBUG ( "setup Event" );
  
 #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 (m_useMT && G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking()->GetWorldVolume() == nullptr)
   {
     ToolHandle<IThreadInitTool> ti ("G4ThreadInitTool", nullptr);
     ATH_CHECK( ti.retrieve() );
     ti->initThread();
   }
 #endif
  
   // 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->getEngine(ctx));
  
   ATH_CHECK(m_senDetTool->BeginOfAthenaEvent());
  
   m_nrOfEntries++;
   if (m_doTiming) m_eventTimer->Start();
  
   // make sure SD collections are properly initialized in every Athena event
   G4SDManager::GetSDMpointer()->PrepareNewEvent();
  
   return StatusCode::SUCCESS;
 }

◆ setupEventST()

virtual StatusCode ISF::BaseSimulatorTool::setupEventST ( )

inlineoverridevirtualinherited

Setup Event chain - in case of a begin-of event action is needed (called by ISimulationSvc)

Reimplemented in ISF::FastCaloSimV2Tool.

Definition at line 67 of file BaseSimulatorTool.h.

68 { return setupEvent(Gaudi::Hive::currentContext()); }

◆ simFlavor()

virtual ISF::SimulationFlavor iGeant4::G4TransportTool::simFlavor ( ) const

inlineoverridevirtual

Definition at line 97 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.h.

97 { return ISF::Geant4; };

◆ simulate()

StatusCode iGeant4::G4TransportTool::simulate	(	const EventContext &	ctx,
		ISF::ISFParticle &	isp,
		ISF::ISFParticleContainer &	secondaries,
		McEventCollection *	mcEventCollection
	)

overridevirtual

Process ParticleState from particle stack

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 261 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.cxx.

                                                                                                   {
  
   // give a screen output that you entered Geant4SimSvc
   ATH_MSG_VERBOSE( "Particle " << isp << " received for simulation." );
  
   // wrap the given ISFParticle into a STL vector of ISFParticles with length 1
   // (minimizing code duplication)
   const ISF::ISFParticleVector ispVector(1, &isp);
   StatusCode success = this->simulateVector(ctx, ispVector, secondaries, mcEventCollection);
   ATH_MSG_VERBOSE( "Simulation done" );
  
   // Geant4 call done
   return success;
 }

◆ simulateVector()

StatusCode iGeant4::G4TransportTool::simulateVector	(	const EventContext &	ctx,
		const ISF::ISFParticleVector &	particles,
		ISF::ISFParticleContainer &	secondaries,
		McEventCollection *	mcEventCollection,
		McEventCollection *	= `nullptr`
	)

overridevirtual

Simulation call for vectors of particles.

Process ParticleState from particle stack

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 279 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.cxx.

                                                                                                                                                                                                                             {
  
   ATH_MSG_DEBUG (name() << ".simulateVector(...) : Received a vector of " << particles.size() << " particles for simulation.");
   G4Event* inputEvent{};
   if (shadowTruth && !shadowTruth->empty()) {
     inputEvent = m_inputConverter->ISF_to_G4Event(ctx, particles, genEvent(mcEventCollection), shadowTruth->back());
   }
   else{
     inputEvent = m_inputConverter->ISF_to_G4Event(ctx, particles, genEvent(mcEventCollection));
   }
   if (!inputEvent) {
     ATH_MSG_ERROR("ISF Event conversion failed ");
     return StatusCode::FAILURE;
   }
  
   ATH_MSG_DEBUG("Calling ISF_Geant4 ProcessEvent");
   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 = G4AtlasRunManager::GetG4AtlasRunManager();  // non-MT case
     abort = workerRM->ProcessEvent(inputEvent);
   }
   if (abort) {
     ATH_MSG_WARNING("Event was aborted !! ");
     //ATH_MSG_WARNING("Simulation will now go on to the next event ");
     //ATH_MSG_WARNING("setFilterPassed is now False");
     //setFilterPassed(false);
     return StatusCode::FAILURE;
   }
  
   // Get user actions that return secondaries
   auto actionsFound = m_secondaryActions.find( std::this_thread::get_id() );
   if ( actionsFound == m_secondaryActions.end() ) {
     // Get all UAs
     std::vector< G4UserSteppingAction* > allActions;
     StatusCode sc = m_userActionSvc->getSecondaryActions( allActions );
     if ( !sc.isSuccess() ) {
       ATH_MSG_ERROR( "Failed to retrieve secondaries from UASvc" );
       return sc;
     }
  
     // Find the UAs that can return secondaries
     for ( G4UserSteppingAction* action : allActions ) {
       passbackAction_t* castAction = dynamic_cast< passbackAction_t* >( action );
       if ( castAction ) {
         m_secondaryActions[ std::this_thread::get_id() ].push_back( castAction );
       }
     }
  
     actionsFound = m_secondaryActions.find( std::this_thread::get_id() );
   }
  
   // Retrieve secondaries from user actions
   for ( auto* action : actionsFound->second ) {
     for ( auto& parent : particles ) {
  
       ISF::ISFParticleContainer someSecondaries = action->ReturnSecondaries( parent );
  
       secondaries.splice( begin(secondaries), std::move(someSecondaries) );
     }
   }
  
   // const DataHandle <TrackRecordCollection> tracks;
  
   // StatusCode sc = evtStore()->retrieve(tracks,m_trackCollName);
  
   // if (sc.isFailure()) {
   //   ATH_MSG_WARNING(" Cannot retrieve TrackRecordCollection " << m_trackCollName);
   // }
  
   // not implemented yet... need to get particle stack from Geant4 and convert to ISFParticle
   ATH_MSG_VERBOSE( "Simulation done" );
  
   // Geant4 call done
   return StatusCode::SUCCESS;
 }

◆ sysInitialize()

virtual StatusCode ISF::BaseSimulatorTool::sysInitialize ( )

inlineoverridevirtualinherited

Gaudi sysInitialize() methods.

Definition at line 49 of file BaseSimulatorTool.h.

     {
       ATH_CHECK( AthAlgTool::sysInitialize() );
       ATH_CHECK( m_chrono.retrieve() );
       return StatusCode::SUCCESS;
     }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

passbackActionMap_t m_secondaryActions iGeant4::G4TransportTool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 123 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.h.

◆ m_accumulatedEventTime

float iGeant4::G4TransportTool::m_accumulatedEventTime {0.}

private

Definition at line 112 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.h.

◆ m_accumulatedEventTimeSq

float iGeant4::G4TransportTool::m_accumulatedEventTimeSq {0.}

private

Definition at line 113 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.h.

◆ m_activateParallelGeometries

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

private

Definition at line 140 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.h.