#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:

[legend]

Collaboration diagram for smash::BoxModus:

[legend]

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, 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

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

int	total_N_number () const

int	proj_N_number () const

bool	cll_in_nucleus () const

bool	is_collider () const

bool	is_box () const

bool	is_list () const

double	sqrt_s_NN () const

double	impact_parameter () const

double	velocity_projectile () const

double	velocity_target () const

FermiMotion	fermi_motion () const

double	max_timestep (double) const

double	equilibration_time () 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, CellSizeStrategy strategy=CellSizeStrategy::Optimal) const
	Creates the Grid with normal boundary conditions. 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/c. 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 bool	insert_jet_ = false
	Whether to insert a single high energy particle at the center of the box (0,0,0). More...

const PdgCode	jet_pdg_
	Pdg of the particle to use as a jet; necessary if insert_jet_ is true, unused otherwise. 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)

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 219 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_)),
       insert_jet_(modus_config.has_value({"Box", "Jet", "Jet_PDG"})),
       jet_pdg_(insert_jet_ ? modus_config.take({"Box", "Jet", "Jet_PDG"})
                                  .convert_for(jet_pdg_)
                            : pdg::p),  // dummy default; never used
       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 253 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 = 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 (insert_jet_) {
     auto &jet_particle = particles->create(jet_pdg_);
     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_).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_;
 }

Here is the call graph for this function:

◆ 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 365 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 =
           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;
 }

Here is the call graph for this function:

◆ create_grid()

Grid<GridOptions::PeriodicBoundaries> smash::BoxModus::create_grid	(	const Particles &	particles,
		double	min_cell_length,
		double	timestep_duration,
		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]	strategy	The strategy to determine the cell size

Returns: the Grid object

See also: Grid::Grid

Definition at line 94 of file boxmodus.h.

                                                                  {
     return {{{0, 0, 0}, {length_, length_, length_}},
             particles,
             min_cell_length,
             timestep_duration,
             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 111 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 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 121 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 126 of file boxmodus.h.

126 { return equilibration_time_; }

◆ is_box()

bool smash::BoxModus::is_box ( ) const

inline

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

Definition at line 128 of file boxmodus.h.

128 { return true; }

Member Data Documentation

◆ initial_condition_

const BoxInitialCondition smash::BoxModus::initial_condition_

private

Initial momenta distribution: thermal or peaked momenta.

Definition at line 132 of file boxmodus.h.

◆ length_

const double smash::BoxModus::length_

private

Length of the cube's edge in fm/c.

Definition at line 134 of file boxmodus.h.

◆ equilibration_time_

const double smash::BoxModus::equilibration_time_

private

time after which output is written

Definition at line 136 of file boxmodus.h.

◆ temperature_

const double smash::BoxModus::temperature_

private

Temperature of the Box in GeV.

Definition at line 138 of file boxmodus.h.

◆ start_time_

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

private

Initial time of the box.

Definition at line 140 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 145 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 150 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 155 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 160 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 166 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 171 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 176 of file boxmodus.h.

◆ insert_jet_

const bool smash::BoxModus::insert_jet_ = false

private

Whether to insert a single high energy particle at the center of the box (0,0,0).

This particle will initially be moving along the x-axis.

Definition at line 182 of file boxmodus.h.

◆ jet_pdg_

const PdgCode smash::BoxModus::jet_pdg_

private

Pdg of the particle to use as a jet; necessary if insert_jet_ is true, unused otherwise.

Definition at line 187 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 191 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()

Member Data Documentation

◆ initial_condition_

◆ length_

◆ equilibration_time_

◆ temperature_

◆ start_time_

◆ use_thermal_

◆ mub_

◆ mus_

◆ muq_

◆ account_for_resonance_widths_

◆ init_multipl_

◆ average_multipl_

◆ insert_jet_

◆ jet_pdg_

◆ jet_mom_