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	beforeNewRun (ldmx::RunHeader &header)
	Handle allowing producers to modify run headers before the run begins.
Public Member Functions inherited from framework::EventProcessor
	EventProcessor (const std::string &name, Process &process)
	Class constructor.
virtual	~EventProcessor ()
	Class destructor.
virtual void	onNewRun (const ldmx::RunHeader &runHeader)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.
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.

Protected Member Functions
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)
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	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
static const std::vector< std::string >	invalidCommands_
	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

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.

Detailed Description

Definition at line 22 of file SimulatorBase.h.

Constructor & Destructor Documentation

SimulatorBase()

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

Definition at line 13 of file SimulatorBase.cxx.

    : framework::Producer(name, process), conditionsIntf_(this) {
  uiManager_ = G4UImanager::GetUIpointer();
}

Member Function Documentation

buildGeometry()

void simcore::SimulatorBase::buildGeometry ( )

private

Definition at line 178 of file SimulatorBase.cxx.

                                  {
  // Instantiate the GDML parser and corresponding messenger owned and
  // managed by DetectorConstruction
  auto parser{simcore::geo::ParserFactory::getInstance().createParser(
      "gdml", parameters_, conditionsIntf_)};
 
  // Set the DetectorConstruction instance used to build the detector
  // from the GDML description.
  runManager_->SetUserInitialization(
      new DetectorConstruction(parser, parameters_, conditionsIntf_));
 
  // Parse the detector geometry and validate if specified.
  auto detectorPath{parameters_.getParameter<std::string>("detector")};
  if (verbosity_ > 0) {
    std::cout << "[ Simulator ] : Reading in geometry from '" << detectorPath
              << "'... " << std::flush;
  }
  G4GeometryManager::GetInstance()->OpenGeometry();
  parser->read();
  runManager_->DefineWorldVolume(parser->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 className equal to the EventProcessor class name.

For an example, look at MyProcessor.

Parameters

parameters

Parameters for configuration.

Reimplemented from framework::EventProcessor.

Definition at line 108 of file SimulatorBase.cxx.

                                                                   {
  // parameters used to configure the simulation
  parameters_ = parameters;
  // Set the verbosity level.  The default level  is 0.
  verbosity_ = parameters_.getParameter<int>("verbosity");
 
  preInitCommands_ =
      parameters_.getParameter<std::vector<std::string>>("preInitCommands", {});
 
  // Get the extra simulation configuring commands
  postInitCommands_ = parameters_.getParameter<std::vector<std::string>>(
      "postInitCommands", {});
 
  verifyParameters();
  if (runManager_) {
    // 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();
  runManager_ = std::make_unique<RunManager>(parameters_, conditionsIntf_);
  // Instantiate the class so cascade parameters can be set.
  // TODO: Are we actually using this?
  G4CascadeParameters::Instance();
 
  buildGeometry();
  for (const std::string& cmd : preInitCommands_) {
    int g4Ret = uiManager_->ApplyCommand(cmd);
    if (g4Ret > 0) {
      EXCEPTION_RAISE("PreInitCmd",
                      "Pre Initialization command '" + cmd +
                          "' returned a failure status from Geant4: " +
                          std::to_string(g4Ret));
    }
  }
}

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

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

createLogging()

void simcore::SimulatorBase::createLogging ( )

private

Definition at line 150 of file SimulatorBase.cxx.

                                  {
  auto loggingPrefix = parameters_.getParameter<std::string>("logging_prefix");
  if (verbosity_ == 0)
    sessionHandle_ = std::make_unique<BatchSession>();
  else if (verbosity_ > 1) {
    if (loggingPrefix.empty())
      sessionHandle_ = std::make_unique<LoggedSession>();
    else
      sessionHandle_ = std::make_unique<LoggedSession>(
          loggingPrefix + "_G4cout.log", loggingPrefix + "_G4cerr.log");
  }
  if (sessionHandle_ != nullptr)
    uiManager_->SetCoutDestination(sessionHandle_.get());
}

onProcessEnd()

void simcore::SimulatorBase::onProcessEnd ( )

overrideprotectedvirtual

Callback called once processing is complete.

Reimplemented from framework::EventProcessor.

Definition at line 30 of file SimulatorBase.cxx.

                                 {
  runManager_->TerminateEventLoop();
  runManager_->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 runManager_ is a unique_ptr
  runManager_.reset(nullptr);
 
  // Delete the G4UIsession
  // I don't think this needs to happen here, but since we are cleaning up
  // loose ends...
  sessionHandle_.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 51 of file SimulatorBase.cxx.

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

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.

saveSDHits()

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

protectedvirtual

Definition at line 170 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 165 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 18 of file SimulatorBase.cxx.

                                                                        {
  auto event_info = static_cast<UserEventInformation*>(
      runManager_->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());
}

verifyParameters()

void simcore::SimulatorBase::verifyParameters ( ) const

private

Definition at line 76 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& invalidCommand : invalidCommands_) {
    for (const auto& cmd : preInitCommands_) {
      if (cmd.find(invalidCommand) != std::string::npos) {
        EXCEPTION_RAISE("PreInitCmd", "Pre Initialization command '" + cmd +
                                          "' is not allowed because another "
                                          "part of Simulator handles it.");
      }
    }
    for (const auto& cmd : postInitCommands_) {
      if (cmd.find(invalidCommand) != std::string::npos) {
        EXCEPTION_RAISE("PostInitCmd", "Post Initialization command '" + cmd +
                                           "' is not allowed because another "
                                           "part of Simulator handles it.");
      }
    }
  }
}

Member Data Documentation

conditionsIntf_

ConditionsInterface simcore::SimulatorBase::conditionsIntf_

protected

Conditions interface.

Definition at line 41 of file SimulatorBase.h.

invalidCommands_

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

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 54 of file SimulatorBase.h.

parameters_

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

protected

The parameters used to configure the simulation.

Definition at line 63 of file SimulatorBase.h.

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

postInitCommands_

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

protected

Definition at line 67 of file SimulatorBase.h.

preInitCommands_

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

protected

Definition at line 65 of file SimulatorBase.h.

runManager_

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

protected

Manager controlling G4 simulation run.

Definition at line 47 of file SimulatorBase.h.

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

sessionHandle_

std::unique_ptr<G4UIsession> simcore::SimulatorBase::sessionHandle_

protected

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

Definition at line 50 of file SimulatorBase.h.

uiManager_

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

protected

User interface handle.

Definition at line 44 of file SimulatorBase.h.

{nullptr};

verbosity_

int simcore::SimulatorBase::verbosity_ {1}

protected

Vebosity for the simulation.

Definition at line 61 of file SimulatorBase.h.

{1};

Referenced by simcore::ReSimulator::produce().

---

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

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