GGSMUAMessenger.cpp

Go to the documentation of this file.

/*
 * GGSMUAMessenger.cpp
 *
 *  Created on: 10 Nov 10 2020
 *      Author: Nicola Mori
 */

#include "montecarlo/mccore/GGSMUAMessenger.h"
#include "montecarlo/mccore/GGSMultiUserAction.h"
#include "montecarlo/mccore/GGSRunManagerExtensions.h"
#include "utils/GGSFactory.h"

GGSMUAMessenger::GGSMUAMessenger(GGSMultiUserAction *muAction, const G4String &path, const G4String &dsc)
    : G4UImessenger(path, dsc), _muAction(muAction), _gaBuildCommand("/GGS/generatorActions/set", this) {
  CreateCommands(GGSFactory<GGSUserAction>::GetInstance().GetListOfRegisteredBuilders());
  CreateCommands(GGSFactory<G4UserSteppingAction>::GetInstance().GetListOfRegisteredBuilders());
  CreateCommands(GGSFactory<G4UserTrackingAction>::GetInstance().GetListOfRegisteredBuilders());
  CreateCommands(GGSFactory<G4UserEventAction>::GetInstance().GetListOfRegisteredBuilders());
  CreateCommands(GGSFactory<G4UserRunAction>::GetInstance().GetListOfRegisteredBuilders());
  CreateCommands(GGSFactory<G4UserStackingAction>::GetInstance().GetListOfRegisteredBuilders());
}

void GGSMUAMessenger::CreateCommands(const std::vector<std::string> &userActionClasses) {
  for (auto &className : userActionClasses) {
    _uaBuildCommands.push_back(std::make_unique<G4UIcommand>(("/GGS/userActions/add" + className).c_str(), this));
  }
}

void GGSMUAMessenger::BuildAction(const std::string &actionClassName) {

  auto BuildWithFactory = [&actionClassName, this](auto &factory) {
    const auto &avaialbleBuilders = factory.GetListOfRegisteredBuilders();
    if (std::find(avaialbleBuilders.begin(), avaialbleBuilders.end(), actionClassName) != avaialbleBuilders.end()) {
      _muAction->AddAction(factory.CreateObject(actionClassName));
      return true;
    }
    return false;
  };

  if (!(BuildWithFactory(GGSFactory<GGSUserAction>::GetInstance()))) {
    if (!(BuildWithFactory(GGSFactory<G4UserSteppingAction>::GetInstance()))) {
      if (!(BuildWithFactory(GGSFactory<G4UserTrackingAction>::GetInstance()))) {
        if (!(BuildWithFactory(GGSFactory<G4UserEventAction>::GetInstance()))) {
          if (!(BuildWithFactory(GGSFactory<G4UserRunAction>::GetInstance()))) {
            if (!(BuildWithFactory(GGSFactory<G4UserStackingAction>::GetInstance()))) {
              G4ExceptionDescription ed;
              ed << "Can't build " << actionClassName << " user action" << std::endl;
              G4Exception("GGSUserActionInitialization::UAIMessenger::SetNewValue", "No builder for given user action",
                          G4ExceptionSeverity::FatalException, ed);
            }
          }
        }
      }
    }
  }
}

void GGSMUAMessenger::SetNewValue(G4UIcommand *command, G4String newValue) {
  std::string path = command->GetCommandPath();
  if (path.size() > 20 && path.substr(0, 20) == "/GGS/userActions/add") {
    // Build user actions
    auto actionClassName = path.substr(20);
    BuildAction(actionClassName);
  } else if (path == "/GGS/generatorActions/set") {
    auto &rme = dynamic_cast<GGSRunManagerExtensions &>(*(G4RunManager::GetRunManager()));
    if (G4RunManager::GetRunManager()->GetUserPrimaryGeneratorAction()) {
      delete G4RunManager::GetRunManager()->GetUserPrimaryGeneratorAction();
    }
    // Build the generator
    std::unique_ptr<G4VUserPrimaryGeneratorAction> gen =
        GGSFactory<G4VUserPrimaryGeneratorAction>::GetInstance().CreateObject(newValue);
    if (!gen) {
      G4ExceptionDescription ed;
      ed << "No registered builder for generator " << newValue << std::endl;
      G4Exception("GGSUserActionInitialization::UAIMessenger::SetNewValue", "Invalid generator",
                  G4ExceptionSeverity::FatalException, ed);
    }
    // Add to the run manager
    if (G4Threading::IsMultithreadedApplication() && G4Threading::IsMasterThread()) {
      // Hold the generator to keep eventual secondary commands alive, but don't pass it to the run manager of the
      // master thread
      _genForMaster = std::move(gen);
    } else {
      rme.SetGGSGeneratorAction(gen.release());
    }
  }
}