APrimePhysics.cxx

Go to the documentation of this file.

 
#include "SimCore/APrimePhysics.h"
 
namespace simcore {
 
const std::string APrimePhysics::NAME = "APrime";
 
static void storeElementZ(const G4Element& element) {
  static_cast<UserEventInformation*>(
      G4EventManager::GetEventManager()->GetUserInformation())
      ->setDarkBremMaterialZ(element.GetZ());
}
 
APrimePhysics::APrimePhysics(const framework::config::Parameters& params)
    : G4VPhysicsConstructor(APrimePhysics::NAME),
      parameters_{params},
      process_{nullptr} {
  ap_mass_ = parameters_.get<double>("ap_mass", 0.) * MeV;
  enable_ = parameters_.get<bool>("enable", false);
}
 
void APrimePhysics::ConstructParticle() {
  auto model{parameters_.get<framework::config::Parameters>("model")};
  static const std::map<std::string, G4APrime::DecayMode> decay_lut = {
      {"no_decay", G4APrime::DecayMode::NoDecay},
      {"flat_decay", G4APrime::DecayMode::FlatDecay},
      {"geant_decay", G4APrime::DecayMode::GeantDecay}};
  auto decay_it{
      decay_lut.find(model.get<std::string>("decay_mode", "no_decay"))};
  if (decay_it == decay_lut.end()) {
    EXCEPTION_RAISE(
        "BadConf",
        "Unrecognized decay mode '" + model.get<std::string>("decay_mode") +
            "',"
            " options are 'no_decay', 'flat_decay', or 'geant_decay'.");
  }
 
  double ap_tau = model.get<double>("ap_tau", -1.0);
 
  G4APrime::Initialize(ap_mass_, 622, ap_tau, decay_it->second);
}
 
void APrimePhysics::ConstructProcess() {
  // add process to electron if we are enabled
  if (enable_) {
    auto model{parameters_.get<framework::config::Parameters>("model")};
    auto model_name{model.get<std::string>("name")};
    if (model_name == "vertex_library" or model_name == "g4db") {
      static const std::map<std::string, g4db::G4DarkBreMModel::ScalingMethod>
          method_lut = {
              {"forward_only",
               g4db::G4DarkBreMModel::ScalingMethod::ForwardOnly},
              {"cm_scaling", g4db::G4DarkBreMModel::ScalingMethod::CMScaling},
              {"undefined", g4db::G4DarkBreMModel::ScalingMethod::Undefined}};
      auto scaling_method_it{method_lut.find(model.get<std::string>("method"))};
      if (scaling_method_it == method_lut.end()) {
        EXCEPTION_RAISE(
            "BadConf",
            "Unrecognized scaling method '" + model.get<std::string>("method") +
                "',"
                " options are 'forward_only', 'cm_scaling', or 'undefined'.");
      }
      // Note: The process variable isn't used here, but creating the
      // G4DarkBremsstahlung object has side-effects
      process_ = std::make_unique<G4DarkBremsstrahlung>(
          std::make_shared<g4db::G4DarkBreMModel>(
              model.get<std::string>("library_path"),
              false /* dark brem off muons instead of electrons - we
                       always DB off electrons here */
              ,
              model.get<double>("threshold"), model.get<double>("epsilon"),
              scaling_method_it->second,
              g4db::G4DarkBreMModel::XsecMethod::Auto,
              model.get<double>("max_R_for_full", 50.0),
              model.get<int>("aprime_lhe_id", 1023),
              true,  // always load the library
              model.get<bool>("scale_APrime", false),
              model.get<double>("dist_decay_min", 0.0),
              model.get<double>("dist_decay_max", 1.0)),
          parameters_.get<bool>("only_one_per_event"),
          1., /* global bias - should use bias operator instead */
          parameters_.get<bool>("cache_xsec"));
      process_->RegisterStorageMechanism(storeElementZ);
    } else {
      EXCEPTION_RAISE("BadConf",
                      "Unrecognized model name '" + model_name + "'.");
    }
    ldmx_log(trace) << "Initialization of dark brem complete";
  }
}
 
}  // namespace simcore