#include <spheremodus.h>

SphereModus: Provides a modus for expanding matter calculations.

Matter is put in a sphere of radius R with uniform density; isotropic thermal momenta are typically used for initialization, although other initial momentum states are also included, see Bazow:2016oky [8] and Tindall:2016try [63]

To use this modus, choose

General:

Modus: Sphere

in the configuration file.

Options for SphereModus go in the "Modi"→"Sphere" section of the configuration:

Modi:
     Sphere:
             # definitions here

The following configuration options are understood: Sphere

Definition at line 49 of file spheremodus.h.

Inheritance diagram for smash::SphereModus:

Public Member Functions
	SphereModus (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...

bool	is_sphere () const

double	radius () 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...

bool	is_IC_for_hybrid () const

const InitialConditionParameters &	IC_parameters () const

const std::map< int32_t, double > &	fluid_background ()

const RectangularLattice< EnergyMomentumTensor > &	fluid_lattice ()

void	build_fluidization_lattice ([[maybe_unused]] const double t, [[maybe_unused]] const std::vector< Particles > &ensembles, [[maybe_unused]] const DensityParameters &dens_par)
	Build lattice of energy momentum tensor. 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
double	radius_
	Sphere radius (in fm) More...

double	sphere_temperature_
	Temperature for momentum distribution (in GeV) More...

const double	start_time_ = 0.
	Starting time for the Sphere. 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 double	hf_multiplier_
	Multiplicative factor for thermal multiplicity of heavy flavored hadrons; only used if `use_thermal_` is true. More...

const bool	account_for_resonance_widths_
	In case of thermal initialization: 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 SphereInitialCondition	init_distr_
	Initialization scheme for momenta in the sphere; used for expanding metric setup. More...

const double	radial_velocity_
	Parameter \( u_0\) in the initial flow velocity profile of particles in the sphere, which has the form \( u = u_0 (r / R)^n\). More...

const double	radial_velocity_exponent_
	Parameter \( n\) in the initial flow velocity profile of particles in the sphere, which has the form \( u = u_0 (r / R)^n\). More...

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

const double	jet_mom_
	Initial momentum of the jet particle; only used if jet_pdg_ is not nullopt. More...

const ThreeVector	jet_pos_
	Initial position of the jet particle; only used if jet_pdg_ is not nullopt. More...

const bool	jet_back_
	Create the back to back jet with the corresponding antiparticle; only used if jet_pdg_ is not nullopt. More...

const double	jet_back_separation_ = smash_NaN<double>
	Initial separation between the back to back jets; can only be set by the user if jet_back_ is true. More...

const SpinInteractionType	spin_interaction_type_
	Spin interaction type. More...

Friends
std::ostream &	operator<< (std::ostream &out, const SphereModus &m)
	Writes the initial state for the Sphere to the output stream. More...

Constructor & Destructor Documentation

◆ SphereModus()

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

explicit

Constructor.

Takes all there is to take from the (truncated!) configuration object (only contains configuration for this modus).

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 37 of file spheremodus.cc.

     : radius_(modus_config.take(InputKeys::modi_sphere_radius)),
       sphere_temperature_(
           modus_config.take(InputKeys::modi_sphere_temperature)),
       start_time_(modus_config.take(InputKeys::modi_sphere_startTime)),
       use_thermal_(
           modus_config.take(InputKeys::modi_sphere_useThermalMultiplicities)),
       mub_(modus_config.take(InputKeys::modi_sphere_baryonChemicalPotential)),
       mus_(modus_config.take(InputKeys::modi_sphere_strangeChemicalPotential)),
       muq_(modus_config.take(InputKeys::modi_sphere_chargeChemicalPotential)),
       hf_multiplier_(
           modus_config.take(InputKeys::modi_sphere_heavyFlavorMultiplier)),
       account_for_resonance_widths_(
           modus_config.take(InputKeys::modi_sphere_accountResonanceWidths)),
       init_multipl_(use_thermal_
                         ? std::map<PdgCode, int>()
                         : modus_config.take(
                               InputKeys::modi_sphere_initialMultiplicities)),
       init_distr_(modus_config.take(InputKeys::modi_sphere_initialCondition)),
       radial_velocity_(
           modus_config.take(InputKeys::modi_sphere_addRadialVelocity)),
       radial_velocity_exponent_(
           modus_config.take(InputKeys::modi_sphere_addRadialVelocityExponent)),
       /* 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 the config because empty,
        * and has_section(InputSections::m_s_jet) method would return false.
        */
       jet_pdg_(modus_config.has_section(InputSections::m_s_jet)
                    ? make_optional<PdgCode>(
                          modus_config.take(InputKeys::modi_sphere_jet_jetPdg))
                    : std::nullopt),
       jet_mom_(modus_config.take(InputKeys::modi_sphere_jet_jetMomentum)),
       jet_pos_(modus_config.take(InputKeys::modi_sphere_jet_jetPosition)),
       jet_back_(modus_config.take(InputKeys::modi_sphere_jet_backToBack)),
       jet_back_separation_(
           jet_back_ ? modus_config.take(
                           InputKeys::modi_sphere_jet_backToBackSeparation)
                     : 0),
       spin_interaction_type_(
           modus_config.take(InputKeys::collTerm_spinInteractions)) {
   if (!jet_back_ &&
       modus_config.has_value(InputKeys::modi_sphere_jet_backToBackSeparation)) {
     throw std::invalid_argument(
         "In order to specify 'Back_To_Back_Separation', 'Back_To_Back' must be "
         "true.");
   }
   if (radial_velocity_ > 1.0) {
     throw std::invalid_argument(
         "Additional velocity cannot be greater than 1!");
   }
   if (sphere_temperature_ <= 0.0) {
     throw std::invalid_argument("Temperature must be positive!");
   }
   if (radial_velocity_exponent_ < 0.0) {
     throw std::invalid_argument("Flow velocity exponent cannot be negative!");
   }
 }

Member Function Documentation

◆ initial_conditions()

double smash::SphereModus::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.

Susbsequently 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

Definition at line 153 of file spheremodus.cc.

                                                                                {
   FourVector momentum_total(0, 0, 0, 0);
   const double T = this->sphere_temperature_;
   const double V = 4.0 / 3.0 * M_PI * radius_ * radius_ * radius_;
   /* Create NUMBER OF PARTICLES according to configuration */
   if (use_thermal_) {
     if (average_multipl_.empty()) {
       for (const ParticleType &ptype : ParticleType::list_all()) {
         const bool is_eos_particle = HadronGasEos::is_eos_particle(ptype);
         const bool use_heavy_flavor = ptype.pdgcode().is_heavy_flavor() &&
                                       (hf_multiplier_ > really_small);
         if (is_eos_particle || use_heavy_flavor) {
           const double n = HadronGasEos::partial_density(
               ptype, T, mub_, mus_, muq_, account_for_resonance_widths_);
           average_multipl_[ptype.pdgcode()] = n * V * parameters.testparticles;
           if (ptype.pdgcode().is_heavy_flavor()) {
             average_multipl_[ptype.pdgcode()] *= hf_multiplier_;
           }
         }
       }
     }
     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[LSphere].debug(mult.first, " initial multiplicity ",
                           thermal_mult_int);
     }
     logg[LSphere].info("Initial hadron gas baryon density ", nb_init);
     logg[LSphere].info("Initial hadron gas strange density ", ns_init);
     logg[LSphere].info("Initial hadron gas charge density ", nq_init);
   } else {
     for (const auto &p : init_multipl_) {
       particles->create(p.second * parameters.testparticles, p.first);
       logg[LSphere].debug("Particle ", p.first, " initial multiplicity ",
                           p.second);
     }
   }
   std::unique_ptr<QuantumSampling> quantum_sampling;
   if (this->init_distr_ == SphereInitialCondition::ThermalMomentaQuantum) {
     quantum_sampling = std::make_unique<QuantumSampling>(init_multipl_, V, T);
   }
   /* loop over particle data to fill in momentum and position information */
   for (ParticleData &data : *particles) {
     Angles phitheta;
     /* thermal momentum according Maxwell-Boltzmann distribution */
     double momentum_radial = 0.0, mass = data.pole_mass();
     /* assign momentum_radial according to requested distribution */
     switch (init_distr_) {
       case (SphereInitialCondition::IC_ES):
         momentum_radial = sample_momenta_IC_ES(T);
         break;
       case (SphereInitialCondition::IC_1M):
         momentum_radial = sample_momenta_1M_IC(T, mass);
         break;
       case (SphereInitialCondition::IC_2M):
         momentum_radial = sample_momenta_2M_IC(T, mass);
         break;
       case (SphereInitialCondition::IC_Massive):
         momentum_radial = sample_momenta_non_eq_mass(T, mass);
         break;
       case (SphereInitialCondition::ThermalMomentaBoltzmann):
       default:
         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);
         break;
       case (SphereInitialCondition::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());
         break;
     }
     phitheta.distribute_isotropically();
     logg[LSphere].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();
     /* uniform sampling in a sphere with radius r */
     double position_radial;
     position_radial = std::cbrt(random::canonical()) * radius_;
     Angles pos_phitheta;
     pos_phitheta.distribute_isotropically();
     data.set_4position(
         FourVector(start_time_, pos_phitheta.threevec() * position_radial));
     data.set_formation_time(start_time_);
   }
  
   /* Boost in radial direction with an underlying velocity field of the form
    * u_r = u_0 * (r / R)^n
    */
   if (radial_velocity_ > 0.0) {
     for (ParticleData &data : *particles) {
       double particle_radius = std::sqrt(data.position().sqr3());
       auto e_r = data.position().threevec() / particle_radius;
       auto radial_velocity =
           -1.0 * radial_velocity_ * e_r *
           std::pow(particle_radius / radius_, radial_velocity_exponent_);
       data.set_4momentum(data.momentum().lorentz_boost(radial_velocity));
       momentum_total += data.momentum();
     }
   }
  
   /* Make total 3-momentum in sphere 0 and set unpolarized spin vector if spin
    * interactions are enabled */
   for (ParticleData &data : *particles) {
     data.set_4momentum(data.momentum().abs(),
                        data.momentum().threevec() -
                            momentum_total.threevec() / particles->size());
     if (spin_interaction_type_ != SpinInteractionType::Off) {
       data.set_unpolarized_spin_vector();
     }
   }
  
   /* Add a single highly energetic particle in the center of the sphere (jet) */
   if (jet_pdg_) {
     auto &pdg = jet_pdg_.value();
     auto &jet_particle = particles->create(pdg);
     auto displacement = ThreeVector(jet_back_separation_ / 2., 0., 0.);
     jet_particle.set_formation_time(start_time_);
     jet_particle.set_4position(
         FourVector(start_time_, jet_pos_ + displacement));
     jet_particle.set_4momentum(ParticleType::find(pdg).mass(),
                                ThreeVector(jet_mom_, 0., 0.));
     if (jet_back_) {
       auto &anti_pdg = pdg.has_antiparticle() ? pdg.get_antiparticle() : pdg;
       auto &jet_antiparticle = particles->create(anti_pdg);
       jet_antiparticle.set_formation_time(start_time_);
       jet_antiparticle.set_4position(
           FourVector(start_time_, jet_pos_ - displacement));
       jet_antiparticle.set_4momentum(ParticleType::find(anti_pdg).mass(),
                                      ThreeVector(-jet_mom_, 0., 0.));
     }
     if (spin_interaction_type_ != SpinInteractionType::Off) {
       jet_particle.set_unpolarized_spin_vector();
     }
   }
  
   /* Recalculate total momentum */
   momentum_total = FourVector(0, 0, 0, 0);
   for (ParticleData &data : *particles) {
     momentum_total += data.momentum();
     /* IC: debug checks */
     logg[LSphere].debug() << data;
   }
   /* allows to check energy conservation */
   logg[LSphere].debug() << "Sphere initial total 4-momentum [GeV]: "
                         << momentum_total;
   return start_time_;
 }

◆ is_sphere()

bool smash::SphereModus::is_sphere ( ) const

inline

Returns: If the modus is sphere modus, which is always true

Definition at line 79 of file spheremodus.h.

79 { return true; }

◆ radius()

double smash::SphereModus::radius ( ) const

inline

Returns: radius

Definition at line 81 of file spheremodus.h.

81 { return radius_; }

Member Data Documentation

◆ radius_

double smash::SphereModus::radius_

private

Sphere radius (in fm)

Definition at line 85 of file spheremodus.h.

◆ sphere_temperature_

double smash::SphereModus::sphere_temperature_

private

Temperature for momentum distribution (in GeV)

Definition at line 87 of file spheremodus.h.

◆ start_time_

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

private

Starting time for the Sphere.

Definition at line 89 of file spheremodus.h.

◆ use_thermal_

const bool smash::SphereModus::use_thermal_ = false

private

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

Definition at line 94 of file spheremodus.h.

◆ mub_

const double smash::SphereModus::mub_

private

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

Definition at line 99 of file spheremodus.h.

◆ mus_

const double smash::SphereModus::mus_

private

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

Definition at line 104 of file spheremodus.h.

◆ muq_

const double smash::SphereModus::muq_

private

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

Definition at line 109 of file spheremodus.h.

◆ hf_multiplier_

const double smash::SphereModus::hf_multiplier_

private

Multiplicative factor for thermal multiplicity of heavy flavored hadrons; only used if use_thermal_ is true.

Definition at line 114 of file spheremodus.h.

◆ account_for_resonance_widths_

const bool smash::SphereModus::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 121 of file spheremodus.h.

◆ init_multipl_

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

private

Particle multiplicities at initialization; required if use_thermal_ is false.

Definition at line 126 of file spheremodus.h.

◆ average_multipl_

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

private

Average multiplicities in case of thermal initialization.

Saved to avoid recalculating at every event

Definition at line 131 of file spheremodus.h.

◆ init_distr_

const SphereInitialCondition smash::SphereModus::init_distr_

private

Initialization scheme for momenta in the sphere; used for expanding metric setup.

Definition at line 136 of file spheremodus.h.

◆ radial_velocity_

const double smash::SphereModus::radial_velocity_

private

Parameter \( u_0\) in the initial flow velocity profile of particles in the sphere, which has the form \( u = u_0 (r / R)^n\).

Definition at line 141 of file spheremodus.h.

◆ radial_velocity_exponent_

const double smash::SphereModus::radial_velocity_exponent_

private

Parameter \( n\) in the initial flow velocity profile of particles in the sphere, which has the form \( u = u_0 (r / R)^n\).

Definition at line 146 of file spheremodus.h.

◆ jet_pdg_

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

private

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

a single high energy particle at the center (0,0,0) of the expanding sphere. This particle will be placed at t=0 and will initially be moving along the x axis, in the positive or negative direction depending on the sign of its momentum.

Definition at line 154 of file spheremodus.h.

◆ jet_mom_

const double smash::SphereModus::jet_mom_

private

Initial momentum of the jet particle; only used if jet_pdg_ is not nullopt.

Definition at line 158 of file spheremodus.h.

◆ jet_pos_

const ThreeVector smash::SphereModus::jet_pos_

private

Initial position of the jet particle; only used if jet_pdg_ is not nullopt.

Definition at line 162 of file spheremodus.h.

◆ jet_back_

const bool smash::SphereModus::jet_back_

private

Create the back to back jet with the corresponding antiparticle; only used if jet_pdg_ is not nullopt.

Definition at line 167 of file spheremodus.h.

◆ jet_back_separation_

const double smash::SphereModus::jet_back_separation_ = smash_NaN<double>

private

Initial separation between the back to back jets; can only be set by the user if jet_back_ is true.

Definition at line 172 of file spheremodus.h.

◆ spin_interaction_type_

const SpinInteractionType smash::SphereModus::spin_interaction_type_

private

Spin interaction type.

Definition at line 174 of file spheremodus.h.

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

src/include/smash/spheremodus.h
src/spheremodus.cc

Public Member Functions

Private Attributes

Friends

Constructor & Destructor Documentation

◆ SphereModus()

Member Function Documentation

◆ initial_conditions()

◆ is_sphere()

◆ radius()

Member Data Documentation

◆ radius_

◆ sphere_temperature_

◆ start_time_

◆ use_thermal_

◆ mub_

◆ mus_

◆ muq_

◆ hf_multiplier_

◆ account_for_resonance_widths_

◆ init_multipl_

◆ average_multipl_

◆ init_distr_

◆ radial_velocity_

◆ radial_velocity_exponent_

◆ jet_pdg_

◆ jet_mom_

◆ jet_pos_

◆ jet_back_

◆ jet_back_separation_

◆ spin_interaction_type_