scatteraction.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2025
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_SCATTERACTION_H_
#define SRC_INCLUDE_SMASH_SCATTERACTION_H_
 
#include <memory>
#include <set>
#include <string>
#include <utility>
 
#include "action.h"
#include "isoparticletype.h"
#include "scatteractionsfinderparameters.h"
#include "stringprocess.h"
 
namespace smash {
 
class ScatterAction : public Action {
 public:
  ScatterAction(const ParticleData& in_part1, const ParticleData& in_part2,
                double time, bool isotropic = false,
                double string_formation_time = 1.0, double box_length = -1.0,
                bool is_total_parametrized = false,
                const SpinInteractionType spin_interaction_type =
                    SpinInteractionType::Off);
  void add_collision(CollisionBranchPtr p);
 
  void add_collisions(CollisionBranchList pv);
 
  double transverse_distance_sqr() const;
 
  double cov_transverse_distance_sqr() const;
  double mandelstam_s() const;
 
  double relative_velocity() const;
 
  void generate_final_state() override;
 
  double get_total_weight() const override;
 
  double get_partial_weight() const override;
 
  void sample_angles(std::pair<double, double> masses,
                     double kinetic_energy_cm) override;
 
  void add_all_scatterings(
      const ScatterActionsFinderParameters& finder_parameters);
 
  void set_parametrized_total_cross_section(
      const ScatterActionsFinderParameters& finder_parameters);
 
  const CollisionBranchList& collision_channels() {
    return collision_channels_;
  }
 
  class InvalidScatterAction : public std::invalid_argument {
    using std::invalid_argument::invalid_argument;
  };
 
  void set_string_interface(StringProcess* str_proc) {
    string_process_ = str_proc;
  }
 
  virtual double cross_section() const {
    if (is_total_parametrized_) {
      return *parametrized_total_cross_section_;
    }
    return sum_of_partial_cross_sections_;
  }
 
 protected:
  double cm_momentum() const;
  double cm_momentum_squared() const;
 
  ThreeVector beta_cm() const;
  double gamma_cm() const;
 
  void elastic_scattering();
 
  void inelastic_scattering();
 
  void two_to_many_scattering();
 
  void create_string_final_state();
  void string_excitation();
 
  void spin_interaction();
 
  void string_spin_interaction();
 
  void format_debug_output(std::ostream& out) const override;
 
  CollisionBranchList collision_channels_;
 
  double sum_of_partial_cross_sections_;
 
  double partial_cross_section_;
 
  bool isotropic_ = false;
 
  double string_formation_time_ = 1.0;
 
 private:
  bool is_elastic() const;
 
  void resonance_formation();
 
  void rescale_outgoing_branches();
 
  ParticleTypePtr try_find_pseudoresonance(
      const PseudoResonance method,
      const StringTransitionParameters& transition) const;
 
  StringProcess* string_process_ = nullptr;
 
  bool is_total_parametrized_ = false;
 
  std::optional<double> parametrized_total_cross_section_ = std::nullopt;
 
  SpinInteractionType spin_interaction_type_ = SpinInteractionType::Off;
 
  bool were_processes_added_ = false;
 
  static inline std::set<std::set<ParticleTypePtr>>
      warned_no_rescaling_available{};
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_SCATTERACTION_H_