iGeant4::G4TransportTool Class Reference

#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, std::shared_ptr< HitCollectionMap > hitCollections) override
	Simulation call for individual particles. More...
virtual StatusCode	simulateVector (const EventContext &ctx, const ISF::ISFParticleVector &particles, ISF::ISFParticleContainer &secondaries, McEventCollection *mcEventCollection, std::shared_ptr< HitCollectionMap > hitCollections, McEventCollection *shadowTruth=nullptr) override
	Simulation call for vectors of particles. More...
virtual StatusCode	setupEvent (const EventContext &, HitCollectionMap &) override
	Create data containers for an event. More...
virtual StatusCode	releaseEvent (const EventContext &, HitCollectionMap &) override
	Finalise data containers for an event. More...
virtual ISF::SimulationFlavor	simFlavor () const override
virtual StatusCode	simulate (const EventContext &, ISFParticle &, ISFParticleContainer &, McEventCollection *)
	Simulation call for individual particles. More...
virtual StatusCode	simulateVector (const EventContext &, const ISFParticleVector &, ISFParticleContainer &, McEventCollection *, McEventCollection *)
	Simulation call for vectors of particles. More...
virtual StatusCode	setupEvent (const EventContext &)
	Create data containers for an event. More...
virtual StatusCode	setupEventST (HitCollectionMap &hitCollections)
	Create data containers for an event (called by ISimulationSvc) More...
virtual StatusCode	setupEventST ()
	Create data containers for an event (called by ISimulationSvc) More...
virtual StatusCode	releaseEvent (const EventContext &)
	Finalise data containers for an event. More...
virtual StatusCode	releaseEventST (HitCollectionMap &hitCollections)
	Finalise data containers for an event (called by ISimulationSvc) More...
virtual StatusCode	releaseEventST ()
	Finalise data containers for an event (called by ISimulationSvc) More...
	BaseSimulatorTool (const std::string &type, const std::string &name, const IInterface *parent)
	Standard BaseSimulatorTool constructor. More...
virtual StatusCode	sysInitialize () override
	Gaudi sysInitialize() methods. 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
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< 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
	Commands to send to the G4 UI. More...
Gaudi::Property< bool >	m_useMT
	Activate multi-threading configuration. More...
Gaudi::Property< bool >	m_activateParallelGeometries
ServiceHandle< IAthRNGSvc >	m_rndmGenSvc
Gaudi::Property< std::string >	m_randomStreamName
	Random Stream Name. More...
ServiceHandle< IUserLimitsSvc >	m_userLimitsSvc
ServiceHandle< G4UA::IUserActionSvc >	m_userActionSvc
	user action service More...
PublicToolHandle< IDetectorConstructionTool >	m_detConstruction {this, "DetectorConstruction", "", "Tool handle of the DetectorConstruction"}
ServiceHandle< ISF::IInputConverter >	m_inputConverter
	Service to convert ISF_Particles into a G4Event. More...
ServiceHandle< IPhysicsListSvc >	m_physListSvc
	Physics List Service. More...
PublicToolHandle< ISensitiveDetectorMasterTool >	m_senDetTool
	Sensitive Detector Master Tool. More...
PublicToolHandle< IFastSimulationMasterTool >	m_fastSimTool
	Fast Simulation Master Tool. More...
PublicToolHandleArray< IPhysicsInitializationTool >	m_physicsInitializationTools {this, "PhysicsInitializationTools", {}, "Physics initialization happening after Geant4 initialization"}

Detailed Description

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

• universal transport tool

Author

Robert Harrington

Definition at line 67 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 138 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 139 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 60 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.cxx.

  : ISF::BaseSimulatorG4Tool(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.

BaseSimulatorTool()

ISF::BaseSimulatorTool::BaseSimulatorTool

inlineinherited

Standard BaseSimulatorTool constructor.

Definition at line 40 of file BaseSimulatorTool.h.

      : base_class(type, name, parent)
    {
    }

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 478 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 225 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 259 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 456 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 70 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() [1/2]

virtual StatusCode ISF::BaseSimulatorG4Tool::releaseEvent ( const EventContext &  )

inlinevirtualinherited

Finalise data containers for an event.

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 87 of file BaseSimulatorG4Tool.h.

                                                       {
    return StatusCode::FAILURE;
  };

releaseEvent() [2/2]

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

overridevirtual

Finalise data containers for an event.

Todo:

: strip hits of the tracks ...

Implements ISF::BaseSimulatorG4Tool.

Definition at line 410 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(hitCollections));
  ATH_CHECK(m_fastSimTool->EndOfAthenaEvent());
 
  return StatusCode::SUCCESS;
}

releaseEventST() [1/2]

virtual StatusCode ISF::BaseSimulatorG4Tool::releaseEventST ( )

inlinevirtualinherited

Finalise data containers for an event (called by ISimulationSvc)

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 92 of file BaseSimulatorG4Tool.h.

{ return StatusCode::FAILURE; };

releaseEventST() [2/2]

virtual StatusCode ISF::BaseSimulatorG4Tool::releaseEventST ( HitCollectionMap &  hitCollections )

inlinevirtualinherited

Finalise data containers for an event (called by ISimulationSvc)

Definition at line 58 of file BaseSimulatorG4Tool.h.

                                                                      {
    return releaseEvent(Gaudi::Hive::currentContext(), hitCollections);
  }

setupEvent() [1/2]

virtual StatusCode ISF::BaseSimulatorG4Tool::setupEvent ( const EventContext &  )

inlinevirtualinherited

Create data containers for an event.

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 79 of file BaseSimulatorG4Tool.h.

                                                     {
    return StatusCode::FAILURE;
  };

setupEvent() [2/2]

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

overridevirtual

Create data containers for an event.

Implements ISF::BaseSimulatorG4Tool.

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

                                                               {
  ATH_MSG_DEBUG ( "setup Event" );
 
  // 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(hitCollections));
 
  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() [1/2]

virtual StatusCode ISF::BaseSimulatorG4Tool::setupEventST ( )

inlinevirtualinherited

Create data containers for an event (called by ISimulationSvc)

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 84 of file BaseSimulatorG4Tool.h.

{ return StatusCode::FAILURE; };

setupEventST() [2/2]

virtual StatusCode ISF::BaseSimulatorG4Tool::setupEventST ( HitCollectionMap &  hitCollections )

inlinevirtualinherited

Create data containers for an event (called by ISimulationSvc)

Definition at line 49 of file BaseSimulatorG4Tool.h.

                                                                    {
    return setupEvent(Gaudi::Hive::currentContext(), hitCollections);
  }

simFlavor()

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

inlineoverridevirtual

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

                                                         {
    return ISF::Geant4;
  };

simulate() [1/2]

virtual StatusCode ISF::BaseSimulatorG4Tool::simulate ( const EventContext &  , ISFParticle &  , ISFParticleContainer &  , McEventCollection *    )

inlinevirtualinherited

Simulation call for individual particles.

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 65 of file BaseSimulatorG4Tool.h.

                                                                         {
    return StatusCode::FAILURE;
  };

simulate() [2/2]

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

overridevirtual

Simulation call for individual particles.

Process ParticleState from particle stack

Implements ISF::BaseSimulatorG4Tool.

Definition at line 268 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, hitCollections);
  ATH_MSG_VERBOSE( "Simulation done" );
 
  // Geant4 call done
  return success;
}

simulateVector() [1/2]

virtual StatusCode ISF::BaseSimulatorG4Tool::simulateVector ( const EventContext &  , const ISFParticleVector &  , ISFParticleContainer &  , McEventCollection *  , McEventCollection *    )

inlinevirtualinherited

Simulation call for vectors of particles.

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 71 of file BaseSimulatorG4Tool.h.

                                                        {
    return StatusCode::FAILURE;
  };

simulateVector() [2/2]

StatusCode iGeant4::G4TransportTool::simulateVector ( const EventContext &  ctx, const ISF::ISFParticleVector &  particles, ISF::ISFParticleContainer &  secondaries, McEventCollection *  mcEventCollection, std::shared_ptr< HitCollectionMap >  HitCollectionMap, McEventCollection *  shadowTruth = nullptr  )

overridevirtual

Simulation call for vectors of particles.

Process ParticleState from particle stack

Implements ISF::BaseSimulatorG4Tool.

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

                                    {
 
  ATH_MSG_DEBUG (name() << ".simulateVector(...) : Received a vector of " << particles.size() << " particles for simulation.");
  bool abort = [&] ATLAS_NOT_THREAD_SAFE {
    auto eventInfo = std::make_unique<AtlasG4EventUserInfo>();
    eventInfo->SetHitCollectionMap(hitCollections);
 
    auto inputEvent = std::make_unique<G4Event>(ctx.eventID().event_number());
    inputEvent->SetUserInformation(eventInfo.release());
 
    HepMC::GenEvent* shadowGenEvent =
        (shadowTruth && !shadowTruth->empty())
            ? static_cast<HepMC::GenEvent*>(shadowTruth->back())
            : nullptr;
    m_inputConverter->ISF_to_G4Event(
        *inputEvent, particles, genEvent(mcEventCollection), shadowGenEvent);
 
    ATH_MSG_DEBUG("Calling ISF_Geant4 ProcessEvent");
    // 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();
        return workerRM->ProcessEvent(inputEvent.release());
#     else
        ATH_MSG_ERROR("Trying to use multi-threading in non-MT build!");
        return true;
#     endif
    } else {
      auto* workerRM ATLAS_THREAD_SAFE =
          G4AtlasRunManager::GetG4AtlasRunManager();  // non-MT case
      return workerRM->ProcessEvent(inputEvent.release());
    }
  }();
 
  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 143 of file ISF_Geant4/ISF_Geant4Tools/src/TransportTool.h.

m_accumulatedEventTime

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

private

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

m_accumulatedEventTimeSq

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

private

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

m_activateParallelGeometries

Gaudi::Property<bool> iGeant4::G4TransportTool::m_activateParallelGeometries

private

Initial value:

{
      this, "ActivateParallelWorlds", false,
      "Toggle on/off the G4 parallel geometry system"}

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

m_chrono

ServiceHandle<IChronoStatSvc> ISF::BaseSimulatorTool::m_chrono {this, "ChronoStatService", "ChronoStatSvc"}

protectedinherited

The timing service for general usage.

Definition at line 115 of file BaseSimulatorTool.h.

m_detConstruction

PublicToolHandle<IDetectorConstructionTool> iGeant4::G4TransportTool::m_detConstruction {this, "DetectorConstruction", "", "Tool handle of the DetectorConstruction"}

private

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

m_doTiming

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

private

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

m_eventTimer

G4Timer* iGeant4::G4TransportTool::m_eventTimer {nullptr}

private

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

m_fastSimTool

PublicToolHandle<IFastSimulationMasterTool> iGeant4::G4TransportTool::m_fastSimTool

private

Initial value:

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

Fast Simulation Master Tool.

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

m_fieldMap

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

private

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

m_g4commands

Gaudi::Property<std::vector<std::string> > iGeant4::G4TransportTool::m_g4commands

private

Initial value:

{
      this, "G4Commands", {}, "Commands to send to the G4UI"}

Commands to send to the G4 UI.

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

m_inputConverter

ServiceHandle<ISF::IInputConverter> iGeant4::G4TransportTool::m_inputConverter

private

Initial value:

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

Service to convert ISF_Particles into a G4Event.

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

m_libList

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

private

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

m_mcEventCollectionName

Gaudi::Property<std::string> iGeant4::G4TransportTool::m_mcEventCollectionName

private

Initial value:

{
      this, "McEventCollection", "TruthEvent", ""}

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

m_nrOfEntries

unsigned int iGeant4::G4TransportTool::m_nrOfEntries {0}

private

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

m_physicsInitializationTools

PublicToolHandleArray<IPhysicsInitializationTool> iGeant4::G4TransportTool::m_physicsInitializationTools {this, "PhysicsInitializationTools", {}, "Physics initialization happening after Geant4 initialization"}

private

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

m_physList

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

private

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

m_physListSvc

ServiceHandle<IPhysicsListSvc> iGeant4::G4TransportTool::m_physListSvc

private

Initial value:

{this, "PhysicsListSvc",
                                               "PhysicsListSvc", ""}

Physics List Service.

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

m_quietMode

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

private

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

m_randomStreamName

Gaudi::Property<std::string> iGeant4::G4TransportTool::m_randomStreamName

private

Initial value:

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

Random Stream Name.

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

m_recordFlux

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

private

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

m_releaseGeoModel

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

private

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

m_rndmGenSvc

ServiceHandle<IAthRNGSvc> iGeant4::G4TransportTool::m_rndmGenSvc

private

Initial value:

{this, "RandomNumberService",
                                         "AthRNGSvc", ""}

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

m_runTimer

G4Timer* iGeant4::G4TransportTool::m_runTimer {nullptr}

private

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

m_senDetTool

PublicToolHandle<ISensitiveDetectorMasterTool> iGeant4::G4TransportTool::m_senDetTool

private

Initial value:

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

Sensitive Detector Master Tool.

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

m_useMT

Gaudi::Property<bool> iGeant4::G4TransportTool::m_useMT

private

Initial value:

{this, "MultiThreading", false,
                                "Multi-threading specific settings"}

Activate multi-threading configuration.

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

m_userActionSvc

ServiceHandle<G4UA::IUserActionSvc> iGeant4::G4TransportTool::m_userActionSvc

private

Initial value:

{this, "UserActionSvc", "",
                                                      ""}

user action service

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

m_userLimitsSvc

ServiceHandle<IUserLimitsSvc> iGeant4::G4TransportTool::m_userLimitsSvc

private

Initial value:

{this, "UserLimitsSvc",
                                                "UserLimitsSvc", ""}

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

---

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

• ISF_Geant4/ISF_Geant4Tools/src/TransportTool.h
• ISF_Geant4/ISF_Geant4Tools/src/TransportTool.cxx