Discrete process for A' -> fcp+ fcp- conversion in a nuclear field. More...

#include <APrimeConversionToFCPs.h>

Public Member Functions
	APrimeConversionToFCPs (const G4String &processName="APrimeToFCPPair", G4ProcessType type=fElectromagnetic)
	Constructor.

	~APrimeConversionToFCPs ()=default
	Destructor Just the default one.

G4bool	IsApplicable (const G4ParticleDefinition &particle) override
	Check if this process applies to the given particle.

void	BuildPhysicsTable (const G4ParticleDefinition &p) override
	Build physics table (called during initialization).

void	printInfoDefinition ()
	Print process information.

void	setCrossSecFactor (G4double fac)
	Set a factor to artificially scale the cross section.

G4double	getCrossSecFactor () const

G4double	GetMeanFreePath (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition) override
	Return the mean free path of the A' in the current material.

G4double	getCrossSectionPerAtom (const G4DynamicParticle aDynamicAPrime, const G4Element anElement)
	Return the total cross section per atom.

G4VParticleChange *	PostStepDoIt (const G4Track &aTrack, const G4Step &aStep) override
	Generate the final state: A' -> fcp+ fcp-.

G4double	computeCrossSectionPerAtom (G4double APrimeEnergy, G4int Z)
	Compute the cross section per atom for the given A' energy and Z.

G4double	computeMeanFreePath (G4double APrimeEnergy, const G4Material *aMaterial)
	Compute the mean free path for the given energy and material.

	APrimeConversionToFCPs (const APrimeConversionToFCPs &)=delete

APrimeConversionToFCPs &	operator= (const APrimeConversionToFCPs &)=delete

Static Public Attributes
static const std::string	PROCESS_NAME = "APrimeToFCPPair"
	The name of this process.

Private Member Functions
const G4Element *	selectRandomAtom (const G4DynamicParticle aDynamicAPrime, const G4Material aMaterial)
	Select a random atom from the material, weighted by cross section.

	enableLogging ("APrimeConversionToFCPs")
	Enable logging for this class.

Private Attributes
G4double	mfcp_
	fcp mass

G4double	rc_
	Coupling-scaled reduced Compton wavelength: q^2 * elm_coupling / Mfcp.

G4double	limit_energy_
	Energy limit for accurate cross section (5 * Mfcp)

G4double	lowest_energy_limit_
	Absolute low energy limit of the model (2 * Mfcp)

G4double	highest_energy_limit_
	High energy limit of the model.

G4double	cross_sec_factor_ = 1.0
	Factor to artificially scale the cross section.

const G4ParticleDefinition *	the_a_prime_
	Pointer to the A' particle definition.

const G4ParticleDefinition *	the_fcp_minus_
	Pointer to fcp- definition.

const G4ParticleDefinition *	the_fcp_plus_
	Pointer to fcp+ definition.

std::vector< G4double >	temp_
	Temporary vector for element selection.

Detailed Description

Discrete process for A' -> fcp+ fcp- conversion in a nuclear field.

This process is the dark-sector analogue of G4GammaConversionToMuons (gamma -> mu+ mu-). A practically massless dark photon (A') converts into a pair of massive fractionally charged particles (fcp+ fcp-) in the electromagnetic field of a nucleus.

Definition at line 31 of file APrimeConversionToFCPs.h.

Constructor & Destructor Documentation

◆ APrimeConversionToFCPs()

simcore::APrimeConversionToFCPs::APrimeConversionToFCPs	(	const G4String &	processName = "APrimeToFCPPair",
		G4ProcessType	type = fElectromagnetic )

explicit

Constructor.

Parameters

[in]	processName	name of this process (default: "APrimeToFCPPair")
[in]	type	Geant4 process type

Definition at line 24 of file APrimeConversionToFCPs.cxx.

    : G4VDiscreteProcess(processName, type) {
  // Get the fcp particle definitions
  auto* fcp_minus = G4FractionallyCharged::FractionallyCharged();
  mfcp_ = fcp_minus->GetPDGMass();
 
  // Get fcp charge magnitude in units of e
  G4double qfcp = std::abs(fcp_minus->GetPDGCharge() / CLHEP::eplus);
 
  // Coupling-scaled reduced Compton wavelength
  // rc_ = q^2 * elm_coupling / mfcp_
  // This gives the correct q^4 scaling in sigfac = 4*alpha*Z^2*rc_^2
  rc_ = qfcp * qfcp * CLHEP::elm_coupling / mfcp_;
 
  limit_energy_ = 5. * mfcp_;
  lowest_energy_limit_ = 2. * mfcp_;
  highest_energy_limit_ = 1e12 * CLHEP::GeV;
  ldmx_log(debug) << "Energy limits: lowest="
                  << lowest_energy_limit_ / CLHEP::MeV
                  << " MeV, limit=" << limit_energy_ / CLHEP::MeV
                  << " MeV, highest=" << highest_energy_limit_ / CLHEP::GeV
                  << " GeV";
 
  the_a_prime_ = G4APrime::APrime();
  the_fcp_minus_ = fcp_minus;
  // Look up the antiparticle (fcp+) from the particle table
  the_fcp_plus_ = G4ParticleTable::GetParticleTable()->FindParticle("fcp+");
 
  ldmx_log(debug) << "A' particle: "
                  << (the_a_prime_ ? the_a_prime_->GetParticleName() : "NULL")
                  << ", mass="
                  << (the_a_prime_ ? the_a_prime_->GetPDGMass() / CLHEP::MeV
                                   : 0)
                  << " MeV";
  ldmx_log(debug) << "FCP+ particle: "
                  << (the_fcp_plus_ ? the_fcp_plus_->GetParticleName()
                                    : "NULL");
  ldmx_log(debug) << "FCP- particle: "
                  << (the_fcp_minus_ ? the_fcp_minus_->GetParticleName()
                                     : "NULL");
}

References highest_energy_limit_, limit_energy_, lowest_energy_limit_, mfcp_, rc_, the_a_prime_, the_fcp_minus_, and the_fcp_plus_.

Member Function Documentation

◆ BuildPhysicsTable()

void simcore::APrimeConversionToFCPs::BuildPhysicsTable ( const G4ParticleDefinition & p )

override

Build physics table (called during initialization).

Sets up the temp vector for element selection.

Definition at line 76 of file APrimeConversionToFCPs.cxx.

                                                                            {
  ldmx_log(debug) << "=== BuildPhysicsTable for particle: "
                  << p.GetParticleName() << " ===";
  auto table = G4Material::GetMaterialTable();
  std::size_t nelm = 0;
  for (auto const& mat : *table) {
    std::size_t n = mat->GetNumberOfElements();
    nelm = std::max(nelm, n);
    ldmx_log(debug) << "  Material: " << mat->GetName() << " with " << n
                    << " elements";
  }
  temp_.resize(nelm, 0);
  ldmx_log(debug) << "Max elements in any material: " << nelm;
  printInfoDefinition();
}

References printInfoDefinition(), and temp_.

◆ computeCrossSectionPerAtom()

G4double simcore::APrimeConversionToFCPs::computeCrossSectionPerAtom	(	G4double	APrimeEnergy,
		G4int	Z )

Compute the cross section per atom for the given A' energy and Z.

Definition at line 141 of file APrimeConversionToFCPs.cxx.

                                                                     {
  // Cross section parametrization adapted from H. Burkhardt
  // (G4GammaConversionToMuons) with Mmuon -> mfcp_ and
  // coupling scaled by q_fcp^4 through rc_
  if (Egam <= lowest_energy_limit_) {
    return 0.0;
  }
 
  G4NistManager* nist = G4NistManager::Instance();
 
  G4double pow_thres, ecor, b, dn, zthird, winfty, w_med_appr, wsatur, sigfac;
 
  if (Z == 1) {  // special case of Hydrogen
    b = 202.4;
    dn = 1.49;
  } else {
    b = 183.;
    dn = 1.54 * nist->GetA27(Z);
  }
  zthird = 1. / nist->GetZ13(Z);  // Z^(-1/3)
  winfty = b * zthird * mfcp_ / (dn * electron_mass_c2);
  w_med_appr = 1. / (4. * dn * SQRTE * mfcp_);
  wsatur = winfty / w_med_appr;
  sigfac = 4. * fine_structure_const * Z * Z * rc_ * rc_;
  pow_thres = 1.479 + 0.00799 * dn;
  ecor = -18. + 4347. / (b * zthird);
 
  G4double cor_fuc = 1. + .04 * G4Log(1. + ecor / Egam);
  G4double eg = G4Exp(G4Log(1. - 4. * mfcp_ / Egam) * pow_thres) *
                G4Exp(G4Log(G4Exp(G4Log(wsatur) * POW_SAT) +
                            G4Exp(G4Log(Egam) * POW_SAT)) /
                      POW_SAT);
 
  G4double cross_section =
      7. / 9. * sigfac * G4Log(1. + w_med_appr * cor_fuc * eg);
  cross_section *= cross_sec_factor_;
  return cross_section;
}

References cross_sec_factor_, lowest_energy_limit_, mfcp_, and rc_.

Referenced by computeMeanFreePath(), getCrossSectionPerAtom(), and selectRandomAtom().

◆ computeMeanFreePath()

G4double simcore::APrimeConversionToFCPs::computeMeanFreePath	(	G4double	APrimeEnergy,
		const G4Material *	aMaterial )

Compute the mean free path for the given energy and material.

Definition at line 105 of file APrimeConversionToFCPs.cxx.

                                                        {
  if (APrimeEnergy <= lowest_energy_limit_) {
    return DBL_MAX;
  }
 
  const G4ElementVector* the_element_vector = aMaterial->GetElementVector();
  const G4double* nb_of_atoms_per_volume =
      aMaterial->GetVecNbOfAtomsPerVolume();
 
  G4double sigma = 0.0;
  G4double fact = 1.0;
  G4double e = APrimeEnergy;
 
  // Low energy approximation as in Bethe-Heitler model
  if (e < limit_energy_) {
    G4double y =
        (e - lowest_energy_limit_) / (limit_energy_ - lowest_energy_limit_);
    fact = y * y;
    e = limit_energy_;
  }
 
  for (std::size_t i = 0; i < aMaterial->GetNumberOfElements(); ++i) {
    sigma += nb_of_atoms_per_volume[i] * fact *
             computeCrossSectionPerAtom(
                 e, G4lrint((*the_element_vector)[i]->GetZ()));
  }
  return (sigma > 0.0) ? 1. / sigma : DBL_MAX;
}

References computeCrossSectionPerAtom(), limit_energy_, and lowest_energy_limit_.

Referenced by GetMeanFreePath().

◆ getCrossSecFactor()

G4double simcore::APrimeConversionToFCPs::getCrossSecFactor ( ) const

inline

Returns: the current cross section scaling factor

Definition at line 79 of file APrimeConversionToFCPs.h.

79{ return cross_sec_factor_; }

References cross_sec_factor_.

◆ getCrossSectionPerAtom()

G4double simcore::APrimeConversionToFCPs::getCrossSectionPerAtom	(	const G4DynamicParticle *	aDynamicAPrime,
		const G4Element *	anElement )

Return the total cross section per atom.

Definition at line 135 of file APrimeConversionToFCPs.cxx.

                                                                         {
  return computeCrossSectionPerAtom(aDynamicAPrime->GetKineticEnergy(),
                                    G4lrint(anElement->GetZ()));
}

References computeCrossSectionPerAtom().

◆ GetMeanFreePath()

G4double simcore::APrimeConversionToFCPs::GetMeanFreePath	(	const G4Track &	aTrack,
		G4double	previousStepSize,
		G4ForceCondition *	condition )

override

Return the mean free path of the A' in the current material.

Definition at line 92 of file APrimeConversionToFCPs.cxx.

                                                                              {
  const G4DynamicParticle* a_dynamic_a_prime = aTrack.GetDynamicParticle();
  G4double a_prime_energy = a_dynamic_a_prime->GetKineticEnergy();
  const G4Material* a_material = aTrack.GetMaterial();
  G4double mfp = computeMeanFreePath(a_prime_energy, a_material);
  ldmx_log(trace) << "GetMeanFreePath: A' KE=" << a_prime_energy / CLHEP::MeV
                  << " MeV in " << a_material->GetName()
                  << " -> MFP=" << (mfp < DBL_MAX ? mfp / CLHEP::mm : -1)
                  << " mm";
  return mfp;
}

References computeMeanFreePath().

◆ IsApplicable()

G4bool simcore::APrimeConversionToFCPs::IsApplicable ( const G4ParticleDefinition & particle )

override

Check if this process applies to the given particle.

Returns: true only for the A' (dark photon)

Definition at line 67 of file APrimeConversionToFCPs.cxx.

                                          {
  bool applicable = (&particle == the_a_prime_);
  ldmx_log(debug) << "IsApplicable called for particle: "
                  << particle.GetParticleName() << " -> "
                  << (applicable ? "YES (this is A')" : "NO");
  return applicable;
}

References the_a_prime_.

◆ PostStepDoIt()

G4VParticleChange * simcore::APrimeConversionToFCPs::PostStepDoIt	(	const G4Track &	aTrack,
		const G4Step &	aStep )

override

Generate the final state: A' -> fcp+ fcp-.

Definition at line 188 of file APrimeConversionToFCPs.cxx.

                                                                             {
  ldmx_log(debug) << "A' -> fcp+ fcp- conversion starting!";
  aParticleChange.Initialize(aTrack);
  const G4Material* a_material = aTrack.GetMaterial();
 
  ldmx_log(debug) << "Conversion in material: " << a_material->GetName();
  ldmx_log(debug) << "A' Track ID: " << aTrack.GetTrackID()
                  << ", Parent ID: " << aTrack.GetParentID();
 
  // Current A' energy and direction
  const G4DynamicParticle* a_dynamic_a_prime = aTrack.GetDynamicParticle();
  G4double egam = a_dynamic_a_prime->GetKineticEnergy();
 
  G4ThreeVector pos = aTrack.GetPosition();
  ldmx_log(debug) << "A' kinetic energy: " << egam / CLHEP::MeV << " MeV";
  ldmx_log(debug) << "A' position: (" << pos.x() / CLHEP::mm << ", "
                  << pos.y() / CLHEP::mm << ", " << pos.z() / CLHEP::mm
                  << ") mm";
  ldmx_log(debug) << "A' momentum direction: "
                  << a_dynamic_a_prime->GetMomentumDirection();
 
  if (egam <= lowest_energy_limit_) {
    ldmx_log(warn) << "A' energy (" << egam / CLHEP::MeV
                   << " MeV) below threshold ("
                   << lowest_energy_limit_ / CLHEP::MeV
                   << " MeV), skipping conversion!";
    return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
  }
 
  // Kill the incident A'
  ldmx_log(debug) << "Killing incident A' and creating fcp+/fcp- pair...";
  aParticleChange.ProposeMomentumDirection(0., 0., 0.);
  aParticleChange.ProposeEnergy(0.);
  aParticleChange.ProposeTrackStatus(fStopAndKill);
 
  G4ParticleMomentum a_prime_direction =
      a_dynamic_a_prime->GetMomentumDirection();
 
  // Select randomly one element constituting the material
  const G4Element* an_element = selectRandomAtom(a_dynamic_a_prime, a_material);
  G4int z = G4lrint(an_element->GetZ());
 
  // Store the element Z where the A' conversion occurred for downstream DQM.
  auto* event_info = static_cast<UserEventInformation*>(
      G4EventManager::GetEventManager()->GetUserInformation());
  if (event_info != nullptr) {
    event_info->setAPrimeConversionMaterialZ(z);
  }
 
  G4NistManager* nist = G4NistManager::Instance();
 
  G4double b, dn;
  G4double a027 = nist->GetA27(z);
 
  if (z == 1) {
    b = 202.4;
    dn = 1.49;
  } else {
    b = 183.;
    dn = 1.54 * a027;
  }
  G4double zthird = 1. / nist->GetZ13(z);
  G4double winfty = b * zthird * mfcp_ / (dn * electron_mass_c2);
 
  G4double c1_num = 0.138 * a027;
  G4double c1_num2 = c1_num * c1_num;
  G4double c2_term2 = electron_mass_c2 / (183. * zthird * mfcp_);
 
  G4double gamma_fcp_inv = mfcp_ / egam;
 
  // Generate xPlus according to the differential cross section by rejection
  G4double xmin =
      (egam <= limit_energy_) ? 0.5 : 0.5 - std::sqrt(0.25 - gamma_fcp_inv);
  G4double xmax = 1. - xmin;
 
  G4double ds2 = (dn * SQRTE - 2.);
  G4double s_bz = SQRTE * b * zthird / electron_mass_c2;
  G4double log_wmax_inv = 1. / G4Log(winfty * (1. + 2. * ds2 * gamma_fcp_inv) /
                                     (1. + 2. * s_bz * mfcp_ * gamma_fcp_inv));
  G4double x_plus = 0.5;
  G4double x_minus = 0.5;
  G4double x_pm = 0.25;
 
  G4int nn = 0;
  const G4int nmax = 1000;
 
  // Sampling for Egam > limit_energy_
  if (xmin < 0.5) {
    G4double result, w;
    do {
      x_plus = xmin + G4UniformRand() * (xmax - xmin);
      x_minus = 1. - x_plus;
      x_pm = x_plus * x_minus;
      G4double del = mfcp_ * mfcp_ / (2. * egam * x_pm);
      w = winfty * (1. + ds2 * del / mfcp_) / (1. + s_bz * del);
      G4double xxp = 1. - 4. / 3. * x_pm;
      result = (xxp > 0.) ? xxp * G4Log(w) * log_wmax_inv : 0.0;
      if (result > 1.0) {
        ldmx_log(warn) << "APrimeConversionToFCPs::PostStepDoIt WARNING:"
                       << " in dSigxPlusGen, result=" << result << " > 1";
      }
      ++nn;
      if (nn >= nmax) {
        break;
      }
    } while (G4UniformRand() > result);
  }
 
  // Generate angular variables via auxiliary variables t, psi, rho
  G4double t;
  G4double psi;
  G4double rho;
 
  G4double a3 = (gamma_fcp_inv / (2. * x_pm));
  G4double a33 = a3 * a3;
  G4double f1;
  G4double b1 = 1. / (4. * c1_num2);
  G4double b3 = b1 * b1 * b1;
  G4double a21 = a33 + b1;
 
  G4double f1_max =
      -(1. - x_pm) * (2. * b1 + (a21 + a33) * G4Log(a33 / a21)) / (2 * b3);
 
  G4double theta_plus, theta_minus, phi_half;
  nn = 0;
 
  // t, psi, rho generation (while angle < pi)
  do {
    // Generate t by rejection method
    do {
      ++nn;
      t = G4UniformRand();
      G4double a34 = a33 / (t * t);
      G4double a22 = a34 + b1;
      if (std::abs(b1) < 0.0001 * a34) {
        f1 = (1. - 2. * x_pm + 4. * x_pm * t * (1. - t)) /
             (12. * a34 * a34 * a34 * a34);
      } else {
        f1 = -(1. - 2. * x_pm + 4. * x_pm * t * (1. - t)) *
             (2. * b1 + (a22 + a34) * G4Log(a34 / a22)) / (2 * b3);
      }
      if (f1 < 0.0 || f1 > f1_max) {
        f1 = 0.0;
      }
      if (nn > nmax) {
        break;
      }
    } while (G4UniformRand() * f1_max > f1);
 
    // Generate psi by rejection method
    G4double f2_max = 1. - 2. * x_pm * (1. - 4. * t * (1. - t));
    G4double f2;
    do {
      ++nn;
      psi = CLHEP::twopi * G4UniformRand();
      f2 =
          1. - 2. * x_pm + 4. * x_pm * t * (1. - t) * (1. + std::cos(2. * psi));
      if (f2 < 0 || f2 > f2_max) {
        f2 = 0.0;
      }
      if (nn >= nmax) {
        break;
      }
    } while (G4UniformRand() * f2_max > f2);
 
    // Generate rho by direct transformation
    G4double c2_term1 = gamma_fcp_inv / (2. * x_pm * t);
    G4double c22 = c2_term1 * c2_term1 + c2_term2 * c2_term2;
    G4double c2 = 4. * c22 * c22 / std::sqrt(x_pm);
    G4double rhomax = (1. / t - 1.) * 1.9 / a027;
    G4double beta = G4Log((c2 + rhomax * rhomax * rhomax * rhomax) / c2);
    rho = G4Exp(G4Log(c2 * (G4Exp(beta * G4UniformRand()) - 1.)) * 0.25);
 
    // Get kinematical variables from t and psi
    G4double u = std::sqrt(1. / t - 1.);
    G4double xi_half = 0.5 * rho * std::cos(psi);
    phi_half = 0.5 * rho / u * std::sin(psi);
 
    theta_plus = gamma_fcp_inv * (u + xi_half) / x_plus;
    theta_minus = gamma_fcp_inv * (u - xi_half) / x_minus;
 
    // Protection against infinite loop
    if (nn > nmax) {
      if (std::abs(theta_plus) > CLHEP::pi) {
        theta_plus = 0.0;
      }
      if (std::abs(theta_minus) > CLHEP::pi) {
        theta_minus = 0.0;
      }
    }
  } while (std::abs(theta_plus) > CLHEP::pi ||
           std::abs(theta_minus) > CLHEP::pi);
 
  // Construct the momentum vectors
  // Azimuthal symmetry: take phi0 random between 0 and 2pi
  G4double phi0 = CLHEP::twopi * G4UniformRand();
  G4double e_plus = x_plus * egam;
  G4double e_minus = x_minus * egam;
 
  // fcp+ fcp- directions for A' in z-direction
  G4ThreeVector fcp_plus_direction(
      std::sin(theta_plus) * std::cos(phi0 + phi_half),
      std::sin(theta_plus) * std::sin(phi0 + phi_half), std::cos(theta_plus));
  G4ThreeVector fcp_minus_direction(
      -std::sin(theta_minus) * std::cos(phi0 - phi_half),
      -std::sin(theta_minus) * std::sin(phi0 - phi_half),
      std::cos(theta_minus));
 
  // Rotate to actual A' direction
  fcp_plus_direction.rotateUz(a_prime_direction);
  fcp_minus_direction.rotateUz(a_prime_direction);
 
  // Create fcp+ secondary
  auto a_particle1 =
      new G4DynamicParticle(the_fcp_plus_, fcp_plus_direction, e_plus - mfcp_);
  aParticleChange.AddSecondary(a_particle1);
 
  ldmx_log(debug) << "Created FCP+ with:";
  ldmx_log(debug) << "  - Kinetic energy: " << (e_plus - mfcp_) / CLHEP::MeV
                  << " MeV";
  ldmx_log(debug) << "  - Total energy: " << e_plus / CLHEP::MeV << " MeV";
  ldmx_log(debug) << "  - Direction: " << fcp_plus_direction;
 
  // Create fcp- secondary
  auto a_particle2 = new G4DynamicParticle(the_fcp_minus_, fcp_minus_direction,
                                           e_minus - mfcp_);
  aParticleChange.AddSecondary(a_particle2);
 
  ldmx_log(debug) << "Created FCP- with:";
  ldmx_log(debug) << "  - Kinetic energy: " << (e_minus - mfcp_) / CLHEP::MeV
                  << " MeV";
  ldmx_log(debug) << "  - Total energy: " << e_minus / CLHEP::MeV << " MeV";
  ldmx_log(debug) << "  - Direction: " << fcp_minus_direction;
 
  ldmx_log(debug) << "=== A' -> fcp+ fcp- CONVERSION COMPLETE ===";
 
  return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
}  // end of PostStepDoIt

References limit_energy_, lowest_energy_limit_, mfcp_, selectRandomAtom(), the_fcp_minus_, and the_fcp_plus_.

◆ printInfoDefinition()

void simcore::APrimeConversionToFCPs::printInfoDefinition ( )

Print process information.

Definition at line 455 of file APrimeConversionToFCPs.cxx.

                                                 {
  G4cout << G4endl << GetProcessName() << ":  "
         << "A' -> fcp+ fcp- Bethe-Heitler-like process" << G4endl;
  G4cout << "        good cross section parametrization from "
         << G4BestUnit(lowest_energy_limit_, "Energy") << " to "
         << highest_energy_limit_ / GeV << " GeV for all Z." << G4endl;
  G4cout << "        cross section factor: " << cross_sec_factor_ << G4endl;
}

References cross_sec_factor_, highest_energy_limit_, and lowest_energy_limit_.

Referenced by BuildPhysicsTable().

◆ selectRandomAtom()

const G4Element * simcore::APrimeConversionToFCPs::selectRandomAtom	(	const G4DynamicParticle *	aDynamicAPrime,
		const G4Material *	aMaterial )

private

Select a random atom from the material, weighted by cross section.

Definition at line 428 of file APrimeConversionToFCPs.cxx.

                                                                          {
  const std::size_t number_of_elements = aMaterial->GetNumberOfElements();
  const G4ElementVector* the_element_vector = aMaterial->GetElementVector();
  const G4Element* elm = (*the_element_vector)[0];
 
  if (number_of_elements > 1) {
    G4double e = std::max(aDynamicAPrime->GetKineticEnergy(), limit_energy_);
    const G4double* natom = aMaterial->GetVecNbOfAtomsPerVolume();
 
    G4double sum = 0.;
    for (std::size_t i = 0; i < number_of_elements; ++i) {
      elm = (*the_element_vector)[i];
      sum += natom[i] * computeCrossSectionPerAtom(e, G4lrint(elm->GetZ()));
      temp_[i] = sum;
    }
    sum *= G4UniformRand();
    for (std::size_t i = 0; i < number_of_elements; ++i) {
      if (sum <= temp_[i]) {
        elm = (*the_element_vector)[i];
        break;
      }
    }
  }
  return elm;
}

References computeCrossSectionPerAtom(), limit_energy_, and temp_.

Referenced by PostStepDoIt().

◆ setCrossSecFactor()

void simcore::APrimeConversionToFCPs::setCrossSecFactor ( G4double fac )

Set a factor to artificially scale the cross section.

Parameters

[in] fac multiplicative factor (default 1.0)

Definition at line 181 of file APrimeConversionToFCPs.cxx.

                                                           {
  if (fac < 0.0) return;
  cross_sec_factor_ = fac;
  ldmx_log(info) << "APrimeConversionToFCPs cross section factor set to "
                 << cross_sec_factor_;
}

References cross_sec_factor_.

Referenced by simcore::APrimePhysics::ConstructProcess().

Member Data Documentation

◆ cross_sec_factor_

G4double simcore::APrimeConversionToFCPs::cross_sec_factor_ = 1.0

private

Factor to artificially scale the cross section.

Definition at line 132 of file APrimeConversionToFCPs.h.

Referenced by computeCrossSectionPerAtom(), getCrossSecFactor(), printInfoDefinition(), and setCrossSecFactor().

◆ highest_energy_limit_

G4double simcore::APrimeConversionToFCPs::highest_energy_limit_

private

High energy limit of the model.

Definition at line 130 of file APrimeConversionToFCPs.h.

Referenced by APrimeConversionToFCPs(), and printInfoDefinition().

◆ limit_energy_

G4double simcore::APrimeConversionToFCPs::limit_energy_

private

Energy limit for accurate cross section (5 * Mfcp)

Definition at line 126 of file APrimeConversionToFCPs.h.

Referenced by APrimeConversionToFCPs(), computeMeanFreePath(), PostStepDoIt(), and selectRandomAtom().

◆ lowest_energy_limit_

G4double simcore::APrimeConversionToFCPs::lowest_energy_limit_

private

Absolute low energy limit of the model (2 * Mfcp)

Definition at line 128 of file APrimeConversionToFCPs.h.

Referenced by APrimeConversionToFCPs(), computeCrossSectionPerAtom(), computeMeanFreePath(), PostStepDoIt(), and printInfoDefinition().

◆ mfcp_

G4double simcore::APrimeConversionToFCPs::mfcp_

private

fcp mass

Definition at line 122 of file APrimeConversionToFCPs.h.

Referenced by APrimeConversionToFCPs(), computeCrossSectionPerAtom(), and PostStepDoIt().

◆ PROCESS_NAME

const std::string simcore::APrimeConversionToFCPs::PROCESS_NAME = "APrimeToFCPPair"

static

The name of this process.

Used to attach biasing operators to this process.

Definition at line 37 of file APrimeConversionToFCPs.h.

Referenced by simcore::biasoperators::APrimeToFCPPair::getProcessToBias().

◆ rc_

G4double simcore::APrimeConversionToFCPs::rc_

private

Coupling-scaled reduced Compton wavelength: q^2 * elm_coupling / Mfcp.

Definition at line 124 of file APrimeConversionToFCPs.h.

Referenced by APrimeConversionToFCPs(), and computeCrossSectionPerAtom().

◆ temp_

std::vector<G4double> simcore::APrimeConversionToFCPs::temp_

private

Temporary vector for element selection.

Definition at line 142 of file APrimeConversionToFCPs.h.

Referenced by BuildPhysicsTable(), and selectRandomAtom().

◆ the_a_prime_

const G4ParticleDefinition* simcore::APrimeConversionToFCPs::the_a_prime_

private

Pointer to the A' particle definition.

Definition at line 135 of file APrimeConversionToFCPs.h.

Referenced by APrimeConversionToFCPs(), and IsApplicable().

◆ the_fcp_minus_

const G4ParticleDefinition* simcore::APrimeConversionToFCPs::the_fcp_minus_

private

Pointer to fcp- definition.

Definition at line 137 of file APrimeConversionToFCPs.h.

Referenced by APrimeConversionToFCPs(), and PostStepDoIt().

◆ the_fcp_plus_

const G4ParticleDefinition* simcore::APrimeConversionToFCPs::the_fcp_plus_

private

Pointer to fcp+ definition.

Definition at line 139 of file APrimeConversionToFCPs.h.

Referenced by APrimeConversionToFCPs(), and PostStepDoIt().

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

SimCore/include/SimCore/APrimeConversionToFCPs.h
SimCore/src/SimCore/APrimeConversionToFCPs.cxx

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ APrimeConversionToFCPs()

Member Function Documentation

◆ BuildPhysicsTable()

◆ computeCrossSectionPerAtom()

◆ computeMeanFreePath()

◆ getCrossSecFactor()

◆ getCrossSectionPerAtom()

◆ GetMeanFreePath()

◆ IsApplicable()

◆ PostStepDoIt()

◆ printInfoDefinition()

◆ selectRandomAtom()

◆ setCrossSecFactor()

Member Data Documentation

◆ cross_sec_factor_

◆ highest_energy_limit_

◆ limit_energy_

◆ lowest_energy_limit_

◆ mfcp_

◆ PROCESS_NAME

◆ rc_

◆ temp_

◆ the_a_prime_

◆ the_fcp_minus_

◆ the_fcp_plus_