isoparticletype.h

Go to the documentation of this file.

/*
 *    Copyright (c) 2015-2022
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 */
 
#ifndef SRC_INCLUDE_SMASH_ISOPARTICLETYPE_H_
#define SRC_INCLUDE_SMASH_ISOPARTICLETYPE_H_
 
#include <filesystem>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "particletype.h"
#include "sha256.h"
#include "tabulation.h"
 
namespace smash {
 
class IsoParticleType {
 public:
  IsoParticleType(const std::string &n, double m, double w, unsigned int s,
                  Parity p);
 
  IsoParticleType(const IsoParticleType &) = delete;
  IsoParticleType &operator=(const IsoParticleType &) = delete;
 
  IsoParticleType(IsoParticleType &&) = default;
  IsoParticleType &operator=(IsoParticleType &&) = default;
 
  bool operator==(const IsoParticleType &rhs) const {
    return states_[0]->pdgcode() == rhs.states_[0]->pdgcode();
  }
 
  const std::string &name() const { return name_; }
 
  const std::string name_filtered_prime() const {
    std::string tmp_s = name_;
    std::size_t found_position = tmp_s.find("'");
    if (found_position != std::string::npos) {
      tmp_s.erase(found_position, 1);
      tmp_s.insert(found_position, "_prime");
    }
    return tmp_s;
  }
 
  double mass() const { return mass_; }
 
  double width() const { return width_; }
 
  int isospin() const { return states_.size() - 1; }
 
  unsigned int spin() const { return spin_; }
 
  Parity parity() const { return parity_; }
 
  bool is_hadron() const { return states_[0]->is_hadron(); }
 
  ParticleTypePtrList get_states() const { return states_; }
 
  void add_state(const ParticleType &type);
 
  const IsoParticleType *anti_multiplet() const;
 
  bool has_anti_multiplet() const;
 
  static const IsoParticleTypeList &list_all();
 
  static const std::vector<const IsoParticleType *> list_baryon_resonances();
 
  static const IsoParticleType *try_find(const std::string &name);
 
  static const IsoParticleType &find(const std::string &name);
 
  static IsoParticleType *find(const ParticleType &type);
 
  struct ParticleNotFoundFailure : public std::runtime_error {
    using std::runtime_error::runtime_error;
  };
 
  static bool exists(const std::string &name);
 
  static const ParticleTypePtr find_state(const std::string &name);
 
  static void create_multiplet(const ParticleType &type);
 
  static void tabulate_integrals(sha256::Hash hash,
                                 const std::filesystem::path &tabulations_path);
 
  double get_integral_NR(double sqrts);
 
  double get_integral_RR(IsoParticleType *type_res_2, double sqrts);
 
  double get_integral_RK(double sqrts);
 
  double get_integral_piR(double sqrts);
 
  double get_integral_rhoR(double sqrts);
 
 private:
  std::string name_;
  double mass_;
  double width_;
  unsigned int spin_;
  Parity parity_;
  ParticleTypePtrList states_;
 
  Tabulation *XS_piR_tabulation_ = nullptr;
  Tabulation *XS_RK_tabulation_ = nullptr;
  Tabulation *XS_NR_tabulation_ = nullptr;
  Tabulation *XS_DeltaR_tabulation_ = nullptr;
  Tabulation *XS_rhoR_tabulation_ = nullptr;
 
  static IsoParticleType &find_private(const std::string &name);
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_ISOPARTICLETYPE_H_