#include <collidermodus.h>

ColliderModus: Provides a modus for colliding nuclei.

To use this modus, choose

General:

Modus: Collider

in the configuration file.

Options for ColliderModus go in the "Modi"→"Collider" section of the configuration.

The following configuration options are understood: Collider

Definition at line 42 of file collidermodus.h.

Inheritance diagram for smash::ColliderModus:

[legend]

Collaboration diagram for smash::ColliderModus:

[legend]

Classes
struct	ColliderEmpty
	Thrown when either projectile_ or target_ nuclei are empty. More...

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

int	total_N_number () const

int	proj_N_number () const

double	velocity_projectile () const

double	velocity_target () const

bool	cll_in_nucleus ()

FermiMotion	fermi_motion ()

bool	is_collider () const

double	impact_parameter () 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 Member Functions
void	sample_impact ()
	Sample impact parameter. More...

std::pair< double, double >	get_velocities (double mandelstam_s, double m_a, double m_b)
	Get the frame dependent velocity for each nucleus, using the current reference frame. More...

Static Private Member Functions
static std::unique_ptr< DeformedNucleus >	create_deformed_nucleus (Configuration &nucleus_cfg, const int ntest, const std::string &nucleus_type)
	Configure Deformed Nucleus. More...

Private Attributes
std::unique_ptr< Nucleus >	projectile_
	Projectile. More...

std::unique_ptr< Nucleus >	target_
	Target. More...

double	total_s_
	Center-of-mass energy squared of the nucleus-nucleus collision. More...

double	sqrt_s_NN_
	Center-of-mass energy of a nucleon-nucleon collision. More...

double	impact_ = 0.
	Impact parameter. More...

Sampling	sampling_ = Sampling::Quadratic
	Method used for sampling of impact parameter. More...

double	imp_min_ = 0.0
	Minimum value of impact parameter. More...

double	imp_max_ = 0.0
	Maximum value of impact parameter. More...

double	yield_max_ = 0.0
	Maximum value of yield. Needed for custom impact parameter sampling. More...

std::unique_ptr< InterpolateDataLinear< double > >	impact_interpolation_
	Pointer to the impact parameter interpolation. More...

double	initial_z_displacement_ = 2.0
	Initial z-displacement of nuclei. More...

CalculationFrame	frame_ = CalculationFrame::CenterOfVelocity
	Reference frame for the system, as specified from config. More...

FermiMotion	fermi_motion_ = FermiMotion::Off
	An option to include Fermi motion ("off", "on", "frozen") More...

bool	cll_in_nucleus_ = false
	An option to accept first collisions within the same nucleus. More...

double	velocity_projectile_ = 0.0
	Beam velocity of the projectile. More...

double	velocity_target_ = 0.0
	Beam velocity of the target. More...

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

Constructor & Destructor Documentation

smash::ColliderModus::ColliderModus	(	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

Exceptions

ColliderEmpty	if projectile or nucleus are empty (i.e. do not contain particles)
InvalidEnergy	if sqrts from config is not large enough to support the colliding masses of the nuclei, or if E_kin or P_lab are negative
domain_error	if more or less than exactly one of the input energy options is specified, or if custom impact parameter Values and Yields are improperly supplied

Determine whether to allow the first collisions within the same nucleus

Todo:: include a check that only one method of specifying impact is used

Definition at line 259 of file collidermodus.cc.

                                                                  {
   Configuration modus_cfg = modus_config["Collider"];
 
   // Get the reference frame for the collision calculation.
   if (modus_cfg.has_value({"Calculation_Frame"})) {
     frame_ = modus_cfg.take({"Calculation_Frame"});
   }
 
   if (modus_cfg.has_value({"Collisions_Within_Nucleus"})) {
     cll_in_nucleus_ = modus_cfg.take({"Collisions_Within_Nucleus"});
   }
 
   // Set up the projectile nucleus
   Configuration proj_cfg = modus_cfg["Projectile"];
   if (proj_cfg.has_value({"Deformed"})) {
     projectile_ =
         create_deformed_nucleus(proj_cfg, params.testparticles, "projectile");
   } else if (proj_cfg.has_value({"Custom"})) {
     projectile_ = make_unique<CustomNucleus>(proj_cfg, params.testparticles);
   } else {
     projectile_ = make_unique<Nucleus>(proj_cfg, params.testparticles);
   }
   if (projectile_->size() < 1) {
     throw ColliderEmpty("Input Error: Projectile nucleus is empty.");
   }
 
   // Set up the target nucleus
   Configuration targ_cfg = modus_cfg["Target"];
   if (targ_cfg.has_value({"Deformed"})) {
     target_ = create_deformed_nucleus(targ_cfg, params.testparticles, "target");
   } else if (targ_cfg.has_value({"Custom"})) {
     target_ = make_unique<CustomNucleus>(targ_cfg, params.testparticles);
   } else {
     target_ = make_unique<Nucleus>(targ_cfg, params.testparticles);
   }
   if (target_->size() < 1) {
     throw ColliderEmpty("Input Error: Target nucleus is empty.");
   }
 
   // Get the Fermi-Motion input (off, on, frozen)
   if (modus_cfg.has_value({"Fermi_Motion"})) {
     // We only read the value, because it is still required by the experiment
     // class to make sure we don't use frozen Fermi momenta with potentials.
     fermi_motion_ = modus_cfg.read({"Fermi_Motion"});
   }
 
   // Get the total nucleus-nucleus collision energy. Since there is
   // no meaningful choice for a default energy, we require the user to
   // give one (and only one) energy input from the available options.
   int energy_input = 0;
   const double mass_projec = projectile_->mass();
   const double mass_target = target_->mass();
   // average mass of a particle in that nucleus
   const double mass_a =
       projectile_->mass() / projectile_->number_of_particles();
   const double mass_b = target_->mass() / target_->number_of_particles();
   // Option 1: Center of mass energy.
   if (modus_cfg.has_value({"Sqrtsnn"})) {
     sqrt_s_NN_ = modus_cfg.take({"Sqrtsnn"});
     // Check that input satisfies the lower bound (everything at rest).
     if (sqrt_s_NN_ <= mass_a + mass_b) {
       throw ModusDefault::InvalidEnergy(
           "Input Error: sqrt(s_NN) is not larger than masses:\n" +
           std::to_string(sqrt_s_NN_) + " GeV <= " + std::to_string(mass_a) +
           " GeV + " + std::to_string(mass_b) + " GeV.");
     }
     // Set the total nucleus-nucleus collision energy.
     total_s_ = (sqrt_s_NN_ * sqrt_s_NN_ - mass_a * mass_a - mass_b * mass_b) *
                    mass_projec * mass_target / (mass_a * mass_b) +
                mass_projec * mass_projec + mass_target * mass_target;
     energy_input++;
   }
   /* Option 2: Kinetic energy per nucleon of the projectile nucleus
    * (target at rest).  */
   if (modus_cfg.has_value({"E_Kin"})) {
     const double e_kin = modus_cfg.take({"E_Kin"});
     if (e_kin < 0) {
       throw ModusDefault::InvalidEnergy(
           "Input Error: "
           "E_Kin must be nonnegative.");
     }
     // Set the total nucleus-nucleus collision energy.
     total_s_ = s_from_Ekin(e_kin * projectile_->number_of_particles(),
                            mass_projec, mass_target);
     sqrt_s_NN_ = std::sqrt(s_from_Ekin(e_kin, mass_a, mass_b));
     energy_input++;
   }
   // Option 3: Momentum of the projectile nucleus (target at rest).
   if (modus_cfg.has_value({"P_Lab"})) {
     const double p_lab = modus_cfg.take({"P_Lab"});
     if (p_lab < 0) {
       throw ModusDefault::InvalidEnergy(
           "Input Error: "
           "P_Lab must be nonnegative.");
     }
     // Set the total nucleus-nucleus collision energy.
     total_s_ = s_from_plab(p_lab * projectile_->number_of_particles(),
                            mass_projec, mass_target);
     sqrt_s_NN_ = std::sqrt(s_from_plab(p_lab, mass_a, mass_b));
     energy_input++;
   }
   if (energy_input == 0) {
     throw std::domain_error(
         "Input Error: Non-existent collision energy. "
         "Please provide one of Sqrtsnn/E_Kin/P_Lab.");
   }
   if (energy_input > 1) {
     throw std::domain_error(
         "Input Error: Redundant collision energy. "
         "Please provide only one of Sqrtsnn/E_Kin/P_Lab.");
   }
 
   /* Impact parameter setting: Either "Value", "Range", "Max" or "Sample".
    * Unspecified means 0 impact parameter.*/
   if (modus_cfg.has_value({"Impact", "Value"})) {
     impact_ = modus_cfg.take({"Impact", "Value"});
     imp_min_ = impact_;
     imp_max_ = impact_;
   } else {
     // If impact is not supplied by value, inspect sampling parameters:
     if (modus_cfg.has_value({"Impact", "Sample"})) {
       sampling_ = modus_cfg.take({"Impact", "Sample"});
       if (sampling_ == Sampling::Custom) {
         if (!(modus_cfg.has_value({"Impact", "Values"}) ||
               modus_cfg.has_value({"Impact", "Yields"}))) {
           throw std::domain_error(
               "Input Error: Need impact parameter spectrum for custom "
               "sampling. "
               "Please provide Values and Yields.");
         }
         const std::vector<double> impacts =
             modus_cfg.take({"Impact", "Values"});
         const std::vector<double> yields = modus_cfg.take({"Impact", "Yields"});
         if (impacts.size() != yields.size()) {
           throw std::domain_error(
               "Input Error: Need as many impact parameter values as yields. "
               "Please make sure that Values and Yields have the same length.");
         }
         impact_interpolation_ = make_unique<InterpolateDataLinear<double>>(
             InterpolateDataLinear<double>(impacts, yields));
 
         const auto imp_minmax =
             std::minmax_element(impacts.begin(), impacts.end());
         imp_min_ = *imp_minmax.first;
         imp_max_ = *imp_minmax.second;
         yield_max_ = *std::max_element(yields.begin(), yields.end());
       }
     }
     if (modus_cfg.has_value({"Impact", "Range"})) {
       const std::array<double, 2> range = modus_cfg.take({"Impact", "Range"});
       imp_min_ = range[0];
       imp_max_ = range[1];
     }
     if (modus_cfg.has_value({"Impact", "Max"})) {
       imp_min_ = 0.0;
       imp_max_ = modus_cfg.take({"Impact", "Max"});
     }
   }
 
   // Look for user-defined initial separation between nuclei.
   if (modus_cfg.has_value({"Initial_Distance"})) {
     initial_z_displacement_ = modus_cfg.take({"Initial_Distance"});
     // the displacement is half the distance (both nuclei are shifted
     // initial_z_displacement_ away from origin)
     initial_z_displacement_ /= 2.0;
   }
 }

Here is the call graph for this function:

Member Function Documentation

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

Generates initial state of the particles in the system.

In particular, it initializes the momenta and positions of nucleons withing the colliding nuclei.

Parameters

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

Returns: The starting time of the simulation (negative, so that nuclei collide exactly at t=0)

Exceptions

domain_error if the velocities of each nucleus are >= 1, or if input for Fermi motion is invalid

Definition at line 459 of file collidermodus.cc.

                                                                        {
   const auto &log = logger<LogArea::Collider>();
   sample_impact();
 
   log.info() << "Impact parameter = " << format(impact_, "fm");
   // Populate the nuclei with appropriately distributed nucleons.
   // If deformed, this includes rotating the nucleus.
   projectile_->arrange_nucleons();
   target_->arrange_nucleons();
 
   // Use the total mandelstam variable to get the frame-dependent velocity for
   // each nucleus. Position a is projectile, position b is target.
   double v_a, v_b;
   std::tie(v_a, v_b) =
       get_velocities(total_s_, projectile_->mass(), target_->mass());
 
   // If velocities are larger or equal to 1, throw an exception.
   if (v_a >= 1.0 || v_b >= 1.0) {
     throw std::domain_error(
         "Found velocity equal to or larger than 1 in "
         "ColliderModus::initial_conditions.\nConsider using "
         "the center of velocity reference frame.");
   }
 
   // Calculate the beam velocity of the projectile and the target, which will be
   // used to calculate the beam momenta in experiment.cc
   if (fermi_motion_ == FermiMotion::Frozen) {
     velocity_projectile_ = v_a;
     velocity_target_ = v_b;
   }
 
   // Generate Fermi momenta if necessary
   if (fermi_motion_ == FermiMotion::On ||
       fermi_motion_ == FermiMotion::Frozen) {
     // Frozen: Fermi momenta will be ignored during the propagation to
     // avoid that the nuclei will fly apart.
     projectile_->generate_fermi_momenta();
     target_->generate_fermi_momenta();
     if (fermi_motion_ == FermiMotion::On) {
       log.info() << "Fermi motion is ON.";
     } else {
       log.info() << "FROZEN Fermi motion is on.";
     }
   } else if (fermi_motion_ == FermiMotion::Off) {
     // No Fermi-momenta are generated in this case
     log.info() << "Fermi motion is OFF.";
   } else {
     throw std::domain_error("Invalid Fermi_Motion input.");
   }
 
   // Boost the nuclei to the appropriate velocity.
   projectile_->boost(v_a);
   target_->boost(v_b);
 
   // Shift the nuclei into starting positions. Contracted spheres with
   // nuclear radii should touch exactly at t=0. Modus starts at negative
   // time corresponding to additional initial displacement.
   const double d_a = std::max(0., projectile_->get_diffusiveness());
   const double d_b = std::max(0., target_->get_diffusiveness());
   const double r_a = projectile_->get_nuclear_radius();
   const double r_b = target_->get_nuclear_radius();
   const double dz = initial_z_displacement_;
 
   const double simulation_time = -dz / std::abs(v_a);
   const double proj_z = -dz - std::sqrt(1.0 - v_a * v_a) * (r_a + d_a);
   const double targ_z =
       +dz * std::abs(v_b / v_a) + std::sqrt(1.0 - v_b * v_b) * (r_b + d_b);
   projectile_->shift(proj_z, +impact_ / 2.0, simulation_time);
   target_->shift(targ_z, -impact_ / 2.0, simulation_time);
 
   // Put the particles in the nuclei into code particles.
   projectile_->copy_particles(particles);
   target_->copy_particles(particles);
   return simulation_time;
 }

Here is the call graph for this function:

int smash::ColliderModus::total_N_number ( ) const

inline

Returns: The total number of test particles in the initial nuclei

Definition at line 82 of file collidermodus.h.

82 { return target_->size() + projectile_->size(); }

smash::ColliderModus::projectile_

std::unique_ptr< Nucleus > projectile_

Projectile.

Definition: collidermodus.h:121

smash::ColliderModus::target_

std::unique_ptr< Nucleus > target_

Target.

Definition: collidermodus.h:129

int smash::ColliderModus::proj_N_number ( ) const

inline

Returns: The number of test particles in the projectile nucleus

Definition at line 84 of file collidermodus.h.

84 { return projectile_->size(); }

smash::ColliderModus::projectile_

std::unique_ptr< Nucleus > projectile_

Projectile.

Definition: collidermodus.h:121

double smash::ColliderModus::velocity_projectile ( ) const

inline

Returns: the beam velocity of the projectile, which will be used to calculate the beam momenta in experiment.cc if Fermi motion is frozen.

Definition at line 90 of file collidermodus.h.

90 { return velocity_projectile_; }

smash::ColliderModus::velocity_projectile_

double velocity_projectile_

Beam velocity of the projectile.

Definition: collidermodus.h:208

double smash::ColliderModus::velocity_target ( ) const

inline

Returns: the beam velocity of the target, which will be used to calculate the beam momenta in experiment.cc if Fermi motion is frozen.

Definition at line 95 of file collidermodus.h.

95 { return velocity_target_; }

smash::ColliderModus::velocity_target_

double velocity_target_

Beam velocity of the target.

Definition: collidermodus.h:212

bool smash::ColliderModus::cll_in_nucleus ( )

inline

Returns: A flag: whether to allow first collisions within the same nucleus.

Definition at line 99 of file collidermodus.h.

99 { return cll_in_nucleus_; }

smash::ColliderModus::cll_in_nucleus_

bool cll_in_nucleus_

An option to accept first collisions within the same nucleus.

Definition: collidermodus.h:204

FermiMotion smash::ColliderModus::fermi_motion ( )

inline

Returns: The Fermi motion type

Definition at line 101 of file collidermodus.h.

101 { return fermi_motion_; }

smash::ColliderModus::fermi_motion_

FermiMotion fermi_motion_

An option to include Fermi motion ("off", "on", "frozen")

Definition: collidermodus.h:200

bool smash::ColliderModus::is_collider ( ) const

inline

Returns: whether the modus is collider (which is, yes, trivially true)

Definition at line 103 of file collidermodus.h.

103 { return true; }

double smash::ColliderModus::impact_parameter ( ) const

inline

Returns: impact parameter of the collision

Definition at line 105 of file collidermodus.h.

105 { return impact_; }

smash::ColliderModus::impact_

double impact_

Impact parameter.

Definition: collidermodus.h:163

std::unique_ptr< DeformedNucleus > smash::ColliderModus::create_deformed_nucleus	(	Configuration &	nucleus_cfg,
		const int	ntest,
		const std::string &	nucleus_type
	)

staticprivate

Configure Deformed Nucleus.

Sets up a deformed nucleus object based on the input parameters in the configuration file.

Parameters

[in]	nucleus_cfg	Subset of configuration, projectile or target section.
[in]	ntest	Number of test particles
[in]	nucleus_type	String 'projectile' or 'target'. To display an appropriate error message.

Returns: Pointer to the created deformed nucleus object.

Definition at line 440 of file collidermodus.cc.

                                                                           {
   bool auto_deform = nucleus_cfg.take({"Deformed", "Automatic"});
   bool is_beta2 = nucleus_cfg.has_value({"Deformed", "Beta_2"}) ? true : false;
   bool is_beta4 = nucleus_cfg.has_value({"Deformed", "Beta_4"}) ? true : false;
   std::unique_ptr<DeformedNucleus> nucleus;
 
   if ((auto_deform && (!is_beta2 && !is_beta4)) ||
       (!auto_deform && (is_beta2 && is_beta4))) {
     nucleus = make_unique<DeformedNucleus>(nucleus_cfg, ntest);
     return nucleus;
   } else {
     throw std::domain_error("Deformation of " + nucleus_type +
                             " nucleus not configured "
                             "properly, please check whether all necessary "
                             "parameters are set.");
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void smash::ColliderModus::sample_impact ( )

private

Sample impact parameter.

Samples the impact parameter from values between imp_min_ and imp_max_, if linear or quadratic sampling is used. By specifying impact parameters and corresponding yields, custom sampling can be used. This depends on the value of sampling_.

Note that imp_max_ less than imp_min_ also works fine.

Definition at line 536 of file collidermodus.cc.

                                   {
   switch (sampling_) {
     case Sampling::Quadratic: {
       // quadratic sampling: Note that for bmin > bmax, this still yields
       // the correct distribution (however canonical() = 0 is then the
       // upper end, not the lower).
       impact_ = std::sqrt(imp_min_ * imp_min_ +
                           random::canonical() *
                               (imp_max_ * imp_max_ - imp_min_ * imp_min_));
     } break;
     case Sampling::Custom: {
       // rejection sampling based on given distribution
       assert(impact_interpolation_ != nullptr);
       double probability_random = 1;
       double probability = 0;
       double b;
       while (probability_random > probability) {
         b = random::uniform(imp_min_, imp_max_);
         probability = (*impact_interpolation_)(b) / yield_max_;
         assert(probability < 1.);
         probability_random = random::uniform(0., 1.);
       }
       impact_ = b;
     } break;
     case Sampling::Uniform: {
       // linear sampling. Still, min > max works fine.
       impact_ = random::uniform(imp_min_, imp_max_);
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair< double, double > smash::ColliderModus::get_velocities	(	double	mandelstam_s,
		double	m_a,
		double	m_b
	)

private

Get the frame dependent velocity for each nucleus, using the current reference frame.

See also: frame_

Parameters

[in]	mandelstam_s	The total center-of-mass energy of the system.
[in]	m_a	The (positive) mass of the projectile.
[in]	m_b	The (positive) mass of the target.

Returns: A pair < v_a, v_b > containing the velocities of the nuclei.

Exceptions

domain_error if the reference frame is not properly specified

Definition at line 567 of file collidermodus.cc.

                                                                     {
   double v_a = 0.0;
   double v_b = 0.0;
   // Frame dependent calculations of velocities. Assume v_a >= 0, v_b <= 0.
   switch (frame_) {
     case CalculationFrame::CenterOfVelocity:
       v_a = center_of_velocity_v(s, m_a, m_b);
       v_b = -v_a;
       break;
     case CalculationFrame::CenterOfMass: {
       // Compute center of mass momentum.
       double pCM = pCM_from_s(s, m_a, m_b);
       v_a = pCM / std::sqrt(m_a * m_a + pCM * pCM);
       v_b = -pCM / std::sqrt(m_b * m_b + pCM * pCM);
     } break;
     case CalculationFrame::FixedTarget:
       v_a = fixed_target_projectile_v(s, m_a, m_b);
       break;
     default:
       throw std::domain_error(
           "Invalid reference frame in "
           "ColliderModus::get_velocities.");
   }
   return std::make_pair(v_a, v_b);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

std::unique_ptr<Nucleus> smash::ColliderModus::projectile_

private

Projectile.

The object that goes from negative z-values to positive z-values with positive velocity.

Definition at line 121 of file collidermodus.h.

std::unique_ptr<Nucleus> smash::ColliderModus::target_

private

Target.

The object that goes from positive z-values to negative z-values with negative velocity. In fixed target experiments, the target is at rest.

Definition at line 129 of file collidermodus.h.

double smash::ColliderModus::total_s_

private

Center-of-mass energy squared of the nucleus-nucleus collision.

Needs to be double to allow for calculations at LHC energies

Definition at line 135 of file collidermodus.h.

double smash::ColliderModus::sqrt_s_NN_

private

Center-of-mass energy of a nucleon-nucleon collision.

Needs to be double to allow for calculations at LHC energies

Definition at line 141 of file collidermodus.h.

double smash::ColliderModus::impact_ = 0.

private

Impact parameter.

The nuclei projectile_ and target_ will be shifted along the x-axis so that their centers move on antiparallel lines that are this distance apart from each other.

Definition at line 163 of file collidermodus.h.

Sampling smash::ColliderModus::sampling_ = Sampling::Quadratic

private

Method used for sampling of impact parameter.

Definition at line 165 of file collidermodus.h.

double smash::ColliderModus::imp_min_ = 0.0

private

Minimum value of impact parameter.

Definition at line 167 of file collidermodus.h.

double smash::ColliderModus::imp_max_ = 0.0

private

Maximum value of impact parameter.

Definition at line 169 of file collidermodus.h.

double smash::ColliderModus::yield_max_ = 0.0

private

Maximum value of yield. Needed for custom impact parameter sampling.

Definition at line 171 of file collidermodus.h.

std::unique_ptr<InterpolateDataLinear<double> > smash::ColliderModus::impact_interpolation_

private

Initial value:

=

nullptr

Pointer to the impact parameter interpolation.

Definition at line 173 of file collidermodus.h.

double smash::ColliderModus::initial_z_displacement_ = 2.0

private

Initial z-displacement of nuclei.

Projectile is shifted on -(this value) in z-direction and target on +(this value)*v_target/v_projectile. In this way projectile and target touch at t=0 in z=0.

Definition at line 192 of file collidermodus.h.

CalculationFrame smash::ColliderModus::frame_ = CalculationFrame::CenterOfVelocity

private

Reference frame for the system, as specified from config.

Definition at line 196 of file collidermodus.h.

FermiMotion smash::ColliderModus::fermi_motion_ = FermiMotion::Off

private

An option to include Fermi motion ("off", "on", "frozen")

Definition at line 200 of file collidermodus.h.

bool smash::ColliderModus::cll_in_nucleus_ = false

private

An option to accept first collisions within the same nucleus.

Definition at line 204 of file collidermodus.h.

double smash::ColliderModus::velocity_projectile_ = 0.0

private

Beam velocity of the projectile.

Definition at line 208 of file collidermodus.h.

double smash::ColliderModus::velocity_target_ = 0.0

private

Beam velocity of the target.

Definition at line 212 of file collidermodus.h.

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

src/include/smash/collidermodus.h
src/collidermodus.cc

Classes

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation