#include <bremsstrahlungactiondilepton.h>

Similar to the photon treatment, BremsstrahlungActionDilepton is a special action which takes two incoming particles and performs a perturbative scattering where a Bremsstrahlung photon is produced.

The final state particles are not further propagated, only written to the dilepton output.

Implements dilepton production via the process pn -> pn e⁺e⁻ using the phase-space corrected soft-photon approximation (SPA) as e.g. outlined in Weil:2013mya [72] (see eq. (40)–(43) in the reference document).

The pion electromagnetic form factor (PEFF) from Shyam:2010vr [58] is optionally applied, modifying the differential cross section by \(|F_\pi(M^2)|^2\). The form factor accounts for the internal charged pion propagator.

Kinematic variables sampled for the dilepton pair are:

m_inv: invariant mass of the dilepton pair [ \(2m_e,\sqrt{s}-2m_N\)]
q: 3-momentum of dilepton in pn-CM frame
\(\cos\theta\): Cosine of polar angle of dilepton in pn-CM frame \([-1, 1]\)
\(\phi\): azimuthal angle of dilepton in pn-CM frame \([0, 2\pi]\)

The dilepton 4-momentum is constructed directly from (m_inv, q, \(\cos\theta\), \(\phi\)) to enable event-by-event acceptance cuts. The e⁺e⁻ pair is subsequently produced isotropically in the virtual photon's rest frame.

Definition at line 50 of file bremsstrahlungactiondilepton.h.

Inheritance diagram for smash::BremsstrahlungActionDilepton:

[legend]

Collaboration diagram for smash::BremsstrahlungActionDilepton:

[legend]

Public Types
enum class	ReactionType { no_reaction , np }
	Enum for encoding bremsstrahlung process for n+p only. More...

Public Member Functions
	BremsstrahlungActionDilepton (const ParticleList &in, double time, double hadronic_cross_section_input, DileptonBremsPionFormFactor ff_type)
	Construct a BremsstrahlungActionDilepton object. More...

void	add_dummy_hadronic_process (double reaction_cross_section)
	Adds the hadronic process with a given cross section. More...

void	perform_dilepton_bremsstrahlung (const OutputsList &outputs)
	Create the final state and write to output. More...

void	generate_final_state () override
	Main function: sample kinematics and compute weight for one dilepton event. More...

double	get_total_weight () const override
	Return the weight of the dilepton pair. More...

double	get_partial_weight () const override
	Return the partial weight of zero as otherwise garbage is written to output. More...

Public Member Functions inherited from smash::ScatterAction
	ScatterAction (const ParticleData &in_part1, const ParticleData &in_part2, double time, bool isotropic=false, double string_formation_time=1.0, double box_length=-1.0, bool is_total_parametrized=false, const SpinInteractionType spin_interaction_type=SpinInteractionType::Off)
	Construct a ScatterAction object. More...

void	add_collision (CollisionBranchPtr p)
	Add a new collision channel. More...

void	add_collisions (CollisionBranchList pv)
	Add several new collision channels at once. More...

double	transverse_distance_sqr () const
	Calculate the transverse distance of the two incoming particles in their local rest frame. More...

double	cov_transverse_distance_sqr () const
	Calculate the transverse distance of the two incoming particles in their local rest frame written in a covariant form. More...

double	mandelstam_s () const
	Determine the Mandelstam s variable,. More...

double	relative_velocity () const
	Get the relative velocity of the two incoming particles. More...

void	generate_final_state () override
	Generate the final-state of the scattering process. More...

double	get_total_weight () const override
	Get the total cross section of scattering particles. More...

double	get_partial_weight () const override
	Get the partial cross section of the chosen channel. More...

void	sample_angles (std::pair< double, double > masses, double kinetic_energy_cm) override
	Sample final-state angles in a 2->2 collision (possibly anisotropic). More...

void	add_all_scatterings (const ScatterActionsFinderParameters &finder_parameters)
	Add all possible scattering subprocesses for this action object. More...

void	set_parametrized_total_cross_section (const ScatterActionsFinderParameters &finder_parameters)
	Given the incoming particles, assigns the correct parametrization of the total cross section. More...

const CollisionBranchList &	collision_channels ()
	Get list of possible collision channels. More...

void	set_string_interface (StringProcess *str_proc)
	Set the StringProcess object to be used. More...

virtual double	cross_section () const
	Get the total cross section of the scattering particles, either from a parametrization, or from the sum of partials. More...

Public Member Functions inherited from smash::Action
	Action (const ParticleList &in_part, double time)
	Construct an action object with incoming particles and relative time. More...

	Action (const ParticleData &in_part, const ParticleData &out_part, double time, ProcessType type)
	Construct an action object with the incoming particles, relative time, and the already known outgoing particles and type of the process. More...

	Action (const ParticleList &in_part, const ParticleList &out_part, double absolute_execution_time, ProcessType type)
	Construct an action object with the incoming particles, absolute time, and the already known outgoing particles and type of the process. More...

	Action (const Action &)=delete
	Copying is disabled. Use pointers or create a new Action. More...

virtual	~Action ()
	Virtual Destructor. More...

bool	operator< (const Action &rhs) const
	Determine whether one action takes place before another in time. More...

virtual ProcessType	get_type () const
	Get the process type. More...

template<typename Branch >
void	add_process (ProcessBranchPtr< Branch > &p, ProcessBranchList< Branch > &subprocesses, double &total_weight)
	Add a new subprocess. More...

template<typename Branch >
void	add_processes (ProcessBranchList< Branch > pv, ProcessBranchList< Branch > &subprocesses, double &total_weight)
	Add several new subprocesses at once. More...

virtual double	perform (Particles *particles, uint32_t id_process)
	Actually perform the action, e.g. More...

bool	is_valid (const Particles &particles) const
	Check whether the action still applies. More...

bool	is_pauli_blocked (const std::vector< Particles > &ensembles, const PauliBlocker &p_bl) const
	Check if the action is Pauli-blocked. More...

const ParticleList &	incoming_particles () const
	Get the list of particles that go into the action. More...

void	update_incoming (const Particles &particles)
	Update the incoming particles that are stored in this action to the state they have in the global particle list. More...

const ParticleList &	outgoing_particles () const
	Get the list of particles that resulted from the action. More...

double	time_of_execution () const
	Get the time at which the action is supposed to be performed. More...

virtual double	check_conservation (const uint32_t id_process) const
	Check various conservation laws. More...

double	sqrt_s () const
	Determine the total energy in the center-of-mass frame [GeV]. More...

FourVector	total_momentum_of_outgoing_particles () const
	Calculate the total kinetic momentum of the outgoing particles. More...

FourVector	get_interaction_point () const
	Get the interaction point. More...

std::pair< FourVector, FourVector >	get_potential_at_interaction_point () const
	Get the skyrme and asymmetry potential at the interaction point. More...

void	set_stochastic_pos_idx ()
	Setter function that stores a random incoming particle index latter used to determine the interaction point. More...

void	assign_unpolarized_spin_vector_to_outgoing_particles ()
	Assign an unpolarized spin vector to all outgoing particles. More...

Static Public Member Functions
static bool	is_dilepton_brems_reaction (const ParticleList &in)
	Check if particles can undergo an implemented dilepton bremsstrahlung process. More...

Static Public Member Functions inherited from smash::Action
static double	lambda_tilde (double a, double b, double c)
	Little helper function that calculates the lambda function (sometimes written with a tilde to better distinguish it) that appears e.g. More...

Private Member Functions
bool	sample_2body_isotropic_ (const FourVector &p_parent, ParticleData &child_1, ParticleData &child_2)
	Generates momenta of outgoing particles (for 2-body isotropic decays only). More...

double	diff_xs_pn_dilepton_ (double m_inv, double q, double sqrts) const
	Fully differential cross section \(\frac{d\sigma}{dM dq d\Omega}\) for \( pn \rightarrow pne^+ e^- \). More...

double	pion_em_form_factor_sq_ (double m_inv) const
	Returns \(\|F_\pi(m_{inv}^2)\|^2\), the squared pion electromagnetic form factor. More...

Static Private Member Functions
static ReactionType	dilepton_brems_reaction_type_ (const ParticleList &in)
	Determine dilepton bremsstrahlung process from incoming particle list. More...

Private Attributes
CollisionBranchList	collision_processes_dilepton_bremsstrahlung_
	Holds the bremsstrahlung branch. More...

const ReactionType	reaction_type_
	Reaction process as determined from incoming particles. More...

double	weight_ = 0.0
	Weight of the dilepton event. More...

double	cross_section_dilepton_bremsstrahlung_ = 0.0
	Total cross section of dilepton bremsstrahlung process [mb]. More...

const double	hadronic_cross_section_
	Total hadronic cross section. More...

const DileptonBremsPionFormFactor	form_factor_type_
	Form factor type: Off, FF1, FF2. More...

double	q_
	Sampled 3-momentum of dilepton pair in pn-CM frame. More...

double	m_inv_
	Sampled invariant mass of the dilepton pair. More...

Additional Inherited Members
Protected Member Functions inherited from smash::ScatterAction
double	cm_momentum () const
	Get the momentum of the center of mass of the incoming particles in the calculation frame. More...

double	cm_momentum_squared () const
	Get the squared momentum of the center of mass of the incoming particles in the calculation frame. More...

ThreeVector	beta_cm () const
	Get the velocity of the center of mass of the scattering/incoming particles in the calculation frame. More...

double	gamma_cm () const
	Get the gamma factor corresponding to a boost to the center of mass frame of the colliding particles. More...

void	elastic_scattering ()
	Perform an elastic two-body scattering, i.e. just exchange momentum. More...

void	inelastic_scattering ()
	Perform an inelastic two-body scattering, i.e. new particles are formed. More...

void	two_to_many_scattering ()
	Perform an inelastic two-to-many-body scattering (more than 2) More...

void	create_string_final_state ()
	Creates the final states for string-processes after they are performed. More...

void	string_excitation ()
	Todo(ryu): document better - it is not really UrQMD-based, isn't it? Perform the UrQMD-based string excitation and decay. More...

void	spin_interaction ()
	Perform spin interaction in binary interactions. More...

void	string_spin_interaction ()
	Perform spin interaction in string excitations. More...

void	format_debug_output (std::ostream &out) const override
	Writes information about this scatter action to the `out` stream. More...

Protected Member Functions inherited from smash::Action
FourVector	total_momentum () const
	Sum of 4-momenta of incoming particles. More...

template<typename Branch >
const Branch *	choose_channel (const ProcessBranchList< Branch > &subprocesses, double total_weight)
	Decide for a particular final-state channel via Monte-Carlo and return it as a ProcessBranch. More...

virtual std::pair< double, double >	sample_masses (double kinetic_energy_cm) const
	Sample final-state masses in general X->2 processes (thus also fixing the absolute c.o.m. More...

virtual void	sample_2body_phasespace ()
	Sample the full 2-body phase-space (masses, momenta, angles) in the center-of-mass frame for the final state particles. More...

virtual void	sample_manybody_phasespace ()
	Sample the full n-body phase-space (masses, momenta, angles) in the center-of-mass frame for the final state particles. More...

void	assign_formation_time_to_outgoing_particles ()
	Assign the formation time to the outgoing particles. More...

Protected Attributes inherited from smash::ScatterAction
CollisionBranchList	collision_channels_
	List of possible collisions. More...

double	sum_of_partial_cross_sections_
	Current sum of partial hadronic cross sections. More...

double	partial_cross_section_
	Partial cross-section to the chosen outgoing channel. More...

bool	isotropic_ = false
	Do this collision isotropically? More...

double	string_formation_time_ = 1.0
	Time fragments take to be fully formed in hard string excitation. More...

Protected Attributes inherited from smash::Action
ParticleList	incoming_particles_
	List with data of incoming particles. More...

ParticleList	outgoing_particles_
	Initially this stores only the PDG codes of final-state particles. More...

const double	time_of_execution_
	Time at which the action is supposed to be performed (absolute time in the lab frame in fm). More...

ProcessType	process_type_
	type of process More...

double	box_length_ = -1.0
	Box length: needed to determine coordinates of collision correctly in case of collision through the wall. More...

int	stochastic_position_idx_ = -1
	This stores a randomly-chosen index to an incoming particle. More...

Member Enumeration Documentation

◆ ReactionType

enum smash::BremsstrahlungActionDilepton::ReactionType

strong

Enum for encoding bremsstrahlung process for n+p only.

It is uniquely determined by the incoming particles.

Enumerator
no_reaction
np

Definition at line 56 of file bremsstrahlungactiondilepton.h.

56 { no_reaction, np };

Constructor & Destructor Documentation

◆ BremsstrahlungActionDilepton()

smash::BremsstrahlungActionDilepton::BremsstrahlungActionDilepton	(	const ParticleList &	in,
		double	time,
		double	hadronic_cross_section_input,
		DileptonBremsPionFormFactor	ff_type
	)

Construct a BremsstrahlungActionDilepton object.

Parameters

[in]	in	ParticleList of incoming particles (n+p only).
[in]	time	Time relative to underlying hadronic action.
[in]	hadronic_cross_section_input	Total np hadronic cross section.
[in]	ff_type	Which form factor parametrization to use.

Returns: The constructed object.

Definition at line 44 of file bremsstrahlungactiondilepton.cc.

     : ScatterAction(in[0], in[1], time),
       reaction_type_(dilepton_brems_reaction_type_(in)),
       hadronic_cross_section_(hadronic_cross_section_input),
       form_factor_type_(ff_type) {}

Member Function Documentation

◆ is_dilepton_brems_reaction()

static bool smash::BremsstrahlungActionDilepton::is_dilepton_brems_reaction ( const ParticleList & in )

inlinestatic

Check if particles can undergo an implemented dilepton bremsstrahlung process.

This function does not check the involved kinematics.

Parameters

[in] in ParticleList of incoming particles.

Returns: bool if dilepton bremsstrahlung reaction implemented.

Definition at line 82 of file bremsstrahlungactiondilepton.h.

                                                                  {
     return dilepton_brems_reaction_type_(in) != ReactionType::no_reaction;
   }

Here is the call graph for this function:

◆ add_dummy_hadronic_process()

void smash::BremsstrahlungActionDilepton::add_dummy_hadronic_process ( double reaction_cross_section )

Adds the hadronic process with a given cross section.

The intended use is to add the hadronic cross section from the already performed hadronic action without recomputing it.

Parameters

[in] reaction_cross_section Total cross section of underlying hadronic process [mb]

Definition at line 73 of file bremsstrahlungactiondilepton.cc.

                                    {
   CollisionBranchPtr dummy_process = std::make_unique<CollisionBranch>(
       incoming_particles_[0].type(), incoming_particles_[1].type(),
       reaction_cross_section, ProcessType::BremsstrahlungDilepton);
  
   add_collision(std::move(dummy_process));
  
   // Define all outgoing particles at the end of the reaction.
   static const ParticleTypePtr e_p_particle = &ParticleType::find(pdg::e_p);
   static const ParticleTypePtr e_m_particle = &ParticleType::find(pdg::e_m);
   static const ParticleTypePtr p_particle = &ParticleType::find(pdg::p);
   static const ParticleTypePtr n_particle = &ParticleType::find(pdg::n);
  
   CollisionBranchList final_state_list;
  
   assert(reaction_type_ != ReactionType::no_reaction);
   if (reaction_type_ == ReactionType::no_reaction) {
     logg[LScatterAction].fatal()
         << "Problem in " << __func__
         << ". Looks like an unknown reaction "
            "type for this dilepton bremsstrahlung process is present.";
     throw std::runtime_error(
         "Unreachable code was reached, "
         "please check logs for details.");
   }
  
   // For the 'np' reaction, the final state is 'pn e⁺e⁻' in this order.
   final_state_list.push_back(std::make_unique<CollisionBranch>(
       *p_particle, *n_particle, *e_p_particle, *e_m_particle,
       reaction_cross_section, ProcessType::BremsstrahlungDilepton));
  
   add_processes<CollisionBranch>(std::move(final_state_list),
                                  collision_processes_dilepton_bremsstrahlung_,
                                  cross_section_dilepton_bremsstrahlung_);
 }

Here is the call graph for this function:

◆ perform_dilepton_bremsstrahlung()

void smash::BremsstrahlungActionDilepton::perform_dilepton_bremsstrahlung ( const OutputsList & outputs )

Create the final state and write to output.

Parameters

[in] outputs List of all outputs. Does not have to be a specific dilepton output, the function will take care of this.

Definition at line 110 of file bremsstrahlungactiondilepton.cc.

                                 {
   // Only one photon is created per event.
   generate_final_state();
   for (const auto &output : outputs) {
     // we only care about the dilepton output, the function will take care
     if (output->is_dilepton_output()) {
       // we do not care about the local density
       output->at_interaction(*this, 0.0);
     }
   }
 }

Here is the call graph for this function:

◆ generate_final_state()

void smash::BremsstrahlungActionDilepton::generate_final_state ( )

overridevirtual

Main function: sample kinematics and compute weight for one dilepton event.

Implements smash::Action.

Definition at line 123 of file bremsstrahlungactiondilepton.cc.

                                                         {
   assert(collision_processes_dilepton_bremsstrahlung_.size() == 1);
   if (collision_processes_dilepton_bremsstrahlung_.size() != 1) {
     logg[LScatterAction].fatal()
         << "Problem in " << __func__
         << ". The function expects exactly "
            "one process branch for the dilepton bremsstrahlung process.";
     throw std::runtime_error(
         "Unreachable code was reached, "
         "please check logs for details.");
   }
  
   auto *proc = collision_processes_dilepton_bremsstrahlung_[0].get();
  
   outgoing_particles_ = proc->particle_list();
   process_type_ = proc->get_type();
   FourVector interaction_point = get_interaction_point();
  
   assert(outgoing_particles_.size() == 4);
   constexpr double m_p = nucleon_mass;
   constexpr double m_n = nucleon_mass;
   constexpr double m_e = electron_mass;
  
   const double M_min = 2.0 * m_e;
   const double M_max = sqrt_s() - m_p - m_n;
   // Check if it is possible to create a dilepton pair, i.e. M_min < M_max.
   if (M_max <= M_min) {
     weight_ = 0.0;
     return;
   } else {
     m_inv_ = random::uniform(M_min, M_max);
   }
  
   /* After fixing M, the momentum q depends on the CM energy sqrt_s.
    * There is no lower limit beside being positive, but the upper limit is given
    * by the kinematics of the 3-body final state.
    */
   const double q_min = 0.0;
   const double q_max = pCM(sqrt_s(), m_inv_, m_p + m_n);
  
   // Sample q_ uniformly in [q_min, q_max] if kinematically allowed.
   if (q_max > q_min) {
     q_ = random::uniform(q_min, q_max);
   } else {
     weight_ = 0.0;
     return;
   }
  
   // The virtual photon carries 4-momentum p_ll with direction (theta, phi)
   const double E_ll = std::sqrt(q_ * q_ + m_inv_ * m_inv_);
  
   Angles phitheta;
   phitheta.distribute_isotropically();
   const FourVector p_ll(E_ll, q_ * phitheta.threevec());
  
   // Calculate the recoil for the (pn)' subsystem after the collision.
   const FourVector p_recoil = FourVector(sqrt_s(), 0.0, 0.0, 0.0) - p_ll;
  
   /* If the invariant mass of (pn)' is smaller than the rest masses of p and n,
    * the sampling check fails and the function returns false, as the action is
    * energetically not possible. Hence, set the weight to 0 and return.
    */
   if (!sample_2body_isotropic_(p_recoil, outgoing_particles_[0],
                                outgoing_particles_[1])) {
     weight_ = 0.0;
     return;
   }
  
   /* Isotropic 2-body decay in the virtual photon rest frame, then boost to
    * pn-CM frame.
    */
   if (!sample_2body_isotropic_(p_ll, outgoing_particles_[2],
                                outgoing_particles_[3])) {
     weight_ = 0.0;
     return;
   }
  
   weight_ =
       diff_xs_pn_dilepton_(m_inv_, q_, sqrt_s()) / hadronic_cross_section_;
  
   weight_ *= incoming_particles_[0].xsec_scaling_factor() *
              incoming_particles_[1].xsec_scaling_factor();
  
   // Set positions and boost to computational frame
   for (auto &new_particle : outgoing_particles_) {
     new_particle.set_formation_time(time_of_execution_);
     new_particle.set_4position(interaction_point);
     new_particle.boost_momentum(
         -total_momentum_of_outgoing_particles().velocity());
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_total_weight()

double smash::BremsstrahlungActionDilepton::get_total_weight ( ) const

inlineoverridevirtual

Return the weight of the dilepton pair.

Returns: The total weight.

Implements smash::Action.

Definition at line 116 of file bremsstrahlungactiondilepton.h.

116 { return weight_; }

◆ get_partial_weight()

double smash::BremsstrahlungActionDilepton::get_partial_weight ( ) const

inlineoverridevirtual

Return the partial weight of zero as otherwise garbage is written to output.

Returns: 0.0 as partial weight.

Implements smash::Action.

Definition at line 124 of file bremsstrahlungactiondilepton.h.

124 { return 0.0; }

◆ dilepton_brems_reaction_type_()

BremsstrahlungActionDilepton::ReactionType smash::BremsstrahlungActionDilepton::dilepton_brems_reaction_type_ ( const ParticleList & in )

staticprivate

Determine dilepton bremsstrahlung process from incoming particle list.

If incoming particles are not part of any implemented dilepton bremsstrahlung process, i.e. currently only p+n (in any order), the function will return no_reaction.

Parameters

[in] in ParticleList of incoming particles.

Returns: ReactionType enum-member

Definition at line 54 of file bremsstrahlungactiondilepton.cc.

                             {
   if (in.size() != 2) {
     return ReactionType::no_reaction;
   }
  
   const PdgCode a = in[0].pdgcode();
   const PdgCode b = in[1].pdgcode();
  
   switch (pack(a.code(), b.code())) {
     case (pack(pdg::p, pdg::n)):
     case (pack(pdg::n, pdg::p)):
       return ReactionType::np;
  
     default:
       return ReactionType::no_reaction;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sample_2body_isotropic_()

bool smash::BremsstrahlungActionDilepton::sample_2body_isotropic_	(	const FourVector &	p_parent,
		ParticleData &	child_1,
		ParticleData &	child_2
	)

private

Generates momenta of outgoing particles (for 2-body isotropic decays only).

Parameters

[in]	p_parent	FourVector of incoming particle momentum.
[in]	child_1	First child particle.
[in]	child_2	Second child particle.

Returns: bool if sampling is successful, i.e. if there is enough energy to create the outgoing particles. If sampling fails, the function returns false and the weight of the dilepton pair is set to 0 when generating the final state.

Definition at line 215 of file bremsstrahlungactiondilepton.cc.

                                                                               {
   const double M_parent = p_parent.abs();
   // Check whether the decay is energetically possible.
   if (M_parent < child_1.type().mass() + child_2.type().mass()) {
     return false;
   }
  
   const double pcm =
       pCM(M_parent, child_1.type().mass(), child_2.type().mass());
  
   Angles phitheta_children;
   phitheta_children.distribute_isotropically();
   child_1.set_4momentum(child_1.type().mass(),
                         pcm * phitheta_children.threevec());
   child_2.set_4momentum(child_2.type().mass(),
                         -pcm * phitheta_children.threevec());
  
   const ThreeVector beta = p_parent.velocity();
   child_1.boost_momentum(-beta);
   child_2.boost_momentum(-beta);
  
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ diff_xs_pn_dilepton_()

double smash::BremsstrahlungActionDilepton::diff_xs_pn_dilepton_	(	double	m_inv,
		double	q,
		double	sqrts
	)		const

private

Fully differential cross section \(\frac{d\sigma}{dM dq d\Omega}\) for \( pn \rightarrow pne^+ e^- \).

Parameters

[in]	m_inv	Invariant mass of dilepton pair
[in]	q	3-momentum of dilepton in pn-CM frame
[in]	sqrts	CM energy \(\sqrt(s)\)

Returns: \(\frac{d\sigma}{dM dq d\Omega}\)

Definition at line 240 of file bremsstrahlungactiondilepton.cc.

                                                               {
   const double s = sqrts * sqrts;
   constexpr double m_p = nucleon_mass;
   constexpr double m_n = nucleon_mass;
   const double m_pn = m_p + m_n;
   const double E = std::sqrt(q * q + M * M);
  
   // Check if the sampled point is kinematically allowed. If not, return 0.
   if (E <= 0.0 || M <= 0.0)
     return 0.0;
  
   const double sigma_bar =
       (s - (m_pn) * (m_pn)) / (2.0 * (m_p * m_p)) * np_elastic(s);
   const double R2_s = R_2_helper(s);
   if (R2_s <= 0.0)
     return 0.0;
  
   const double s2 = s + M * M - 2.0 * E * sqrts;
   const double R2_s2 = R_2_helper(s2);
   const double prefactor =
       fine_structure * fine_structure / (6.0 * M_PI * M_PI * M_PI);
  
   // Factor q²/(ME³) after dE->dq substitution in diff. cross section formula.
   return prefactor * (q * q) / (M * E * E * E) * sigma_bar * (R2_s2 / R2_s) *
          pion_em_form_factor_sq_(M);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pion_em_form_factor_sq_()

double smash::BremsstrahlungActionDilepton::pion_em_form_factor_sq_ ( double m_inv ) const

private

Returns \(|F_\pi(m_{inv}^2)|^2\), the squared pion electromagnetic form factor.

Parameters

[in] m_inv Invariant mass of dilepton pair [GeV]

Returns: \(|F_\pi(m_{inv}^2)|^2\) (dimensionless)

Definition at line 268 of file bremsstrahlungactiondilepton.cc.

                           {
   const double rho_mass = ParticleType::find(pdg::rho_z).mass();
   const double rho_width = ParticleType::find(pdg::rho_z).total_width(M);
  
   switch (form_factor_type_) {
     case DileptonBremsPionFormFactor::FF1:
       return pion_em_form_factor_sqr_FF1(M * M, rho_mass, rho_width);
     case DileptonBremsPionFormFactor::FF2:
       return pion_em_form_factor_sqr_FF2(M * M, rho_mass, rho_width);
     case DileptonBremsPionFormFactor::Off:
       return 1.0;
     default:
       using namespace std::string_literals;  // NOLINT(build/namespaces)
       throw std::logic_error("Problem in "s + __func__ +
                              ". Unknown pion form factor.");
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ collision_processes_dilepton_bremsstrahlung_

CollisionBranchList smash::BremsstrahlungActionDilepton::collision_processes_dilepton_bremsstrahlung_

private

Holds the bremsstrahlung branch.

As of now, this will hold only one branch.

Definition at line 180 of file bremsstrahlungactiondilepton.h.

◆ reaction_type_

const ReactionType smash::BremsstrahlungActionDilepton::reaction_type_

private

Reaction process as determined from incoming particles.

Definition at line 183 of file bremsstrahlungactiondilepton.h.

◆ weight_

double smash::BremsstrahlungActionDilepton::weight_ = 0.0

private

Weight of the dilepton event.

Definition at line 186 of file bremsstrahlungactiondilepton.h.

◆ cross_section_dilepton_bremsstrahlung_

double smash::BremsstrahlungActionDilepton::cross_section_dilepton_bremsstrahlung_ = 0.0

private

Total cross section of dilepton bremsstrahlung process [mb].

Definition at line 189 of file bremsstrahlungactiondilepton.h.

◆ hadronic_cross_section_

const double smash::BremsstrahlungActionDilepton::hadronic_cross_section_

private

Total hadronic cross section.

Definition at line 192 of file bremsstrahlungactiondilepton.h.

◆ form_factor_type_

const DileptonBremsPionFormFactor smash::BremsstrahlungActionDilepton::form_factor_type_

private

Form factor type: Off, FF1, FF2.

Definition at line 195 of file bremsstrahlungactiondilepton.h.

◆ q_

double smash::BremsstrahlungActionDilepton::q_

private

Sampled 3-momentum of dilepton pair in pn-CM frame.

Definition at line 198 of file bremsstrahlungactiondilepton.h.

◆ m_inv_

double smash::BremsstrahlungActionDilepton::m_inv_

private

Sampled invariant mass of the dilepton pair.

Definition at line 201 of file bremsstrahlungactiondilepton.h.

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

src/include/smash/bremsstrahlungactiondilepton.h
src/bremsstrahlungactiondilepton.cc

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Member Enumeration Documentation

◆ ReactionType

Constructor & Destructor Documentation

◆ BremsstrahlungActionDilepton()

Member Function Documentation

◆ is_dilepton_brems_reaction()

◆ add_dummy_hadronic_process()

◆ perform_dilepton_bremsstrahlung()

◆ generate_final_state()

◆ get_total_weight()

◆ get_partial_weight()

◆ dilepton_brems_reaction_type_()

◆ sample_2body_isotropic_()

◆ diff_xs_pn_dilepton_()

◆ pion_em_form_factor_sq_()

Member Data Documentation

◆ collision_processes_dilepton_bremsstrahlung_

◆ reaction_type_

◆ weight_

◆ cross_section_dilepton_bremsstrahlung_

◆ hadronic_cross_section_

◆ form_factor_type_

◆ q_

◆ m_inv_