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.
Public Member Functions inherited from framework::EventProcessor
	EventProcessor (const std::string &name, Process &process)
	Class constructor.
virtual	~EventProcessor ()
	Class destructor.
virtual void	onFileOpen (EventFile &eventFile)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.
virtual void	onFileClose (EventFile &eventFile)
	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	numEventsBegan_ {0}
	Number of events started.
int	numEventsCompleted_ {0}
	Number of events completed.
int	run_ {-1}
	the run number (for accessing the run header in onFileClose

Additional Inherited Members
Static Public Member Functions inherited from framework::EventProcessor
static void	declare (const std::string &classname, int classtype, EventProcessorMaker *)
	Internal function which is part of the PluginFactory machinery.
Static Public Attributes inherited from framework::Producer
static const int	CLASSTYPE {1}
	Constant used to track EventProcessor types by the PluginFactory.
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	conditionsIntf_
	Conditions interface.
G4UImanager *	uiManager_ {nullptr}
	User interface handle.
std::unique_ptr< RunManager >	runManager_
	Manager controlling G4 simulation run.
std::unique_ptr< G4UIsession >	sessionHandle_
	Handle to the G4Session -> how to deal with G4cout and G4cerr.
int	verbosity_ {1}
	Vebosity for the simulation.
framework::config::Parameters	parameters_
	The parameters used to configure the simulation.
std::vector< std::string >	preInitCommands_
std::vector< std::string >	postInitCommands_
Protected Attributes inherited from framework::EventProcessor
HistogramHelper	histograms_
	Interface class for making and filling histograms.
NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.
logging::logger	theLog_
	The logger for this EventProcessor.
Static Protected Attributes inherited from simcore::SimulatorBase
static const std::vector< std::string >	invalidCommands_
	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 46 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 45 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::Producer.

Definition at line 52 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_.getParameter<std::string>("description"));
  header.setIntParameter(
      "Included Scoring Planes",
      !parameters_.getParameter<std::string>("scoringPlanes").empty());
  header.setIntParameter(
      "Use Random Seed from Event Header",
      parameters_.getParameter<bool>("rootPrimaryGenUseSeed"));
 
  // lambda function for dumping 3-vectors into the run header
  auto threeVectorDump = [&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 beamSpotSmear{
      parameters_.getParameter<std::vector<double>>("beamSpotSmear", {})};
  if (!beamSpotSmear.empty()) {
    threeVectorDump("Smear Beam Spot [mm]", beamSpotSmear);
  }
 
  // lambda function for dumping vectors of strings to the run header
  auto stringVectorDump = [&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);
    }
  };
 
  stringVectorDump("Pre Init Command",
                   parameters_.getParameter<std::vector<std::string>>(
                       "preInitCommands", {}));
  stringVectorDump("Post Init Command",
                   parameters_.getParameter<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 g4Version{
        G4RunManagerKernel::GetRunManagerKernel()->GetVersionString()};
    header.setStringParameter("Geant4 revision", g4Version);
  } else {
    ldmx_log(warn) << "Unable to access G4 RunManager Kernel. Will not store "
                      "G4 Version string.";
  }
 
  header.setStringParameter("ldmx-sw revision", GIT_SHA1);
}

References simcore::Factory< Prototype, PrototypePtr, PrototypeConstructorArgs >::apply(), simcore::Factory< Prototype, PrototypePtr, PrototypeConstructorArgs >::get(), simcore::DetectorConstruction::getDetectorName(), framework::config::Parameters::getParameter(), 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 48 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 119 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, 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 169 of file Simulator.cxx.

                             {
  SimulatorBase::onProcessEnd();
  std::cout << "[ Simulator ] : "
            << "Started " << numEventsBegan_ << " events to produce "
            << numEventsCompleted_ << " events." << std::endl;
}

References numEventsBegan_, numEventsCompleted_, 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 131 of file Simulator.cxx.

                                             {
  // Generate and process a Geant4 event.
  numEventsBegan_++;
  // 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);
  runManager_->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 (runManager_->GetCurrentEvent()->IsAborted()) {
    runManager_->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.
  numEventsCompleted_++;
 
  // store event-wide information in EventHeader
  auto& event_header = event.getEventHeader();
  updateEventHeader(event_header);
 
  event_header.setStringParameter("eventSeed", stream.str());
 
  saveTracks(event);
 
  saveSDHits(event);
 
  runManager_->TerminateOneEvent();
 
  return;
}

References framework::EventProcessor::abortEvent(), simcore::Factory< Prototype, PrototypePtr, PrototypeConstructorArgs >::apply(), simcore::Factory< Prototype, PrototypePtr, PrototypeConstructorArgs >::get(), framework::Event::getEventHeader(), ldmx::EventHeader::getEventNumber(), numEventsBegan_, numEventsCompleted_, and simcore::SimulatorBase::runManager_.

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 176 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> seedVec(max_number_of_seeds, 0);
  for (std::size_t index{0}; index < seeds.size(); ++index) {
    seedVec[index] = static_cast<long>(seeds[index]);
  }
 
  // Pass the array of seeds to the random engine.
  G4Random::setTheSeeds(seedVec.data());
}

Referenced by onNewRun().

Member Data Documentation

numEventsBegan_

int simcore::Simulator::numEventsBegan_ {0}

private

Number of events started.

Definition at line 113 of file Simulator.h.

{0};

Referenced by onProcessEnd(), and produce().

numEventsCompleted_

int simcore::Simulator::numEventsCompleted_ {0}

private

Number of events completed.

Definition at line 116 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 119 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