forwarddeclarations.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2024
 *      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 <bitset>
#include <iosfwd>
#include <memory>
#include <vector>
 
namespace smash {
 
class Action;
class ScatterAction;
class ScatterActionMulti;
class BoxModus;
class Clock;
class CollisionBranch;
class Configuration;
class CrossSections;
class DecayBranch;
class DecayModes;
class DecayType;
class ExperimentBase;
class FourVector;
class IsoParticleType;
template <typename T>
class Key;
class ModusDefault;
class OutputInterface;
class ParticleData;
class Particles;
class ParticleType;
class ParticleTypePtr;
class PdgCode;
class ScatterActionsFinderParameters;
class Tabulation;
class ThreeVector;
 
struct ExperimentParameters;
struct InitialConditionParameters;
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,
};
 
// Because std::bitset does not handle enum classes, this is a simple enum.
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;
 
// Because std::bitset does not handle enum classes, this is a simple enum.
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,
};
 
enum class TotalCrossSectionStrategy {
  BottomUp,
  TopDown,
  TopDownMeasured,
};
 
enum class PseudoResonance {
  None,
  Largest,
  Closest,
  LargestFromUnstable,
  ClosestFromUnstable,
};
 
enum class FluidizationType {
  ConstantTau,
  Dynamic,
};
 
// Because std::bitset does not handle enum classes, this is a simple enum.
enum IncludedFluidizableProcesses {
  From_Elastic = 0,
  From_Decay = 1,
  From_Inelastic = 2,
  From_SoftString = 3,
  From_HardString = 4,
};
 
typedef std::bitset<5> FluidizableProcessesBitSet;
 
enum class DensityType {
  None = 0,
  Hadron = 1,
  Baryon = 2,
  BaryonicIsospin = 3,
  Pion = 4,
  Isospin3_tot = 5,
  Charge = 6,
  Strangeness = 7,
};
 
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>>;
 
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_