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

std::string	custom_file_path (const std::string &file_directory, const std::string &file_name)
	Creates full path string consisting of file_directory and file_name Needed to initialize a customnucleus. More...

double	initial_conditions (Particles *particles, const ExperimentParameters &parameters)
	Generates initial state of the particles in the system. More...

void	sample_impact ()
	Sample impact parameter. More...

double	nuclei_passing_time () const
	Time until nuclei have passed through each other. More...

double	velocity_projectile () const

double	velocity_target () const

FermiMotion	fermi_motion ()

bool	is_collider () const

double	sqrt_s_NN () const

double	impact_parameter () const

bool	calculation_frame_is_fixed_target () 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...

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

Private Member Functions
bool	same_inputfile (Configuration &proj_config, Configuration &targ_config)
	Checks if target and projectile are read from the same external file if they are both initialized as a customnucleus. More...

void	rotate_reaction_plane (double phi, Particles *particles)
	Rotate the reaction plane about the angle phi. 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...

bool	random_reaction_plane_
	Whether the reaction plane should be randomized. 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...

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

◆ ColliderModus()

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

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

Definition at line 322 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"});
   }
  
   Configuration proj_cfg = modus_cfg["Projectile"];
   Configuration targ_cfg = modus_cfg["Target"];
   /* Needed to check if projectile and target in customnucleus are read from
    * the same input file.*/
   bool same_file = false;
   // Set up the projectile nucleus
   if (proj_cfg.has_value({"Deformed"})) {
     projectile_ =
         create_deformed_nucleus(proj_cfg, params.testparticles, "projectile");
   } else if (proj_cfg.has_value({"Custom"})) {
     same_file = same_inputfile(proj_cfg, targ_cfg);
     projectile_ =
         make_unique<CustomNucleus>(proj_cfg, params.testparticles, same_file);
   } else {
     projectile_ = make_unique<Nucleus>(proj_cfg, params.testparticles);
   }
   if (projectile_->size() < 1) {
     throw ColliderEmpty("Input Error: Projectile nucleus is empty.");
   }
   projectile_->set_label(BelongsTo::Projectile);
  
   // Set up the target nucleus
   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, same_file);
   } else {
     target_ = make_unique<Nucleus>(targ_cfg, params.testparticles);
   }
   if (target_->size() < 1) {
     throw ColliderEmpty("Input Error: Target nucleus is empty.");
   }
   target_->set_label(BelongsTo::Target);
  
   // 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: Total energy per nucleon of the projectile nucleus
    * (target at rest).  */
   if (modus_cfg.has_value({"E_Tot"})) {
     const double e_tot = modus_cfg.take({"E_Tot"});
     if (e_tot < 0) {
       throw ModusDefault::InvalidEnergy(
           "Input Error: "
           "E_Tot must be nonnegative.");
     }
     // Set the total nucleus-nucleus collision energy.
     total_s_ = s_from_Etot(e_tot * projectile_->number_of_particles(),
                            mass_projec, mass_target);
     sqrt_s_NN_ = std::sqrt(s_from_Etot(e_tot, mass_a, mass_b));
     energy_input++;
   }
   /* Option 3: 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 4: 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++;
   }
   // Option 5: Total energy per nucleon of _each_ beam
   if (proj_cfg.has_value({"E_Tot"}) && targ_cfg.has_value({"E_Tot"})) {
     const double e_tot_p = proj_cfg.take({"E_Tot"});
     const double e_tot_t = targ_cfg.take({"E_tot"});
     if (e_tot_p < 0 || e_tot_t < 0) {
       throw ModusDefault::InvalidEnergy(
           "Input Error: "
           "E_Tot must be nonnegative.");
     }
     total_s_ = s_from_Etot(e_tot_p * projectile_->number_of_particles(),
                            e_tot_t * target_->number_of_particles(),
                            mass_projec, mass_target);
     sqrt_s_NN_ = std::sqrt(s_from_Ekin(e_tot_p, e_tot_t, mass_a, mass_b));
     energy_input++;
   }
   // Option 6: Kinetic energy per nucleon of _each_ beam
   if (proj_cfg.has_value({"E_Kin"}) && targ_cfg.has_value({"E_Kin"})) {
     const double e_kin_p = proj_cfg.take({"E_Kin"});
     const double e_kin_t = targ_cfg.take({"E_Kin"});
     if (e_kin_p < 0 || e_kin_t < 0) {
       throw ModusDefault::InvalidEnergy(
           "Input Error: "
           "E_Kin must be nonnegative.");
     }
     total_s_ = s_from_Ekin(e_kin_p * projectile_->number_of_particles(),
                            e_kin_t * target_->number_of_particles(),
                            mass_projec, mass_target);
     sqrt_s_NN_ = std::sqrt(s_from_Ekin(e_kin_p, e_kin_t, mass_a, mass_b));
     energy_input++;
   }
   // Option 7: Momentum per nucleon of _each_ beam
   if (proj_cfg.has_value({"P_Lab"}) && targ_cfg.has_value({"P_Lab"})) {
     const double p_lab_p = proj_cfg.take({"P_Lab"});
     const double p_lab_t = targ_cfg.take({"P_Lab"});
     if (p_lab_p < 0 || p_lab_t < 0) {
       throw ModusDefault::InvalidEnergy(
           "Input Error: "
           "P_Lab must be nonnegative.");
     }
     total_s_ = s_from_plab(p_lab_p * projectile_->number_of_particles(),
                            p_lab_t * target_->number_of_particles(),
                            mass_projec, mass_target);
     sqrt_s_NN_ = std::sqrt(s_from_plab(p_lab_p, p_lab_t, 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"});
     }
   }
   // whether the direction of separation should be ramdomly smapled
   random_reaction_plane_ =
       modus_cfg.take({"Impact", "Random_Reaction_Plane"}, false);
   // 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;
   }
  
   if (fermi_motion_ == FermiMotion::On) {
     logg[LCollider].info() << "Fermi motion is ON.";
   } else if (fermi_motion_ == FermiMotion::Frozen) {
     logg[LCollider].info() << "FROZEN Fermi motion is on.";
   } else if (fermi_motion_ == FermiMotion::Off) {
     logg[LCollider].info() << "Fermi motion is OFF.";
   }
 }

Here is the call graph for this function:

Member Function Documentation

◆ custom_file_path()

std::string smash::ColliderModus::custom_file_path	(	const std::string &	file_directory,
		const std::string &	file_name
	)

Creates full path string consisting of file_directory and file_name Needed to initialize a customnucleus.

Parameters

[in]	file_directory	is the path to the external file
[in]	file_name	is the name of the external file

Definition at line 734 of file collidermodus.cc.

                                                                         {
   // make sure that path is correct even if the / at the end is missing
   if (file_directory.back() == '/') {
     return file_directory + file_name;
   } else {
     return file_directory + '/' + file_name;
   }
 }

Here is the caller graph for this function:

◆ initial_conditions()

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 594 of file collidermodus.cc.

                                                                        {
   // 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();
   } else if (fermi_motion_ == FermiMotion::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);
   // rotation angle in the transverse plane
   const double phi =
       random_reaction_plane_ ? random::uniform(0.0, 2.0 * M_PI) : 0.0;
  
   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);
   rotate_reaction_plane(phi, particles);
   return simulation_time;
 }

Here is the call graph for this function:

◆ sample_impact()

void smash::ColliderModus::sample_impact ( )

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

◆ nuclei_passing_time()

double smash::ColliderModus::nuclei_passing_time ( ) const

inline

Time until nuclei have passed through each other.

Definition at line 103 of file collidermodus.h.

                                      {
     const double passing_distance =
         projectile_->get_nuclear_radius() + target_->get_nuclear_radius();
     const double passing_time =
         passing_distance /
         std::sqrt(sqrt_s_NN_ * sqrt_s_NN_ /
                       ((2 * nucleon_mass) * (2 * nucleon_mass)) -
                   1);
     return passing_time;
   }

◆ velocity_projectile()

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 118 of file collidermodus.h.

118 { return velocity_projectile_; }

◆ velocity_target()

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 123 of file collidermodus.h.

123 { return velocity_target_; }

◆ fermi_motion()

FermiMotion smash::ColliderModus::fermi_motion ( )

inline

Returns: The Fermi motion type

Definition at line 125 of file collidermodus.h.

125 { return fermi_motion_; }

◆ is_collider()

bool smash::ColliderModus::is_collider ( ) const

inline

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

Definition at line 127 of file collidermodus.h.

127 { return true; }

◆ sqrt_s_NN()

double smash::ColliderModus::sqrt_s_NN ( ) const

inline

Returns: center of mass energy per nucleon pair

Definition at line 129 of file collidermodus.h.

129 { return sqrt_s_NN_; }

◆ impact_parameter()

double smash::ColliderModus::impact_parameter ( ) const

inline

Returns: impact parameter of the collision

Definition at line 131 of file collidermodus.h.

131 { return impact_; }

◆ calculation_frame_is_fixed_target()

bool smash::ColliderModus::calculation_frame_is_fixed_target ( ) const

inline

Returns: Whether the calculation frame is the fixed target frame

Definition at line 133 of file collidermodus.h.

                                                  {
     return frame_ == CalculationFrame::FixedTarget ? true : false;
   }

◆ create_deformed_nucleus()

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 575 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, auto_deform);
     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:

◆ same_inputfile()

bool smash::ColliderModus::same_inputfile	(	Configuration &	proj_config,
		Configuration &	targ_config
	)

private

Checks if target and projectile are read from the same external file if they are both initialized as a customnucleus.

Function is only called if, projectile is customnucleus. /param[in] proj_config Configuration of projectile nucleus /param[in] targ_config Configuration of target nucleus

Definition at line 744 of file collidermodus.cc.

                                                                {
   /* Check if both nuclei are custom
    * Only check target as function is called after if statement for projectile.
    */
   if (!targ_config.has_value({"Custom"})) {
     return false;
   }
   std::string projectile_file_directory =
       proj_config.read({"Custom", "File_Directory"});
   std::string target_file_directory =
       targ_config.read({"Custom", "File_Directory"});
   std::string projectile_file_name = proj_config.read({"Custom", "File_Name"});
   std::string target_file_name = targ_config.read({"Custom", "File_Name"});
   // Check if files are the same for projectile and target
   std::string proj_path =
       custom_file_path(projectile_file_directory, projectile_file_name);
   std::string targ_path =
       custom_file_path(target_file_directory, target_file_name);
   if (proj_path == targ_path) {
     return true;
   } else {
     return false;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rotate_reaction_plane()

void smash::ColliderModus::rotate_reaction_plane	(	double	phi,
		Particles *	particles
	)

private

Rotate the reaction plane about the angle phi.

Parameters

[in]	phi	Angle about which to rotate
[in]	particles	Particles, whose position is rotated

Definition at line 665 of file collidermodus.cc.

                                                                           {
   for (ParticleData &p : *particles) {
     ThreeVector pos = p.position().threevec();
     ThreeVector mom = p.momentum().threevec();
     pos.rotate_around_z(phi);
     mom.rotate_around_z(phi);
     p.set_3position(pos);
     p.set_3momentum(mom);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_velocities()

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

◆ projectile_

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 152 of file collidermodus.h.

◆ target_

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 160 of file collidermodus.h.

◆ total_s_

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 166 of file collidermodus.h.

◆ sqrt_s_NN_

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 172 of file collidermodus.h.

◆ impact_

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 202 of file collidermodus.h.

◆ random_reaction_plane_

bool smash::ColliderModus::random_reaction_plane_

private

Whether the reaction plane should be randomized.

Definition at line 204 of file collidermodus.h.

◆ sampling_

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

private

Method used for sampling of impact parameter.

Definition at line 206 of file collidermodus.h.

◆ imp_min_

double smash::ColliderModus::imp_min_ = 0.0

private

Minimum value of impact parameter.

Definition at line 208 of file collidermodus.h.

◆ imp_max_

double smash::ColliderModus::imp_max_ = 0.0

private

Maximum value of impact parameter.

Definition at line 210 of file collidermodus.h.

◆ yield_max_

double smash::ColliderModus::yield_max_ = 0.0

private

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

Definition at line 212 of file collidermodus.h.

◆ impact_interpolation_

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

private

Initial value:

=

nullptr

Pointer to the impact parameter interpolation.

Definition at line 214 of file collidermodus.h.

◆ initial_z_displacement_

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 231 of file collidermodus.h.

◆ frame_

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

private

Reference frame for the system, as specified from config.

Definition at line 235 of file collidermodus.h.

◆ fermi_motion_

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

private

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

Definition at line 239 of file collidermodus.h.

◆ velocity_projectile_

double smash::ColliderModus::velocity_projectile_ = 0.0

private

Beam velocity of the projectile.

Definition at line 243 of file collidermodus.h.

◆ velocity_target_

double smash::ColliderModus::velocity_target_ = 0.0

private

Beam velocity of the target.

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

◆ ColliderModus()

Member Function Documentation

◆ custom_file_path()

◆ initial_conditions()

◆ sample_impact()

◆ nuclei_passing_time()

◆ velocity_projectile()

◆ velocity_target()

◆ fermi_motion()

◆ is_collider()

◆ sqrt_s_NN()

◆ impact_parameter()

◆ calculation_frame_is_fixed_target()

◆ create_deformed_nucleus()

◆ same_inputfile()

◆ rotate_reaction_plane()

◆ get_velocities()

Member Data Documentation

◆ projectile_

◆ target_

◆ total_s_

◆ sqrt_s_NN_

◆ impact_

◆ random_reaction_plane_

◆ sampling_

◆ imp_min_

◆ imp_max_

◆ yield_max_

◆ impact_interpolation_

◆ initial_z_displacement_

◆ frame_

◆ fermi_motion_

◆ velocity_projectile_

◆ velocity_target_