#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	length () 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_list () const

double	impact_parameter () const

double	velocity_projectile () const

double	velocity_target () const

FermiMotion	fermi_motion () const

double	max_timestep (double) const

double	length () 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	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 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)
	Console output on startup of box specific parameters; writes the initial state for the box to the output stream. More...

Constructor & Destructor Documentation

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 205 of file boxmodus.cc.

     : initial_condition_(modus_config.take({"Box", "Initial_Condition"})),
       length_(modus_config.take({"Box", "Length"})),
       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.)),
       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.)) {}

Member Function Documentation

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 226 of file boxmodus.cc.

                                                                             {
   const auto &log = logger<LogArea::Box>();
   double momentum_radial = 0, mass;
   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_;
   /* Create NUMBER OF PARTICLES according to configuration, or thermal case */
   if (use_thermal_) {
     const double V = length_ * length_ * length_;
     if (average_multipl_.empty()) {
       for (const ParticleType &ptype : ParticleType::list_all()) {
         if (HadronGasEos::is_eos_particle(ptype)) {
           const double n = HadronGasEos::partial_density(
               ptype, T, mub_, mus_, account_for_resonance_widths_);
           average_multipl_[ptype.pdgcode()] = n * V * parameters.testparticles;
         }
       }
     }
     double nb_init = 0.0, ns_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();
       log.debug(mult.first, " initial multiplicity ", thermal_mult_int);
     }
     log.info("Initial hadron gas baryon density ", nb_init);
     log.info("Initial hadron gas strange density ", ns_init);
   } else {
     for (const auto &p : init_multipl_) {
       particles->create(p.second * parameters.testparticles, p.first);
       log.debug("Particle ", p.first, " initial multiplicity ", p.second);
     }
   }
 
   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 {
       /* 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);
     }
     phitheta.distribute_isotropically();
     log.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 */
     log.debug() << data;
   }
   /* allows to check energy conservation */
   log.debug() << "Initial total 4-momentum [GeV]: " << momentum_total;
   return start_time_;
 }

Here is the call graph for this function:

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 317 of file boxmodus.cc.

                                                                          {
   const auto &log = logger<LogArea::Box>();
   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.);
         }
       }
     }
   }
   log.debug("Moved ", wraps, " particles back into the box.");
   return wraps;
 }

Here is the call graph for this function:

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

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

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

double smash::BoxModus::length ( ) const

inline

Returns: Length of the box

Definition at line 126 of file boxmodus.h.

126 { return length_; }

smash::BoxModus::length_

const double length_

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

Definition: boxmodus.h:132

Member Data Documentation

const BoxInitialCondition smash::BoxModus::initial_condition_

private

Initial momenta distribution: thermal or peaked momenta.

Definition at line 130 of file boxmodus.h.

const double smash::BoxModus::length_

private

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

Definition at line 132 of file boxmodus.h.

const double smash::BoxModus::temperature_

private

Temperature of the Box in GeV.

Definition at line 134 of file boxmodus.h.

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

private

Initial time of the box.

Definition at line 136 of file boxmodus.h.

const bool smash::BoxModus::use_thermal_ = false

private

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

Definition at line 141 of file boxmodus.h.

const double smash::BoxModus::mub_

private

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

Definition at line 146 of file boxmodus.h.

const double smash::BoxModus::mus_

private

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

Definition at line 151 of file boxmodus.h.

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 157 of file boxmodus.h.

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

private

Particle multiplicities at initialization; required if use_thermal_ is false.

Definition at line 162 of file boxmodus.h.

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 167 of file boxmodus.h.

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 173 of file boxmodus.h.

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 178 of file boxmodus.h.

const double smash::BoxModus::jet_mom_

private

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

Definition at line 182 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

Member Function Documentation

Member Data Documentation