simcore::SimulatorBase Class Reference

Public Member Functions
	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	beforeNewRun (ldmx::RunHeader &run_header)
	Callback for Producers to add parameters to the run header before conditions are initialized.
virtual void	onNewRun (const ldmx::RunHeader &run_header)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.
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.

Protected Member Functions
void	onProcessEnd () override
	Callback called once processing is complete.
void	onProcessStart () override
	Initialization of simulation.
virtual void	prepEvent (framework::Event &event)
	prepare a new event before entering into the Geant4 simulation
virtual void	updateEventHeader (ldmx::EventHeader &eventHeader) const
virtual void	saveTracks (framework::Event &event)
virtual void	saveSDHits (framework::Event &event)
virtual void	savePhotonuclearInteractions (framework::Event &event)
virtual void	produce (framework::Event &event) override=0
	Process the event and put new data products into it.
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.

Protected Attributes
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
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.

Private Member Functions
void	createLogging ()
void	buildGeometry ()
void	verifyParameters () const

Detailed Description

Definition at line 15 of file SimulatorBase.h.

Constructor & Destructor Documentation

SimulatorBase()

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

Definition at line 24 of file SimulatorBase.cxx.

    : framework::Producer(name, process), conditions_intf_(this) {
  ui_manager_ = G4UImanager::GetUIpointer();
}

Member Function Documentation

buildGeometry()

void simcore::SimulatorBase::buildGeometry ( )

private

Definition at line 201 of file SimulatorBase.cxx.

                                  {
  // Instantiate the GDML parser and corresponding messenger owned and
  // managed by DetectorConstruction
  auto parser{simcore::geo::Parser::Factory::get().make("gdml", parameters_,
                                                        conditions_intf_)};
  if (not parser) {
    EXCEPTION_RAISE(
        "UnableToCreate",
        "Unable to find a parser registered under the name 'gdml'.");
  }
  auto parser_ptr{parser.value()};
 
  // Set the DetectorConstruction instance used to build the detector
  // from the GDML description.
  run_manager_->SetUserInitialization(
      new DetectorConstruction(parser_ptr, parameters_, conditions_intf_));
 
  // Parse the detector geometry and validate if specified.
  auto detector_path{parameters_.get<std::string>("detector")};
  ldmx_log(trace) << "Reading in geometry from '" << detector_path << "'";
  G4GeometryManager::GetInstance()->OpenGeometry();
  parser_ptr->read();
  run_manager_->DefineWorldVolume(parser_ptr->getWorldVolume());
}

configure()

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

overridevirtual

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

The parameters a processor has access to are the member variables of the python class in the sequence that has class_name equal to the EventProcessor class name.

For an example, look at MyProcessor.

Parameters

parameters

Parameters for configuration.

Reimplemented from framework::EventProcessor.

Definition at line 130 of file SimulatorBase.cxx.

                                                                   {
  // parameters used to configure the simulation
  parameters_ = parameters;
 
  pre_init_commands_ =
      parameters_.get<std::vector<std::string>>("pre_init_commands", {});
 
  // Get the extra simulation configuring commands
  post_init_commands_ =
      parameters_.get<std::vector<std::string>>("post_init_commands", {});
 
  verifyParameters();
  if (run_manager_) {
    // TODO: This won't work, need to think of a better solution
    EXCEPTION_RAISE(
        "MultipleSimulators",
        "A simulator or resimulator producer has already been created. Only "
        "one of them can be present in a given run. To run the resimulator, "
        "use a an existing eventFile as input.");
  }
  // Set up logging before creating the run manager so that output from the
  // creation of the runManager goes to the appropriate place.
  createLogging();
  run_manager_ = std::make_unique<RunManager>(parameters_, conditions_intf_);
  // Instantiate the class so cascade parameters can be set.
  // TODO: Are we actually using this?
  G4CascadeParameters::Instance();
 
  buildGeometry();
  for (const std::string& cmd : pre_init_commands_) {
    int g4_ret = ui_manager_->ApplyCommand(cmd);
    if (g4_ret > 0) {
      EXCEPTION_RAISE("PreInitCmd",
                      "Pre Initialization command '" + cmd +
                          "' returned a failure status from Geant4: " +
                          std::to_string(g4_ret));
    }
  }
}

References framework::config::Parameters::get().

Referenced by simcore::ReSimulator::configure(), and simcore::Simulator::configure().

createLogging()

void simcore::SimulatorBase::createLogging ( )

private

Definition at line 169 of file SimulatorBase.cxx.

                                  {
  auto logging_prefix = parameters_.get<std::string>("logging_prefix");
  session_handle_ = std::make_unique<LoggedSession>(logging_prefix);
 
  if (session_handle_ != nullptr)
    ui_manager_->SetCoutDestination(session_handle_.get());
}

onProcessEnd()

void simcore::SimulatorBase::onProcessEnd ( )

overrideprotectedvirtual

Callback called once processing is complete.

Reimplemented from framework::EventProcessor.

Definition at line 52 of file SimulatorBase.cxx.

                                 {
  run_manager_->TerminateEventLoop();
  run_manager_->RunTermination();
  // Delete Run Manager
  // From Geant4 Basic Example B01:
  //      Job termination
  //      Free the store: user actions, physics list and detector descriptions
  //      are owned and deleted by the run manager, so they should not be
  //      deleted in the main() program
  // This needs to happen here because otherwise, Geant4 objects are deleted
  // twice:
  //  1. When the histogram file is closed (all ROOT objects created during
  //  processing are put there because ROOT)
  //  2. When Simulator is deleted because run_manager_ is a unique_ptr
  run_manager_.reset(nullptr);
 
  // Delete the G4UIsession
  // I don't think this needs to happen here, but since we are cleaning up
  // loose ends...
  session_handle_.reset(nullptr);
};

Referenced by simcore::Simulator::onProcessEnd().

onProcessStart()

void simcore::SimulatorBase::onProcessStart ( )

overrideprotectedvirtual

Initialization of simulation.

This uses the parameters set in the configure method to construct and initialize the simulation objects.

This function runs the post init setup commands.

Reimplemented from framework::EventProcessor.

Definition at line 73 of file SimulatorBase.cxx.

                                   {
  // initialize run
  run_manager_->Initialize();
 
  for (const std::string& cmd : post_init_commands_) {
    int g4_ret = ui_manager_->ApplyCommand(cmd);
    if (g4_ret > 0) {
      EXCEPTION_RAISE("PostInitCmd",
                      "Post Initialization command '" + cmd +
                          "' returned a failue status from Geant4: " +
                          std::to_string(g4_ret));
    }
  }
 
  // Instantiate the scoring worlds including any parallel worlds.
  run_manager_->ConstructScoringWorlds();
 
  // Initialize the current run
  run_manager_->RunInitialization();
 
  // Initialize the event processing
  run_manager_->InitializeEventLoop(1);
 
  return;
}

prepEvent()

void simcore::SimulatorBase::prepEvent ( framework::Event & event )

protectedvirtual

prepare a new event before entering into the Geant4 simulation

right now, we just make sure the PrimaryVertices are all prepared

Definition at line 29 of file SimulatorBase.cxx.

                                                   {
  PrimaryGenerator::Factory::get().apply(
      [&event](auto gen) { gen->prepEvent(event); });
}

Referenced by simcore::ReSimulator::produce(), and simcore::Simulator::produce().

produce()

virtual void simcore::SimulatorBase::produce ( framework::Event & event )

overrideprotectedpure virtual

Process the event and put new data products into it.

Parameters

event

The Event to process.

Implements framework::Producer.

Implemented in simcore::ReSimulator, and simcore::Simulator.

savePhotonuclearInteractions()

void simcore::SimulatorBase::savePhotonuclearInteractions ( framework::Event & event )

protectedvirtual

Definition at line 190 of file SimulatorBase.cxx.

                                                                      {
  // Save photonuclear interactions if the PhotonuclearTracker is active
  auto pn_tracker = PhotonuclearTracker::get();
  if (pn_tracker) {
    auto pn_interactions = pn_tracker->getInteractions();
    if (!pn_interactions.empty()) {
      event.add("PhotonuclearInteractions", pn_interactions);
    }
  }
}

saveSDHits()

void simcore::SimulatorBase::saveSDHits ( framework::Event & event )

protectedvirtual

Definition at line 182 of file SimulatorBase.cxx.

                                                    {
  // Copy hit objects from SD hit collections into the output event.
  SensitiveDetector::Factory::get().apply([&event](auto sd) {
    sd->saveHits(event);
    sd->onFinishedEvent();
  });
}

saveTracks()

void simcore::SimulatorBase::saveTracks ( framework::Event & event )

protectedvirtual

Definition at line 177 of file SimulatorBase.cxx.

                                                    {
  TrackMap& tracks{g4user::TrackingAction::get()->getTrackMap()};
  tracks.traceAncestry();
  event.add("SimParticles", tracks.getParticleMap());
}

updateEventHeader()

void simcore::SimulatorBase::updateEventHeader ( ldmx::EventHeader & eventHeader ) const

protectedvirtual

Definition at line 34 of file SimulatorBase.cxx.

                                                                        {
  auto event_info = static_cast<UserEventInformation*>(
      run_manager_->GetCurrentEvent()->GetUserInformation());
 
  eventHeader.setWeight(event_info->getWeight());
  eventHeader.setFloatParameter("total_photonuclear_energy",
                                event_info->getPNEnergy());
  eventHeader.setFloatParameter("total_electronuclear_energy",
                                event_info->getENEnergy());
  eventHeader.setFloatParameter("db_material_z",
                                event_info->getDarkBremMaterialZ());
  eventHeader.setFloatParameter("aprime_conversion_material_z",
                                event_info->getAPrimeConversionMaterialZ());
  eventHeader.setIntParameter("pn_target_z", event_info->getPNTargetZ());
  eventHeader.setIntParameter("pn_target_a", event_info->getPNTargetA());
  eventHeader.setIntParameter("pn_resample_count",
                              event_info->getPNResampleCount());
}

verifyParameters()

void simcore::SimulatorBase::verifyParameters ( ) const

private

Definition at line 98 of file SimulatorBase.cxx.

                                           {
  // in past versions of SimCore, the run number for the simulation was
  // passed directly to the simulator class rather than pulled from central
  // framework. This is here to prevent the user from accidentally using the
  // old style.
  if (parameters_.exists("runNumber")) {
    EXCEPTION_RAISE("InvalidParam",
                    "Remove old-style of setting the simulation run number "
                    "(sim.runNumber)."
                    " Replace with using the Process object (p.run).");
  }
  // Looks for sub-strings matching the ones listed as an invalid command.
  // These invalid commands are mostly commands where control has been handed
  // over to Simulator.
  for (const auto& invalid_command : INVALID_COMMANDS) {
    for (const auto& cmd : pre_init_commands_) {
      if (cmd.find(invalid_command) != std::string::npos) {
        EXCEPTION_RAISE("PreInitCmd", "Pre Initialization command '" + cmd +
                                          "' is not allowed because another "
                                          "part of Simulator handles it.");
      }
    }
    for (const auto& cmd : post_init_commands_) {
      if (cmd.find(invalid_command) != std::string::npos) {
        EXCEPTION_RAISE("PostInitCmd", "Post Initialization command '" + cmd +
                                           "' is not allowed because another "
                                           "part of Simulator handles it.");
      }
    }
  }
}

Member Data Documentation

conditions_intf_

ConditionsInterface simcore::SimulatorBase::conditions_intf_

protected

Conditions interface.

Definition at line 34 of file SimulatorBase.h.

INVALID_COMMANDS

const std::vector< std::string > simcore::SimulatorBase::INVALID_COMMANDS

staticprotected

Initial value:

= {
    "/run/initialize",        
    "/run/beamOn",            
    "/random/setSeeds",       
    "ldmx",                   
    "/persistency/gdml/read"  
                              
}

Commands not allowed to be passed from python config file This is because Simulator already runs them.

Definition at line 47 of file SimulatorBase.h.

parameters_

framework::config::Parameters simcore::SimulatorBase::parameters_

protected

The parameters used to configure the simulation.

Definition at line 53 of file SimulatorBase.h.

Referenced by simcore::Simulator::beforeNewRun().

post_init_commands_

std::vector<std::string> simcore::SimulatorBase::post_init_commands_

protected

Definition at line 57 of file SimulatorBase.h.

pre_init_commands_

std::vector<std::string> simcore::SimulatorBase::pre_init_commands_

protected

Definition at line 55 of file SimulatorBase.h.

run_manager_

std::unique_ptr<RunManager> simcore::SimulatorBase::run_manager_

protected

Manager controlling G4 simulation run.

Definition at line 40 of file SimulatorBase.h.

Referenced by simcore::ReSimulator::produce(), and simcore::Simulator::produce().

session_handle_

std::unique_ptr<LoggedSession> simcore::SimulatorBase::session_handle_

protected

Handle to the G4Session -> how to deal with G4cout and G4cerr.

Definition at line 43 of file SimulatorBase.h.

ui_manager_

G4UImanager* simcore::SimulatorBase::ui_manager_ {nullptr}

protected

User interface handle.

Definition at line 37 of file SimulatorBase.h.

{nullptr};

---

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

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