scatteractionphoton.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2016-2018
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */

#ifndef SRC_INCLUDE_SCATTERACTIONPHOTON_H_
#define SRC_INCLUDE_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>(photon_cross_sections(),
                                   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_;

  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 diff_cross_section(const double t, const double m_rho,
                            MediatorType mediator = default_mediator_) const;

  double rho_mass() const;

  CollisionBranchList photon_cross_sections(
      MediatorType mediator = default_mediator_);

  std::pair<double, double> diff_cross_section_single(const double t,
                                                      const double m_rho);

  std::pair<double, double> form_factor_single(const double E_photon);

  double form_factor_pion(const double E_photon) const;

  double form_factor_omega(const double E_photon) const;

  double diff_cross_section_w_ff(const double t, const double m_rho,
                                 const double E_photon);
};

}  // namespace smash

#endif  // SRC_INCLUDE_SCATTERACTIONPHOTON_H_