particledata.h

Go to the documentation of this file.

/*
 *    Copyright (c) 2012-2020,2022-2025
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 */
#ifndef SRC_INCLUDE_SMASH_PARTICLEDATA_H_
#define SRC_INCLUDE_SMASH_PARTICLEDATA_H_
 
#include <limits>
#include <utility>
 
#include "forwarddeclarations.h"
#include "fourvector.h"
#include "particletype.h"
#include "pdgcode.h"
#include "processbranch.h"
 
namespace smash {
 
enum class BelongsTo : uint8_t {
  Nothing = 0,
  Projectile = 1,
  Target = 2,
};
 
struct HistoryData {
  int32_t collisions_per_particle = 0;
  int32_t id_process = 0;
  ProcessType process_type = ProcessType::None;
  double time_last_collision = smash_NaN<double>;
  PdgCode p1 = 0x0;
  PdgCode p2 = 0x0;
};
 
class ParticleData {
 public:
  explicit ParticleData(const ParticleType &particle_type, int unique_id = -1)
      : id_(unique_id), type_(&particle_type) {}
 
  int32_t id() const { return id_; }
  void set_id(int i) { id_ = i; }
 
  PdgCode pdgcode() const { return type_->pdgcode(); }
 
  // Convenience accessors to PdgCode:
  bool is_hadron() const { return type_->is_hadron(); }
 
  bool is_baryon() const { return pdgcode().is_baryon(); }
 
  bool is_nucleus() const { return pdgcode().is_nucleus(); }
 
  bool is_rho() const { return type_->is_rho(); }
 
  bool is_proton() const { return pdgcode().is_proton(); }
 
  bool is_neutron() const { return pdgcode().is_neutron(); }
 
  bool is_pion() const { return pdgcode().is_pion(); }
 
  bool is_sigmastar() const { return pdgcode().is_Sigmastar(); }
 
  double pole_mass() const { return type_->mass(); }
  double effective_mass() const;
  const ParticleType &type() const { return *type_; }
 
  uint32_t id_process() const { return history_.id_process; }
  HistoryData get_history() const { return history_; }
  void set_history(HistoryData &&history) { history_ = std::move(history); }
 
  void set_history(int ncoll, uint32_t pid, ProcessType pt,
                   double time_last_coll, const ParticleList &plist);
 
  const FourVector &momentum() const { return momentum_; }
 
  void set_4momentum(const FourVector &momentum_vector) {
    momentum_ = momentum_vector;
  }
 
  void set_4momentum(double mass, const ThreeVector &mom) {
    momentum_ = FourVector(std::sqrt(mass * mass + mom * mom), mom);
  }
 
  void set_4momentum(double mass, double px, double py, double pz) {
    momentum_ = FourVector(std::sqrt(mass * mass + px * px + py * py + pz * pz),
                           px, py, pz);
  }
  void set_3momentum(const ThreeVector &mom) {
    momentum_ = FourVector(momentum_.x0(), mom);
  }
 
  const FourVector &position() const { return position_; }
  void set_4position(const FourVector &pos) { position_ = pos; }
  void set_3position(const ThreeVector &pos) {
    position_ = FourVector(position_.x0(), pos);
  }
 
  ParticleData translated(const ThreeVector &delta) const {
    ParticleData p = *this;
    p.position_[1] += delta[0];
    p.position_[2] += delta[1];
    p.position_[3] += delta[2];
    return p;
  }
 
  double formation_time() const { return formation_time_; }
  double begin_formation_time() const { return begin_formation_time_; }
 
  void set_formation_time(double form_time) {
    formation_time_ = form_time;
    // cross section scaling factor will be a step function in time
    begin_formation_time_ = form_time;
    // if time of the last collision is NaN set it to the formation time
    if (std::isnan(history_.time_last_collision)) {
      history_.time_last_collision = form_time;
    }
  }
  void set_slow_formation_times(double begin_form_time, double form_time) {
    begin_formation_time_ = begin_form_time;
    formation_time_ = form_time;
    if (std::isnan(history_.time_last_collision)) {
      history_.time_last_collision = form_time;
    }
  }
 
  const double &initial_xsec_scaling_factor() const {
    return initial_xsec_scaling_factor_;
  }
  void set_cross_section_scaling_factor(const double &xsec_scal) {
    initial_xsec_scaling_factor_ = xsec_scal;
  }
 
  ThreeVector velocity() const { return momentum_.velocity(); }
 
  double inverse_gamma() const {
    return std::sqrt(1. - momentum_.sqr3() / (momentum_.x0() * momentum_.x0()));
  }
 
  void boost(const ThreeVector &v) {
    set_4momentum(momentum_.lorentz_boost(v));
    set_4position(position_.lorentz_boost(v));
  }
 
  void boost_momentum(const ThreeVector &v) {
    set_4momentum(momentum_.lorentz_boost(v));
  }
  int spin() const { return pdgcode().spin(); }
  const FourVector &spin_vector() const { return spin_vector_; }
  FourVector &spin_vector() { return spin_vector_; }
  void set_spin_vector(const FourVector &s) { spin_vector_ = s; }
  void set_spin_vector_component(int index, double value) {
    if (index < 0 || index > 3) {
      throw std::out_of_range("Invalid spin vector component index");
    }
    spin_vector_[index] = value;
  }
 
  void set_unpolarized_spin_vector();
  void set_belongs_to(BelongsTo label) { belongs_to_ = label; }
  BelongsTo belongs_to() const { return belongs_to_; }
 
  void fluidize() { core_ = true; }
  bool is_core() const { return core_; }
  double hyperbolic_time() const { return position_.tau(); }
  double spatial_rapidity() const { return position_.eta(); }
  double transverse_mass() const { return momentum_.tau(); }
  double rapidity() const { return momentum_.eta(); }
 
  void set_perturbative_weight(const double weight) {
    perturbative_weight_ = weight;
  }
  double perturbative_weight() const { return perturbative_weight_; }
 
  bool operator==(const ParticleData &a) const { return this->id_ == a.id_; }
  bool operator<(const ParticleData &a) const { return this->id_ < a.id_; }
 
  bool operator==(int id_a) const { return this->id_ == id_a; }
  bool operator<(int id_a) const { return this->id_ < id_a; }
 
  ParticleData(const ParticleType &ptype, int uid, int index)
      : id_(uid), index_(index), type_(&ptype) {}
 
  double xsec_scaling_factor(double delta_time = 0.) const;
 
  static double formation_power_;
 
 private:
  friend class Particles;
  ParticleData() = default;
 
  void copy_to(ParticleData &dst) const {
    dst.history_ = history_;
    dst.momentum_ = momentum_;
    dst.position_ = position_;
    dst.spin_vector_ = spin_vector_;
    dst.formation_time_ = formation_time_;
    dst.initial_xsec_scaling_factor_ = initial_xsec_scaling_factor_;
    dst.begin_formation_time_ = begin_formation_time_;
    dst.belongs_to_ = belongs_to_;
    dst.core_ = core_;
    dst.perturbative_weight_ = perturbative_weight_;
  }
 
  int32_t id_ = -1;
 
  unsigned index_ = std::numeric_limits<unsigned>::max();
 
  ParticleTypePtr type_;
 
  // this leaves us two Bytes padding to use for "free"
  static_assert(sizeof(ParticleTypePtr) == 2, "");
  // make sure we don't exceed that space
  static_assert(sizeof(bool) <= 2, "");
  bool hole_ = false;
 
  // A particle cannot be un-core, and any children it produces inherits
  // this trait.
  bool core_ = false;
 
  FourVector momentum_;
  FourVector position_;
  FourVector spin_vector_ = FourVector(smash_NaN<double>, smash_NaN<double>,
                                       smash_NaN<double>, smash_NaN<double>);
  double formation_time_ = smash_NaN<double>;
  double begin_formation_time_ = smash_NaN<double>;
  double initial_xsec_scaling_factor_ = 1.0;
  double perturbative_weight_ = 1.0;
  HistoryData history_;
  BelongsTo belongs_to_ = BelongsTo::Nothing;
};
 
std::ostream &operator<<(std::ostream &s, const ParticleData &p);
 
std::ostream &operator<<(std::ostream &out, const ParticleList &particle_list);
 
struct PrintParticleListDetailed {
  const ParticleList &list;
};
inline PrintParticleListDetailed detailed(const ParticleList &list) {
  return {list};
}
 
std::ostream &operator<<(std::ostream &out,
                         const PrintParticleListDetailed &particle_list);
 
ParticleData create_valid_smash_particle_matching_provided_quantities(
    PdgCode pdgcode, double mass, const FourVector &four_position,
    const FourVector &four_momentum, int log_area, bool &mass_warning,
    bool &on_shell_warning);
 
bool are_particles_identical_at_given_time(const ParticleData &p1,
                                           const ParticleData &p2, double time);
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_PARTICLEDATA_H_