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

double	impact_parameter () const

double	velocity_projectile () const

double	velocity_target () const

FermiMotion	fermi_motion () const

double	max_timestep (double) const

double	length () const

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

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 161 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.)),
       init_multipl_(use_thermal_
                         ? std::map<PdgCode, int>()
                         : modus_config.take({"Box", "Init_Multiplicities"})
                               .convert_for(init_multipl_)) {}

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 175 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_);
           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 = 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());
   }
 
   /* 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.

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. Wall crossings are written to collision output: this is where OutputsList is used.

Definition at line 254 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 90 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 107 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 117 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 122 of file boxmodus.h.

122 { return length_; }

smash::BoxModus::length_

const double length_

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

Definition: boxmodus.h:128

Member Data Documentation

const BoxInitialCondition smash::BoxModus::initial_condition_

private

Initial momenta distribution: thermal or peaked momenta.

Definition at line 126 of file boxmodus.h.

const double smash::BoxModus::length_

private

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

Definition at line 128 of file boxmodus.h.

const double smash::BoxModus::temperature_

private

Temperature of the Box in GeV.

Definition at line 130 of file boxmodus.h.

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

private

Initial time of the box.

Definition at line 132 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 137 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 142 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 147 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 152 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 157 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