simcore::RunManager Class Reference

Extension of Geant4 run manager. More...

#include <RunManager.h>

Public Member Functions
	RunManager (framework::config::Parameters &parameters, ConditionsInterface &)
	Class constructor.
virtual	~RunManager ()=default
	Class destructor.
void	setupPhysics ()
	Initialize physics.
void	Initialize ()
	Perform application initialization.
void	TerminateOneEvent ()
	Called at the end of each event.
DetectorConstruction *	getDetectorConstruction ()
	Get the user detector construction cast to a specific type.
void	setUseRootSeed (bool useIt=true)
	Tell RunManager to use the seed from the root file.
bool	useRootSeed ()
	Should we use the seed from the root file?

Private Attributes
framework::config::Parameters	parameters_
	The set of parameters used to configure the RunManager.
G4PhysListFactory	physics_list_factory_
	Factory class for instantiating the physics list.
bool	is_pw_enabled_ {false}
	Flag indicating whether a parallel world should be registered.
std::string	parallel_world_path_ {""}
	Path to GDML description of parallel world.
bool	use_root_seed_ {false}
	Should we use random seed from root file?

Detailed Description

Extension of Geant4 run manager.

Definition at line 42 of file RunManager.h.

Constructor & Destructor Documentation

RunManager()

simcore::RunManager::RunManager	(	framework::config::Parameters &	parameters,
		ConditionsInterface &	)

Class constructor.

Definition at line 40 of file RunManager.cxx.

                                             {
  parameters_ = parameters;
 
  // Set whether the ROOT primary generator should use the persisted seed.
  auto root_primary_gen_use_seed{
      parameters.get<bool>("root_primary_gen_use_seed")};
 
  // Validate the geometry if specified.
  setUseRootSeed(root_primary_gen_use_seed);
}

References framework::config::Parameters::get(), parameters_, and setUseRootSeed().

Member Function Documentation

getDetectorConstruction()

DetectorConstruction * simcore::RunManager::getDetectorConstruction

(

)

Get the user detector construction cast to a specific type.

Returns

The user detector construction.

Definition at line 207 of file RunManager.cxx.

                                                          {
  return static_cast<DetectorConstruction*>(this->userDetector);
}

Referenced by Initialize().

Initialize()

void simcore::RunManager::Initialize

(

)

Perform application initialization.

Definition at line 113 of file RunManager.cxx.

                            {
  setupPhysics();
 
  // The parallel world needs to be registered before the mass world is
  // constructed i.e. before G4RunManager::Initialize() is called.
  if (is_pw_enabled_) {
    ldmx_log(debug) << "Parallel worlds have been enabled";
 
    auto validate_geometry{parameters_.get<bool>("validate_detector")};
    G4GDMLParser* pw_parser = new G4GDMLParser();
    pw_parser->Read(parallel_world_path_, validate_geometry);
    this->getDetectorConstruction()->RegisterParallelWorld(
        new ParallelWorld(pw_parser, "ldmxParallelWorld"));
  }
 
  // This is where the physics lists are told to construct their particles and
  // their processes
  //  They are constructed in order, so it is important to register the biasing
  //  physics *after* any other processes that need to be able to be biased
  G4RunManager::Initialize();
 
  // create our G4User actions
  auto primary_action{new PrimaryGeneratorAction(parameters_)};
  auto run_action{new g4user::RunAction};
  auto event_action{new g4user::EventAction};
  auto tracking_action{new g4user::TrackingAction};
  auto stepping_action{new g4user::SteppingAction};
  auto stacking_action{new g4user::StackingAction};
  // ...and register them with G4
  SetUserAction(primary_action);
  SetUserAction(run_action);
  SetUserAction(event_action);
  SetUserAction(tracking_action);
  SetUserAction(stepping_action);
  SetUserAction(stacking_action);
 
  // Create all user actions and attch them to the corresponding G4 actions
  auto user_actions{parameters_.get<std::vector<framework::config::Parameters>>(
      "actions", {})};
  for (auto& user_action : user_actions) {
    auto ua = UserAction::Factory::get().make(
        user_action.get<std::string>("class_name"),
        user_action.get<std::string>("instance_name"), user_action);
    if (not ua) {
      EXCEPTION_RAISE(
          "UnableToCreate",
          "Unable to create a UserAction of type " +
              user_action.get<std::string>("class_name") +
              ". Did you inherit from simcore::UserAction? "
              "Do you have DECLARE_ACTION in your implementation (.cxx) file? "
              "Did you include the fully-specified class name in your python "
              "configuration class? "
              "Did you specify the correct library in the python configuration "
              "class?");
    }
    for (auto& type : ua.value()->getTypes()) {
      if (type == simcore::TYPE::RUN) {
        run_action->registerAction(ua.value());
      } else if (type == simcore::TYPE::EVENT) {
        event_action->registerAction(ua.value());
      } else if (type == simcore::TYPE::TRACKING) {
        tracking_action->registerAction(ua.value());
      } else if (type == simcore::TYPE::STEPPING) {
        stepping_action->registerAction(ua.value());
      } else if (type == simcore::TYPE::STACKING) {
        stacking_action->registerAction(ua.value());
      } else {
        EXCEPTION_RAISE("ActionType", "Action type does not exist.");
      }
    }
  }
}

References framework::config::Parameters::get(), getDetectorConstruction(), is_pw_enabled_, parallel_world_path_, parameters_, and setupPhysics().

setupPhysics()

void simcore::RunManager::setupPhysics

(

)

Initialize physics.

Definition at line 52 of file RunManager.cxx.

                              {
  auto p_list{physics_list_factory_.GetReferencePhysList("FTFP_BERT")};
  p_list->SetVerboseLevel(0);
 
  parallel_world_path_ = parameters_.get<std::string>("scoring_planes");
  is_pw_enabled_ = !parallel_world_path_.empty();
  if (is_pw_enabled_) {
    ldmx_log(debug) << "Parallel worlds physics list has been registered";
    p_list->RegisterPhysics(new G4ParallelWorldPhysics("ldmxParallelWorld"));
  }
 
  p_list->RegisterPhysics(new GammaPhysics{"GammaPhysics", parameters_});
  p_list->RegisterPhysics(new APrimePhysics(
      parameters_.get<framework::config::Parameters>("dark_brem")));
  p_list->RegisterPhysics(new KaonPhysics(
      "KaonPhysics",
      parameters_.get<framework::config::Parameters>("kaon_parameters")));
  p_list->RegisterPhysics(new FCPPhysics(
      "FCPPhysics",
      parameters_.get<framework::config::Parameters>("fcp_physics")));
  p_list->RegisterPhysics(new GenieNuclearPhysics(
      parameters_.get<framework::config::Parameters>("genie_nuclear")));
 
  auto biasing_operators{
      parameters_.get<std::vector<framework::config::Parameters>>(
          "biasing_operators", {})};
  if (!biasing_operators.empty()) {
    ldmx_log(info) << " Biasing enabled with " << biasing_operators.size()
                   << " operator(s)";
 
    // create all the biasing operators that will be used
    for (framework::config::Parameters& bop : biasing_operators) {
      if (not simcore::XsecBiasingOperator::Factory::get().make(
              bop.get<std::string>("class_name"),
              bop.get<std::string>("instance_name"), bop)) {
        EXCEPTION_RAISE("UnableToCreate",
                        "Unable to create a XsecBiasingOperator of type " +
                            bop.get<std::string>("class_name"));
      }
    }
 
    // Instantiate the constructor used when biasing
    G4GenericBiasingPhysics* biasing_physics = new G4GenericBiasingPhysics();
 
    // specify which particles are going to be biased
    //  this will put a biasing interface wrapper around *all* processes
    //  associated with these particles
    simcore::XsecBiasingOperator::Factory::get().apply(
        [this, biasing_physics](auto bop) {
          ldmx_log(info) << "Biasing operator '" << bop->GetName()
                         << "' set to bias " << bop->getParticleToBias();
          biasing_physics->Bias(bop->getParticleToBias());
        });
 
    // Register the physics constructor to the physics list:
    p_list->RegisterPhysics(biasing_physics);
  }
 
  this->SetUserInitialization(p_list);
}

References framework::config::Parameters::get(), is_pw_enabled_, parallel_world_path_, parameters_, and physics_list_factory_.

Referenced by Initialize().

setUseRootSeed()

void simcore::RunManager::setUseRootSeed ( bool useIt = true )

inline

Tell RunManager to use the seed from the root file.

Definition at line 82 of file RunManager.h.

{ use_root_seed_ = useIt; }

References use_root_seed_.

Referenced by RunManager().

TerminateOneEvent()

void simcore::RunManager::TerminateOneEvent

(

)

Called at the end of each event.

Runs parent process G4RunManager::TerminateOneEvent() and resets the activation for the G4DarkBremsstrahlung process (if dark brem is possible)

Definition at line 186 of file RunManager.cxx.

                                   {
  // have geant4 do its own thing
  G4RunManager::TerminateOneEvent();
 
  // A process may deactivate itself after firing so that it only happens once
  // per event (dark brem and GENIE electronNuclear both do this). At most one
  // of them is present in a given run, so find whichever it is, reactivate it
  // so it can fire again next event, and stop. This covers both cases where the
  // process is biased and not.
  G4ProcessManager* pman = G4Electron::Definition()->GetProcessManager();
  for (int i_proc{0}; i_proc < pman->GetProcessList()->size(); i_proc++) {
    G4VProcess* p{(*(pman->GetProcessList()))[i_proc]};
    if (p->GetProcessName().contains(G4DarkBremsstrahlung::PROCESS_NAME) or
        p->GetProcessName().contains(
            GenieElectroNuclearProcess::PROCESS_NAME)) {
      pman->SetProcessActivation(p, true);
      break;
    }
  }
}

References simcore::GenieElectroNuclearProcess::PROCESS_NAME.

useRootSeed()

bool simcore::RunManager::useRootSeed ( )

inline

Should we use the seed from the root file?

Definition at line 87 of file RunManager.h.

{ return use_root_seed_; }

References use_root_seed_.

Member Data Documentation

is_pw_enabled_

bool simcore::RunManager::is_pw_enabled_ {false}

private

Flag indicating whether a parallel world should be registered.

Definition at line 102 of file RunManager.h.

{false};

Referenced by Initialize(), and setupPhysics().

parallel_world_path_

std::string simcore::RunManager::parallel_world_path_ {""}

private

Path to GDML description of parallel world.

Definition at line 105 of file RunManager.h.

{""};

Referenced by Initialize(), and setupPhysics().

parameters_

framework::config::Parameters simcore::RunManager::parameters_

private

The set of parameters used to configure the RunManager.

Definition at line 91 of file RunManager.h.

Referenced by Initialize(), RunManager(), and setupPhysics().

physics_list_factory_

G4PhysListFactory simcore::RunManager::physics_list_factory_

private

Factory class for instantiating the physics list.

Definition at line 96 of file RunManager.h.

Referenced by setupPhysics().

use_root_seed_

bool simcore::RunManager::use_root_seed_ {false}

private

Should we use random seed from root file?

Definition at line 110 of file RunManager.h.

{false};

Referenced by setUseRootSeed(), and useRootSeed().

---

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

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