#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:

[legend]

Collaboration diagram for smash::ScatterActionPhoton:

[legend]

Public Types
enum	ReactionType { ReactionType::no_reaction, ReactionType::pi_z_pi_p_rho_p, ReactionType::pi_z_pi_m_rho_m, ReactionType::pi_p_rho_z_pi_p, ReactionType::pi_m_rho_z_pi_m, ReactionType::pi_m_rho_p_pi_z, ReactionType::pi_p_rho_m_pi_z, ReactionType::pi_z_rho_p_pi_p, ReactionType::pi_z_rho_m_pi_m, ReactionType::pi_p_pi_m_rho_z, ReactionType::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)
	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	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 (double elastic_parameter, bool two_to_one, ReactionsBitSet included_2to2, double low_snn_cut, bool strings_switch, bool use_AQM, bool strings_with_probability, NNbarTreatment nnbar_treatment)
	Add all possible scattering subprocesses for this action object. 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. 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 void	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 Particles &particles, 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...

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

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

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

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

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

CollisionBranchList	photon_cross_sections (MediatorType mediator=default_mediator_)
	Computes the total cross section of the photon process. More...

std::pair< double, double >	diff_cross_section_single (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...

std::pair< double, double >	form_factor_single (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...

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

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

Private Attributes
CollisionBranchList	collision_processes_photons_
	Holds the photon branch. 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	mandelstam_s () const
	Determine the Mandelstam s variable,. More...

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

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

double	total_cross_section_
	Total hadronic cross section. 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/c). More...

ProcessType	process_type_
	type of process 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 215 of file scatteractionphoton.h.

215 { 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 29 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 92 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);
       }
     }
   }
 }

Here is the call graph for this function:

◆ 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 188 of file scatteractionphoton.cc.

                                                {
   // we have only one reaction per incoming particle pair
   if (collision_processes_photons_.size() != 1) {
     const auto &log = logger<LogArea::ScatterAction>();
     log.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) {
     const auto &log = logger<LogArea::ScatterAction>();
     log.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(-beta_cm());
   }
 
   const double E_Photon = outgoing_particles_[1].momentum()[0];
 
   // 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);
 
   // Weighing of the fractional photons
   if (number_of_fractional_photons_ > 1) {
     weight_ = diff_xs * (t2 - t1) /
               (number_of_fractional_photons_ * hadronic_cross_section());
   } else {
     weight_ = proc->weight() / hadronic_cross_section();
   }
   // 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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_; }

smash::ScatterActionPhoton::weight_

double weight_

Weight of the produced photon.

Definition: scatteractionphoton.h:220

◆ 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_; }

smash::ScatterActionPhoton::hadronic_cross_section_

const double hadronic_cross_section_

Total hadronic cross section.

Definition: scatteractionphoton.h:226

Here is the caller graph for this function:

◆ 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 286 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;
 }

Here is the call graph for this function:

◆ 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 278 of file scatteractionphoton.cc.

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

Here is the call graph for this function:

◆ 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>(photon_cross_sections(),
                                    collision_processes_photons_,
                                    cross_section_photons_);
   }

Here is the call graph for this function:

◆ 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 39 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;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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;
   }

Here is the call graph for this function:

◆ 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 150 of file scatteractionphoton.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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 104 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;
   }
 }

Here is the call graph for this function:

◆ 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 156 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;
   } else {
     return true;
   }
 }

Here is the call graph for this function:

◆ 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 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 412 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;
   }
   return diff_xsection;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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 302 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()");
   }
 }

Here is the caller graph for this function:

◆ photon_cross_sections()

CollisionBranchList smash::ScatterActionPhoton::photon_cross_sections ( MediatorType mediator = default_mediator_ )

private

Computes the total cross section of the photon process.

Parameters

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

Returns: List of photon reaction branches.

Definition at line 328 of file scatteractionphoton.cc.

                            {
   CollisionBranchList process_list;
   CrosssectionsPhoton<ComputationMethod::Analytic> xs_object;
 
   static ParticleTypePtr photon_particle = &ParticleType::find(pdg::photon);
 
   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;
   }
 
   // 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).
 
   if (xsection <= 0) {
     xsection = 0.1;
     const auto &log = logger<LogArea::ScatterAction>();
     log.warn("Calculated negative cross section.\nParticles ",
              incoming_particles_, " mass rho particle: ", m_rho,
              ", sqrt_s: ", std::sqrt(s));
   }
   process_list.push_back(make_unique<CollisionBranch>(
       *hadron_out_t_, *photon_particle, xsection, ProcessType::TwoToTwo));
   return process_list;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ diff_cross_section_single()

std::pair< double, double > smash::ScatterActionPhoton::diff_cross_section_single	(	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.

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 568 of file scatteractionphoton.cc.

                                         {
   const double diff_xs_rho = 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_rho, diff_xs_omega);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ form_factor_single()

std::pair< double, double > smash::ScatterActionPhoton::form_factor_single ( 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.

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 562 of file scatteractionphoton.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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 538 of file scatteractionphoton.cc.

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

Here is the caller graph for this function:

◆ 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 550 of file scatteractionphoton.cc.

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

Here is the caller graph for this function:

◆ 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 with form factors included.

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:2006) are used.

Definition at line 473 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_single(E_photon);
         std::pair<double, double> diff_xs = diff_cross_section_single(t, m_rho);
         const double xs_ff = pow_int(FF.first, 4) * diff_xs.first +
                              pow_int(FF.second, 4) * diff_xs.second;
         return 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 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 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 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 xs_ff;
     }
 
     case ReactionType::no_reaction:
     default:
       throw std::runtime_error("");
       return 0;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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.

◆ reac_

const ReactionType smash::ScatterActionPhoton::reac_

private

Photonic process as determined from incoming particles.

Definition at line 191 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 198 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 201 of file scatteractionphoton.h.

◆ hadron_out_mass_

const double smash::ScatterActionPhoton::hadron_out_mass_

private

Mass of outgoing hadron.

Definition at line 204 of file scatteractionphoton.h.

◆ default_mediator_

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

staticprivate

Value used for default exchange particle. See MediatorType.

Definition at line 217 of file scatteractionphoton.h.

◆ weight_

double smash::ScatterActionPhoton::weight_ = 0.0

private

Weight of the produced photon.

Definition at line 220 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 223 of file scatteractionphoton.h.

◆ hadronic_cross_section_

const double smash::ScatterActionPhoton::hadronic_cross_section_

private

Total hadronic cross section.

Definition at line 226 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()

◆ diff_cross_section()

◆ rho_mass()

◆ photon_cross_sections()

◆ diff_cross_section_single()

◆ form_factor_single()

◆ form_factor_pion()

◆ form_factor_omega()

◆ diff_cross_section_w_ff()

Member Data Documentation

◆ collision_processes_photons_

◆ reac_

◆ number_of_fractional_photons_

◆ hadron_out_t_

◆ hadron_out_mass_

◆ default_mediator_

◆ weight_

◆ cross_section_photons_

◆ hadronic_cross_section_