simcore::Simulator Class Reference

Producer that runs Geant4 simulation inside of ldmx-app. More...

#include <Simulator.h>

Public Member Functions
	Simulator (const std::string &name, framework::Process &process)
	Constructor.
virtual	~Simulator ()=default
	Destructor.
void	configure (framework::config::Parameters &parameters) override
	Callback for the processor to configure itself from the given set of parameters.
void	beforeNewRun (ldmx::RunHeader &header) override
	Given a non-const reference to the new RunHeader, we can add parameters from the simulation here before the run starts.
void	onNewRun (const ldmx::RunHeader &header) override
	Before the run starts (but after the conditions are configured) set up the random seeds for this run.
virtual void	produce (framework::Event &event) override
	Run simulation and export results to output event.
void	onProcessEnd () override
	Callback called once processing is complete.
Public Member Functions inherited from simcore::SimulatorBase
	SimulatorBase (const std::string &name, framework::Process &process)
void	configure (framework::config::Parameters &parameters) override
	Callback for the EventProcessor to configure itself from the given set of parameters.
Public Member Functions inherited from framework::Producer
	Producer (const std::string &name, Process &process)
	Class constructor.
virtual void	process (Event &event) final
	Processing an event for a Producer is calling produce.
Public Member Functions inherited from framework::EventProcessor
	DECLARE_FACTORY (EventProcessor, EventProcessor *, const std::string &, Process &)
	declare that we have a factory for this class
	EventProcessor (const std::string &name, Process &process)
	Class constructor.
virtual	~EventProcessor ()=default
	Class destructor.
virtual void	onFileOpen (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.
virtual void	onFileClose (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a event input ROOT file is closed.
template<class T >
const T &	getCondition (const std::string &condition_name)
	Access a conditions object for the current event.
TDirectory *	getHistoDirectory ()
	Access/create a directory in the histogram file for this event processor to create histograms and analysis tuples.
void	setStorageHint (framework::StorageControl::Hint hint)
	Mark the current event as having the given storage control hint from this module_.
void	setStorageHint (framework::StorageControl::Hint hint, const std::string &purposeString)
	Mark the current event as having the given storage control hint from this module and the given purpose string.
int	getLogFrequency () const
	Get the current logging frequency from the process.
int	getRunNumber () const
	Get the run number from the process.
std::string	getName () const
	Get the processor name.
void	createHistograms (const std::vector< framework::config::Parameters > &histos)
	Internal function which is used to create histograms passed from the python configuration @parma histos vector of Parameters that configure histograms to create.

Private Member Functions
void	setSeeds (std::vector< int > seeds)
	Set the seeds to be used by the Geant4 random engine.

Private Attributes
int	num_events_began_ {0}
	Number of events started.
int	num_events_completed_ {0}
	Number of events completed.
int	run_ {-1}
	the run number (for accessing the run header in onFileClose

Additional Inherited Members
Protected Member Functions inherited from simcore::SimulatorBase
void	onProcessEnd () override
	Callback called once processing is complete.
void	onProcessStart () override
	Initialization of simulation.
virtual void	updateEventHeader (ldmx::EventHeader &eventHeader) const
virtual void	saveTracks (framework::Event &event)
virtual void	saveSDHits (framework::Event &event)
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.
Protected Attributes inherited from simcore::SimulatorBase
ConditionsInterface	conditions_intf_
	Conditions interface.
G4UImanager *	ui_manager_ {nullptr}
	User interface handle.
std::unique_ptr< RunManager >	run_manager_
	Manager controlling G4 simulation run.
std::unique_ptr< LoggedSession >	session_handle_
	Handle to the G4Session -> how to deal with G4cout and G4cerr.
framework::config::Parameters	parameters_
	The parameters used to configure the simulation.
std::vector< std::string >	pre_init_commands_
std::vector< std::string >	post_init_commands_
Protected Attributes inherited from framework::EventProcessor
HistogramPool	histograms_
	helper object for making and filling histograms
NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.
logging::logger	the_log_
	The logger for this EventProcessor.
Static Protected Attributes inherited from simcore::SimulatorBase
static const std::vector< std::string >	INVALID_COMMANDS
	Commands not allowed to be passed from python config file This is because Simulator already runs them.

Detailed Description

Producer that runs Geant4 simulation inside of ldmx-app.

Most (if not all) of the heavy lifting is done in the classes in the Sim* modules. This producer is mainly focused on calling appropriate functions at the right time in the processing chain.

Definition at line 87 of file Simulator.h.

Constructor & Destructor Documentation

Simulator()

simcore::Simulator::Simulator	(	const std::string &	name,
		framework::Process &	process )

Constructor.

Blank Producer constructor Constructs object that are non-configurable.

Parameters

name	Name for this instance of the class.
process	The Process class assocaited with EventProcessor, provided by the Framework.

Definition at line 12 of file Simulator.cxx.

    : simcore::SimulatorBase(name, process) {}

Member Function Documentation

beforeNewRun()

void simcore::Simulator::beforeNewRun ( ldmx::RunHeader & header )

overridevirtual

Given a non-const reference to the new RunHeader, we can add parameters from the simulation here before the run starts.

Parameters

header

of new run

Reimplemented from framework::EventProcessor.

Definition at line 19 of file Simulator.cxx.

                                                  {
  // Get the detector header from the user detector construction
  DetectorConstruction* detector =
      dynamic_cast<RunManager*>(RunManager::GetRunManager())
          ->getDetectorConstruction();
 
  header.setDetectorName(detector->getDetectorName());
  header.setDescription(parameters_.get<std::string>("description"));
  header.setIntParameter(
      "Included Scoring Planes",
      !parameters_.get<std::string>("scoringPlanes").empty());
  header.setIntParameter("Use Random Seed from Event Header",
                         parameters_.get<bool>("rootPrimaryGenUseSeed"));
 
  // lambda function for dumping 3-vectors into the run header
  auto three_vector_dump = [&header](const std::string& name,
                                     const std::vector<double>& vec) {
    header.setFloatParameter(name + " X", vec.at(0));
    header.setFloatParameter(name + " Y", vec.at(1));
    header.setFloatParameter(name + " Z", vec.at(2));
  };
 
  auto beam_spot_smear{
      parameters_.get<std::vector<double>>("beamSpotSmear", {})};
  if (!beam_spot_smear.empty()) {
    three_vector_dump("Smear Beam Spot [mm]", beam_spot_smear);
  }
 
  // lambda function for dumping vectors of strings to the run header
  auto string_vector_dump = [&header](const std::string& name,
                                      const std::vector<std::string>& vec) {
    int index = 0;
    for (auto const& val : vec) {
      header.setStringParameter(name + " " + std::to_string(++index), val);
    }
  };
 
  string_vector_dump(
      "Pre Init Command",
      parameters_.get<std::vector<std::string>>("preInitCommands", {}));
  string_vector_dump(
      "Post Init Command",
      parameters_.get<std::vector<std::string>>("postInitCommands", {}));
 
  simcore::XsecBiasingOperator::Factory::get().apply(
      [&header](auto bop) { bop->RecordConfig(header); });
 
  int counter = 0;
  PrimaryGenerator::Factory::get().apply([&header, &counter](auto gen) {
    std::string gen_id = "Gen" + std::to_string(counter++);
    gen->RecordConfig(gen_id, header);
  });
 
  // Set a string parameter with the Geant4 SHA-1.
  if (G4RunManagerKernel::GetRunManagerKernel()) {
    G4String g4_version{
        G4RunManagerKernel::GetRunManagerKernel()->GetVersionString()};
    header.setStringParameter("Geant4 revision", g4_version);
  } else {
    ldmx_log(warn) << "Unable to access G4 RunManager Kernel. Will not store "
                      "G4 Version string.";
  }
 
  header.setStringParameter("SIM version", LDMXSW_VERSION);
  header.setStringParameter("SIM revision", GIT_SHA1);
}

References framework::config::Parameters::get(), simcore::DetectorConstruction::getDetectorName(), simcore::SimulatorBase::parameters_, ldmx::RunHeader::setDescription(), ldmx::RunHeader::setDetectorName(), ldmx::RunHeader::setFloatParameter(), ldmx::RunHeader::setIntParameter(), and ldmx::RunHeader::setStringParameter().

configure()

void simcore::Simulator::configure ( framework::config::Parameters & parameters )

overridevirtual

Callback for the processor to configure itself from the given set of parameters.

Parameters

parameters

ParameterSet for configuration.

Reimplemented from framework::EventProcessor.

Definition at line 15 of file Simulator.cxx.

                                                               {
  SimulatorBase::configure(parameters);
}

References simcore::SimulatorBase::configure().

onNewRun()

void simcore::Simulator::onNewRun ( const ldmx::RunHeader & header )

overridevirtual

Before the run starts (but after the conditions are configured) set up the random seeds for this run.

Parameters

[in]

header

RunHeader for this run, unused

Reimplemented from framework::EventProcessor.

Definition at line 86 of file Simulator.cxx.

                                                       {
  const framework::RandomNumberSeedService& rseed =
      getCondition<framework::RandomNumberSeedService>(
          framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME);
  std::vector<int> seeds;
  seeds.push_back(rseed.getSeed("Simulator[0]"));
  seeds.push_back(rseed.getSeed("Simulator[1]"));
  setSeeds(seeds);
 
  run_ = runHeader.getRunNumber();
}

References framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME, framework::EventProcessor::getCondition(), ldmx::RunHeader::getRunNumber(), framework::RandomNumberSeedService::getSeed(), run_, and setSeeds().

onProcessEnd()

void simcore::Simulator::onProcessEnd ( )

overridevirtual

Callback called once processing is complete.

Reimplemented from framework::EventProcessor.

Definition at line 145 of file Simulator.cxx.

                             {
  SimulatorBase::onProcessEnd();
  // Put this to warn level, just so it's printed out for sure
  ldmx_log(warn) << "Started " << num_events_began_ << " events to produce "
                 << num_events_completed_ << " events.";
}

References num_events_began_, num_events_completed_, and simcore::SimulatorBase::onProcessEnd().

produce()

void simcore::Simulator::produce ( framework::Event & event )

overridevirtual

Run simulation and export results to output event.

Parameters

event

The event to process.

Implements simcore::SimulatorBase.

Definition at line 98 of file Simulator.cxx.

                                             {
  // Generate and process a Geant4 event.
  num_events_began_++;
  // Save the state of the random engine to an output stream. A string
  // is then extracted and saved to the event header.
  std::ostringstream stream;
  G4Random::saveFullState(stream);
  run_manager_->ProcessOneEvent(event.getEventHeader().getEventNumber());
 
  // If a Geant4 event has been aborted, skip the rest of the processing
  // sequence. This will immediately force the simulation to move on to
  // the next event.
  if (run_manager_->GetCurrentEvent()->IsAborted()) {
    run_manager_->TerminateOneEvent();  // clean up event objects
    SensitiveDetector::Factory::get().apply(
        [](auto sd) { sd->onFinishedEvent(); });
    this->abortEvent();  // get out of processors loop
  }
 
  // Terminate the event.  This checks if an event is to be stored or
  // stacked for later.
  num_events_completed_++;
 
  // store event-wide information in EventHeader
  auto& event_header = event.getEventHeader();
  updateEventHeader(event_header);
 
  event_header.setStringParameter("eventSeed", stream.str());
 
  auto event_info = static_cast<UserEventInformation*>(
      run_manager_->GetCurrentEvent()->GetUserInformation());
 
  auto hepmc3_events = event_info->getHepMC3GenEvents();
  for (auto& hepmc3ev : hepmc3_events) {
    hepmc3ev.event_number = event.getEventHeader().getEventNumber();
  }
  if (hepmc3_events.size() > 0) event.add("SimHepMC3Events", hepmc3_events);
 
  saveTracks(event);
 
  saveSDHits(event);
 
  run_manager_->TerminateOneEvent();
 
  return;
}

References framework::EventProcessor::abortEvent(), framework::Event::getEventHeader(), ldmx::EventHeader::getEventNumber(), num_events_began_, num_events_completed_, and simcore::SimulatorBase::run_manager_.

setSeeds()

void simcore::Simulator::setSeeds ( std::vector< int > seeds )

private

Set the seeds to be used by the Geant4 random engine.

Parameters

[in]

seeds

A vector of seeds to pass to the G4 random engine. The vector must contain at least 2 seeds otherwise an exception is thrown.

Definition at line 152 of file Simulator.cxx.

                                             {
  // If no seeds have been specified then return immediately.
  if (seeds.empty()) {
    return;
  }
 
  // If seeds are specified, make sure that the container has at least
  // two seeds.  If not, throw an exception.
  if (seeds.size() == 1) {
    EXCEPTION_RAISE("ConfigurationException",
                    "At least two seeds need to be specified.");
  }
 
  // Create the array of seeds and pass them to G4Random.  Currently,
  // only 100 seeds can be specified at a time.  If less than 100
  // seeds are specified, the remaining slots are set to 0.
 
  constexpr int max_number_of_seeds{100};
  std::vector<long> seed_vec(max_number_of_seeds, 0);
  for (std::size_t index{0}; index < seeds.size(); ++index) {
    seed_vec[index] = static_cast<long>(seeds[index]);
  }
 
  // Pass the array of seeds to the random engine.
  G4Random::setTheSeeds(seed_vec.data());
}

Referenced by onNewRun().

Member Data Documentation

num_events_began_

int simcore::Simulator::num_events_began_ {0}

private

Number of events started.

Definition at line 154 of file Simulator.h.

{0};

Referenced by onProcessEnd(), and produce().

num_events_completed_

int simcore::Simulator::num_events_completed_ {0}

private

Number of events completed.

Definition at line 157 of file Simulator.h.

{0};

Referenced by onProcessEnd(), and produce().

run_

int simcore::Simulator::run_ {-1}

private

the run number (for accessing the run header in onFileClose

Definition at line 160 of file Simulator.h.

{-1};

Referenced by onNewRun().

---

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

• SimCore/include/SimCore/Simulator.h
• SimCore/src/SimCore/Simulator.cxx