scatteractionphoton.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2016-2020
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_SCATTERACTIONPHOTON_H_
#define SRC_INCLUDE_SMASH_SCATTERACTIONPHOTON_H_
 
#include <utility>
 
#include "scatteraction.h"
 
namespace smash {
 
class ScatterActionPhoton : public ScatterAction {
 public:
  ScatterActionPhoton(const ParticleList &in, const double time,
                      const int n_frac_photons,
                      const double hadronic_cross_section_input);
 
  void perform_photons(const OutputsList &outputs);
 
  void generate_final_state() override;
 
  double get_total_weight() const override { return weight_; }
 
  double hadronic_cross_section() const { return hadronic_cross_section_; }
 
  double sample_out_hadron_mass(const ParticleTypePtr out_type);
 
  void add_dummy_hadronic_process(double reaction_cross_section);
 
  void add_single_process() {
    add_processes<CollisionBranch>(create_collision_branch(),
                                   collision_processes_photons_,
                                   cross_section_photons_);
  }
 
  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
  };
 
  static ReactionType photon_reaction_type(const ParticleList &in);
 
  static bool is_photon_reaction(const ParticleList &in) {
    return photon_reaction_type(in) != ReactionType::no_reaction;
  }
 
  static ParticleTypePtr outgoing_hadron_type(const ParticleList &in);
 
  static ParticleTypePtr outgoing_hadron_type(const ReactionType reaction);
 
  static bool is_kinematically_possible(const double s_sqrt,
                                        const ParticleList &in);
 
 private:
  CollisionBranchList collision_processes_photons_;
 
  bool collision_branch_created_ = false;
 
  const ReactionType reac_;
 
  const int number_of_fractional_photons_;
 
  const ParticleTypePtr hadron_out_t_;
 
  const double hadron_out_mass_;
 
  enum class MediatorType { SUM, PION, OMEGA };
  static constexpr MediatorType default_mediator_ = MediatorType::SUM;
 
  double weight_ = 0.0;
 
  double cross_section_photons_ = 0.0;
 
  const double hadronic_cross_section_;
 
  double rho_mass() const;
 
  CollisionBranchList create_collision_branch();
 
  double total_cross_section(MediatorType mediator = default_mediator_) const;
 
  double total_cross_section_w_ff(const double E_photon);
 
  double diff_cross_section(const double t, const double m_rho,
                            MediatorType mediator = default_mediator_) const;
 
  double diff_cross_section_w_ff(const double t, const double m_rho,
                                 const double E_photon);
 
  double form_factor_pion(const double E_photon) const;
 
  double form_factor_omega(const double E_photon) const;
 
  std::pair<double, double> form_factor_pair(const double E_photon);
 
  std::pair<double, double> total_cross_section_pair();
 
  std::pair<double, double> diff_cross_section_pair(const double t,
                                                    const double m_rho);
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_SCATTERACTIONPHOTON_H_