iGeant4::G4LegacyTransportTool Class Reference

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

#include <G4LegacyTransportTool.h>

Inheritance diagram for iGeant4::G4LegacyTransportTool:

Collaboration diagram for iGeant4::G4LegacyTransportTool:

Classes
struct	Slot

Public Member Functions
	G4LegacyTransportTool (const std::string &, const std::string &, const IInterface *)
	Constructor.
virtual	~G4LegacyTransportTool ()=default
	Destructor.
virtual StatusCode	initialize () override final
	AlgTool initialize method.
void initializeOnce	ATLAS_NOT_THREAD_SAFE ()
	G4 initialization called only by the first tool instance.
virtual StatusCode	finalize () override final
	AlgTool finalize method.
void	finalizeOnce ()
	G4 finalization called only by the first tool instance.
virtual StatusCode	simulate (const EventContext &ctx, ISF::ISFParticle &isp, ISF::ISFParticleContainer &secondaries, McEventCollection *mcEventCollection, std::shared_ptr< HitCollectionMap >) override
	Simulation call for individual particles.
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.
virtual StatusCode	setupEvent (const EventContext &, HitCollectionMap &) override
	Create data containers for an event.
virtual StatusCode	releaseEvent (const EventContext &, HitCollectionMap &) override
	Finalise data containers for an event.
virtual ISF::SimulationFlavor	simFlavor () const override
virtual StatusCode	releaseEvent (const EventContext &)
	Finalise data containers for an event.
virtual StatusCode	setupEvent (const EventContext &)
	Create data containers for an event.
virtual StatusCode	simulate (const EventContext &, ISFParticle &, ISFParticleContainer &, McEventCollection *)
	Simulation call for individual particles.
virtual StatusCode	simulateVector (const EventContext &, const ISFParticleVector &, ISFParticleContainer &, McEventCollection *, McEventCollection *)
	Simulation call for vectors of particles.
virtual StatusCode	simulate (const EventContext &, ISFParticle &, ISFParticleContainer &, McEventCollection *)
	Simulation call for individual particles.
virtual StatusCode	simulateVector (const EventContext &, const ISFParticleVector &, ISFParticleContainer &, McEventCollection *, McEventCollection *)
	Simulation call for vectors of particles.
virtual StatusCode	setupEventST (HitCollectionMap &hitCollections)
	Create data containers for an event (called by ISimulationSvc)
virtual StatusCode	setupEventST ()
	Create data containers for an event (called by ISimulationSvc)
virtual StatusCode	releaseEventST (HitCollectionMap &hitCollections)
	Finalise data containers for an event (called by ISimulationSvc)
virtual StatusCode	releaseEventST ()
	Finalise data containers for an event (called by ISimulationSvc)
	BaseSimulatorTool (const std::string &type, const std::string &name, const IInterface *parent)
	Standard BaseSimulatorTool constructor.
virtual StatusCode	sysInitialize () override
	Gaudi sysInitialize() methods.
const ChronoEntity *	chronoStart (const IChronoSvc::ChronoTag &tag)
	wrapper call to start chrono with given tag
const ChronoEntity *	chronoStop (const IChronoSvc::ChronoTag &tag)
	wrapper call to stop chrono with given tag

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

Private Member Functions
void	commandLog (int returnCode, const std::string &commandString) const
	This command prints a message about a G4Command depending on its returnCode.
HepMC::GenEvent *	genEvent (McEventCollection *mcEventCollection) const

Private Attributes
Configurable Properties
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}
SG::SlotSpecificObj< Slot > m_slots	ATLAS_THREAD_SAFE
Gaudi::Property< std::string >	m_mcEventCollectionName
PublicToolHandle< ISF::IG4RunManagerHelper >	m_g4RunManagerHelper
	Helper Tool to provide G4RunManager.
G4AtlasRunManager *	m_pRunMgr {}
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.
Gaudi::Property< bool >	m_useMT
	Activate multi-threading configuration.
Gaudi::Property< bool >	m_activateParallelGeometries
ServiceHandle< IAthRNGSvc >	m_rndmGenSvc
Gaudi::Property< std::string >	m_randomStreamName
	Random Stream Name.
ServiceHandle< IUserLimitsSvc >	m_userLimitsSvc
ServiceHandle< G4UA::IUserActionSvc >	m_userActionSvc
	user action service
PublicToolHandle< IDetectorConstructionTool >	m_detConstruction {this, "DetectorConstruction", "", "Tool handle of the DetectorConstruction"}
ServiceHandle< ISF::IInputConverter >	m_inputConverter
	Service to convert ISF_Particles into a G4Event.
ServiceHandle< IPhysicsListSvc >	m_physListSvc
	Physics List Service.
PublicToolHandle< ISensitiveDetectorMasterTool >	m_senDetTool
	Sensitive Detector Master Tool.
PublicToolHandle< IFastSimulationMasterTool >	m_fastSimTool
	Fast Simulation Master Tool.
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 60 of file G4LegacyTransportTool.h.

Constructor & Destructor Documentation

G4LegacyTransportTool()

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

Constructor.

Definition at line 55 of file G4LegacyTransportTool.cxx.

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

~G4LegacyTransportTool()

virtual iGeant4::G4LegacyTransportTool::~G4LegacyTransportTool ( )

virtualdefault

Destructor.

Member Function Documentation

ATLAS_NOT_THREAD_SAFE()

void initializeOnce iGeant4::G4LegacyTransportTool::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 ( const std::string & type, const std::string & name, const IInterface * parent )

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::G4LegacyTransportTool::commandLog ( int returnCode, const std::string & commandString ) const

private

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

Definition at line 422 of file G4LegacyTransportTool.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::G4LegacyTransportTool::finalize ( )

finaloverridevirtual

AlgTool finalize method.

Definition at line 202 of file G4LegacyTransportTool.cxx.

{
  ATH_MSG_VERBOSE("++++++++++++  ISF G4 G4LegacyTransportTool finalized  ++++++++++++");
 
  // One time finalization
  try {
    std::call_once(finalizeOnceFlag, &iGeant4::G4LegacyTransportTool::finalizeOnce, this);
  }
  catch(const std::exception& e) {
    ATH_MSG_ERROR("Failure in iGeant4::G4LegacyTransportTool::finalizeOnce: " << e.what());
    return StatusCode::FAILURE;
  }
 
  if (m_doTiming) {
    m_runTimer->Stop();
    float runTime=m_runTimer->GetUserElapsed()+m_runTimer->GetSystemElapsed();
    float avgTimePerEvent=(m_nrOfEntries>1) ? m_accumulatedEventTime/(m_nrOfEntries-1.) : runTime;
    float sigma=( m_nrOfEntries>2) ? std::sqrt((m_accumulatedEventTimeSq/float(m_nrOfEntries-1)-
                                                avgTimePerEvent*avgTimePerEvent)/float(m_nrOfEntries-2)) : 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::G4LegacyTransportTool::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 235 of file G4LegacyTransportTool.cxx.

{
  ATH_MSG_DEBUG("\t terminating the current G4 run");
 
  m_pRunMgr->RunTermination();
 
  return;
}

genEvent()

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

private

Definition at line 400 of file G4LegacyTransportTool.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::G4LegacyTransportTool::initialize ( )

finaloverridevirtual

AlgTool initialize method.

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 65 of file G4LegacyTransportTool.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::G4LegacyTransportTool::initializeOnce, this);
  }
  catch(const std::exception& e) {
    ATH_MSG_ERROR("Failure in iGeant4::G4LegacyTransportTool::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 & )

inlinevirtual

Finalise data containers for an event.

Reimplemented from ISF::BaseSimulatorG4Tool.

Definition at line 87 of file BaseSimulatorG4Tool.h.

                                                       {
    return StatusCode::FAILURE;
  };

releaseEvent() [2/2]

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

overridevirtual

Finalise data containers for an event.

Todo

: strip hits of the tracks ...

Implements ISF::BaseSimulatorG4Tool.

Definition at line 353 of file G4LegacyTransportTool.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();
 
    double eventTime=m_eventTimer->GetUserElapsed()+m_eventTimer->GetSystemElapsed();
    if (m_nrOfEntries>1) {
      m_accumulatedEventTime  +=eventTime;
      m_accumulatedEventTimeSq+=eventTime*eventTime;
    }
 
    float avgTimePerEvent=(m_nrOfEntries>1) ? m_accumulatedEventTime/(m_nrOfEntries-1.) : eventTime;
    float sigma=(m_nrOfEntries>2) ? std::sqrt((m_accumulatedEventTimeSq/float(m_nrOfEntries-1)-
                                               avgTimePerEvent*avgTimePerEvent)/float(m_nrOfEntries-2)) : 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_userActionSvc->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 & )

inlinevirtual

Create data containers for an event.

Reimplemented from ISF::BaseSimulatorG4Tool.

Definition at line 79 of file BaseSimulatorG4Tool.h.

                                                     {
    return StatusCode::FAILURE;
  };

setupEvent() [2/2]

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

overridevirtual

Create data containers for an event.

Implements ISF::BaseSimulatorG4Tool.

Definition at line 331 of file G4LegacyTransportTool.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));
  ATH_CHECK(m_userActionSvc->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::G4LegacyTransportTool::simFlavor ( ) const

inlineoverridevirtual

Definition at line 107 of file G4LegacyTransportTool.h.

                                                         {
    return ISF::Geant4;
  };

simulate() [1/3]

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

inline

Simulation call for individual particles.

Definition at line 65 of file BaseSimulatorG4Tool.h.

                                                                         {
    return StatusCode::FAILURE;
  };

simulate() [2/3]

StatusCode iGeant4::G4LegacyTransportTool::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 245 of file G4LegacyTransportTool.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;
}

simulate() [3/3]

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

simulateVector() [1/3]

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

inline

Simulation call for vectors of particles.

Definition at line 71 of file BaseSimulatorG4Tool.h.

                                                        {
    return StatusCode::FAILURE;
  };

simulateVector() [2/3]

StatusCode iGeant4::G4LegacyTransportTool::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 266 of file G4LegacyTransportTool.cxx.

                        {
 
  ATH_MSG_DEBUG (name() << ".simulateVector(...) : Received a vector of " << particles.size() << " particles for simulation.");
  // Lambda prevents using the unique_ptr 
  bool abort = [&] ATLAS_NOT_THREAD_SAFE {
    auto eventInfo = std::make_unique<AtlasG4EventUserInfo>(ctx);
    eventInfo->SetHitCollectionMap(hitCollections);
 
    auto inputEvent = std::make_unique<G4Event>(ctx.eventID().event_number());
    inputEvent->SetUserInformation(eventInfo.release());
 
    m_inputConverter->ISF_to_G4Event(*inputEvent, particles,
                                    genEvent(mcEventCollection));
 
    ATH_MSG_DEBUG("Calling ISF_Geant4 ProcessEvent");
    return m_pRunMgr->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;
  }
 
 
  // 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" );
 
  Slot& slot = *m_slots;
  Slot::lock_t lock (slot.m_mutex);
  
  for (auto* cisp : particles) {
    // return any secondaries associated with this particle
    auto searchResult = slot.m_secondariesMap.find( cisp );
    if ( searchResult == slot.m_secondariesMap.end() ) {
 
      ATH_MSG_VERBOSE( "Found no secondaries" );
 
    } else {
 
      ATH_MSG_VERBOSE( "Found secondaries: " << searchResult->second.size() );
      secondaries.splice( end(secondaries), std::move(searchResult->second) ); //append vector
      slot.m_secondariesMap.erase( searchResult );
    }
  }
  // Geant4 call done
  return StatusCode::SUCCESS;
}

simulateVector() [3/3]

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

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

SG::SlotSpecificObj<Slot> m_slots iGeant4::G4LegacyTransportTool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 139 of file G4LegacyTransportTool.h.

m_accumulatedEventTime

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

private

Definition at line 124 of file G4LegacyTransportTool.h.

{0.};

m_accumulatedEventTimeSq

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

private

Definition at line 125 of file G4LegacyTransportTool.h.

{0.};

m_activateParallelGeometries

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

private

Initial value:

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

Definition at line 160 of file G4LegacyTransportTool.h.

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

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.

{this, "ChronoStatService", "ChronoStatSvc"};

m_detConstruction

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

private

Definition at line 175 of file G4LegacyTransportTool.h.

{this, "DetectorConstruction", "", "Tool handle of the DetectorConstruction"};

m_doTiming

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

private

Definition at line 122 of file G4LegacyTransportTool.h.

{this, "PrintTimingInfo", true, ""};

m_eventTimer

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

private

Definition at line 129 of file G4LegacyTransportTool.h.

{nullptr};

m_fastSimTool

PublicToolHandle<IFastSimulationMasterTool> iGeant4::G4LegacyTransportTool::m_fastSimTool

private

Initial value:

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

Fast Simulation Master Tool.

Definition at line 186 of file G4LegacyTransportTool.h.

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

m_fieldMap

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

private

Definition at line 150 of file G4LegacyTransportTool.h.

{this, "FieldMap", "", ""};

m_g4commands

Gaudi::Property<std::vector<std::string> > iGeant4::G4LegacyTransportTool::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 G4LegacyTransportTool.h.

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

m_g4RunManagerHelper

PublicToolHandle<ISF::IG4RunManagerHelper> iGeant4::G4LegacyTransportTool::m_g4RunManagerHelper

private

Initial value:

{
      this, "G4RunManagerHelper",
      "iGeant4::G4RunManagerHelper/G4RunManagerHelper", ""}

Helper Tool to provide G4RunManager.

Definition at line 143 of file G4LegacyTransportTool.h.

                                                               {
      this, "G4RunManagerHelper",
      "iGeant4::G4RunManagerHelper/G4RunManagerHelper", ""};

m_inputConverter

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

private

Initial value:

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

Service to convert ISF_Particles into a G4Event.

Definition at line 177 of file G4LegacyTransportTool.h.

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

m_libList

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

private

Definition at line 148 of file G4LegacyTransportTool.h.

{this, "Dll", "", ""};

m_mcEventCollectionName

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

private

Initial value:

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

Definition at line 140 of file G4LegacyTransportTool.h.

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

m_nrOfEntries

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

private

Definition at line 126 of file G4LegacyTransportTool.h.

{0};

m_physicsInitializationTools

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

private

Definition at line 188 of file G4LegacyTransportTool.h.

{this, "PhysicsInitializationTools", {}, "Physics initialization happening after Geant4 initialization"};

m_physList

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

private

Definition at line 149 of file G4LegacyTransportTool.h.

{this, "Physics", "", ""};

m_physListSvc

ServiceHandle<IPhysicsListSvc> iGeant4::G4LegacyTransportTool::m_physListSvc

private

Initial value:

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

Physics List Service.

Definition at line 180 of file G4LegacyTransportTool.h.

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

m_pRunMgr

G4AtlasRunManager* iGeant4::G4LegacyTransportTool::m_pRunMgr {}

private

Definition at line 146 of file G4LegacyTransportTool.h.

{};

m_quietMode

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

private

Definition at line 153 of file G4LegacyTransportTool.h.

{this, "QuietMode", false, ""};

m_randomStreamName

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

private

Initial value:

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

Random Stream Name.

Definition at line 167 of file G4LegacyTransportTool.h.

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

m_recordFlux

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

private

Definition at line 152 of file G4LegacyTransportTool.h.

{this, "RecordFlux", false, ""};

m_releaseGeoModel

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

private

Definition at line 151 of file G4LegacyTransportTool.h.

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

m_rndmGenSvc

ServiceHandle<IAthRNGSvc> iGeant4::G4LegacyTransportTool::m_rndmGenSvc

private

Initial value:

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

Definition at line 164 of file G4LegacyTransportTool.h.

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

m_runTimer

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

private

Definition at line 128 of file G4LegacyTransportTool.h.

{nullptr};

m_senDetTool

PublicToolHandle<ISensitiveDetectorMasterTool> iGeant4::G4LegacyTransportTool::m_senDetTool

private

Initial value:

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

Sensitive Detector Master Tool.

Definition at line 183 of file G4LegacyTransportTool.h.

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

m_useMT

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

private

Initial value:

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

Activate multi-threading configuration.

Definition at line 158 of file G4LegacyTransportTool.h.

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

m_userActionSvc

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

private

Initial value:

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

user action service

Definition at line 173 of file G4LegacyTransportTool.h.

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

m_userLimitsSvc

ServiceHandle<IUserLimitsSvc> iGeant4::G4LegacyTransportTool::m_userLimitsSvc

private

Initial value:

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

Definition at line 170 of file G4LegacyTransportTool.h.

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

---

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

• G4LegacyTransportTool.h
• G4LegacyTransportTool.cxx