forwarddeclarations.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2023
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_FORWARDDECLARATIONS_H_
#define SRC_INCLUDE_SMASH_FORWARDDECLARATIONS_H_
 
// exclude most content here from documentation
 
#include <iosfwd>
#include <memory>
#include <vector>
 
#ifdef _LIBCPP_BEGIN_NAMESPACE_STD
_LIBCPP_BEGIN_NAMESPACE_STD
#else
namespace std {
#endif
 
template <typename T>
class allocator;
template <typename T, typename A>
class vector;
 
template <typename T>
struct default_delete;
template <typename T, typename Deleter>
class unique_ptr;
 
template <std::size_t N>
class bitset;
 
#ifdef _LIBCPP_END_NAMESPACE_STD
_LIBCPP_END_NAMESPACE_STD
#else
}  // namespace std
#endif
 
namespace smash {
 
template <typename T>
using build_unique_ptr_ = std::unique_ptr<T, std::default_delete<T>>;
template <typename T>
using build_vector_ = std::vector<T, std::allocator<T>>;
 
class Action;
class ScatterAction;
class ScatterActionMulti;
class BoxModus;
class Clock;
class Configuration;
class CrossSections;
class DecayModes;
class DecayType;
class FourVector;
class ThreeVector;
class ModusDefault;
class OutputInterface;
class ParticleData;
class Particles;
class ParticleType;
class ParticleTypePtr;
class IsoParticleType;
class PdgCode;
class DecayBranch;
class CollisionBranch;
class Tabulation;
class ExperimentBase;
struct ExperimentParameters;
struct ScatterActionsFinderParameters;
struct StringTransitionParameters;
struct Nucleoncorr;
 
 
enum class CalculationFrame {
  CenterOfVelocity,
  CenterOfMass,
  FixedTarget,
};
 
enum class FermiMotion {
  Off,
  On,
  Frozen,
};
 
enum class Sampling {
  Uniform,
  Quadratic,
  Custom,
};
 
enum class DerivativesMode {
  CovariantGaussian,
  FiniteDifference,
  Off,
};
 
enum class RestFrameDensityDerivativesMode {
  On,
  Off,
};
 
enum class FieldDerivativesMode {
  ChainRule,
  Direct,
};
 
enum class SmearingMode {
  CovariantGaussian,
  Discrete,
  Triangular,
};
 
enum class TimeStepMode : char {
  None,
  Fixed,
};
 
enum class BoxInitialCondition {
  ThermalMomentaBoltzmann,
  ThermalMomentaQuantum,
  PeakedMomenta,
};
 
enum class SphereInitialCondition {
  ThermalMomentaBoltzmann,
  ThermalMomentaQuantum,
  IC_ES,
  IC_1M,
  IC_2M,
  IC_Massive,
};
 
enum class ExpansionMode {
  NoExpansion,
  MasslessFRW,
  MassiveFRW,
  Exponential,
};
 
enum class NNbarTreatment {
  NoAnnihilation,
  Resonances,
  TwoToFive,
  Strings,
};
 
enum class ThermodynamicQuantity : char {
  EckartDensity,
  Tmn,
  TmnLandau,
  LandauVelocity,
  j_QBS
};
 
enum class CollisionCriterion {
  Geometric,
  Stochastic,
  Covariant
};
 
enum class OutputOnlyFinal {
  Yes,
  No,
  IfNotEmpty,
};
 
enum IncludedReactions {
  All = 50,
  Elastic = 0,
  NN_to_NR = 1,
  NN_to_DR = 2,
  KN_to_KN = 3,
  KN_to_KDelta = 4,
  Strangeness_exchange = 5,
  NNbar = 6,
  PiDeuteron_to_NN = 7,
  PiDeuteron_to_pidprime = 8,
  NDeuteron_to_Ndprime = 9,
};
 
typedef std::bitset<10> ReactionsBitSet;
 
enum IncludedMultiParticleReactions {
  Meson_3to1 = 0,
  Deuteron_3to2 = 1,
  NNbar_5to2 = 2,
  A3_Nuclei_4to2 = 3,
};
 
typedef std::bitset<4> MultiParticleReactionsBitSet;
 
enum class ThermalizationAlgorithm {
  ModeSampling,
  BiasedBF,
  UnbiasedBF,
};
 
enum class EventCounting {
  FixedNumber,
  MinimumNonEmpty,
  Invalid,
};
 
using ActionPtr = build_unique_ptr_<Action>;
using ScatterActionPtr = build_unique_ptr_<ScatterAction>;
using ScatterActionMultiPtr = build_unique_ptr_<ScatterActionMulti>;
using ActionList = build_vector_<ActionPtr>;
 
using OutputPtr = build_unique_ptr_<OutputInterface>;
using OutputsList = build_vector_<OutputPtr>;
 
using ParticleList = build_vector_<ParticleData>;
using ParticleTypeList = build_vector_<ParticleType>;
using ParticleTypePtrList = build_vector_<ParticleTypePtr>;
using IsoParticleTypeList = build_vector_<IsoParticleType>;
 
template <typename T>
using ProcessBranchPtr = build_unique_ptr_<T>;
template <typename T>
using ProcessBranchList = build_vector_<ProcessBranchPtr<T>>;
using DecayBranchPtr = build_unique_ptr_<DecayBranch>;
using DecayBranchList = build_vector_<DecayBranchPtr>;
using CollisionBranchPtr = build_unique_ptr_<CollisionBranch>;
using CollisionBranchList = build_vector_<CollisionBranchPtr>;
 
using TabulationPtr = build_unique_ptr_<Tabulation>;
using ExperimentPtr = build_unique_ptr_<ExperimentBase>;
using DecayTypePtr = build_unique_ptr_<DecayType>;
 
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_FORWARDDECLARATIONS_H_