ATLAS Offline Software
Classes | Public Member Functions | Protected Attributes | Private Member Functions | List of all members
iGeant4::G4LegacyTransportTool Class Reference

#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. More...
 
virtual ~G4LegacyTransportTool ()=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 >) 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
 

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::IG4RunManagerHelperm_g4RunManagerHelper
 Helper Tool to provide G4RunManager. More...
 
G4AtlasRunManagerm_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. More...
 
Gaudi::Property< bool > m_useMT
 Activate multi-threading configuration. More...
 
Gaudi::Property< bool > m_activateParallelGeometries
 
ServiceHandle< IAthRNGSvcm_rndmGenSvc
 
Gaudi::Property< std::string > m_randomStreamName
 Random Stream Name. More...
 
ServiceHandle< IUserLimitsSvcm_userLimitsSvc
 
ServiceHandle< G4UA::IUserActionSvcm_userActionSvc
 user action service More...
 
PublicToolHandle< IDetectorConstructionToolm_detConstruction {this, "DetectorConstruction", "", "Tool handle of the DetectorConstruction"}
 
ServiceHandle< ISF::IInputConverterm_inputConverter
 Service to convert ISF_Particles into a G4Event. More...
 
ServiceHandle< IPhysicsListSvcm_physListSvc
 Physics List Service. More...
 
PublicToolHandle< ISensitiveDetectorMasterToolm_senDetTool
 Sensitive Detector Master Tool. More...
 
PublicToolHandle< IFastSimulationMasterToolm_fastSimTool
 Fast Simulation Master Tool. More...
 
PublicToolHandleArray< IPhysicsInitializationToolm_physicsInitializationTools {this, "PhysicsInitializationTools", {}, "Physics initialization happening after Geant4 initialization"}
 

Detailed Description

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

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 56 of file G4LegacyTransportTool.cxx.

60 {
61  //declareProperty("KillAllNeutrinos", m_KillAllNeutrinos=true);
62  //declareProperty("KillLowEPhotons", m_KillLowEPhotons=-1.);
63 }

◆ ~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
inlineinherited

Standard BaseSimulatorTool constructor.

Definition at line 40 of file BaseSimulatorTool.h.

41  : base_class(type, name, parent)
42  {
43  }

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

98  {
99  if (m_chrono) return m_chrono->chronoStart( tag);
100  return nullptr;
101  }

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

104  {
105  if (m_chrono) return m_chrono->chronoStop( tag);
106  return nullptr;
107  }

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

423 {
424  switch(returnCode) {
425  case 0: { ATH_MSG_DEBUG("G4 Command: " << commandString << " - Command Succeeded"); } break;
426  case 100: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Command Not Found!"); } break;
427  case 200: {
428  auto* stateManager = G4StateManager::GetStateManager();
429  ATH_MSG_DEBUG("G4 Command: " << commandString << " - Illegal Application State (" <<
430  stateManager->GetStateString(stateManager->GetCurrentState()) << ")!");
431  } break;
432  case 300: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Parameter Out of Range!"); } break;
433  case 400: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Parameter Unreadable!"); } break;
434  case 500: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Parameter Out of Candidates!"); } break;
435  case 600: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Alias Not Found!"); } break;
436  default: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Unknown Status!"); } break;
437  }
438 
439 }

◆ finalize()

StatusCode iGeant4::G4LegacyTransportTool::finalize ( )
finaloverridevirtual

AlgTool finalize method.

Definition at line 204 of file G4LegacyTransportTool.cxx.

205 {
206  ATH_MSG_VERBOSE("++++++++++++ ISF G4 G4LegacyTransportTool finalized ++++++++++++");
207 
208  // One time finalization
209  try {
210  std::call_once(finalizeOnceFlag, &iGeant4::G4LegacyTransportTool::finalizeOnce, this);
211  }
212  catch(const std::exception& e) {
213  ATH_MSG_ERROR("Failure in iGeant4::G4LegacyTransportTool::finalizeOnce: " << e.what());
214  return StatusCode::FAILURE;
215  }
216 
217  if (m_doTiming) {
218  m_runTimer->Stop();
219  float runTime=m_runTimer->GetUserElapsed()+m_runTimer->GetSystemElapsed();
220  float avgTimePerEvent=(m_nrOfEntries>1) ? m_accumulatedEventTime/(m_nrOfEntries-1.) : runTime;
221  float sigma=( m_nrOfEntries>2) ? std::sqrt((m_accumulatedEventTimeSq/float(m_nrOfEntries-1)-
222  avgTimePerEvent*avgTimePerEvent)/float(m_nrOfEntries-2)) : 0;
223  ATH_MSG_INFO("*****************************************"<<endmsg<<
224  "** **"<<endmsg<<
225  " End of run - time spent is "<<std::setprecision(4) <<
226  runTime<<endmsg<<
227  " Average time per event was "<<std::setprecision(4) <<
228  avgTimePerEvent <<" +- "<< std::setprecision(4) << sigma<<endmsg<<
229  "** **"<<endmsg<<
230  "*****************************************");
231  }
232 
233  return StatusCode::SUCCESS;
234 }

◆ 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 237 of file G4LegacyTransportTool.cxx.

238 {
239  ATH_MSG_DEBUG("\t terminating the current G4 run");
240 
242 
243  return;
244 }

◆ genEvent()

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

Definition at line 400 of file G4LegacyTransportTool.cxx.

401 {
402 
403  if(!mcEventCollection) {
404  // retrieve McEventCollection from storegate
405  if (evtStore()->contains<McEventCollection>(m_mcEventCollectionName)) {
406  if (evtStore()->retrieve( mcEventCollection, m_mcEventCollectionName).isFailure()) {
407  ATH_MSG_ERROR( "Unable to retrieve McEventCollection with name=" << m_mcEventCollectionName
408  << ".");
409  return nullptr;
410  }
411  else {
412  ATH_MSG_WARNING( "Fallback. Sucessfully retrieved McEventCollection with name=" << m_mcEventCollectionName);
413  }
414  }
415  else { return nullptr; }
416  }
417  // collect last GenEvent from McEventCollection
418  return mcEventCollection->back();
419 }

◆ initialize()

StatusCode iGeant4::G4LegacyTransportTool::initialize ( )
finaloverridevirtual

AlgTool initialize method.

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 66 of file G4LegacyTransportTool.cxx.

67 {
68  ATH_MSG_VERBOSE("initialize");
69 
71 
72  // create G4Timers if enabled
73  if (m_doTiming) {
74  m_runTimer = new G4Timer();
75  m_eventTimer = new G4Timer();
76  m_runTimer->Start();
77  }
78 
79  // Create the scoring manager if requested
80  if (m_recordFlux) G4ScoringManager::GetScoringManager();
81 
82  // One-time initialization
83  try {
84  std::call_once(initializeOnceFlag, &iGeant4::G4LegacyTransportTool::initializeOnce, this);
85  }
86  catch(const std::exception& e) {
87  ATH_MSG_ERROR("Failure in iGeant4::G4LegacyTransportTool::initializeOnce: " << e.what());
88  return StatusCode::FAILURE;
89  }
90 
91  ATH_CHECK( m_rndmGenSvc.retrieve() );
92  ATH_CHECK( m_userActionSvc.retrieve() );
93 
94  ATH_CHECK(m_senDetTool.retrieve());
95  ATH_CHECK(m_fastSimTool.retrieve());
96 
97  ATH_CHECK(m_inputConverter.retrieve());
98 
99  return StatusCode::SUCCESS;
100 }

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

87  {
88  return StatusCode::FAILURE;
89  };

◆ 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 354 of file G4LegacyTransportTool.cxx.

355  {
356  ATH_MSG_DEBUG ( "release Event" );
359  /* todo: ELLI: the following is copied in from the PyG4AtlasAlg:
360  -> this somehow needs to be moved into C++
361  and put into releaseEvent() ( or setupEvent() ?)
362 
363  from ISF_Geant4Example import AtlasG4Eng
364  from ISF_Geant4Example.ISF_SimFlags import simFlags
365  if self.doFirstEventG4SeedsCheck :
366  if simFlags.SeedsG4.statusOn:
367  rnd = AtlasG4Eng.G4Eng.menu_G4RandomNrMenu()
368  rnd.set_Seed(simFlags.SeedsG4.get_Value())
369  self.doFirstEventG4SeedsCheck = False
370  if self.RndG4Menu.SaveStatus:
371  self.RndG4Menu.Menu.saveStatus('G4Seeds.txt')
372  */
373 
374  // print per-event timing info if enabled
375  if (m_doTiming) {
376  m_eventTimer->Stop();
377 
378  double eventTime=m_eventTimer->GetUserElapsed()+m_eventTimer->GetSystemElapsed();
379  if (m_nrOfEntries>1) {
380  m_accumulatedEventTime +=eventTime;
381  m_accumulatedEventTimeSq+=eventTime*eventTime;
382  }
383 
384  float avgTimePerEvent=(m_nrOfEntries>1) ? m_accumulatedEventTime/(m_nrOfEntries-1.) : eventTime;
385  float sigma=(m_nrOfEntries>2) ? std::sqrt((m_accumulatedEventTimeSq/float(m_nrOfEntries-1)-
386  avgTimePerEvent*avgTimePerEvent)/float(m_nrOfEntries-2)) : 0.;
387 
388  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) <<
389  eventTime << " s. New average " << std::setprecision(4) <<
390  avgTimePerEvent<<" +- "<<std::setprecision(4) << sigma);
391  }
392 
393  ATH_CHECK(m_senDetTool->EndOfAthenaEvent(hitCollections));
394  ATH_CHECK(m_fastSimTool->EndOfAthenaEvent());
395 
396  return StatusCode::SUCCESS;
397 }

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

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

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

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

79  {
80  return StatusCode::FAILURE;
81  };

◆ setupEvent() [2/2]

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

Create data containers for an event.

Implements ISF::BaseSimulatorG4Tool.

Definition at line 333 of file G4LegacyTransportTool.cxx.

334  {
335  ATH_MSG_DEBUG ( "setup Event" );
336 
337  // Set the RNG to use for this event. We need to reset it for MT jobs
338  // because of the mismatch between Gaudi slot-local and G4 thread-local RNG.
339  ATHRNG::RNGWrapper* rngWrapper = m_rndmGenSvc->getEngine(this, m_randomStreamName);
340  rngWrapper->setSeed( m_randomStreamName, ctx );
341  G4Random::setTheEngine(rngWrapper->getEngine(ctx));
342  ATH_CHECK(m_senDetTool->BeginOfAthenaEvent(hitCollections));
343 
344  m_nrOfEntries++;
345  if (m_doTiming) m_eventTimer->Start();
346 
347  // make sure SD collections are properly initialized in every Athena event
348  G4SDManager::GetSDMpointer()->PrepareNewEvent();
349 
350  return StatusCode::SUCCESS;
351 }

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

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

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

◆ simFlavor()

virtual ISF::SimulationFlavor iGeant4::G4LegacyTransportTool::simFlavor ( ) const
inlineoverridevirtual

Definition at line 107 of file G4LegacyTransportTool.h.

107  {
108  return ISF::Geant4;
109  };

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

66  {
67  return StatusCode::FAILURE;
68  };

◆ simulate() [2/2]

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 247 of file G4LegacyTransportTool.cxx.

250  {
251 
252  // give a screen output that you entered Geant4SimSvc
253  ATH_MSG_VERBOSE( "Particle " << isp << " received for simulation." );
254 
256  // wrap the given ISFParticle into a STL vector of ISFParticles with length 1
257  // (minimizing code duplication)
258  const ISF::ISFParticleVector ispVector(1, &isp);
259  StatusCode success = this->simulateVector(ctx, ispVector, secondaries,
260  mcEventCollection, hitCollections);
261  ATH_MSG_VERBOSE( "Simulation done" );
262 
263  // Geant4 call done
264  return success;
265 }

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

74  {
75  return StatusCode::FAILURE;
76  };

◆ simulateVector() [2/2]

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 268 of file G4LegacyTransportTool.cxx.

272  {
273 
274  ATH_MSG_DEBUG (name() << ".simulateVector(...) : Received a vector of " << particles.size() << " particles for simulation.");
276  // Lambda prevents using the unique_ptr
277  bool abort = [&] ATLAS_NOT_THREAD_SAFE {
278  auto eventInfo = std::make_unique<AtlasG4EventUserInfo>();
279  eventInfo->SetHitCollectionMap(hitCollections);
280 
281  auto inputEvent = std::make_unique<G4Event>(ctx.eventID().event_number());
282  inputEvent->SetUserInformation(eventInfo.release());
283 
284  m_inputConverter->ISF_to_G4Event(*inputEvent, particles,
285  genEvent(mcEventCollection));
286 
287  ATH_MSG_DEBUG("Calling ISF_Geant4 ProcessEvent");
288  return m_pRunMgr->ProcessEvent(inputEvent.release());
289  }();
290 
291  if (abort) {
292  ATH_MSG_WARNING("Event was aborted !! ");
293  //ATH_MSG_WARNING("Simulation will now go on to the next event ");
294  //ATH_MSG_WARNING("setFilterPassed is now False");
295  //setFilterPassed(false);
296  return StatusCode::FAILURE;
297  }
298 
299 
300  // const DataHandle <TrackRecordCollection> tracks;
301 
302  // StatusCode sc = evtStore()->retrieve(tracks,m_trackCollName);
303 
304  // if (sc.isFailure()) {
305  // ATH_MSG_WARNING(" Cannot retrieve TrackRecordCollection " << m_trackCollName);
306  // }
307 
308  // not implemented yet... need to get particle stack from Geant4 and convert to ISFParticle
309  ATH_MSG_VERBOSE( "Simulation done" );
310 
311  Slot& slot = *m_slots;
312  Slot::lock_t lock (slot.m_mutex);
313 
314  for (auto* cisp : particles) {
315  // return any secondaries associated with this particle
316  auto searchResult = slot.m_secondariesMap.find( cisp );
317  if ( searchResult == slot.m_secondariesMap.end() ) {
318 
319  ATH_MSG_VERBOSE( "Found no secondaries" );
320 
321  } else {
322 
323  ATH_MSG_VERBOSE( "Found secondaries: " << searchResult->second.size() );
324  secondaries.splice( end(secondaries), std::move(searchResult->second) ); //append vector
325  slot.m_secondariesMap.erase( searchResult );
326  }
327  }
328  // Geant4 call done
329  return StatusCode::SUCCESS;
330 }

◆ sysInitialize()

virtual StatusCode ISF::BaseSimulatorTool::sysInitialize ( )
inlineoverridevirtualinherited

Gaudi sysInitialize() methods.

Definition at line 49 of file BaseSimulatorTool.h.

50  {
52  ATH_CHECK( m_chrono.retrieve() );
53  return StatusCode::SUCCESS;
54  }

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.

◆ m_accumulatedEventTimeSq

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

Definition at line 125 of file G4LegacyTransportTool.h.

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

◆ 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::G4LegacyTransportTool::m_detConstruction {this, "DetectorConstruction", "", "Tool handle of the DetectorConstruction"}
private

Definition at line 175 of file G4LegacyTransportTool.h.

◆ m_doTiming

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

Definition at line 122 of file G4LegacyTransportTool.h.

◆ m_eventTimer

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

Definition at line 129 of file G4LegacyTransportTool.h.

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

◆ m_fieldMap

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

Definition at line 150 of file G4LegacyTransportTool.h.

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

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

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

◆ m_libList

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

Definition at line 148 of file G4LegacyTransportTool.h.

◆ m_mcEventCollectionName

Gaudi::Property<std::string> iGeant4::G4LegacyTransportTool::m_mcEventCollectionName
private
Initial value:
{
this, "McEventCollection", "TruthEvent", ""}

Definition at line 140 of file G4LegacyTransportTool.h.

◆ m_nrOfEntries

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

Definition at line 126 of file G4LegacyTransportTool.h.

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

◆ m_physList

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

Definition at line 149 of file G4LegacyTransportTool.h.

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

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

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

◆ m_recordFlux

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

Definition at line 152 of file G4LegacyTransportTool.h.

◆ m_releaseGeoModel

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

Definition at line 151 of file G4LegacyTransportTool.h.

◆ m_rndmGenSvc

ServiceHandle<IAthRNGSvc> iGeant4::G4LegacyTransportTool::m_rndmGenSvc
private
Initial value:
{this, "RandomNumberService",
"AthRNGSvc", ""}

Definition at line 164 of file G4LegacyTransportTool.h.

◆ m_runTimer

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

Definition at line 128 of file G4LegacyTransportTool.h.

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

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

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

◆ m_userLimitsSvc

ServiceHandle<IUserLimitsSvc> iGeant4::G4LegacyTransportTool::m_userLimitsSvc
private
Initial value:
{this, "UserLimitsSvc",
"UserLimitsSvc", ""}

Definition at line 170 of file G4LegacyTransportTool.h.


The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
ATHRNG::RNGWrapper::setSeed
void setSeed(const std::string &algName, const EventContext &ctx)
Set the random seed using a string (e.g.
Definition: RNGWrapper.h:169
pdg_comparison.sigma
sigma
Definition: pdg_comparison.py:324
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
G4AtlasRunManager::RunTermination
void RunTermination() override final
G4 function called at end of run.
Definition: G4AtlasRunManager.cxx:128
iGeant4::G4LegacyTransportTool::finalizeOnce
void finalizeOnce()
G4 finalization called only by the first tool instance.
Definition: G4LegacyTransportTool.cxx:237
ISF::BaseSimulatorG4Tool::releaseEvent
virtual StatusCode releaseEvent(const EventContext &, HitCollectionMap &)=0
Finalise data containers for an event.
iGeant4::G4LegacyTransportTool::m_accumulatedEventTime
float m_accumulatedEventTime
Definition: G4LegacyTransportTool.h:124
python.RatesEmulationExample.lock
lock
Definition: RatesEmulationExample.py:148
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
iGeant4::G4LegacyTransportTool::m_accumulatedEventTimeSq
float m_accumulatedEventTimeSq
Definition: G4LegacyTransportTool.h:125
iGeant4::G4LegacyTransportTool::m_userActionSvc
ServiceHandle< G4UA::IUserActionSvc > m_userActionSvc
user action service
Definition: G4LegacyTransportTool.h:173
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
iGeant4::G4LegacyTransportTool::m_pRunMgr
G4AtlasRunManager * m_pRunMgr
Definition: G4LegacyTransportTool.h:146
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
ISF::BaseSimulatorG4Tool::setupEvent
virtual StatusCode setupEvent(const EventContext &, HitCollectionMap &)=0
Create data containers for an event.
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
iGeant4::G4LegacyTransportTool::simulateVector
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.
Definition: G4LegacyTransportTool.cxx:268
iGeant4::G4LegacyTransportTool::m_rndmGenSvc
ServiceHandle< IAthRNGSvc > m_rndmGenSvc
Definition: G4LegacyTransportTool.h:164
ISF::Geant4
@ Geant4
Definition: SimulationFlavor.h:23
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ISF::BaseSimulatorTool::m_chrono
ServiceHandle< IChronoStatSvc > m_chrono
The timing service for general usage.
Definition: BaseSimulatorTool.h:115
ISF::ISFParticleVector
std::vector< ISF::ISFParticle * > ISFParticleVector
ISFParticle vector.
Definition: ISFParticleContainer.h:26
calibdata.exception
exception
Definition: calibdata.py:495
G4AtlasRunManager::ProcessEvent
bool ProcessEvent(G4Event *event)
Does the work of simulating an ATLAS event.
Definition: G4AtlasRunManager.cxx:104
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
iGeant4::G4LegacyTransportTool::m_doTiming
Gaudi::Property< bool > m_doTiming
Definition: G4LegacyTransportTool.h:122
iGeant4::G4LegacyTransportTool::m_runTimer
G4Timer * m_runTimer
Definition: G4LegacyTransportTool.h:128
DataVector::back
const T * back() const
Access the last element in the collection as an rvalue.
iGeant4::G4LegacyTransportTool::m_inputConverter
ServiceHandle< ISF::IInputConverter > m_inputConverter
Service to convert ISF_Particles into a G4Event.
Definition: G4LegacyTransportTool.h:177
iGeant4::G4LegacyTransportTool::m_nrOfEntries
unsigned int m_nrOfEntries
Definition: G4LegacyTransportTool.h:126
iGeant4::G4LegacyTransportTool::m_recordFlux
Gaudi::Property< bool > m_recordFlux
Definition: G4LegacyTransportTool.h:152
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ATHRNG::RNGWrapper
A wrapper class for event-slot-local random engines.
Definition: RNGWrapper.h:56
iGeant4::G4LegacyTransportTool::m_eventTimer
G4Timer * m_eventTimer
Definition: G4LegacyTransportTool.h:129
AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize
virtual StatusCode sysInitialize() override
Perform system initialization for an algorithm.
iGeant4::G4LegacyTransportTool::m_randomStreamName
Gaudi::Property< std::string > m_randomStreamName
Random Stream Name.
Definition: G4LegacyTransportTool.h:167
ATHRNG::RNGWrapper::getEngine
CLHEP::HepRandomEngine * getEngine(const EventContext &ctx) const
Retrieve the random engine corresponding to the provided EventContext.
Definition: RNGWrapper.h:134
iGeant4::G4LegacyTransportTool::m_senDetTool
PublicToolHandle< ISensitiveDetectorMasterTool > m_senDetTool
Sensitive Detector Master Tool.
Definition: G4LegacyTransportTool.h:183
ISF::BaseSimulatorTool::initialize
virtual StatusCode initialize() override
Definition: BaseSimulatorTool.h:57
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
iGeant4::G4LegacyTransportTool::Slot::lock_t
std::lock_guard< mutex_t > lock_t
Definition: G4LegacyTransportTool.h:136
LArG4FSStartPointFilter.particles
list particles
Definition: LArG4FSStartPointFilter.py:84
iGeant4::G4LegacyTransportTool::ATLAS_NOT_THREAD_SAFE
void initializeOnce ATLAS_NOT_THREAD_SAFE()
G4 initialization called only by the first tool instance.
ISF::BaseSimulatorG4Tool
Definition: BaseSimulatorG4Tool.h:28
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:23
iGeant4::G4LegacyTransportTool::m_mcEventCollectionName
Gaudi::Property< std::string > m_mcEventCollectionName
Definition: G4LegacyTransportTool.h:140
iGeant4::G4LegacyTransportTool::genEvent
HepMC::GenEvent * genEvent(McEventCollection *mcEventCollection) const
Definition: G4LegacyTransportTool.cxx:400
iGeant4::G4LegacyTransportTool::m_fastSimTool
PublicToolHandle< IFastSimulationMasterTool > m_fastSimTool
Fast Simulation Master Tool.
Definition: G4LegacyTransportTool.h:186