modusdefault.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2013-2022,2024
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_MODUSDEFAULT_H_
#define SRC_INCLUDE_SMASH_MODUSDEFAULT_H_
 
#include <map>
#include <memory>
#include <vector>
 
#include "configuration.h"
#include "forwarddeclarations.h"
#include "fourvector.h"
#include "grandcan_thermalizer.h"
#include "grid.h"
#include "icparameters.h"
#include "outputinterface.h"
#include "potentials.h"
 
namespace smash {
class ModusDefault {
 public:
  // Never needs a virtual destructor.
 
  // Missing functions for concrete Modus implementations:
  // \todo(JB): Why is the function below commented out?
  // double initial_conditions(Particles *particles);
 
  int impose_boundary_conditions(Particles* /*p*/,
                                 const OutputsList& /*out_list*/ = {}) {
    return 0;
  }
 
  bool is_collider() const { return false; }
  bool is_box() const { return false; }
  bool is_list() const { return false; }
  bool is_sphere() const { return false; }
  double sqrt_s_NN() const { return 0.; }
  double impact_parameter() const { return -1.; }
  void sample_impact() const {}
  double velocity_projectile() const { return 0.0; }
  double velocity_target() const { return 0.0; }
  FermiMotion fermi_motion() const { return FermiMotion::Off; }
  double max_timestep(double) const { return -1.; }
  double equilibration_time() const { return -1.; }
  double length() const { return -1.; }
  double radius() const { return -1.; }
  bool calculation_frame_is_fixed_target() const { return false; }
  double nuclei_passing_time() const { return 0.0; }
  bool is_IC_for_hybrid() const { return false; }
  const InitialConditionParameters& IC_parameters() const {
    throw std::logic_error(
        "Only ColliderModus has parameters for initial conditions.");
  }
  const std::map<int32_t, double>& fluid_background() {
    throw std::logic_error("Only ColliderModus has a fluid background.");
  }
  const RectangularLattice<EnergyMomentumTensor>& fluid_lattice() {
    throw std::logic_error("Only ColliderModus has a fluid lattice.");
  }
 
  void build_fluidization_lattice(
      [[maybe_unused]] const double t,
      [[maybe_unused]] const std::vector<Particles>& ensembles,
      [[maybe_unused]] const DensityParameters& dens_par) {}
  Grid<GridOptions::Normal> create_grid(
      const Particles& particles, double min_cell_length,
      double timestep_duration, CollisionCriterion crit,
      const bool include_unformed_particles,
      CellSizeStrategy strategy = CellSizeStrategy::Optimal) const {
    CellNumberLimitation limit = CellNumberLimitation::ParticleNumber;
    if (crit == CollisionCriterion::Stochastic) {
      limit = CellNumberLimitation::None;
    }
    return {particles,
            min_cell_length,
            timestep_duration,
            limit,
            include_unformed_particles,
            strategy};
  }
 
  std::unique_ptr<GrandCanThermalizer> create_grandcan_thermalizer(
      Configuration& conf) const {
    /* Lattice is placed such that the center is 0,0,0.
       If one wants to have a central cell with center at 0,0,0 then
       number of cells should be odd (2k+1) in every direction.
     */
    const std::array<double, 3> l =
        conf.take(InputKeys::forcedThermalization_latticeSizes);
    const std::array<double, 3> origin = {-0.5 * l[0], -0.5 * l[1],
                                          -0.5 * l[2]};
    const bool periodicity = false;
    return std::make_unique<GrandCanThermalizer>(conf, l, origin, periodicity);
  }
 
  struct BadInput : public std::invalid_argument {
    using std::invalid_argument::invalid_argument;
  };
  struct InvalidEnergy : public BadInput {
    using BadInput::BadInput;
  };
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_MODUSDEFAULT_H_