boxmodus.h

Go to the documentation of this file.

/*
 *    Copyright (c) 2012-2023
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 */
#ifndef SRC_INCLUDE_SMASH_BOXMODUS_H_
#define SRC_INCLUDE_SMASH_BOXMODUS_H_
 
#include <map>
#include <memory>
 
#include "forwarddeclarations.h"
#include "modusdefault.h"
 
namespace smash {
 
class BoxModus : public ModusDefault {
 public:
  explicit BoxModus(Configuration modus_config,
                    const ExperimentParameters &parameters);
 
  double initial_conditions(Particles *particles,
                            const ExperimentParameters &parameters);
 
  int impose_boundary_conditions(Particles *particles,
                                 const OutputsList &output_list = {});
 
  Grid<GridOptions::PeriodicBoundaries> 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 {{{0, 0, 0}, {length_, length_, length_}},
            particles,
            min_cell_length,
            timestep_duration,
            limit,
            include_unformed_particles,
            strategy};
  }
 
  std::unique_ptr<GrandCanThermalizer> create_grandcan_thermalizer(
      Configuration &conf) const {
    const std::array<double, 3> lat_size = {length_, length_, length_};
    const std::array<double, 3> origin = {0., 0., 0.};
    const bool periodicity = true;
    return std::make_unique<GrandCanThermalizer>(conf, lat_size, origin,
                                                 periodicity);
  }
 
  double max_timestep(double max_transverse_distance_sqr) const {
    return 0.5 * std::sqrt(length_ * length_ - max_transverse_distance_sqr);
  }
 
  double equilibration_time() const { return equilibration_time_; }
  bool is_box() const { return true; }
  double length() const { return length_; }
 
 private:
  const BoxInitialCondition initial_condition_;
  const double length_;
  const double equilibration_time_;
  const double temperature_;
  const double start_time_ = 0.;
  const bool use_thermal_ = false;
  const double mub_;
  const double mus_;
  const double muq_;
  const bool account_for_resonance_widths_;
  const std::map<PdgCode, int> init_multipl_;
  std::map<PdgCode, double> average_multipl_;
  const std::optional<PdgCode> jet_pdg_;
  const double jet_mom_;
 
  friend std::ostream &operator<<(std::ostream &out, const BoxModus &m);
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_BOXMODUS_H_