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	physicsListFactory_
	Factory class for instantiating the physics list.
bool	isPWEnabled_ {false}
	Flag indicating whether a parallel world should be registered.
std::string	parallelWorldPath_ {""}
	Path to GDML description of parallel world.
bool	useRootSeed_ {false}
	Should we use random seed from root file?

Detailed Description

Extension of Geant4 run manager.

Definition at line 41 of file RunManager.h.

Constructor & Destructor Documentation

RunManager()

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

Class constructor.

Definition at line 37 of file RunManager.cxx.

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

References framework::config::Parameters::getParameter(), 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 191 of file RunManager.cxx.

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

Referenced by Initialize().

Initialize()

void simcore::RunManager::Initialize

(

)

Perform application initialization.

Definition at line 102 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 (isPWEnabled_) {
    std::cout << "[ RunManager ]: Parallel worlds have been enabled."
              << std::endl;
 
    auto validateGeometry_{parameters_.getParameter<bool>("validate_detector")};
    G4GDMLParser* pwParser = new G4GDMLParser();
    pwParser->Read(parallelWorldPath_, validateGeometry_);
    this->getDetectorConstruction()->RegisterParallelWorld(
        new ParallelWorld(pwParser, "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 g4user::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_.getParameter<std::vector<framework::config::Parameters>>(
          "actions", {})};
  for (auto& user_action : user_actions) {
    auto ua = UserAction::Factory::get().make(
        user_action.getParameter<std::string>("class_name"),
        user_action.getParameter<std::string>("instance_name"), user_action);
    for (auto& type : ua->getTypes()) {
      if (type == simcore::TYPE::RUN) {
        run_action->registerAction(ua.get());
      } else if (type == simcore::TYPE::EVENT) {
        event_action->registerAction(ua.get());
      } else if (type == simcore::TYPE::TRACKING) {
        tracking_action->registerAction(ua.get());
      } else if (type == simcore::TYPE::STEPPING) {
        stepping_action->registerAction(ua.get());
      } else if (type == simcore::TYPE::STACKING) {
        stacking_action->registerAction(ua.get());
      } else {
        EXCEPTION_RAISE("ActionType", "Action type does not exist.");
      }
    }
  }
}

References simcore::Factory< Prototype, PrototypePtr, PrototypeConstructorArgs >::get(), getDetectorConstruction(), framework::config::Parameters::getParameter(), isPWEnabled_, simcore::Factory< Prototype, PrototypePtr, PrototypeConstructorArgs >::make(), parallelWorldPath_, parameters_, and setupPhysics().

setupPhysics()

void simcore::RunManager::setupPhysics

(

)

Initialize physics.

Definition at line 49 of file RunManager.cxx.

                              {
  auto pList{physicsListFactory_.GetReferencePhysList("FTFP_BERT")};
 
  parallelWorldPath_ = parameters_.getParameter<std::string>("scoringPlanes");
  isPWEnabled_ = !parallelWorldPath_.empty();
  if (isPWEnabled_) {
    std::cout
        << "[ RunManager ]: Parallel worlds physics list has been registered."
        << std::endl;
    pList->RegisterPhysics(new G4ParallelWorldPhysics("ldmxParallelWorld"));
  }
 
  pList->RegisterPhysics(new GammaPhysics{"GammaPhysics", parameters_});
  pList->RegisterPhysics(new APrimePhysics(
      parameters_.getParameter<framework::config::Parameters>("dark_brem")));
  pList->RegisterPhysics(new KaonPhysics(
      "KaonPhysics", parameters_.getParameter<framework::config::Parameters>(
                         "kaon_parameters")));
 
  auto biasing_operators{
      parameters_.getParameter<std::vector<framework::config::Parameters>>(
          "biasing_operators", {})};
  if (!biasing_operators.empty()) {
    std::cout << "[ RunManager ]: Biasing enabled with "
              << biasing_operators.size() << " operator(s)." << std::endl;
 
    // create all the biasing operators that will be used
    for (framework::config::Parameters& bop : biasing_operators) {
      simcore::XsecBiasingOperator::Factory::get().make(
          bop.getParameter<std::string>("class_name"),
          bop.getParameter<std::string>("instance_name"), bop);
    }
 
    // Instantiate the constructor used when biasing
    G4GenericBiasingPhysics* biasingPhysics = 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([biasingPhysics](
                                                           auto bop) {
      std::cout << "[ RunManager ]: Biasing operator '" << bop->GetName()
                << "' set to bias " << bop->getParticleToBias() << std::endl;
      biasingPhysics->Bias(bop->getParticleToBias());
    });
 
    // Register the physics constructor to the physics list:
    pList->RegisterPhysics(biasingPhysics);
  }
 
  this->SetUserInitialization(pList);
}

References simcore::Factory< Prototype, PrototypePtr, PrototypeConstructorArgs >::apply(), simcore::Factory< Prototype, PrototypePtr, PrototypeConstructorArgs >::get(), framework::config::Parameters::getParameter(), isPWEnabled_, simcore::Factory< Prototype, PrototypePtr, PrototypeConstructorArgs >::make(), parallelWorldPath_, parameters_, and physicsListFactory_.

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 81 of file RunManager.h.

{ useRootSeed_ = useIt; }

References useRootSeed_.

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 165 of file RunManager.cxx.

                                   {
  // have geant4 do its own thing
  G4RunManager::TerminateOneEvent();
 
  // go through the processes attached to the electron and
  // reactivate any process that contains the G4DarkBremmstrahlung name
  // this covers both cases where the process is biased and not
  static auto reactivate_dark_brem = [](G4ProcessManager* pman) {
    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)) {
        pman->SetProcessActivation(p, true);
        break;
      }
    }
  };
 
  reactivate_dark_brem(G4Electron::Definition()->GetProcessManager());
 
  if (this->GetVerboseLevel() > 1) {
    std::cout << "[ RunManager ] : "
              << "Reset the dark brem process (if it was activated)."
              << std::endl;
  }
}

useRootSeed()

bool simcore::RunManager::useRootSeed ( )

inline

Should we use the seed from the root file?

Definition at line 86 of file RunManager.h.

{ return useRootSeed_; }

References useRootSeed_.

Member Data Documentation

isPWEnabled_

bool simcore::RunManager::isPWEnabled_ {false}

private

Flag indicating whether a parallel world should be registered.

Definition at line 101 of file RunManager.h.

{false};

Referenced by Initialize(), and setupPhysics().

parallelWorldPath_

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

private

Path to GDML description of parallel world.

Definition at line 104 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 90 of file RunManager.h.

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

physicsListFactory_

G4PhysListFactory simcore::RunManager::physicsListFactory_

private

Factory class for instantiating the physics list.

Definition at line 95 of file RunManager.h.

Referenced by setupPhysics().

useRootSeed_

bool simcore::RunManager::useRootSeed_ {false}

private

Should we use random seed from root file?

Definition at line 109 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