setup.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2015-2020
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_TESTS_SETUP_H_
#define SRC_TESTS_SETUP_H_
 
#include "../include/smash/cxx14compat.h"
#include "../include/smash/decaymodes.h"
#include "../include/smash/experiment.h"
#include "../include/smash/particledata.h"
#include "../include/smash/particles.h"
#include "../include/smash/particletype.h"
#include "../include/smash/random.h"
 
#include <boost/filesystem.hpp>
 
namespace smash {
namespace Test {
 
inline void create_actual_particletypes() {
#ifndef DOXYGEN
#include <particles.txt.h>
#endif
  ParticleType::create_type_list(data);
}
 
inline void create_actual_decaymodes() {
#ifndef DOXYGEN
#include <decaymodes.txt.h>
#endif
  DecayModes::load_decaymodes(data);
}
 
static constexpr double smashon_mass = 0.123;
static constexpr double smashon_width = 1.2;
static constexpr const char smashon_pdg_string[] = "661";
 
inline void create_smashon_particletypes() {
  ParticleType::create_type_list(
      "# NAME MASS[GEV] WIDTH[GEV] PARITY PDG\n"
      "σ " +
      std::to_string(smashon_mass) + " " + std::to_string(smashon_width) +
      " + 661\n");
}
 
struct Position : public FourVector {
  using FourVector::FourVector;
};
struct Momentum : public FourVector {
  using FourVector::FourVector;
};
 
inline ParticleData smashon(int id = -1) {
  ParticleData p{ParticleType::find(0x661), id};
  return p;
}
inline ParticleData smashon(const Position &position, int id = -1) {
  ParticleData p{ParticleType::find(0x661), id};
  p.set_4position(position);
  return p;
}
inline ParticleData smashon(const Momentum &momentum, int id = -1) {
  ParticleData p{ParticleType::find(0x661), id};
  p.set_4momentum(momentum);
  return p;
}
inline ParticleData smashon(const Position &position, const Momentum &momentum,
                            int id = -1) {
  ParticleData p{ParticleType::find(0x661), id};
  p.set_4position(position);
  p.set_4momentum(momentum);
  return p;
}
inline ParticleData smashon(const Momentum &momentum, const Position &position,
                            int id = -1) {
  ParticleData p{ParticleType::find(0x661), id};
  p.set_4position(position);
  p.set_4momentum(momentum);
  return p;
}
inline ParticleData smashon_random(int id = -1) {
  auto random_value = random::make_uniform_distribution(-15.0, +15.0);
  ParticleData p{ParticleType::find(0x661), id};
  p.set_4position(
      {random_value(), random_value(), random_value(), random_value()});
  p.set_4momentum(smashon_mass,
                  {random_value(), random_value(), random_value()});
  return p;
}
 
inline Configuration configuration(std::string overrides = {}) {
  Configuration c{bf::path{TEST_CONFIG_PATH} / "input"};
  if (!overrides.empty()) {
    c.merge_yaml(overrides);
  }
  return c;
}
 
inline std::unique_ptr<ExperimentBase> experiment(
    const Configuration &c = configuration()) {
  return ExperimentBase::create(c, ".");
}
 
inline std::unique_ptr<ExperimentBase> experiment(const char *configOverrides) {
  return ExperimentBase::create(configuration(configOverrides), ".");
}
 
template <typename G>
inline ParticleList create_particle_list(std::size_t n, G &&generator) {
  ParticleList list;
  list.reserve(n);
  for (auto i = n; i; --i) {
    list.emplace_back(generator());
  }
  return list;
}
 
using ParticlesPtr = std::unique_ptr<Particles>;
 
template <typename G>
inline ParticlesPtr create_particles(int n, G &&generator) {
  ParticlesPtr p = make_unique<Particles>();
  for (auto i = n; i; --i) {
    p->insert(generator());
  }
  return p;
}
 
inline ParticlesPtr create_particles(
    const std::initializer_list<ParticleData> &init) {
  ParticlesPtr p = make_unique<Particles>();
  for (const auto &data : init) {
    p->insert(data);
  }
  return p;
}
 
inline ReactionsBitSet all_reactions_included() {
  return ReactionsBitSet().set();
}
 
inline ExperimentParameters default_parameters(int testparticles = 1,
                                               double dt = 0.1) {
  return ExperimentParameters{make_unique<UniformClock>(0., dt),  // labclock
                              make_unique<UniformClock>(0., 1.),  // outputclock
                              testparticles,  // testparticles
                              1.0,            // Gaussian smearing width
                              4.0,            // Gaussian smearing cut-off
                              true,           // two_to_one
                              all_reactions_included(),
                              false,  // strings switch
                              false,  // use_AQM
                              1.0,
                              false,  // string_with_probability
                              NNbarTreatment::NoAnnihilation,
                              0.,      // low energy sigma_NN cut-off
                              false};  // potential_affect_threshold
}
 
}  // namespace Test
}  // namespace smash
 
#endif  // SRC_TESTS_SETUP_H_