#include <boxmodus.h>

BoxModus: Provides a modus for infinite matter calculations.

Matter is confined in a cubical box. Depending on the initial condition, particles are either reflected on the boundaries (not implemented now) or inserted on opposite positions.

To use this modus, choose Modus: Box

General:

Modus: Box

in the configuration file.

Options for BoxModus go in the "Modi"→"Box" section of the configuration:

Modi:
     Box:
             # definitions here

The following configuration options are understood: Box

Definition at line 46 of file boxmodus.h.

Inheritance diagram for smash::BoxModus:

Public Member Functions
	BoxModus (Configuration modus_config, const ExperimentParameters &parameters)
	Constructor. More...

double	initial_conditions (Particles *particles, const ExperimentParameters &parameters)
	Generates initial state of the particles in the system according to specified parameters: number of particles of each species, momentum and coordinate space distributions. More...

int	impose_boundary_conditions (Particles *particles, const OutputsList &output_list={})
	Enforces that all particles are inside the box at the beginning of an event. More...

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
	Creates the Grid with normal boundary conditions. More...

std::unique_ptr< GrandCanThermalizer >	create_grandcan_thermalizer (Configuration &conf) const
	Creates GrandCanThermalizer. More...

double	max_timestep (double max_transverse_distance_sqr) const

double	equilibration_time () const

bool	is_box () const

double	length () const

Public Member Functions inherited from smash::ModusDefault
int	impose_boundary_conditions (Particles *, const OutputsList &={})
	Enforces sensible positions for the particles. More...

bool	is_collider () const

bool	is_box () const

bool	is_list () const

bool	is_sphere () const

double	sqrt_s_NN () const

double	impact_parameter () const

void	sample_impact () const
	sample impact parameter for collider modus More...

double	velocity_projectile () const

double	velocity_target () const

FermiMotion	fermi_motion () const

double	max_timestep (double) const

double	equilibration_time () const

double	length () const

double	radius () const

bool	calculation_frame_is_fixed_target () const

double	nuclei_passing_time () const
	Get the passing time of the two nuclei in a collision. More...

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
	Creates the Grid with normal boundary conditions. More...

std::unique_ptr< GrandCanThermalizer >	create_grandcan_thermalizer (Configuration &conf) const
	Creates GrandCanThermalizer. More...

Private Attributes
const BoxInitialCondition	initial_condition_
	Initial momenta distribution: thermal or peaked momenta. More...

const double	length_
	Length of the cube's edge in fm. More...

const double	equilibration_time_
	time after which output is written More...

const double	temperature_
	Temperature of the Box in GeV. More...

const double	start_time_ = 0.
	Initial time of the box. More...

const bool	use_thermal_ = false
	Whether to use a thermal initialization for all particles instead of specific numbers. More...

const double	mub_
	Baryon chemical potential for thermal initialization; only used if use_thermal_ is true. More...

const double	mus_
	Strange chemical potential for thermal initialization; only used if use_thermal_ is true. More...

const double	muq_
	Charge chemical potential for thermal initialization; only used if use_thermal_ is true. More...

const bool	account_for_resonance_widths_
	In case of thermal initialization: true – account for resonance spectral functions, while computing multiplicities and sampling masses, false – simply use pole masses. More...

const std::map< PdgCode, int >	init_multipl_
	Particle multiplicities at initialization; required if use_thermal_ is false. More...

std::map< PdgCode, double >	average_multipl_
	Average multiplicities in case of thermal initialization. More...

const std::optional< PdgCode >	jet_pdg_
	Optional PDG code of the particle to use as a jet. More...

const double	jet_mom_
	Initial momentum of the jet particle; only used if insert_jet_ is true. More...

Friends
std::ostream &	operator<< (std::ostream &out, const BoxModus &m)
	Console output on startup of box specific parameters; writes the initial state for the box to the output stream. More...

Constructor & Destructor Documentation

◆ BoxModus()

smash::BoxModus::BoxModus	(	Configuration	modus_config,
		const ExperimentParameters &	parameters
	)

explicit

Constructor.

Gathers all configuration variables for the Box.

Parameters

[in]	modus_config	The configuration object that sets all initial conditions of the experiment.
[in]	parameters	Unused, but necessary because of templated initialization

Definition at line 65 of file boxmodus.cc.

     : initial_condition_(modus_config.take({"Box", "Initial_Condition"})),
       length_(modus_config.take({"Box", "Length"})),
       equilibration_time_(
           modus_config.take({"Box", "Equilibration_Time"}, -1.)),
       temperature_(modus_config.take({"Box", "Temperature"})),
       start_time_(modus_config.take({"Box", "Start_Time"}, 0.)),
       use_thermal_(
           modus_config.take({"Box", "Use_Thermal_Multiplicities"}, false)),
       mub_(modus_config.take({"Box", "Baryon_Chemical_Potential"}, 0.)),
       mus_(modus_config.take({"Box", "Strange_Chemical_Potential"}, 0.)),
       muq_(modus_config.take({"Box", "Charge_Chemical_Potential"}, 0.)),
       account_for_resonance_widths_(
           modus_config.take({"Box", "Account_Resonance_Widths"}, true)),
       init_multipl_(use_thermal_
                         ? std::map<PdgCode, int>()
                         : modus_config.take({"Box", "Init_Multiplicities"})
                               .convert_for(init_multipl_)),
       /* Note that it is crucial not to take other keys from the Jet section
        * before Jet_PDG, since we want here the take to throw in case the user
        * had a Jet section without the mandatory Jet_PDG key. If all other keys
        * are taken first, the section is removed from modus_config, because
        * empty, and that has_value({"Box", "Jet"}) method would return false.
        */
       jet_pdg_(modus_config.has_value({"Box", "Jet"})
                    ? make_optional<PdgCode>(
                          modus_config.take({"Box", "Jet", "Jet_PDG"}))
                    : std::nullopt),
  
       jet_mom_(modus_config.take({"Box", "Jet", "Jet_Momentum"}, 20.)) {
   if (parameters.res_lifetime_factor < 0.) {
     throw std::invalid_argument(
         "Resonance lifetime modifier cannot be negative!");
   }
   // Check consistency, just in case
   if (std::abs(length_ - parameters.box_length) > really_small) {
     throw std::runtime_error("Box length inconsistency");
   }
 }

Member Function Documentation

◆ initial_conditions()

double smash::BoxModus::initial_conditions	(	Particles *	particles,
		const ExperimentParameters &	parameters
	)

Generates initial state of the particles in the system according to specified parameters: number of particles of each species, momentum and coordinate space distributions.

Subsequently makes the total 3-momentum 0.

Parameters

[out]	particles	An empty list that gets filled up by this function
[in]	parameters	The initialization parameters of the box

Returns: The starting time of the simulation

Initialize formation time

Definition at line 106 of file boxmodus.cc.

                                                                             {
   double momentum_radial = 0.0, mass = 0.0;
   Angles phitheta;
   FourVector momentum_total(0, 0, 0, 0);
   auto uniform_length = random::make_uniform_distribution(0.0, this->length_);
   const double T = this->temperature_;
   const double V = length_ * length_ * length_;
   /* Create NUMBER OF PARTICLES according to configuration, or thermal case */
   if (use_thermal_) {
     if (average_multipl_.empty()) {
       for (const ParticleType &ptype : ParticleType::list_all()) {
         if (HadronGasEos::is_eos_particle(ptype)) {
           const double lifetime_factor =
               ptype.is_stable() ? 1. : parameters.res_lifetime_factor;
           const double n = lifetime_factor * HadronGasEos::partial_density(
                                                  ptype, T, mub_, mus_, muq_,
                                                  account_for_resonance_widths_);
           average_multipl_[ptype.pdgcode()] = n * V * parameters.testparticles;
         }
       }
     }
     double nb_init = 0.0, ns_init = 0.0, nq_init = 0.0;
     for (const auto &mult : average_multipl_) {
       const int thermal_mult_int = random::poisson(mult.second);
       particles->create(thermal_mult_int, mult.first);
       nb_init += mult.second * mult.first.baryon_number();
       ns_init += mult.second * mult.first.strangeness();
       nq_init += mult.second * mult.first.charge();
       logg[LBox].debug(mult.first, " initial multiplicity ", thermal_mult_int);
     }
     logg[LBox].info("Initial hadron gas baryon density ", nb_init);
     logg[LBox].info("Initial hadron gas strange density ", ns_init);
     logg[LBox].info("Initial hadron gas charge density ", nq_init);
   } else {
     for (const auto &p : init_multipl_) {
       particles->create(p.second * parameters.testparticles, p.first);
       logg[LBox].debug("Particle ", p.first, " initial multiplicity ",
                        p.second);
     }
   }
   std::unique_ptr<QuantumSampling> quantum_sampling;
   if (this->initial_condition_ == BoxInitialCondition::ThermalMomentaQuantum) {
     quantum_sampling = std::make_unique<QuantumSampling>(init_multipl_, V, T);
   }
   for (ParticleData &data : *particles) {
     /* Set MOMENTUM SPACE distribution */
     if (this->initial_condition_ == BoxInitialCondition::PeakedMomenta) {
       /* initial thermal momentum is the average 3T */
       momentum_radial = 3.0 * T;
       mass = data.pole_mass();
     } else {
       if (this->initial_condition_ ==
           BoxInitialCondition::ThermalMomentaBoltzmann) {
         /* thermal momentum according Maxwell-Boltzmann distribution */
         mass = (!account_for_resonance_widths_)
                    ? data.type().mass()
                    : HadronGasEos::sample_mass_thermal(data.type(), 1.0 / T);
         momentum_radial = sample_momenta_from_thermal(T, mass);
       } else if (this->initial_condition_ ==
                  BoxInitialCondition::ThermalMomentaQuantum) {
         /*
          * Sampling the thermal momentum according Bose/Fermi/Boltzmann
          * distribution.
          * We take the pole mass as the mass.
          */
         mass = data.type().mass();
         momentum_radial = quantum_sampling->sample(data.pdgcode());
       }
     }
     phitheta.distribute_isotropically();
     logg[LBox].debug(data.type().name(), "(id ", data.id(),
                      ") radial momentum ", momentum_radial, ", direction",
                      phitheta);
     data.set_4momentum(mass, phitheta.threevec() * momentum_radial);
     momentum_total += data.momentum();
  
     /* Set COORDINATE SPACE distribution */
     ThreeVector pos{uniform_length(), uniform_length(), uniform_length()};
     data.set_4position(FourVector(start_time_, pos));
     data.set_formation_time(start_time_);
   }
  
   /* Make total 3-momentum 0 */
   for (ParticleData &data : *particles) {
     data.set_4momentum(data.momentum().abs(),
                        data.momentum().threevec() -
                            momentum_total.threevec() / particles->size());
   }
  
   /* Add a single highly energetic particle in the center of the box (jet) */
   if (jet_pdg_) {
     auto &jet_particle = particles->create(jet_pdg_.value());
     jet_particle.set_formation_time(start_time_);
     jet_particle.set_4position(FourVector(start_time_, 0., 0., 0.));
     jet_particle.set_4momentum(ParticleType::find(jet_pdg_.value()).mass(),
                                ThreeVector(jet_mom_, 0., 0.));
   }
  
   /* Recalculate total momentum */
   momentum_total = FourVector(0, 0, 0, 0);
   for (ParticleData &data : *particles) {
     momentum_total += data.momentum();
     /* IC: debug checks */
     logg[LBox].debug() << data;
   }
   /* allows to check energy conservation */
   logg[LBox].debug() << "Initial total 4-momentum [GeV]: " << momentum_total;
   return start_time_;
 }

◆ impose_boundary_conditions()

int smash::BoxModus::impose_boundary_conditions	(	Particles *	particles,
		const OutputsList &	output_list = `{}`
	)

Enforces that all particles are inside the box at the beginning of an event.

It checks if the particles were placed correctly inside the box at initialization and places them inside if they are not.

Parameters

[in]	particles	particles to check their position and possibly move it
[in]	output_list	output objects

Returns: The number of particles that were put back into the box

In BoxModus if a particle crosses the wall of the box, it is inserted from the opposite side. However these wall crossings are not performed by this function but in the Experiment constructor when the WallCrossActionsFinder are created. Wall crossings are written to collision output: this is where OutputsList is used.

Definition at line 218 of file boxmodus.cc.

                                                                          {
   int wraps = 0;
  
   for (ParticleData &data : *particles) {
     FourVector position = data.position();
     bool wall_hit = enforce_periodic_boundaries(position.begin() + 1,
                                                 position.end(), length_);
     if (wall_hit) {
       const ParticleData incoming_particle(data);
       data.set_4position(position);
       ++wraps;
       ActionPtr action =
           std::make_unique<WallcrossingAction>(incoming_particle, data);
       for (const auto &output : output_list) {
         if (!output->is_dilepton_output() && !output->is_photon_output()) {
           output->at_interaction(*action, 0.);
         }
       }
     }
   }
   logg[LBox].debug("Moved ", wraps, " particles back into the box.");
   return wraps;
 }

◆ create_grid()

Grid<GridOptions::PeriodicBoundaries> smash::BoxModus::create_grid	(	const Particles &	particles,
		double	min_cell_length,
		double	timestep_duration,
		CollisionCriterion	crit,
		const bool	include_unformed_particles,
		CellSizeStrategy	strategy = `CellSizeStrategy::Optimal`
	)		const

inline

Creates the Grid with normal boundary conditions.

Parameters

[in]	particles	The Particles object containing all particles of the currently running Experiment.
[in]	min_cell_length	The minimal length of the grid cells.
[in]	timestep_duration	Duration of the timestep. It is necessary for formation times treatment: if particle is fully or partially formed before the end of the timestep, it has to be on the grid.
[in]	crit	Collision criterion (decides if cell number can be limited)
[in]	include_unformed_particles	include unformed particles from the grid (worsens runtime, necessary for IC output)
[in]	strategy	The strategy to determine the cell size

Returns: the Grid object

See also: Grid::Grid

Definition at line 94 of file boxmodus.h.

                                                                  {
     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};
   }

◆ create_grandcan_thermalizer()

std::unique_ptr<GrandCanThermalizer> smash::BoxModus::create_grandcan_thermalizer ( Configuration & conf ) const

inline

Creates GrandCanThermalizer.

(Special Box implementation.)

Parameters

[in] conf configuration object

Returns: unique pointer to created thermalizer class

Definition at line 118 of file boxmodus.h.

                                  {
     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);
   }

◆ max_timestep()

double smash::BoxModus::max_timestep ( double max_transverse_distance_sqr ) const

inline

Returns: Maximal timestep accepted by this modus. Negative means infinity.

Definition at line 128 of file boxmodus.h.

                                                                 {
     return 0.5 * std::sqrt(length_ * length_ - max_transverse_distance_sqr);
   }

◆ equilibration_time()

double smash::BoxModus::equilibration_time ( ) const

inline

Returns: equilibration time of the box

Definition at line 133 of file boxmodus.h.

133 { return equilibration_time_; }

◆ is_box()

bool smash::BoxModus::is_box ( ) const

inline

Returns: whether the modus is box (also, trivially true)

Definition at line 135 of file boxmodus.h.

135 { return true; }

◆ length()

double smash::BoxModus::length ( ) const

inline

Returns: length of the box

Definition at line 137 of file boxmodus.h.

137 { return length_; }

Member Data Documentation

◆ initial_condition_

const BoxInitialCondition smash::BoxModus::initial_condition_

private

Initial momenta distribution: thermal or peaked momenta.

Definition at line 141 of file boxmodus.h.

◆ length_

const double smash::BoxModus::length_

private

Length of the cube's edge in fm.

Definition at line 143 of file boxmodus.h.

◆ equilibration_time_

const double smash::BoxModus::equilibration_time_

private

time after which output is written

Definition at line 145 of file boxmodus.h.

◆ temperature_

const double smash::BoxModus::temperature_

private

Temperature of the Box in GeV.

Definition at line 147 of file boxmodus.h.

◆ start_time_

const double smash::BoxModus::start_time_ = 0.

private

Initial time of the box.

Definition at line 149 of file boxmodus.h.

◆ use_thermal_

const bool smash::BoxModus::use_thermal_ = false

private

Whether to use a thermal initialization for all particles instead of specific numbers.

Definition at line 154 of file boxmodus.h.

◆ mub_

const double smash::BoxModus::mub_

private

Baryon chemical potential for thermal initialization; only used if use_thermal_ is true.

Definition at line 159 of file boxmodus.h.

◆ mus_

const double smash::BoxModus::mus_

private

Strange chemical potential for thermal initialization; only used if use_thermal_ is true.

Definition at line 164 of file boxmodus.h.

◆ muq_

const double smash::BoxModus::muq_

private

Charge chemical potential for thermal initialization; only used if use_thermal_ is true.

Definition at line 169 of file boxmodus.h.

◆ account_for_resonance_widths_

const bool smash::BoxModus::account_for_resonance_widths_

private

In case of thermal initialization: true – account for resonance spectral functions, while computing multiplicities and sampling masses, false – simply use pole masses.

Definition at line 175 of file boxmodus.h.

◆ init_multipl_

const std::map<PdgCode, int> smash::BoxModus::init_multipl_

private

Particle multiplicities at initialization; required if use_thermal_ is false.

Definition at line 180 of file boxmodus.h.

◆ average_multipl_

std::map<PdgCode, double> smash::BoxModus::average_multipl_

private

Average multiplicities in case of thermal initialization.

Saved to avoid recalculating at every event

Definition at line 185 of file boxmodus.h.

◆ jet_pdg_

const std::optional<PdgCode> smash::BoxModus::jet_pdg_

private

Optional PDG code of the particle to use as a jet.

Same setup as in the sphere modus case.

Definition at line 190 of file boxmodus.h.

◆ jet_mom_

const double smash::BoxModus::jet_mom_

private

Initial momentum of the jet particle; only used if insert_jet_ is true.

Definition at line 194 of file boxmodus.h.

The documentation for this class was generated from the following files:

src/include/smash/boxmodus.h
src/boxmodus.cc

Public Member Functions

Private Attributes

Friends

Constructor & Destructor Documentation

◆ BoxModus()

Member Function Documentation

◆ initial_conditions()

◆ impose_boundary_conditions()

◆ create_grid()

◆ create_grandcan_thermalizer()

◆ max_timestep()

◆ equilibration_time()

◆ is_box()

◆ length()

Member Data Documentation

◆ initial_condition_

◆ length_

◆ equilibration_time_

◆ temperature_

◆ start_time_

◆ use_thermal_

◆ mub_

◆ mus_

◆ muq_

◆ account_for_resonance_widths_

◆ init_multipl_

◆ average_multipl_

◆ jet_pdg_

◆ jet_mom_