Defines basic APrime physics. More...

#include <APrimePhysics.h>

Public Member Functions
	APrimePhysics (const framework::config::Parameters &params)
	Class constructor.

virtual	~APrimePhysics ()=default
	Class destructor.

void	ConstructParticle ()
	Construct particle.

void	ConstructProcess ()
	Construct the process.

Static Public Attributes
static const std::string	NAME = "APrime"
	The name of this physics constructor.

Private Attributes
G4double	ap_mass_
	the mass of the A' for this run

bool	enable_
	is dark brem enabled for this run?

bool	fcp_enable_
	is A' -> fcp conversion enabled for this run?

G4double	fcp_mass_
	mass of the fcp in MeV

G4double	fcp_charge_
	charge of the fcp in units of e

G4double	fcp_xsec_factor_
	cross section biasing factor for A' -> fcp conversion

framework::config::Parameters	parameters_
	Dark brem parameters to pass to the process (if enabled)

std::unique_ptr< G4DarkBremsstrahlung >	process_

APrimeConversionToFCPs *	fcp_conversion_process_ {nullptr}
	A' -> fcp conversion process (owned by G4 process manager after registration)

Detailed Description

Defines basic APrime physics.

It constructs the APrime particle and links the dark brem process to the electron.

See also: G4APrime; G4DarkBremsstrahlung in G4DarkBreM

Note: This class basically does not do anything except register the custom particle (G4APrime) and custom process (G4DarkBremsstrahlung).

Definition at line 37 of file APrimePhysics.h.

Constructor & Destructor Documentation

◆ APrimePhysics()

simcore::APrimePhysics::APrimePhysics ( const framework::config::Parameters & params )

Class constructor.

Parameters

params Parameters to configure the dark brem process

Definition at line 37 of file APrimePhysics.cxx.

    : G4VPhysicsConstructor(APrimePhysics::NAME),
      parameters_{params},
      process_{nullptr} {
  ap_mass_ = parameters_.get<double>("ap_mass", 0.) * MeV;
  enable_ = parameters_.get<bool>("enable", false);
  fcp_enable_ = parameters_.get<bool>("fcp_enable", false);
  fcp_mass_ = parameters_.get<double>("fcp_mass", 0.) * MeV;
  fcp_charge_ = parameters_.get<double>("fcp_charge", 0.1);
  fcp_xsec_factor_ = parameters_.get<double>("fcp_xsec_factor", 1.0);
 
  ldmx_log(info) << "Configuration:" << " A' mass: " << ap_mass_ / MeV << " MeV"
                 << ", Dark brem enabled: " << (enable_ ? "YES" : "NO")
                 << ", FCP enabled: " << (fcp_enable_ ? "YES" : "NO")
                 << ", FCP mass: " << fcp_mass_ / MeV << " MeV"
                 << ", FCP charge: " << fcp_charge_ << " e"
                 << ", FCP xsec factor: " << fcp_xsec_factor_;
}

References ap_mass_, enable_, fcp_charge_, fcp_enable_, fcp_mass_, fcp_xsec_factor_, framework::config::Parameters::get(), and parameters_.

◆ ~APrimePhysics()

virtual simcore::APrimePhysics::~APrimePhysics ( )

virtualdefault

Class destructor.

Nothing right now.

Member Function Documentation

◆ ConstructParticle()

void simcore::APrimePhysics::ConstructParticle ( )

Construct particle.

Insert A' into the Geant4 particle table. Geant4 registers all instances derived from G4ParticleDefinition and deletes them at the end of processing.

Uses the A' mass given by the parameter APrimeMass to inform the G4APrime instance what mass to use.

See also: G4APrime

Insert A-prime into the Geant4 particle table.

Geant4 registers all instances derived from G4ParticleDefinition and deletes them at the end of the run. We configure the A' to have the input mass and the PDG ID number of 622.

If fcp is enabled, the A' decays to fcp+fcp- (decay_id=17), otherwise to e+e- (decay_id=11).

If fcp is enabled, initialize the fractionally charged particles. This registers fcp- and fcp+ in the Geant4 particle table.

Definition at line 56 of file APrimePhysics.cxx.

                                      {
  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);
 
  int decay_id = fcp_enable_ ? 17 : 11;
  ldmx_log(info) << "Initializing A' with:" << ", Mass: " << ap_mass_ / MeV
                 << " MeV" << ", PDG ID: 622" << ", Lifetime (tau): " << ap_tau
                 << ", Decay mode: "
                 << model.get<std::string>("decay_mode", "no_decay")
                 << ", Decay product ID: " << decay_id
                 << (fcp_enable_ ? " (fcp+fcp-)" : " (e+e-)");
 
  // Initialize the A' with the specified parameters
  G4APrime::Initialize(ap_mass_, 622, ap_tau, decay_it->second, decay_id);
 
  if (fcp_enable_) {
    G4FractionallyCharged::Initialize(fcp_mass_, 17, fcp_charge_);
  }
}

References ap_mass_, fcp_charge_, fcp_enable_, fcp_mass_, framework::config::Parameters::get(), and parameters_.

◆ ConstructProcess()

void simcore::APrimePhysics::ConstructProcess ( )

Construct the process.

Links the dark brem processs to the electron through the process manager only if the dark brem process is enabled ('enable' is True).

Also sets up the A' -> fcp+ fcp- conversion process if fcp is enabled.

G4ProcessManager registers and cleans up any created processes, so we can forget about it after creating it.

See also: G4DarkBremsstrahlung in G4DarkBreM; APrimeConversionToFCPs

Definition at line 104 of file APrimePhysics.cxx.

                                     {
  ldmx_log(trace) << "=== APrimePhysics::ConstructProcess ===";
  // add process to electron if we are enabled
  if (enable_) {
    ldmx_log(debug)
        << "Dark brem is enabled, setting up G4DarkBremsstrahlung...";
    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<bool>("correct_forward", 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";
  }
 
  // Add A' -> fcp+ fcp- conversion process if enabled
  if (fcp_enable_) {
    ldmx_log(debug)
        << "FCP is enabled, setting up A' -> fcp+ fcp- conversion process...";
    G4ProcessManager* aprime_proc_man = G4APrime::APrime()->GetProcessManager();
    if (aprime_proc_man == nullptr) {
      ldmx_log(error) << "FATAL: Unable to access process manager for A'!";
      EXCEPTION_RAISE("APrimePhysics",
                      "Was unable to access the process manager for A', "
                      "something is very wrong!");
    }
    ldmx_log(debug) << "Creating APrimeConversionToFCPs process...";
    fcp_conversion_process_ = new APrimeConversionToFCPs();
 
    // Apply cross section biasing factor
    if (fcp_xsec_factor_ != 1.0) {
      fcp_conversion_process_->setCrossSecFactor(fcp_xsec_factor_);
      ldmx_log(debug) << "Applied cross section biasing factor: "
                      << fcp_xsec_factor_;
    }
 
    aprime_proc_man->AddDiscreteProcess(fcp_conversion_process_);
    aprime_proc_man->SetProcessOrderingToFirst(
        fcp_conversion_process_, G4ProcessVectorDoItIndex::idxAll);
    ldmx_log(info)
        << "A' -> fcp+ fcp- conversion process registered successfully!";
  } else {
    ldmx_log(info) << "FCP not enabled, A' conversion process not registered";
  }
}

References enable_, fcp_conversion_process_, fcp_enable_, fcp_xsec_factor_, framework::config::Parameters::get(), parameters_, simcore::APrimeConversionToFCPs::setCrossSecFactor(), and simcore::storeElementZ().

Member Data Documentation

◆ ap_mass_

G4double simcore::APrimePhysics::ap_mass_

private

the mass of the A' for this run

Definition at line 94 of file APrimePhysics.h.

Referenced by APrimePhysics(), and ConstructParticle().

◆ enable_

bool simcore::APrimePhysics::enable_

private

is dark brem enabled for this run?

Definition at line 97 of file APrimePhysics.h.

Referenced by APrimePhysics(), and ConstructProcess().

◆ fcp_charge_

G4double simcore::APrimePhysics::fcp_charge_

private

charge of the fcp in units of e

Definition at line 106 of file APrimePhysics.h.

Referenced by APrimePhysics(), and ConstructParticle().

◆ fcp_conversion_process_

APrimeConversionToFCPs* simcore::APrimePhysics::fcp_conversion_process_ {nullptr}

private

A' -> fcp conversion process (owned by G4 process manager after registration)

Definition at line 124 of file APrimePhysics.h.

124{nullptr};

Referenced by ConstructProcess().

◆ fcp_enable_

bool simcore::APrimePhysics::fcp_enable_

private

is A' -> fcp conversion enabled for this run?

Definition at line 100 of file APrimePhysics.h.

Referenced by APrimePhysics(), ConstructParticle(), and ConstructProcess().

◆ fcp_mass_

G4double simcore::APrimePhysics::fcp_mass_

private

mass of the fcp in MeV

Definition at line 103 of file APrimePhysics.h.

Referenced by APrimePhysics(), and ConstructParticle().

◆ fcp_xsec_factor_

G4double simcore::APrimePhysics::fcp_xsec_factor_

private

cross section biasing factor for A' -> fcp conversion

Definition at line 109 of file APrimePhysics.h.

Referenced by APrimePhysics(), and ConstructProcess().

◆ NAME

const std::string simcore::APrimePhysics::NAME = "APrime"

static

The name of this physics constructor.

Passed into Geant4 to register this physics, should not conflict with any other Geant4 physics.

Definition at line 46 of file APrimePhysics.h.

◆ parameters_

framework::config::Parameters simcore::APrimePhysics::parameters_

private

Dark brem parameters to pass to the process (if enabled)

Note: This can't be a reference because we pass it to the process after the configuration step from our POV is done. Thus we need our own copy that won't be destroyed.

Definition at line 118 of file APrimePhysics.h.

Referenced by APrimePhysics(), ConstructParticle(), and ConstructProcess().

◆ process_

std::unique_ptr<G4DarkBremsstrahlung> simcore::APrimePhysics::process_

private

Definition at line 120 of file APrimePhysics.h.

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

SimCore/include/SimCore/APrimePhysics.h
SimCore/src/SimCore/APrimePhysics.cxx

Public Member Functions

Static Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ APrimePhysics()

◆ ~APrimePhysics()

Member Function Documentation

◆ ConstructParticle()

◆ ConstructProcess()

Member Data Documentation

◆ ap_mass_

◆ enable_

◆ fcp_charge_

◆ fcp_conversion_process_

◆ fcp_enable_

◆ fcp_mass_

◆ fcp_xsec_factor_

◆ NAME

◆ parameters_

◆ process_