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/outputinterface.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 MultiParticleReactionsBitSet no_multiparticle_reactions() {
  return MultiParticleReactionsBitSet().reset();
}
 
inline ExperimentParameters default_parameters(
    int testparticles = 1, double dt = 0.1,
    CollisionCriterion crit = CollisionCriterion::Geometric) {
  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
      crit,
      true,  // two_to_one
      all_reactions_included(),
      no_multiparticle_reactions(),
      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
      -1.0,   // box_length
      200.0,  // max. cross section
      1.0,    // cross section scaling
      0.0     // additional elastic cross section
  };
}
 
inline EventInfo default_event_info(double impact_parameter = 0.0,
                                    bool empty_event = false) {
  return EventInfo{impact_parameter, 0.0, 0.0, 0.0, 0.0, 0.0, 1, empty_event};
}
 
}  // namespace Test
}  // namespace smash
 
#endif  // SRC_TESTS_SETUP_H_