smash::ColliderModus Class Reference

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

Collaboration diagram for smash::ColliderModus:

Classes
struct	ColliderEmpty

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...
int	total_N_number () const
int	proj_N_number () const
double	nuclei_passing_time () const
	Time until nuclei have passed through each other. More...
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
bool	is_box () const
bool	is_list () const
double	impact_parameter () const
double	velocity_projectile () const
double	velocity_target () const
FermiMotion	fermi_motion () const
double	max_timestep (double) const
double	length () const
double	equilibration_time () const
double	nuclei_passing_time () const
	Get the passing time of the two nuclei in a collision. More...
Grid< GridOptions::Normal >	create_grid (const Particles &particles, double min_cell_length, double timestep_duration, CellSizeStrategy strategy=CellSizeStrategy::Optimal) const
	Creates the Grid with normal boundary conditions. More...

Private 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...
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...
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...
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 &)

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 264 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"});
  }
 
  // Determine whether to allow the first collisions within the same nucleus
  if (modus_cfg.has_value({"Collisions_Within_Nucleus"})) {
    cll_in_nucleus_ = modus_cfg.take({"Collisions_Within_Nucleus"});
  }
  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.");
  }
 
  // 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.");
  }
 
  // 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"});
    }
  }
  // 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;
  }
}

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

                                                                       {
  sample_impact();
 
  logg[LCollider].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) {
      logg[LCollider].info() << "Fermi motion is ON.";
    } else {
      logg[LCollider].info() << "FROZEN Fermi motion is on.";
    }
  } else if (fermi_motion_ == FermiMotion::Off) {
    // No Fermi-momenta are generated in this case
    logg[LCollider].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);
  // 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:

total_N_number()

int smash::ColliderModus::total_N_number ( ) const

inline

Returns

The total number of test particles in the initial nuclei

Definition at line 89 of file collidermodus.h.

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

proj_N_number()

int smash::ColliderModus::proj_N_number ( ) const

inline

Returns

The number of test particles in the projectile nucleus

Definition at line 91 of file collidermodus.h.

{ return projectile_->size(); }

nuclei_passing_time()

double smash::ColliderModus::nuclei_passing_time ( ) const

inline

Time until nuclei have passed through each other.

Definition at line 94 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 109 of file collidermodus.h.

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

{ return velocity_target_; }

cll_in_nucleus()

bool smash::ColliderModus::cll_in_nucleus ( )

inline

Returns

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

Definition at line 118 of file collidermodus.h.

{ return cll_in_nucleus_; }

fermi_motion()

FermiMotion smash::ColliderModus::fermi_motion ( )

inline

Returns

The Fermi motion type

Definition at line 120 of file collidermodus.h.

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

{ return true; }

impact_parameter()

double smash::ColliderModus::impact_parameter ( ) const

inline

Returns

impact parameter of the collision

Definition at line 124 of file collidermodus.h.

{ return impact_; }

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 451 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 630 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 551 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:

sample_impact()

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

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 593 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 140 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 148 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 154 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 160 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 190 of file collidermodus.h.

random_reaction_plane_

bool smash::ColliderModus::random_reaction_plane_

private

Whether the reaction plane should be randomized.

Definition at line 192 of file collidermodus.h.

sampling_

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

private

Method used for sampling of impact parameter.

Definition at line 194 of file collidermodus.h.

imp_min_

double smash::ColliderModus::imp_min_ = 0.0

private

Minimum value of impact parameter.

Definition at line 196 of file collidermodus.h.

imp_max_

double smash::ColliderModus::imp_max_ = 0.0

private

Maximum value of impact parameter.

Definition at line 198 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 200 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 202 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 230 of file collidermodus.h.

frame_

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

private

Reference frame for the system, as specified from config.

Definition at line 234 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 238 of file collidermodus.h.

cll_in_nucleus_

bool smash::ColliderModus::cll_in_nucleus_ = false

private

An option to accept first collisions within the same nucleus.

Definition at line 242 of file collidermodus.h.

velocity_projectile_

double smash::ColliderModus::velocity_projectile_ = 0.0

private

Beam velocity of the projectile.

Definition at line 246 of file collidermodus.h.

velocity_target_

double smash::ColliderModus::velocity_target_ = 0.0

private

Beam velocity of the target.

Definition at line 250 of file collidermodus.h.

---

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

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