#include <scatteractionphoton.h>

ScatterActionPhoton is a special action which takes two incoming particles and performs a perturbative electromagnetic scattering.

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

Definition at line 27 of file scatteractionphoton.h.

Inheritance diagram for smash::ScatterActionPhoton:

Public Types
enum class	ReactionType { no_reaction , pi_z_pi_p_rho_p , pi_z_pi_m_rho_m , pi_p_rho_z_pi_p , pi_m_rho_z_pi_m , pi_m_rho_p_pi_z , pi_p_rho_m_pi_z , pi_z_rho_p_pi_p , pi_z_rho_m_pi_m , pi_p_pi_m_rho_z , pi_z_rho_z_pi_z }
	Enum for encoding the photon process. More...

Public Member Functions
	ScatterActionPhoton (const ParticleList &in, const double time, const int n_frac_photons, const double hadronic_cross_section_input)
	Construct a ScatterActionPhoton object. More...

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

void	generate_final_state () override
	Generate the final-state for the photon scatter process. More...

double	get_total_weight () const override
	Return the weight of the last created photon. More...

double	hadronic_cross_section () const
	Return the total cross section of the underlying hadronic scattering. More...

double	sample_out_hadron_mass (const ParticleTypePtr out_type)
	Sample the mass of the outgoing hadron. More...

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

void	add_single_process ()
	Add the photonic process. 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)
	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...

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...

Static Public Member Functions
static ReactionType	photon_reaction_type (const ParticleList &in)
	Determine photon process from incoming particles. More...

static bool	is_photon_reaction (const ParticleList &in)
	Check if particles can undergo an implemented photon process. More...

static ParticleTypePtr	outgoing_hadron_type (const ParticleList &in)
	Return ParticleTypePtr of hadron in the out channel, given the incoming particles. More...

static ParticleTypePtr	outgoing_hadron_type (const ReactionType reaction)
	Return ParticleTypePtr of hadron in the out channel, given the ReactionType. More...

static bool	is_kinematically_possible (const double s_sqrt, const ParticleList &in)
	Check if CM-energy is sufficient to produce hadron in final state. 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...

static void	sample_manybody_phasespace_impl (double sqrts, const std::vector< double > &m, std::vector< FourVector > &sampled_momenta)
	Implementation of the full n-body phase-space sampling (masses, momenta, angles) in the center-of-mass frame for the final state particles. More...

Private Types
enum class	MediatorType { SUM , PION , OMEGA }
	Compile-time switch for setting the handling of processes which can happen via different mediating particles. More...

Private Member Functions
double	rho_mass () const
	Find the mass of the participating rho-particle. More...

CollisionBranchList	create_collision_branch ()
	Creates a CollisionBranchList containing the photon processes. More...

double	total_cross_section (MediatorType mediator=default_mediator_) const
	Calculate the total cross section of the photon process. More...

double	total_cross_section_w_ff (const double E_photon)
	Compute the total cross corrected for form factors. More...

double	diff_cross_section (const double t, const double m_rho, MediatorType mediator=default_mediator_) const
	Calculate the differential cross section of the photon process. More...

double	diff_cross_section_w_ff (const double t, const double m_rho, const double E_photon)
	Compute the differential cross section corrected for form factors. More...

double	form_factor_pion (const double E_photon) const
	Compute the form factor for a process with a pion as the lightest exchange particle. More...

double	form_factor_omega (const double E_photon) const
	Compute the form factor for a process with a omega as the lightest exchange particle. More...

std::pair< double, double >	form_factor_pair (const double E_photon)
	For processes which can happen via (pi, a1, rho) and omega exchange, return the form factor for the (pi, a1, rho) process in the first argument, for the omega process in the second. More...

std::pair< double, double >	total_cross_section_pair ()
	For processes which can happen via (pi, a1, rho) and omega exchange, return the total cross section for the (pi, a1, rho) process in the first argument, for the omega process in the second. More...

std::pair< double, double >	diff_cross_section_pair (const double t, const double m_rho)
	For processes which can happen via (pi, a1, rho) and omega exchange, return the differential cross section for the (pi, a1, rho) process in the first argument, for the omega process in the second. More...

Private Attributes
CollisionBranchList	collision_processes_photons_
	Holds the photon branch. More...

bool	collision_branch_created_ = false
	Was the collision branch already created? More...

const ReactionType	reac_
	Photonic process as determined from incoming particles. More...

const int	number_of_fractional_photons_
	Number of photons created for each hadronic scattering, needed for correct weighting. More...

const ParticleTypePtr	hadron_out_t_
	ParticleTypePtr to the type of the outgoing hadron. More...

const double	hadron_out_mass_
	Mass of outgoing hadron. More...

double	weight_ = 0.0
	Weight of the produced photon. More...

double	cross_section_photons_ = 0.0
	Total cross section of photonic process. More...

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

Static Private Attributes
static constexpr MediatorType	default_mediator_ = MediatorType::SUM
	Value used for default exchange particle. See MediatorType. 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	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...

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::ScatterActionPhoton::ReactionType

strong

Enum for encoding the photon process.

It is uniquely determined by the incoming particles. The naming scheme is : Incoming_1__Incoming_2__Outgoing_hadron. The photon is omitted in the naming.

Enumerator
no_reaction
pi_z_pi_p_rho_p
pi_z_pi_m_rho_m
pi_p_rho_z_pi_p
pi_m_rho_z_pi_m
pi_m_rho_p_pi_z
pi_p_rho_m_pi_z
pi_z_rho_p_pi_p
pi_z_rho_m_pi_m
pi_p_pi_m_rho_z
pi_z_rho_z_pi_z

Definition at line 112 of file scatteractionphoton.h.

                           {
     no_reaction,
     pi_z_pi_p_rho_p,
     pi_z_pi_m_rho_m,
     pi_p_rho_z_pi_p,
     pi_m_rho_z_pi_m,
     pi_m_rho_p_pi_z,
     pi_p_rho_m_pi_z,
     pi_z_rho_p_pi_p,
     pi_z_rho_m_pi_m,
     pi_p_pi_m_rho_z,
     pi_z_rho_z_pi_z
   };

◆ MediatorType

enum smash::ScatterActionPhoton::MediatorType

strongprivate

Compile-time switch for setting the handling of processes which can happen via different mediating particles.

Relevant only for the processes pi0 + rho => pi + y and pi + rho => pi0 + gamma, which both can happen via exchange of (rho, a1, pi) or omega. If MediatorType::SUM is set, the cross section for both processes is added. If MediatorType::PION/ OMEGA is set, only the respective processes are computed.

Enumerator
SUM
PION
OMEGA

Definition at line 218 of file scatteractionphoton.h.

218 { SUM, PION, OMEGA };

Constructor & Destructor Documentation

◆ ScatterActionPhoton()

smash::ScatterActionPhoton::ScatterActionPhoton	(	const ParticleList &	in,
		const double	time,
		const int	n_frac_photons,
		const double	hadronic_cross_section_input
	)

Construct a ScatterActionPhoton object.

Parameters

[in]	in	ParticleList of incoming particles.
[in]	time	Time relative to underlying hadronic action.
[in]	n_frac_photons	Number of photons to produce for each hadronic scattering.
[in]	hadronic_cross_section_input	Cross-section of underlying hadronic cross-section.

Returns: The constructed object.

Definition at line 26 of file scatteractionphoton.cc.

     : ScatterAction(in[0], in[1], time),
       reac_(photon_reaction_type(in)),
       number_of_fractional_photons_(n_frac_photons),
       hadron_out_t_(outgoing_hadron_type(in)),
       hadron_out_mass_(sample_out_hadron_mass(hadron_out_t_)),
       hadronic_cross_section_(hadronic_cross_section_input) {}

Member Function Documentation

◆ perform_photons()

void smash::ScatterActionPhoton::perform_photons ( const OutputsList & outputs )

Create the photon final state and write to output.

Parameters

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

Definition at line 89 of file scatteractionphoton.cc.

                                                                     {
   for (int i = 0; i < number_of_fractional_photons_; i++) {
     generate_final_state();
     for (const auto &output : outputs) {
       if (output->is_photon_output()) {
         // we do not care about the local density
         output->at_interaction(*this, 0.0);
       }
     }
   }
 }

◆ generate_final_state()

void smash::ScatterActionPhoton::generate_final_state ( )

overridevirtual

Generate the final-state for the photon scatter process.

Generates only one photon / hadron pair

Reimplemented from smash::ScatterAction.

Definition at line 190 of file scatteractionphoton.cc.

                                                {
   // we have only one reaction per incoming particle pair
   if (collision_processes_photons_.size() != 1) {
     logg[LScatterAction].fatal()
         << "Problem in ScatterActionPhoton::generate_final_state().\n";
     throw std::runtime_error("");
   }
   auto *proc = collision_processes_photons_[0].get();
  
   outgoing_particles_ = proc->particle_list();
   process_type_ = proc->get_type();
  
   FourVector middle_point = get_interaction_point();
  
   // t is defined to be the momentum exchanged between the rho meson and the
   // photon in pi + rho -> pi + photon channel. Therefore,
   // get_t_range needs to be called with m2 being the rho mass instead of the
   // pion mass. So, particles 1 and 2 are swapped if necessary.
  
   if (!incoming_particles_[0].pdgcode().is_pion()) {
     std::swap(incoming_particles_[0], incoming_particles_[1]);
   }
  
   // 2->2 inelastic scattering
   // Sample the particle momenta in CM system
   const double m1 = incoming_particles_[0].effective_mass();
   const double m2 = incoming_particles_[1].effective_mass();
  
   const double &m_out = hadron_out_mass_;
  
   const double s = mandelstam_s();
   const double sqrts = sqrt_s();
   std::array<double, 2> mandelstam_t = get_t_range(sqrts, m1, m2, m_out, 0.0);
   const double t1 = mandelstam_t[1];
   const double t2 = mandelstam_t[0];
   const double pcm_in = cm_momentum();
   const double pcm_out = pCM(sqrts, m_out, 0.0);
  
   const double t = random::uniform(t1, t2);
  
   double costheta = (t - pow_int(m2, 2) +
                      0.5 * (s + pow_int(m2, 2) - pow_int(m1, 2)) *
                          (s - pow_int(m_out, 2)) / s) /
                     (pcm_in * (s - pow_int(m_out, 2)) / sqrts);
  
   // on very rare occasions near the kinematic threshold numerical issues give
   // unphysical angles.
   if (costheta > 1 || costheta < -1) {
     logg[LScatterAction].warn()
         << "Cos(theta)of photon scattering out of physical bounds in "
            "the following scattering: "
         << incoming_particles_ << "Clamping to [-1,1].";
     if (costheta > 1.0)
       costheta = 1.0;
     if (costheta < -1.0)
       costheta = -1.0;
   }
   Angles phitheta(random::uniform(0.0, twopi), costheta);
   outgoing_particles_[0].set_4momentum(hadron_out_mass_,
                                        phitheta.threevec() * pcm_out);
   outgoing_particles_[1].set_4momentum(0.0, -phitheta.threevec() * pcm_out);
  
   // Set positions & boost to computational frame.
   for (ParticleData &new_particle : outgoing_particles_) {
     new_particle.set_4position(middle_point);
     new_particle.boost_momentum(
         -total_momentum_of_outgoing_particles().velocity());
   }
  
   const double E_Photon = outgoing_particles_[1].momentum()[0];
  
   // Weighing of the fractional photons
   if (number_of_fractional_photons_ > 1) {
     // if rho in final state take already sampled mass (same as m_out). If rho
     // is incoming take the mass of the incoming particle
     const double m_rho = rho_mass();
  
     // compute the differential cross section with form factor included
     const double diff_xs = diff_cross_section_w_ff(t, m_rho, E_Photon);
  
     weight_ = diff_xs * (t2 - t1) /
               (number_of_fractional_photons_ * hadronic_cross_section());
   } else {
     // compute the total cross section with form factor included
     const double total_xs = total_cross_section_w_ff(E_Photon);
  
     weight_ = total_xs / hadronic_cross_section();
   }
   // Scale weight by cross section scaling factor of incoming particles
   weight_ *= incoming_particles_[0].xsec_scaling_factor() *
              incoming_particles_[1].xsec_scaling_factor();
  
   // Photons are not really part of the normal processes, so we have to set a
   // constant arbitrary number.
   const auto id_process = ID_PROCESS_PHOTON;
   Action::check_conservation(id_process);
 }

◆ get_total_weight()

double smash::ScatterActionPhoton::get_total_weight ( ) const

inlineoverridevirtual

Return the weight of the last created photon.

Returns: The total weight.

Reimplemented from smash::ScatterAction.

Definition at line 64 of file scatteractionphoton.h.

64 { return weight_; }

◆ hadronic_cross_section()

double smash::ScatterActionPhoton::hadronic_cross_section ( ) const

inline

Return the total cross section of the underlying hadronic scattering.

Returns: total cross-section [mb]

Definition at line 71 of file scatteractionphoton.h.

71 { return hadronic_cross_section_; }

◆ sample_out_hadron_mass()

double smash::ScatterActionPhoton::sample_out_hadron_mass ( const ParticleTypePtr out_type )

Sample the mass of the outgoing hadron.

Returns the pole mass if particle is stable.

Parameters

[in] out_type TypePtr of the outgoing hadron.

Returns: Mass of outgoing hadron [GeV]

Definition at line 296 of file scatteractionphoton.cc.

                                  {
   double mass = out_t->mass();
   const double cms_energy = sqrt_s();
   if (cms_energy <= out_t->min_mass_kinematic()) {
     throw InvalidResonanceFormation(
         "Problem in ScatterActionPhoton::sample_hadron_mass");
   }
  
   if (!out_t->is_stable()) {
     mass = out_t->sample_resonance_mass(0, cms_energy);
   }
  
   return mass;
 }

◆ add_dummy_hadronic_process()

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

Adds one 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 288 of file scatteractionphoton.cc.

                                    {
   CollisionBranchPtr dummy_process = std::make_unique<CollisionBranch>(
       incoming_particles_[0].type(), incoming_particles_[1].type(),
       reaction_cross_section, ProcessType::TwoToTwo);
   add_collision(std::move(dummy_process));
 }

◆ add_single_process()

void smash::ScatterActionPhoton::add_single_process ( )

inline

Add the photonic process.

Also compute the total cross section as a side effect.

Definition at line 100 of file scatteractionphoton.h.

                             {
     add_processes<CollisionBranch>(create_collision_branch(),
                                    collision_processes_photons_,
                                    cross_section_photons_);
   }

◆ photon_reaction_type()

ScatterActionPhoton::ReactionType smash::ScatterActionPhoton::photon_reaction_type ( const ParticleList & in )

static

Determine photon process from incoming particles.

If incoming particles are not part of any implemented photonic process, return no_reaction.

Parameters

[in] in ParticleList of incoming particles.

Returns: ReactionType enum-member

Definition at line 36 of file scatteractionphoton.cc.

                             {
   if (in.size() != 2) {
     return ReactionType::no_reaction;
   }
  
   PdgCode a = in[0].pdgcode();
   PdgCode b = in[1].pdgcode();
  
   // swap so that pion is first and there are less cases to be listed
   if (!a.is_pion()) {
     std::swap(a, b);
   }
  
   switch (pack(a.code(), b.code())) {
     case (pack(pdg::pi_p, pdg::pi_z)):
     case (pack(pdg::pi_z, pdg::pi_p)):
       return ReactionType::pi_z_pi_p_rho_p;
  
     case (pack(pdg::pi_m, pdg::pi_z)):
     case (pack(pdg::pi_z, pdg::pi_m)):
       return ReactionType::pi_z_pi_m_rho_m;
  
     case (pack(pdg::pi_p, pdg::rho_z)):
       return ReactionType::pi_p_rho_z_pi_p;
  
     case (pack(pdg::pi_m, pdg::rho_z)):
       return ReactionType::pi_m_rho_z_pi_m;
  
     case (pack(pdg::pi_m, pdg::rho_p)):
       return ReactionType::pi_m_rho_p_pi_z;
  
     case (pack(pdg::pi_p, pdg::rho_m)):
       return ReactionType::pi_p_rho_m_pi_z;
  
     case (pack(pdg::pi_z, pdg::rho_p)):
       return ReactionType::pi_z_rho_p_pi_p;
  
     case (pack(pdg::pi_z, pdg::rho_m)):
       return ReactionType::pi_z_rho_m_pi_m;
  
     case (pack(pdg::pi_p, pdg::pi_m)):
     case (pack(pdg::pi_m, pdg::pi_p)):
       return ReactionType::pi_p_pi_m_rho_z;
  
     case (pack(pdg::pi_z, pdg::rho_z)):
       return ReactionType::pi_z_rho_z_pi_z;
  
     default:
       return ReactionType::no_reaction;
   }
 }

◆ is_photon_reaction()

static bool smash::ScatterActionPhoton::is_photon_reaction ( const ParticleList & in )

inlinestatic

Check if particles can undergo an implemented photon process.

This function does not check the involved kinematics.

Parameters

[in] in ParticleList of incoming particles.

Returns: bool if photon reaction implemented.

Definition at line 145 of file scatteractionphoton.h.

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

◆ outgoing_hadron_type() [1/2]

ParticleTypePtr smash::ScatterActionPhoton::outgoing_hadron_type ( const ParticleList & in )

static

Return ParticleTypePtr of hadron in the out channel, given the incoming particles.

This function is overloaded since we need the hadron type in different places.

Parameters

[in] in ParticleList of incoming particles.

Returns: ParticeTypePtr to hadron in outgoing channel.

Definition at line 147 of file scatteractionphoton.cc.

                             {
   auto reac = photon_reaction_type(in);
   return outgoing_hadron_type(reac);
 }

◆ outgoing_hadron_type() [2/2]

ParticleTypePtr smash::ScatterActionPhoton::outgoing_hadron_type ( const ReactionType reaction )

static

Return ParticleTypePtr of hadron in the out channel, given the ReactionType.

This function is overloaded since we need the hadron type in different places.

Parameters

[in] reaction ReactionType, determined from incoming particles.

Returns: ParticeTypePtr to hadron in outgoing channel.

Definition at line 101 of file scatteractionphoton.cc.

                                  {
   static const ParticleTypePtr rho_z_particle_ptr =
       &ParticleType::find(pdg::rho_z);
   static const ParticleTypePtr rho_p_particle_ptr =
       &ParticleType::find(pdg::rho_p);
   static const ParticleTypePtr rho_m_particle_ptr =
       &ParticleType::find(pdg::rho_m);
   static const ParticleTypePtr pi_z_particle_ptr =
       &ParticleType::find(pdg::pi_z);
   static const ParticleTypePtr pi_p_particle_ptr =
       &ParticleType::find(pdg::pi_p);
   static const ParticleTypePtr pi_m_particle_ptr =
       &ParticleType::find(pdg::pi_m);
  
   switch (reaction) {
     case ReactionType::pi_z_pi_p_rho_p:
       return rho_p_particle_ptr;
       break;
     case ReactionType::pi_z_pi_m_rho_m:
       return rho_m_particle_ptr;
       break;
     case ReactionType::pi_p_pi_m_rho_z:
       return rho_z_particle_ptr;
       break;
  
     case ReactionType::pi_p_rho_z_pi_p:
     case ReactionType::pi_z_rho_p_pi_p:
       return pi_p_particle_ptr;
  
     case ReactionType::pi_m_rho_z_pi_m:
     case ReactionType::pi_z_rho_m_pi_m:
       return pi_m_particle_ptr;
  
     case ReactionType::pi_m_rho_p_pi_z:
     case ReactionType::pi_p_rho_m_pi_z:
     case ReactionType::pi_z_rho_z_pi_z:
       return pi_z_particle_ptr;
       break;
     default:
       // default constructor constructs p with invalid index
       ParticleTypePtr p{};
       return p;
   }
 }

◆ is_kinematically_possible()

bool smash::ScatterActionPhoton::is_kinematically_possible	(	const double	s_sqrt,
		const ParticleList &	in
	)

static

Check if CM-energy is sufficient to produce hadron in final state.

Parameters

[in]	s_sqrt	CM-energy [GeV]
[in]	in	ParticleList of incoming hadrons

Returns: true if particles can be produced.

Definition at line 153 of file scatteractionphoton.cc.

                                                                             {
   auto reac = photon_reaction_type(in);
   auto hadron = outgoing_hadron_type(in);
  
   if (reac == ReactionType::no_reaction)
     return false;
  
   if (default_mediator_ == MediatorType::PION &&
       reac == ReactionType::pi_z_rho_z_pi_z) {
     return false;
   }
  
   // C15 has only s-channel. Make sure that CM-energy is high
   // enough to produce mediating omega meson
   if ((reac == ReactionType::pi_m_rho_p_pi_z ||
        reac == ReactionType::pi_p_rho_m_pi_z) &&
       default_mediator_ == MediatorType::OMEGA) {
     if (s_sqrt < omega_mass) {
       return false;
     }
   }
  
   // for all other processes: if cm-energy is not high enough to produce final
   // state particle reject the collision.
   if (hadron->is_stable() && s_sqrt < hadron->mass()) {
     return false;
     // Make sure energy is high enough to not only create final state particle,
     // but to also assign momentum.
   } else if (!hadron->is_stable() &&
              s_sqrt < (hadron->min_mass_spectral() + really_small)) {
     return false;
   } else {
     return true;
   }
 }

◆ rho_mass()

double smash::ScatterActionPhoton::rho_mass ( ) const

private

Find the mass of the participating rho-particle.

In case of a rho in the incoming channel it is the mass of the incoming rho, in case of an rho in the outgoing channel it is the mass sampled in the constructor. When an rho acts in addition as a mediator, its mass is the same as the incoming / outgoing rho. This function returns the alrady sampled mass or the mass of the incoming rho, depending on the process.

Returns: mass of participating rho [GeV]

Definition at line 312 of file scatteractionphoton.cc.

                                            {
   assert(reac_ != ReactionType::no_reaction);
   switch (reac_) {
     // rho in final state. use already sampled mass
     case ReactionType::pi_p_pi_m_rho_z:
     case ReactionType::pi_z_pi_m_rho_m:
     case ReactionType::pi_z_pi_p_rho_p:
       return hadron_out_mass_;
     // rho in initial state, use its mass
     case ReactionType::pi_m_rho_p_pi_z:
     case ReactionType::pi_p_rho_m_pi_z:
     case ReactionType::pi_p_rho_z_pi_p:
     case ReactionType::pi_m_rho_z_pi_m:
     case ReactionType::pi_z_rho_m_pi_m:
     case ReactionType::pi_z_rho_p_pi_p:
     case ReactionType::pi_z_rho_z_pi_z:
       return (incoming_particles_[0].is_rho())
                  ? incoming_particles_[0].effective_mass()
                  : incoming_particles_[1].effective_mass();
     case ReactionType::no_reaction:
     default:
       throw std::runtime_error(
           "Invalid ReactionType in ScatterActionPhoton::rho_mass()");
   }
 }

◆ create_collision_branch()

CollisionBranchList smash::ScatterActionPhoton::create_collision_branch ( )

private

Creates a CollisionBranchList containing the photon processes.

By construction (perturbative treatment) this list will always contain only one branch.

Returns: List containing the photon collision branch

Definition at line 338 of file scatteractionphoton.cc.

                                                                  {
   CollisionBranchList process_list;
  
   static ParticleTypePtr photon_particle = &ParticleType::find(pdg::photon);
   double xsection = total_cross_section();
  
   process_list.push_back(std::make_unique<CollisionBranch>(
       *hadron_out_t_, *photon_particle, xsection, ProcessType::TwoToTwo));
   collision_branch_created_ = true;
   return process_list;
 }

◆ total_cross_section()

double smash::ScatterActionPhoton::total_cross_section ( MediatorType mediator = default_mediator_ ) const

private

Calculate the total cross section of the photon process.

Formfactors are not included

Parameters

[in] mediator Switch for determing which mediating particle to use

Returns: Total cross section. [mb]

Definition at line 350 of file scatteractionphoton.cc.

                                                                            {
   CollisionBranchList process_list;
   CrosssectionsPhoton<ComputationMethod::Analytic> xs_object;
  
   const double s = mandelstam_s();
   // the mass of the mediating particle depends on the channel. For an incoming
   // rho it is the mass of the incoming particle, for an outgoing rho it is the
   // sampled mass
   const double m_rho = rho_mass();
   double xsection = 0.0;
  
   switch (reac_) {
     case ReactionType::pi_p_pi_m_rho_z:
       xsection = xs_object.xs_pi_pi_rho0(s, m_rho);
       break;
  
     case ReactionType::pi_z_pi_m_rho_m:
     case ReactionType::pi_z_pi_p_rho_p:
       xsection = xs_object.xs_pi_pi0_rho(s, m_rho);
       break;
  
     case ReactionType::pi_m_rho_z_pi_m:
     case ReactionType::pi_p_rho_z_pi_p:
       xsection = xs_object.xs_pi_rho0_pi(s, m_rho);
       break;
  
     case ReactionType::pi_m_rho_p_pi_z:
     case ReactionType::pi_p_rho_m_pi_z:
       if (mediator == MediatorType::SUM) {
         xsection = xs_object.xs_pi_rho_pi0(s, m_rho);
         break;
       } else if (mediator == MediatorType::PION) {
         xsection = xs_object.xs_pi_rho_pi0_rho_mediated(s, m_rho);
         break;
       } else if (mediator == MediatorType::OMEGA) {
         xsection = xs_object.xs_pi_rho_pi0_omega_mediated(s, m_rho);
         break;
       } else {
         throw std::runtime_error("");
       }
     case ReactionType::pi_z_rho_m_pi_m:
     case ReactionType::pi_z_rho_p_pi_p:
       if (mediator == MediatorType::SUM) {
         xsection = xs_object.xs_pi0_rho_pi(s, m_rho);
         break;
       } else if (mediator == MediatorType::PION) {
         xsection = xs_object.xs_pi0_rho_pi_rho_mediated(s, m_rho);
         break;
       } else if (mediator == MediatorType::OMEGA) {
         xsection = xs_object.xs_pi0_rho_pi_omega_mediated(s, m_rho);
         break;
       } else {
         throw std::runtime_error("");
       }
  
     case ReactionType::pi_z_rho_z_pi_z:
       xsection = xs_object.xs_pi0_rho0_pi0(s, m_rho);
       break;
  
     case ReactionType::no_reaction:
       // never reached
       break;
   }
  
   if (xsection == 0.0) {
     // Vanishing cross sections are problematic for the creation of a
     // CollisionBranch. For infrastructure reasons it is however necessary to
     // create such a collision branch whenever the underlying hadronic
     // scattering is a candidate for a photon interaction. In these cases we
     // need to manually set a dummy value for the cross section and produce the
     // photon. This photon will however automatically be assigned a 0 weight
     // because of the vanishing cross section and therefore not be of relevance
     // for any analysis.
     // In other cases, where the collision branch was already created, we
     // do not want to overwrite the cross section, of course.
     xsection = collision_branch_created_ ? 0.0 : 0.01;
   } else if (xsection < 0) {
     // Due to numerical reasons it can happen that the calculated cross sections
     // are negative (approximately -1e-15) if sqrt(s) is close to the threshold
     // energy. In those cases the cross section is manually set to 0.1 mb, which
     // is a reasonable value for the processes we are looking at (C14,C15,C16).
     xsection = 0.1;
     logg[LScatterAction].warn(
         "Calculated negative cross section.\nParticles ", incoming_particles_,
         " mass rho particle: ", m_rho, ", sqrt_s: ", std::sqrt(s));
   }
   return xsection;
 }

◆ total_cross_section_w_ff()

double smash::ScatterActionPhoton::total_cross_section_w_ff ( const double E_photon )

private

Compute the total cross corrected for form factors.

Takes care of correct handling of reactions with multiple processes by reading the default_mediator_ member variable.

Parameters

[in] E_photon of outgoing photon [GeV]

Returns: total cross section including form factors [mb]

The form factor is assumed to be a hadronic dipole form factor which takes the shape: FF = (2*Lambda^2/(2*Lambda^2 - t))^2 with Lambda = 1.0 GeV. t depends on the lightest possible exchange particle in the different channels. This could either be a pion or an omega meson. For the computation the parametrizations given in (Turbide:2006zz [59]) are used.

Definition at line 439 of file scatteractionphoton.cc.

                                                                           {
   /* C12, C13, C15, C16 need special treatment. These processes have identical
      incoming and outgoing particles, but diffrent mediating particles and
      hence different form factors. If both channels are added up
      (MediatorType::SUM), each contribution is corrected by the corresponding
      form factor.
   */
   switch (reac_) {
     case ReactionType::pi_m_rho_p_pi_z:
     case ReactionType::pi_p_rho_m_pi_z:
     case ReactionType::pi_z_rho_m_pi_m:
     case ReactionType::pi_z_rho_p_pi_p: {
       if (default_mediator_ == MediatorType::SUM) {
         std::pair<double, double> FF = form_factor_pair(E_photon);
         std::pair<double, double> xs = total_cross_section_pair();
         const double xs_ff =
             pow_int(FF.first, 4) * xs.first + pow_int(FF.second, 4) * xs.second;
         return cut_off(xs_ff);
       } else if (default_mediator_ == MediatorType::PION) {
         const double FF = form_factor_pion(E_photon);
         const double xs = total_cross_section();
         return cut_off(pow_int(FF, 4) * xs);
       } else if (default_mediator_ == MediatorType::OMEGA) {
         const double FF = form_factor_omega(E_photon);
         const double xs = total_cross_section();
         return cut_off(pow_int(FF, 4) * xs);
       }
       break;
     }
     case ReactionType::pi_z_pi_p_rho_p:
     case ReactionType::pi_z_pi_m_rho_m:
     case ReactionType::pi_p_rho_z_pi_p:
     case ReactionType::pi_m_rho_z_pi_m:
     case ReactionType::pi_p_pi_m_rho_z: {
       const double FF = form_factor_pion(E_photon);
       const double xs = total_cross_section();
       const double xs_ff = pow_int(FF, 4) * xs;
       return cut_off(xs_ff);
     }
  
     case ReactionType::pi_z_rho_z_pi_z: {
       const double FF = form_factor_omega(E_photon);
       const double xs = total_cross_section();
       const double xs_ff = pow_int(FF, 4) * xs;
       return cut_off(xs_ff);
     }
  
     case ReactionType::no_reaction:
     default:
       throw std::runtime_error("");
       return 0;
   }
 }

◆ diff_cross_section()

double smash::ScatterActionPhoton::diff_cross_section	(	const double	t,
		const double	m_rho,
		MediatorType	mediator = `default_mediator_`
	)		const

private

Calculate the differential cross section of the photon process.

Formfactors are not included

Parameters

[in]	t	Mandelstam-t [GeV^2].
[in]	m_rho	Mass of the incoming or outgoing rho-particle [GeV]
[in]	mediator	Switch for determing which mediating particle to use

Returns: Differential cross section. [mb/ \(GeV^2\)]

Definition at line 502 of file scatteractionphoton.cc.

                                                                             {
   const double s = mandelstam_s();
   double diff_xsection = 0.0;
  
   CrosssectionsPhoton<ComputationMethod::Analytic> xs_object;
  
   switch (reac_) {
     case ReactionType::pi_p_pi_m_rho_z:
       diff_xsection = xs_object.xs_diff_pi_pi_rho0(s, t, m_rho);
       break;
  
     case ReactionType::pi_z_pi_m_rho_m:
     case ReactionType::pi_z_pi_p_rho_p:
       diff_xsection = xs_object.xs_diff_pi_pi0_rho(s, t, m_rho);
       break;
  
     case ReactionType::pi_m_rho_z_pi_m:
     case ReactionType::pi_p_rho_z_pi_p:
       diff_xsection = xs_object.xs_diff_pi_rho0_pi(s, t, m_rho);
       break;
  
     case ReactionType::pi_m_rho_p_pi_z:
     case ReactionType::pi_p_rho_m_pi_z:
       if (mediator == MediatorType::SUM) {
         diff_xsection =
             xs_object.xs_diff_pi_rho_pi0_rho_mediated(s, t, m_rho) +
             xs_object.xs_diff_pi_rho_pi0_omega_mediated(s, t, m_rho);
       } else if (mediator == MediatorType::OMEGA) {
         diff_xsection =
             xs_object.xs_diff_pi_rho_pi0_omega_mediated(s, t, m_rho);
       } else if (mediator == MediatorType::PION) {
         diff_xsection = xs_object.xs_diff_pi_rho_pi0_rho_mediated(s, t, m_rho);
       }
       break;
  
     case ReactionType::pi_z_rho_m_pi_m:
     case ReactionType::pi_z_rho_p_pi_p:
       if (mediator == MediatorType::SUM) {
         diff_xsection =
             xs_object.xs_diff_pi0_rho_pi_rho_mediated(s, t, m_rho) +
             xs_object.xs_diff_pi0_rho_pi_omega_mediated(s, t, m_rho);
       } else if (mediator == MediatorType::OMEGA) {
         diff_xsection =
             xs_object.xs_diff_pi0_rho_pi_omega_mediated(s, t, m_rho);
       } else if (mediator == MediatorType::PION) {
         diff_xsection = xs_object.xs_diff_pi0_rho_pi_rho_mediated(s, t, m_rho);
       }
       break;
  
     case ReactionType::pi_z_rho_z_pi_z:
       diff_xsection = xs_object.xs_diff_pi0_rho0_pi0(s, t, m_rho);
       break;
     case ReactionType::no_reaction:
       // never reached
       break;
   }
  
   // Rarely, it can happen that the computed differential cross sections slip
   // slightly below zero for numerical reasons. This is unphysical. We
   // approximate them with dSigma/dt = 0.01 mb/GeV^2, which is a reasonable
   // value in the kinetic regime where this occurs.
   if (diff_xsection < 0) {
     diff_xsection = 0.01;
   }
   return diff_xsection;
 }

◆ diff_cross_section_w_ff()

double smash::ScatterActionPhoton::diff_cross_section_w_ff	(	const double	t,
		const double	m_rho,
		const double	E_photon
	)

private

Compute the differential cross section corrected for form factors.

Takes care of correct handling of reactions with multiple processes by reading the default_mediator_ member variable.

Parameters

[in]	t	Mandelstam-t [GeV^2]
[in]	m_rho	Mass of the incoming or outgoing rho-particle [GeV]
[in]	E_photon	of outgoing photon [GeV]

Returns: diff. cross section [mb / GeV \(^2\)]

The form factor is assumed to be a hadronic dipole form factor which takes the shape: FF = (2*Lambda^2/(2*Lambda^2 - t))^2 with Lambda = 1.0 GeV. t depends on the lightest possible exchange particle in the different channels. This could either be a pion or an omega meson. For the computation the parametrizations given in (Turbide:2006zz [59]) are used.

Definition at line 571 of file scatteractionphoton.cc.

                                                                            {
   /* C12, C13, C15, C16 need special treatment. These processes have identical
      incoming and outgoing particles, but diffrent mediating particles and
      hence different form factors. If both channels are added up
      (MediatorType::SUM), each contribution is corrected by the corresponding
      form factor.
   */
   switch (reac_) {
     case ReactionType::pi_m_rho_p_pi_z:
     case ReactionType::pi_p_rho_m_pi_z:
     case ReactionType::pi_z_rho_m_pi_m:
     case ReactionType::pi_z_rho_p_pi_p: {
       if (default_mediator_ == MediatorType::SUM) {
         std::pair<double, double> FF = form_factor_pair(E_photon);
         std::pair<double, double> diff_xs = diff_cross_section_pair(t, m_rho);
         const double xs_ff = pow_int(FF.first, 4) * diff_xs.first +
                              pow_int(FF.second, 4) * diff_xs.second;
         return cut_off(xs_ff);
       } else if (default_mediator_ == MediatorType::PION) {
         const double FF = form_factor_pion(E_photon);
         const double diff_xs = diff_cross_section(t, m_rho);
         return cut_off(pow_int(FF, 4) * diff_xs);
       } else if (default_mediator_ == MediatorType::OMEGA) {
         const double FF = form_factor_omega(E_photon);
         const double diff_xs = diff_cross_section(t, m_rho);
         return cut_off(pow_int(FF, 4) * diff_xs);
       }
       break;
     }
     case ReactionType::pi_z_pi_p_rho_p:
     case ReactionType::pi_z_pi_m_rho_m:
     case ReactionType::pi_p_rho_z_pi_p:
     case ReactionType::pi_m_rho_z_pi_m:
     case ReactionType::pi_p_pi_m_rho_z: {
       const double FF = form_factor_pion(E_photon);
       const double xs = diff_cross_section(t, m_rho);
       const double xs_ff = pow_int(FF, 4) * xs;
       return cut_off(xs_ff);
     }
  
     case ReactionType::pi_z_rho_z_pi_z: {
       const double FF = form_factor_omega(E_photon);
       const double xs = diff_cross_section(t, m_rho);
       const double xs_ff = pow_int(FF, 4) * xs;
       return cut_off(xs_ff);
     }
  
     case ReactionType::no_reaction:
     default:
       throw std::runtime_error("");
       return 0;
   }
 }

◆ form_factor_pion()

double smash::ScatterActionPhoton::form_factor_pion ( const double E_photon ) const

private

Compute the form factor for a process with a pion as the lightest exchange particle.

See wiki for details how form factors are handled.

Parameters

[in] E_photon Energy of photon [GeV]

Returns: form factor

Definition at line 636 of file scatteractionphoton.cc.

                                                                         {
   const double Lambda = 1.0;
   const double Lambda2 = Lambda * Lambda;
  
   const double t_ff = 34.5096 * std::pow(E_photon, 0.737) -
                       67.557 * std::pow(E_photon, 0.7584) +
                       32.858 * std::pow(E_photon, 0.7806);
   const double ff = 2 * Lambda2 / (2 * Lambda2 - t_ff);
  
   return ff * ff;
 }

◆ form_factor_omega()

double smash::ScatterActionPhoton::form_factor_omega ( const double E_photon ) const

private

Compute the form factor for a process with a omega as the lightest exchange particle.

See wiki for details how form factors are handled.

Parameters

[in] E_photon Energy of photon [GeV]

Returns: form factor

Definition at line 648 of file scatteractionphoton.cc.

                                                                          {
   const double Lambda = 1.0;
   const double Lambda2 = Lambda * Lambda;
  
   const double t_ff = -61.595 * std::pow(E_photon, 0.9979) +
                       28.592 * std::pow(E_photon, 1.1579) +
                       37.738 * std::pow(E_photon, 0.9317) -
                       5.282 * std::pow(E_photon, 1.3686);
   const double ff = 2 * Lambda2 / (2 * Lambda2 - t_ff);
  
   return ff * ff;
 }

◆ form_factor_pair()

std::pair< double, double > smash::ScatterActionPhoton::form_factor_pair ( const double E_photon )

private

For processes which can happen via (pi, a1, rho) and omega exchange, return the form factor for the (pi, a1, rho) process in the first argument, for the omega process in the second.

If only one process exists, both values are the same. Helper function to easier combine processes with different mediating particles.

Parameters

[in] E_photon Energy of the photon [GeV]

Returns: Form factor for (pi,a1,rho) in the first argument, for omega in the second.

Definition at line 661 of file scatteractionphoton.cc.

                            {
   return std::pair<double, double>(form_factor_pion(E_photon),
                                    form_factor_omega(E_photon));
 }

◆ total_cross_section_pair()

std::pair< double, double > smash::ScatterActionPhoton::total_cross_section_pair ( )

private

For processes which can happen via (pi, a1, rho) and omega exchange, return the total cross section for the (pi, a1, rho) process in the first argument, for the omega process in the second.

If only one process exists, both values are the same.Helper function to easier combine processes with different mediating particles.

Returns: total cross section for (pi,a1,rho) in the first argument, for omega in the second.

Definition at line 667 of file scatteractionphoton.cc.

                                                                       {
   const double xs_pion = total_cross_section(MediatorType::PION);
   const double xs_omega = total_cross_section(MediatorType::OMEGA);
  
   return std::pair<double, double>(xs_pion, xs_omega);
 }

◆ diff_cross_section_pair()

std::pair< double, double > smash::ScatterActionPhoton::diff_cross_section_pair	(	const double	t,
		const double	m_rho
	)

private

For processes which can happen via (pi, a1, rho) and omega exchange, return the differential cross section for the (pi, a1, rho) process in the first argument, for the omega process in the second.

If only one process exists, both values are the same.Helper function to easier combine processes with different mediating particles.

Parameters

[in]	t	Mandelstam-t [GeV^2]
[in]	m_rho	Mass of the incoming or outgoing rho-particle [GeV]

Returns: diff. cross section for (pi,a1,rho) in the first argument, for omega in the second.

Definition at line 674 of file scatteractionphoton.cc.

                                         {
   const double diff_xs_pion = diff_cross_section(t, m_rho, MediatorType::PION);
   const double diff_xs_omega =
       diff_cross_section(t, m_rho, MediatorType::OMEGA);
  
   return std::pair<double, double>(diff_xs_pion, diff_xs_omega);
 }

Member Data Documentation

◆ collision_processes_photons_

CollisionBranchList smash::ScatterActionPhoton::collision_processes_photons_

private

Holds the photon branch.

As of now, this will always hold only one branch.

Definition at line 188 of file scatteractionphoton.h.

◆ collision_branch_created_

bool smash::ScatterActionPhoton::collision_branch_created_ = false

private

Was the collision branch already created?

Definition at line 191 of file scatteractionphoton.h.

◆ reac_

const ReactionType smash::ScatterActionPhoton::reac_

private

Photonic process as determined from incoming particles.

Definition at line 194 of file scatteractionphoton.h.

◆ number_of_fractional_photons_

const int smash::ScatterActionPhoton::number_of_fractional_photons_

private

Number of photons created for each hadronic scattering, needed for correct weighting.

Note that in generate_final_state() only one photon + hadron is created.

Definition at line 201 of file scatteractionphoton.h.

◆ hadron_out_t_

const ParticleTypePtr smash::ScatterActionPhoton::hadron_out_t_

private

ParticleTypePtr to the type of the outgoing hadron.

Definition at line 204 of file scatteractionphoton.h.

◆ hadron_out_mass_

const double smash::ScatterActionPhoton::hadron_out_mass_

private

Mass of outgoing hadron.

Definition at line 207 of file scatteractionphoton.h.

◆ default_mediator_

constexpr MediatorType smash::ScatterActionPhoton::default_mediator_ = MediatorType::SUM

staticconstexprprivate

Value used for default exchange particle. See MediatorType.

Definition at line 220 of file scatteractionphoton.h.

◆ weight_

double smash::ScatterActionPhoton::weight_ = 0.0

private

Weight of the produced photon.

Definition at line 223 of file scatteractionphoton.h.

◆ cross_section_photons_

double smash::ScatterActionPhoton::cross_section_photons_ = 0.0

private

Total cross section of photonic process.

Definition at line 226 of file scatteractionphoton.h.

◆ hadronic_cross_section_

const double smash::ScatterActionPhoton::hadronic_cross_section_

private

Total hadronic cross section.

Definition at line 229 of file scatteractionphoton.h.

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

src/include/smash/scatteractionphoton.h
src/scatteractionphoton.cc

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Member Enumeration Documentation

◆ ReactionType

◆ MediatorType

Constructor & Destructor Documentation

◆ ScatterActionPhoton()

Member Function Documentation

◆ perform_photons()

◆ generate_final_state()

◆ get_total_weight()

◆ hadronic_cross_section()

◆ sample_out_hadron_mass()

◆ add_dummy_hadronic_process()

◆ add_single_process()

◆ photon_reaction_type()

◆ is_photon_reaction()

◆ outgoing_hadron_type() [1/2]

◆ outgoing_hadron_type() [2/2]

◆ is_kinematically_possible()

◆ rho_mass()

◆ create_collision_branch()

◆ total_cross_section()

◆ total_cross_section_w_ff()

◆ diff_cross_section()

◆ diff_cross_section_w_ff()

◆ form_factor_pion()

◆ form_factor_omega()

◆ form_factor_pair()

◆ total_cross_section_pair()

◆ diff_cross_section_pair()

Member Data Documentation

◆ collision_processes_photons_

◆ collision_branch_created_

◆ reac_

◆ number_of_fractional_photons_

◆ hadron_out_t_

◆ hadron_out_mass_

◆ default_mediator_

◆ weight_

◆ cross_section_photons_

◆ hadronic_cross_section_