processbranch.h

Go to the documentation of this file.

/*
 *    Copyright (c) 2013-2025
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 */
#ifndef SRC_INCLUDE_SMASH_PROCESSBRANCH_H_
#define SRC_INCLUDE_SMASH_PROCESSBRANCH_H_
 
#include <iostream>
#include <memory>
#include <utility>
#include <vector>
 
#include "decaytype.h"
#include "forwarddeclarations.h"
#include "particletype.h"
 
namespace smash {
 
enum class ProcessType {
  None = 0,
  Elastic = 1,
  TwoToOne = 2,
  TwoToTwo = 3,
  TwoToThree = 4,
  TwoToFour = 15,
  TwoToFive = 13,
  Decay = 5,
  Wall = 6,
  Thermalization = 7,
  Fluidization = 8,
  FluidizationNoRemoval = 21,
  Bremsstrahlung = 9,
  MultiParticleThreeMesonsToOne = 10,
  MultiParticleThreeToTwo = 11,
  MultiParticleFourToTwo = 14,
  MultiParticleFiveToTwo = 12,
  StringSoftSingleDiffractiveAX = 41,
  StringSoftSingleDiffractiveXB = 42,
  StringSoftDoubleDiffractive = 43,
  StringSoftAnnihilation = 44,
  StringSoftNonDiffractive = 45,
  StringHard = 46,
  FailedString = 47,
  Freeforall = 90
};
 
inline bool is_valid_process_type(int v) {
  // NOTE: There must NOT be a default case in the following switch, to let the
  // compiler warn about missing cases.
  switch (static_cast<ProcessType>(v)) {
    case ProcessType::None:
    case ProcessType::Elastic:
    case ProcessType::TwoToOne:
    case ProcessType::TwoToTwo:
    case ProcessType::TwoToThree:
    case ProcessType::TwoToFour:
    case ProcessType::TwoToFive:
    case ProcessType::Decay:
    case ProcessType::Wall:
    case ProcessType::Thermalization:
    case ProcessType::Fluidization:
    case ProcessType::FluidizationNoRemoval:
    case ProcessType::Bremsstrahlung:
    case ProcessType::MultiParticleThreeMesonsToOne:
    case ProcessType::MultiParticleThreeToTwo:
    case ProcessType::MultiParticleFourToTwo:
    case ProcessType::MultiParticleFiveToTwo:
    case ProcessType::StringSoftSingleDiffractiveAX:
    case ProcessType::StringSoftSingleDiffractiveXB:
    case ProcessType::StringSoftDoubleDiffractive:
    case ProcessType::StringSoftAnnihilation:
    case ProcessType::StringSoftNonDiffractive:
    case ProcessType::StringHard:
    case ProcessType::FailedString:
    case ProcessType::Freeforall:
      return true;
  }
  return false;
}
bool is_string_soft_process(ProcessType p);
 
std::ostream &operator<<(std::ostream &os, ProcessType process_type);
 
class ProcessBranch {
 public:
  ProcessBranch() : branch_weight_(0.) {}
 
  explicit ProcessBranch(double w) : branch_weight_(w) {}
 
  ProcessBranch(const ProcessBranch &) = delete;
 
  virtual ~ProcessBranch() = default;
 
  inline void set_weight(double process_weight);
 
  virtual ProcessType get_type() const = 0;
 
  virtual const ParticleTypePtrList &particle_types() const = 0;
 
  ParticleList particle_list() const;
 
  inline double weight() const;
 
  double threshold() const;
 
  virtual unsigned int particle_number() const = 0;
 
 protected:
  double branch_weight_;
  mutable double threshold_ = -1.;
};
 
inline void ProcessBranch::set_weight(double process_weight) {
  branch_weight_ = process_weight;
}
 
inline double ProcessBranch::weight() const { return branch_weight_; }
 
template <typename Branch>
inline double total_weight(const ProcessBranchList<Branch> &l) {
  double sum = 0.;
  for (const auto &p : l) {
    sum += p->weight();
  }
  return sum;
}
 
class CollisionBranch : public ProcessBranch {
 public:
  CollisionBranch(double w, ProcessType p_type)
      : ProcessBranch(w), process_type_(p_type) {}
  CollisionBranch(const ParticleType &type, double w, ProcessType p_type)
      : ProcessBranch(w), process_type_(p_type) {
    particle_types_.reserve(1);
    particle_types_.push_back(&type);
  }
  CollisionBranch(const ParticleType &type_a, const ParticleType &type_b,
                  double w, ProcessType p_type)
      : ProcessBranch(w), process_type_(p_type) {
    particle_types_.reserve(2);
    particle_types_.push_back(&type_a);
    particle_types_.push_back(&type_b);
  }
 
  CollisionBranch(const ParticleType &type_a, const ParticleType &type_b,
                  const ParticleType &type_c, double w, ProcessType p_type)
      : ProcessBranch(w), process_type_(p_type) {
    particle_types_.reserve(3);
    particle_types_.push_back(&type_a);
    particle_types_.push_back(&type_b);
    particle_types_.push_back(&type_c);
  }
 
  CollisionBranch(const ParticleType &type_a, const ParticleType &type_b,
                  const ParticleType &type_c, const ParticleType &type_d,
                  double w, ProcessType p_type)
      : ProcessBranch(w), process_type_(p_type) {
    particle_types_.reserve(4);
    particle_types_.push_back(&type_a);
    particle_types_.push_back(&type_b);
    particle_types_.push_back(&type_c);
    particle_types_.push_back(&type_d);
  }
 
  CollisionBranch(const ParticleType &type_a, const ParticleType &type_b,
                  const ParticleType &type_c, const ParticleType &type_d,
                  const ParticleType &type_e, double w, ProcessType p_type)
      : ProcessBranch(w), process_type_(p_type) {
    particle_types_.reserve(5);
    particle_types_.push_back(&type_a);
    particle_types_.push_back(&type_b);
    particle_types_.push_back(&type_c);
    particle_types_.push_back(&type_d);
    particle_types_.push_back(&type_e);
  }
 
  CollisionBranch(ParticleTypePtrList new_types, double w, ProcessType p_type)
      : ProcessBranch(w),
        particle_types_(std::move(new_types)),
        process_type_(p_type) {}
  CollisionBranch(CollisionBranch &&rhs)
      : ProcessBranch(rhs.branch_weight_),
        particle_types_(std::move(rhs.particle_types_)),
        process_type_(rhs.process_type_) {}
  const ParticleTypePtrList &particle_types() const override {
    return particle_types_;
  }
  inline void set_type(ProcessType p_type) { process_type_ = p_type; }
  inline ProcessType get_type() const override { return process_type_; }
  unsigned int particle_number() const override {
    return particle_types_.size();
  }
 
 private:
  ParticleTypePtrList particle_types_;
 
  ProcessType process_type_;
};
 
std::ostream &operator<<(std::ostream &os, const CollisionBranch &cbranch);
 
class DecayBranch : public ProcessBranch {
 public:
  DecayBranch(const DecayType &t, double w) : ProcessBranch(w), type_(t) {}
  DecayBranch(DecayBranch &&rhs)
      : ProcessBranch(rhs.branch_weight_), type_(rhs.type_) {}
  inline int angular_momentum() const { return type_.angular_momentum(); }
  const ParticleTypePtrList &particle_types() const override {
    return type_.particle_types();
  }
  unsigned int particle_number() const override {
    return type_.particle_number();
  }
  inline const DecayType &type() const { return type_; }
  inline ProcessType get_type() const override { return ProcessType::Decay; }
 
 private:
  const DecayType &type_;
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_PROCESSBRANCH_H_