processbranch.cc

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2023,2025-2026
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#include "smash/processbranch.h"
 
#include <limits>
 
#include "smash/particledata.h"
 
namespace smash {
 
bool is_string_soft_process(ProcessType type) {
  return type == ProcessType::StringSoftSingleDiffractiveAX ||
         type == ProcessType::StringSoftSingleDiffractiveXB ||
         type == ProcessType::StringSoftDoubleDiffractive ||
         type == ProcessType::StringSoftAnnihilation ||
         type == ProcessType::StringSoftNonDiffractive;
}
bool is_string_hard_process(ProcessType type) {
  return type == ProcessType::StringHardSingleDiffractiveAX ||
         type == ProcessType::StringHardSingleDiffractiveXB ||
         type == ProcessType::StringHardDoubleDiffractive ||
         type == ProcessType::StringHardNonDiffractive;
}
 
bool is_string_process(ProcessType type) {
  return is_string_soft_process(type) || is_string_hard_process(type);
}
ParticleList ProcessBranch::particle_list() const {
  ParticleList l;
  l.reserve(particle_number());
  for (const auto& type : particle_types()) {
    l.push_back(ParticleData{*type});
  }
  return l;
}
 
double ProcessBranch::threshold() const {
  if (threshold_ < 0.) {
    /* Sum up the (minimum) masses of all final-state particles
     * this requires double-precision to ensure that the sum is never
     * smaller than the real sum would be without rounding. */
    double thr = 0.;
    for (const auto& type : particle_types()) {
      thr += type->min_mass_kinematic();
    }
    /* This may round up or down. Up is good. If down
     * we must add one ULP via 'nextafter'. */
    const double rounded = thr;
    threshold_ =
        rounded < thr
            ? std::nextafter(rounded, std::numeric_limits<double>::max())
            : rounded;
  }
  return threshold_;
}
 
std::ostream& operator<<(std::ostream& os, const CollisionBranch& cbranch) {
  ProcessType ptype = cbranch.get_type();
  if (ptype == ProcessType::StringSoftSingleDiffractiveAX ||
      ptype == ProcessType::StringSoftSingleDiffractiveXB) {
    os << "soft-1-diff";
  } else if (ptype == ProcessType::StringSoftDoubleDiffractive) {
    os << "soft-2-diff";
  } else if (ptype == ProcessType::StringSoftAnnihilation) {
    os << "soft-BBbar";
  } else if (ptype == ProcessType::StringSoftNonDiffractive) {
    os << "soft-non-diff";
  } else if (ptype == ProcessType::StringHardNonDiffractive) {
    os << "hard-non-diff";
  } else if (ptype == ProcessType::StringHardSingleDiffractiveXB ||
             ptype == ProcessType::StringHardSingleDiffractiveAX) {
    os << "hard-1-diff";
  } else if (ptype == ProcessType::StringHardDoubleDiffractive) {
    os << "hard-2-diff";
  } else if (ptype == ProcessType::TwoToOne || ptype == ProcessType::TwoToTwo ||
             ptype == ProcessType::TwoToThree ||
             ptype == ProcessType::TwoToFour ||
             ptype == ProcessType::TwoToFive || ptype == ProcessType::Elastic ||
             ptype == ProcessType::Decay ||
             ptype == ProcessType::MultiParticleThreeMesonsToOne ||
             ptype == ProcessType::MultiParticleThreeToTwo ||
             ptype == ProcessType::MultiParticleFourToTwo ||
             ptype == ProcessType::MultiParticleFiveToTwo) {
    ParticleTypePtrList ptype_list = cbranch.particle_types();
    /* Sorting ensures unique name for every channel
     * It avoids duplicates, such as Δ⁰Δ⁺⁺ and Δ⁺⁺Δ⁰,
     * which actually occur in SMASH, because of the way channels are added:
     * for example one channel can be added twice with halved cross-section. */
    std::sort(ptype_list.begin(), ptype_list.end());
    for (const auto& type : ptype_list) {
      os << type->name();
    }
  } else {
    os << ptype;
  }
  return os;
}
 
std::ostream& operator<<(std::ostream& os, ProcessType process_type) {
  switch (process_type) {
    case ProcessType::None:
      os << "None";
      break;
    case ProcessType::Elastic:
      os << "Elastic";
      break;
    case ProcessType::TwoToOne:
      os << "TwoToOne";
      break;
    case ProcessType::TwoToTwo:
      os << "TwoToTwo";
      break;
    case ProcessType::TwoToThree:
      os << "TwoToThree";
      break;
    case ProcessType::TwoToFour:
      os << "TwoToFour";
      break;
    case ProcessType::TwoToFive:
      os << "TwoToFive";
      break;
    case ProcessType::StringSoftSingleDiffractiveAX:
    case ProcessType::StringSoftSingleDiffractiveXB:
    case ProcessType::StringSoftDoubleDiffractive:
    case ProcessType::StringSoftAnnihilation:
    case ProcessType::StringSoftNonDiffractive:
      os << "SoftStringExcitation";
      break;
    case ProcessType::StringHardNonDiffractive:
    case ProcessType::StringHardSingleDiffractiveAX:
    case ProcessType::StringHardSingleDiffractiveXB:
    case ProcessType::StringHardDoubleDiffractive:
      os << "HardStringExcitation";
      break;
    case ProcessType::Decay:
      os << "Decay";
      break;
    case ProcessType::Wall:
      os << "Wall";
      break;
    case ProcessType::Thermalization:
      os << "Thermalization";
      break;
    case ProcessType::Fluidization:
    case ProcessType::FluidizationNoRemoval:
      os << "Fluidization";
      break;
    case ProcessType::MultiParticleThreeMesonsToOne:
      os << "ThreeMesonsToOne";
      break;
    case ProcessType::MultiParticleThreeToTwo:
      os << "ThreeToTwo";
      break;
    case ProcessType::MultiParticleFourToTwo:
      os << "FourToTwo";
      break;
    case ProcessType::MultiParticleFiveToTwo:
      os << "FiveToTwo";
      break;
    case ProcessType::Freeforall:
      os << "Freeforall";
      break;
    default:
      os.setstate(std::ios_base::failbit);
  }
  return os;
}
 
}  // namespace smash