smash::ScatterAction Class Reference

#include <scatteraction.h>

ScatterAction is a special action which takes two incoming particles and performs a scattering, producing one or more final-state particles.

Definition at line 31 of file scatteraction.h.

Inheritance diagram for smash::ScatterAction:

Collaboration diagram for smash::ScatterAction:

Classes
class	InvalidScatterAction
	Thrown when ScatterAction is called to perform with unknown ProcessType. More...

Public Member Functions
	ScatterAction (const ParticleData &in_part1, const ParticleData &in_part2, double time, bool isotropic=false, double string_formation_time=1.0)
	Construct a ScatterAction object. More...
void	add_collision (CollisionBranchPtr p)
	Add a new collision channel. More...
void	add_collisions (CollisionBranchList pv)
	Add several new collision channels at once. More...
double	transverse_distance_sqr () const
	Calculate the transverse distance of the two incoming particles in their local rest frame. More...
void	generate_final_state () override
	Generate the final-state of the scattering process. More...
double	get_total_weight () const override
	Get the total cross section of scattering particles. More...
double	get_partial_weight () const override
	Get the partial cross section of the chosen channel. More...
void	sample_angles (std::pair< double, double > masses, double kinetic_energy_cm) override
	Sample final-state angles in a 2->2 collision (possibly anisotropic). More...
void	add_all_scatterings (double elastic_parameter, bool two_to_one, ReactionsBitSet included_2to2, double low_snn_cut, bool strings_switch, bool use_AQM, bool strings_with_probability, NNbarTreatment nnbar_treatment)
	Add all possible scattering subprocesses for this action object. More...
const CollisionBranchList &	collision_channels ()
	Get list of possible collision channels. More...
void	set_string_interface (StringProcess *str_proc)
	Set the StringProcess object to be used. More...
virtual double	cross_section () const
	Get the total cross section of the scattering particles. More...
Public Member Functions inherited from smash::Action
	Action (const ParticleList &in_part, double time)
	Construct an action object with incoming particles and relative time. More...
	Action (const ParticleData &in_part, const ParticleData &out_part, double time, ProcessType type)
	Construct an action object with the incoming particles, relative time, and the already known outgoing particles and type of the process. More...
	Action (const ParticleList &in_part, const ParticleList &out_part, double absolute_execution_time, ProcessType type)
	Construct an action object with the incoming particles, absolute time, and the already known outgoing particles and type of the process. More...
	Action (const Action &)=delete
	Copying is disabled. Use pointers or create a new Action. More...
virtual	~Action ()
	Virtual Destructor. More...
bool	operator< (const Action &rhs) const
	Determine whether one action takes place before another in time. More...
virtual ProcessType	get_type () const
	Get the process type. More...
template<typename Branch >
void	add_process (ProcessBranchPtr< Branch > &p, ProcessBranchList< Branch > &subprocesses, double &total_weight)
	Add a new subprocess. More...
template<typename Branch >
void	add_processes (ProcessBranchList< Branch > pv, ProcessBranchList< Branch > &subprocesses, double &total_weight)
	Add several new subprocesses at once. More...
virtual void	perform (Particles *particles, uint32_t id_process)
	Actually perform the action, e.g. More...
bool	is_valid (const Particles &particles) const
	Check whether the action still applies. More...
bool	is_pauli_blocked (const Particles &particles, const PauliBlocker &p_bl) const
	Check if the action is Pauli-blocked. More...
const ParticleList &	incoming_particles () const
	Get the list of particles that go into the action. More...
void	update_incoming (const Particles &particles)
	Update the incoming particles that are stored in this action to the state they have in the global particle list. More...
const ParticleList &	outgoing_particles () const
	Get the list of particles that resulted from the action. More...
double	time_of_execution () const
	Get the time at which the action is supposed to be performed. More...
void	check_conservation (const uint32_t id_process) const
	Check various conservation laws. More...
double	sqrt_s () const
	Determine the total energy in the center-of-mass frame [GeV]. More...
FourVector	total_momentum_of_outgoing_particles () const
	Calculate the total kinetic momentum of the outgoing particles. More...
FourVector	get_interaction_point () const
	Get the interaction point. More...
std::pair< FourVector, FourVector >	get_potential_at_interaction_point () const
	Get the skyrme and asymmetry potential at the interaction point. More...

Protected Member Functions
double	mandelstam_s () const
	Determine the Mandelstam s variable,. More...
double	cm_momentum () const
	Get the momentum of the center of mass of the incoming particles in the calculation frame. More...
double	cm_momentum_squared () const
	Get the squared momentum of the center of mass of the incoming particles in the calculation frame. More...
ThreeVector	beta_cm () const
	Get the velocity of the center of mass of the scattering particles in the calculation frame. More...
double	gamma_cm () const
	Get the gamma factor corresponding to a boost to the center of mass frame of the colliding particles. More...
void	elastic_scattering ()
	Perform an elastic two-body scattering, i.e. just exchange momentum. More...
void	inelastic_scattering ()
	Perform an inelastic two-body scattering, i.e. new particles are formed. More...
void	string_excitation ()
	Todo(ryu): document better - it is not really UrQMD-based, isn't it? Perform the UrQMD-based string excitation and decay. More...
void	format_debug_output (std::ostream &out) const override
	Writes information about this scatter action to the out stream. More...
Protected Member Functions inherited from smash::Action
FourVector	total_momentum () const
	Sum of 4-momenta of incoming particles. More...
template<typename Branch >
const Branch *	choose_channel (const ProcessBranchList< Branch > &subprocesses, double total_weight)
	Decide for a particular final-state channel via Monte-Carlo and return it as a ProcessBranch. More...
virtual std::pair< double, double >	sample_masses (double kinetic_energy_cm) const
	Sample final-state masses in general X->2 processes (thus also fixing the absolute c.o.m. More...
void	sample_2body_phasespace ()
	Sample the full 2-body phase-space (masses, momenta, angles) in the center-of-mass frame for the final state particles. More...
virtual void	sample_3body_phasespace ()
	Sample the full 3-body phase-space (masses, momenta, angles) in the center-of-mass frame for the final state particles. More...

Protected Attributes
CollisionBranchList	collision_channels_
	List of possible collisions. More...
double	total_cross_section_
	Total hadronic cross section. More...
double	partial_cross_section_
	Partial cross-section to the chosen outgoing channel. More...
bool	isotropic_ = false
	Do this collision isotropically? More...
double	string_formation_time_ = 1.0
	Time fragments take to be fully formed in hard string excitation. More...
Protected Attributes inherited from smash::Action
ParticleList	incoming_particles_
	List with data of incoming particles. More...
ParticleList	outgoing_particles_
	Initially this stores only the PDG codes of final-state particles. More...
const double	time_of_execution_
	Time at which the action is supposed to be performed (absolute time in the lab frame in fm/c). More...
ProcessType	process_type_
	type of process More...

Private Member Functions
bool	is_elastic () const
	Check if the scattering is elastic. More...
void	resonance_formation ()
	Perform a 2->1 resonance-formation process. More...

Private Attributes
StringProcess *	string_process_ = nullptr
	Pointer to interface class for strings. More...

Constructor & Destructor Documentation

smash::ScatterAction::ScatterAction	(	const ParticleData &	in_part1,
		const ParticleData &	in_part2,
		double	time,
		bool	isotropic = false,
		double	string_formation_time = 1.0
	)

Construct a ScatterAction object.

Parameters

[in]	in_part1	first scattering partner
[in]	in_part2	second scattering partner
[in]	time	Time at which the action is supposed to take place
[in]	isotropic	if true, do the collision isotropically
[in]	string_formation_time	Time string fragments take to form

Definition at line 32 of file scatteraction.cc.

    : Action({in_part_a, in_part_b}, time),
      total_cross_section_(0.),
      isotropic_(isotropic),
      string_formation_time_(string_formation_time) {}

Member Function Documentation

void smash::ScatterAction::add_collision

(

CollisionBranchPtr

p

)

Add a new collision channel.

Parameters

[in]

p

Channel to be added.

Definition at line 40 of file scatteraction.cc.

                                                      {
  add_process<CollisionBranch>(p, collision_channels_, total_cross_section_);
}

Here is the caller graph for this function:

void smash::ScatterAction::add_collisions

(

CollisionBranchList

pv

)

Add several new collision channels at once.

Parameters

[in]

pv

list of channels to be added.

Definition at line 44 of file scatteraction.cc.

                                                         {
  add_processes<CollisionBranch>(std::move(pv), collision_channels_,
                                 total_cross_section_);
}

Here is the caller graph for this function:

double smash::ScatterAction::transverse_distance_sqr

(

)

const

Calculate the transverse distance of the two incoming particles in their local rest frame.

According to UrQMD criterion position of particle a: x_a
position of particle b: x_b
momentum of particle a: p_a
momentum of particle b: p_b

\[d^2_\mathrm{coll} = (\vec{x_a} - \vec{x_b})^2 - \frac{((\vec{x_a} - \vec{x_b}) \cdot (\vec{p_a} - \vec{p_b}))^2 } {(\vec{p_a} - \vec{p_b})^2}\]

Returns

squared distance \(d^2_\mathrm{coll}\).

UrQMD squared distance criterion: Bass:1998ca (3.27): in center of momentum frame position of particle a: x_a position of particle b: x_b momentum of particle a: p_a momentum of particle b: p_b d^2_{coll} = (x_a - x_b)^2 - ((x_a - x_b) . (p_a - p_b))^2 / (p_a - p_b)^2

Definition at line 168 of file scatteraction.cc.

                                                    {
  // local copy of particles (since we need to boost them)
  ParticleData p_a = incoming_particles_[0];
  ParticleData p_b = incoming_particles_[1];
  /* Boost particles to center-of-momentum frame. */
  const ThreeVector velocity = beta_cm();
  p_a.boost(velocity);
  p_b.boost(velocity);
  const ThreeVector pos_diff =
      p_a.position().threevec() - p_b.position().threevec();
  const ThreeVector mom_diff =
      p_a.momentum().threevec() - p_b.momentum().threevec();

  const auto &log = logger<LogArea::ScatterAction>();
  log.debug("Particle ", incoming_particles_,
            " position difference [fm]: ", pos_diff,
            ", momentum difference [GeV]: ", mom_diff);

  const double dp2 = mom_diff.sqr();
  const double dr2 = pos_diff.sqr();
  /* Zero momentum leads to infite distance. */
  if (dp2 < really_small) {
    return dr2;
  }
  const double dpdr = pos_diff * mom_diff;

  const double result = dr2 - dpdr * dpdr / dp2;
  return result > 0.0 ? result : 0.0;
}

Here is the call graph for this function:

void smash::ScatterAction::generate_final_state ( )

overridevirtual

Generate the final-state of the scattering process.

Performs either elastic or inelastic scattering.

Exceptions

InvalidScatterAction

Implements smash::Action.

Reimplemented in smash::ScatterActionPhoton.

Definition at line 49 of file scatteraction.cc.

                                         {
  const auto &log = logger<LogArea::ScatterAction>();

  log.debug("Incoming particles: ", incoming_particles_);

  /* Decide for a particular final state. */
  const CollisionBranch *proc = choose_channel<CollisionBranch>(
      collision_channels_, total_cross_section_);
  process_type_ = proc->get_type();
  outgoing_particles_ = proc->particle_list();
  partial_cross_section_ = proc->weight();

  log.debug("Chosen channel: ", process_type_, outgoing_particles_);

  /* The production point of the new particles.  */
  FourVector middle_point = get_interaction_point();

  switch (process_type_) {
    case ProcessType::Elastic:
      /* 2->2 elastic scattering */
      elastic_scattering();
      break;
    case ProcessType::TwoToOne:
      /* resonance formation */
      resonance_formation();
      break;
    case ProcessType::TwoToTwo:
      /* 2->2 inelastic scattering */
      /* Sample the particle momenta in CM system. */
      inelastic_scattering();
      break;
    case ProcessType::StringSoftSingleDiffractiveAX:
    case ProcessType::StringSoftSingleDiffractiveXB:
    case ProcessType::StringSoftDoubleDiffractive:
    case ProcessType::StringSoftAnnihilation:
    case ProcessType::StringSoftNonDiffractive:
    case ProcessType::StringHard:
      string_excitation();
      break;
    default:
      throw InvalidScatterAction(
          "ScatterAction::generate_final_state: Invalid process type " +
          std::to_string(static_cast<int>(process_type_)) + " was requested. " +
          "(PDGcode1=" + incoming_particles_[0].pdgcode().string() +
          ", PDGcode2=" + incoming_particles_[1].pdgcode().string() + ")");
  }

  for (ParticleData &new_particle : outgoing_particles_) {
    // Boost to the computational frame
    new_particle.boost_momentum(
        -total_momentum_of_outgoing_particles().velocity());
    /* Set positions of the outgoing particles */
    if (proc->get_type() != ProcessType::Elastic) {
      new_particle.set_4position(middle_point);
    }
  }
}

Here is the call graph for this function:

double smash::ScatterAction::get_total_weight ( ) const

overridevirtual

Get the total cross section of scattering particles.

Returns

total cross section.

Implements smash::Action.

Reimplemented in smash::ScatterActionPhoton.

Definition at line 136 of file scatteraction.cc.

                                             {
  return total_cross_section_ * incoming_particles_[0].xsec_scaling_factor() *
         incoming_particles_[1].xsec_scaling_factor();
}

double smash::ScatterAction::get_partial_weight ( ) const

overridevirtual

Get the partial cross section of the chosen channel.

Returns

partial cross section.

Implements smash::Action.

Definition at line 141 of file scatteraction.cc.

                                               {
  return partial_cross_section_ * incoming_particles_[0].xsec_scaling_factor() *
         incoming_particles_[1].xsec_scaling_factor();
}

void smash::ScatterAction::sample_angles ( std::pair< double, double >  masses, double  kinetic_energy_cm  )

overridevirtual

Sample final-state angles in a 2->2 collision (possibly anisotropic).

NN → NN: Choose angular distribution according to Cugnon parametrization, see Cugnon:1996kh.

NN → NΔ: Sample scattering angles in center-of-mass frame from an anisotropic angular distribution, using the same distribution as for elastic pp scattering, as suggested in Cugnon:1996kh.

NN → NR: Fit to HADES data, see Agakishiev:2014wqa.

Reimplemented from smash::Action.

Definition at line 250 of file scatteraction.cc.

                                                            {
  if (is_string_soft_process(process_type_) ||
      (process_type_ == ProcessType::StringHard)) {
    // We potentially have more than two particles, so the following angular
    // distributions don't work. Instead we just keep the angular
    // distributions generated by string fragmentation.
    return;
  }
  assert(outgoing_particles_.size() == 2);
  const auto &log = logger<LogArea::ScatterAction>();

  // NN scattering is anisotropic currently
  const bool nn_scattering = incoming_particles_[0].type().is_nucleon() &&
                             incoming_particles_[1].type().is_nucleon();
  /* Elastic process is anisotropic and
   * the angular distribution is based on the NN elastic scattering. */
  const bool el_scattering = process_type_ == ProcessType::Elastic;

  const double mass_in_a = incoming_particles_[0].effective_mass();
  const double mass_in_b = incoming_particles_[1].effective_mass();

  ParticleData *p_a = &outgoing_particles_[0];
  ParticleData *p_b = &outgoing_particles_[1];

  const double mass_a = masses.first;
  const double mass_b = masses.second;

  const std::array<double, 2> t_range = get_t_range<double>(
      kinetic_energy_cm, mass_in_a, mass_in_b, mass_a, mass_b);
  Angles phitheta;
  if (el_scattering && !isotropic_) {
    double mandelstam_s_new = 0.;
    if (nn_scattering) {
      mandelstam_s_new = mandelstam_s();
    } else {
      /* In the case of elastic collisions other than NN collisions,
       * there is an ambiguity on how to get the lab-frame momentum (plab),
       * since the incoming particles can have different masses.
       * Right now, we first obtain the center-of-mass momentum
       * of the collision (pcom_now).
       * Then, the lab-frame momentum is evaluated from the mandelstam s,
       * which yields the original center-of-mass momentum
       * when nucleon mass is assumed. */
      const double pcm_now = pCM_from_s(mandelstam_s(), mass_in_a, mass_in_b);
      mandelstam_s_new =
          4. * std::sqrt(pcm_now * pcm_now + nucleon_mass * nucleon_mass);
    }
    double bb, a, plab = plab_from_s(mandelstam_s_new);
    if (nn_scattering &&
        p_a->pdgcode().antiparticle_sign() ==
            p_b->pdgcode().antiparticle_sign() &&
        std::abs(p_a->type().charge() + p_b->type().charge()) == 1) {
      // proton-neutron and antiproton-antineutron
      bb = std::max(Cugnon_bnp(plab), really_small);
      a = (plab < 0.8) ? 1. : 0.64 / (plab * plab);
    } else {
      /* all others including pp, nn and AQM elastic processes
       * This is applied for all particle pairs, which are allowed to
       * interact elastically. */
      bb = std::max(Cugnon_bpp(plab), really_small);
      a = 1.;
    }
    double t = random::expo(bb, t_range[0], t_range[1]);
    if (random::canonical() > 1. / (1. + a)) {
      t = t_range[0] + t_range[1] - t;
    }
    // determine scattering angles in center-of-mass frame
    phitheta = Angles(2. * M_PI * random::canonical(),
                      1. - 2. * (t - t_range[0]) / (t_range[1] - t_range[0]));
  } else if (nn_scattering && p_a->pdgcode().is_Delta() &&
             p_b->pdgcode().is_nucleon() &&
             p_a->pdgcode().antiparticle_sign() ==
                 p_b->pdgcode().antiparticle_sign() &&
             !isotropic_) {
    const double plab = plab_from_s(mandelstam_s());
    const double bb = std::max(Cugnon_bpp(plab), really_small);
    double t = random::expo(bb, t_range[0], t_range[1]);
    if (random::canonical() > 0.5) {
      t = t_range[0] + t_range[1] - t;  // symmetrize
    }
    phitheta = Angles(2. * M_PI * random::canonical(),
                      1. - 2. * (t - t_range[0]) / (t_range[1] - t_range[0]));
  } else if (nn_scattering && p_b->pdgcode().is_nucleon() && !isotropic_ &&
             (p_a->type().is_Nstar() || p_a->type().is_Deltastar())) {
    const std::array<double, 4> p{1.46434, 5.80311, -6.89358, 1.94302};
    const double a = p[0] + mass_a * (p[1] + mass_a * (p[2] + mass_a * p[3]));
    /*  If the resonance is so heavy that the index "a" exceeds 30,
     *  the power function turns out to be too sharp. Take t directly to be
     *  t_0 in such a case. */
    double t = t_range[0];
    if (a < 30) {
      t = random::power(-a, t_range[0], t_range[1]);
    }
    if (random::canonical() > 0.5) {
      t = t_range[0] + t_range[1] - t;  // symmetrize
    }
    phitheta = Angles(2. * M_PI * random::canonical(),
                      1. - 2. * (t - t_range[0]) / (t_range[1] - t_range[0]));
  } else {
    /* isotropic angular distribution */
    phitheta.distribute_isotropically();
  }

  ThreeVector pscatt = phitheta.threevec();
  // 3-momentum of first incoming particle in center-of-mass frame
  ThreeVector pcm =
      incoming_particles_[0].momentum().LorentzBoost(beta_cm()).threevec();
  pscatt.rotate_z_axis_to(pcm);

  // final-state CM momentum
  const double p_f = pCM(kinetic_energy_cm, mass_a, mass_b);
  if (!(p_f > 0.0)) {
    log.warn("Particle: ", p_a->pdgcode(), " radial momentum: ", p_f);
    log.warn("Etot: ", kinetic_energy_cm, " m_a: ", mass_a, " m_b: ", mass_b);
  }
  p_a->set_4momentum(mass_a, pscatt * p_f);
  p_b->set_4momentum(mass_b, -pscatt * p_f);

  /* Debug message is printed before boost, so that p_a and p_b are
   * the momenta in the center of mass frame and thus opposite to
   * each other.*/
  log.debug("p_a: ", *p_a, "\np_b: ", *p_b);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void smash::ScatterAction::add_all_scatterings	(	double	elastic_parameter,
		bool	two_to_one,
		ReactionsBitSet	included_2to2,
		double	low_snn_cut,
		bool	strings_switch,
		bool	use_AQM,
		bool	strings_with_probability,
		NNbarTreatment	nnbar_treatment
	)

Add all possible scattering subprocesses for this action object.

Parameters

[in]	elastic_parameter	If non-zero, given global elastic cross section.
[in]	two_to_one	2->1 reactions enabled?
[in]	included_2to2	Which 2->2 reactions are enabled?
[in]	low_snn_cut	Elastic collisions with CME below are forbidden.
[in]	strings_switch	Are string processes enabled?
[in]	use_AQM	use elastic cross sections via AQM?
[in]	strings_with_probability	Are string processes triggered according to a probability?
[in]	nnbar_treatment	NNbar treatment through resonance, strings or none

Definition at line 107 of file scatteraction.cc.

                                                                   {
  CrossSections xs(incoming_particles_, sqrt_s(),
                   get_potential_at_interaction_point());
  CollisionBranchList processes = xs.generate_collision_list(
      elastic_parameter, two_to_one, included_2to2, low_snn_cut, strings_switch,
      use_AQM, strings_with_probability, nnbar_treatment, string_process_);

  /* Add various subprocesses.*/
  add_collisions(std::move(processes));

  /* If the string processes are not triggered by a probability, then they
   * always happen as long as the parametrized total cross section is larger
   * than the sum of the cross sections of the non-string processes, and the
   * square root s exceeds the threshold by at least 0.9 GeV. The cross section
   * of the string processes are counted by taking the difference between the
   * parametrized total and the sum of the non-strings. */
  if (!strings_with_probability &&
      xs.string_probability(strings_switch, strings_with_probability, use_AQM,
                            nnbar_treatment == NNbarTreatment::Strings) == 1.) {
    const double xs_diff = xs.high_energy() - cross_section();
    if (xs_diff > 0.) {
      add_collisions(xs.string_excitation(xs_diff, string_process_, use_AQM));
    }
  }
}

Here is the call graph for this function:

const CollisionBranchList& smash::ScatterAction::collision_channels ( )

inline

Get list of possible collision channels.

Returns

list of possible collision channels.

Definition at line 132 of file scatteraction.h.

                                                  {
    return collision_channels_;
  }

void smash::ScatterAction::set_string_interface ( StringProcess *  str_proc )

inline

Set the StringProcess object to be used.

The StringProcess object is used to handle string excitation and to generate final state particles.

Parameters

[in]

str_proc

String process object to be used.

Definition at line 152 of file scatteraction.h.

                                                     {
    string_process_ = str_proc;
  }

virtual double smash::ScatterAction::cross_section ( ) const

inlinevirtual

Get the total cross section of the scattering particles.

Returns

total cross section.

Definition at line 161 of file scatteraction.h.

{ return total_cross_section_; }

Here is the call graph for this function:

Here is the caller graph for this function:

double smash::ScatterAction::mandelstam_s ( ) const

protected

Determine the Mandelstam s variable,.

\[s = (p_a + p_b)^2\]

Equal to the square of CMS energy.

Returns

Mandelstam s

Definition at line 154 of file scatteraction.cc.

{ return total_momentum().sqr(); }

Here is the call graph for this function:

Here is the caller graph for this function:

double smash::ScatterAction::cm_momentum ( ) const

protected

Get the momentum of the center of mass of the incoming particles in the calculation frame.

Returns

center of mass momentum.

Definition at line 156 of file scatteraction.cc.

                                        {
  const double m1 = incoming_particles_[0].effective_mass();
  const double m2 = incoming_particles_[1].effective_mass();
  return pCM(sqrt_s(), m1, m2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

double smash::ScatterAction::cm_momentum_squared ( ) const

protected

Get the squared momentum of the center of mass of the incoming particles in the calculation frame.

Returns

center of mass momentum squared.

Definition at line 162 of file scatteraction.cc.

                                                {
  const double m1 = incoming_particles_[0].effective_mass();
  const double m2 = incoming_particles_[1].effective_mass();
  return pCM_sqr(sqrt_s(), m1, m2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ThreeVector smash::ScatterAction::beta_cm ( ) const

protected

Get the velocity of the center of mass of the scattering particles in the calculation frame.

Returns

boost velocity between center of mass and calculation frame.

Definition at line 146 of file scatteraction.cc.

                                         {
  return total_momentum().velocity();
}

Here is the call graph for this function:

Here is the caller graph for this function:

double smash::ScatterAction::gamma_cm ( ) const

protected

Get the gamma factor corresponding to a boost to the center of mass frame of the colliding particles.

Returns

gamma factor.

Definition at line 150 of file scatteraction.cc.

                                     {
  return (1. / std::sqrt(1.0 - beta_cm().sqr()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void smash::ScatterAction::elastic_scattering ( )

protected

Perform an elastic two-body scattering, i.e. just exchange momentum.

Definition at line 382 of file scatteraction.cc.

                                       {
  // copy initial particles into final state
  outgoing_particles_[0] = incoming_particles_[0];
  outgoing_particles_[1] = incoming_particles_[1];
  // resample momenta
  sample_angles({outgoing_particles_[0].effective_mass(),
                 outgoing_particles_[1].effective_mass()},
                sqrt_s());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void smash::ScatterAction::inelastic_scattering ( )

protected

Perform an inelastic two-body scattering, i.e. new particles are formed.

Definition at line 392 of file scatteraction.cc.

                                         {
  // create new particles
  sample_2body_phasespace();
  /* Set the formation time of the 2 particles to the larger formation time of
   * the incoming particles, if it is larger than the execution time;
   * execution time is otherwise taken to be the formation time */
  const double t0 = incoming_particles_[0].formation_time();
  const double t1 = incoming_particles_[1].formation_time();

  const size_t index_tmax = (t0 > t1) ? 0 : 1;
  const double form_time_begin =
      incoming_particles_[index_tmax].begin_formation_time();
  const double sc =
      incoming_particles_[index_tmax].initial_xsec_scaling_factor();
  if (t0 > time_of_execution_ || t1 > time_of_execution_) {
    /* The newly produced particles are supposed to continue forming exactly
     * like the latest forming ingoing particle. Therefore the details on the
     * formation are adopted. The initial cross section scaling factor of the
     * incoming particles is considered to also be the scaling factor of the
     * newly produced outgoing particles.
     */
    outgoing_particles_[0].set_slow_formation_times(form_time_begin,
                                                    std::max(t0, t1));
    outgoing_particles_[1].set_slow_formation_times(form_time_begin,
                                                    std::max(t0, t1));
    outgoing_particles_[0].set_cross_section_scaling_factor(sc);
    outgoing_particles_[1].set_cross_section_scaling_factor(sc);
  } else {
    outgoing_particles_[0].set_formation_time(time_of_execution_);
    outgoing_particles_[1].set_formation_time(time_of_execution_);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void smash::ScatterAction::string_excitation ( )

protected

Todo(ryu): document better - it is not really UrQMD-based, isn't it? Perform the UrQMD-based string excitation and decay.

Definition at line 466 of file scatteraction.cc.

                                      {
  assert(incoming_particles_.size() == 2);
  const auto &log = logger<LogArea::Pythia>();
  // Disable floating point exception trap for Pythia
  {
    DisableFloatTraps guard;
    /* initialize the string_process_ object for this particular collision */
    string_process_->init(incoming_particles_, time_of_execution_);
    /* implement collision */
    bool success = false;
    int ntry = 0;
    const int ntry_max = 10000;
    while (!success && ntry < ntry_max) {
      ntry++;
      switch (process_type_) {
        case ProcessType::StringSoftSingleDiffractiveAX:
          /* single diffractive to A+X */
          success = string_process_->next_SDiff(true);
          break;
        case ProcessType::StringSoftSingleDiffractiveXB:
          /* single diffractive to X+B */
          success = string_process_->next_SDiff(false);
          break;
        case ProcessType::StringSoftDoubleDiffractive:
          /* double diffractive */
          success = string_process_->next_DDiff();
          break;
        case ProcessType::StringSoftNonDiffractive:
          /* soft non-diffractive */
          success = string_process_->next_NDiffSoft();
          break;
        case ProcessType::StringSoftAnnihilation:
          /* soft BBbar 2 mesonic annihilation */
          success = string_process_->next_BBbarAnn();
          break;
        case ProcessType::StringHard:
          success = string_process_->next_NDiffHard();
          break;
        default:
          log.error("Unknown string process required.");
          success = false;
      }
    }
    if (ntry == ntry_max) {
      /* If pythia fails to form a string, it is usually because the energy
       * is not large enough. In this case, an elastic scattering happens.
       *
       * Since particles are normally added after process selection for
       * strings, outgoing_particles is still uninitialized, and memory
       * needs to be allocated. We also shift the process_type_ to elastic
       * so that sample_angles does a proper treatment. */
      outgoing_particles_.reserve(2);
      outgoing_particles_.push_back(ParticleData{incoming_particles_[0]});
      outgoing_particles_.push_back(ParticleData{incoming_particles_[1]});
      process_type_ = ProcessType::Elastic;
      elastic_scattering();
    } else {
      outgoing_particles_ = string_process_->get_final_state();
      /* If the incoming particles already were unformed, the formation
       * times and cross section scaling factors need to be adjusted */
      const double tform_in = std::max(incoming_particles_[0].formation_time(),
                                       incoming_particles_[1].formation_time());
      if (tform_in > time_of_execution_) {
        const double fin =
            (incoming_particles_[0].formation_time() >
             incoming_particles_[1].formation_time())
                ? incoming_particles_[0].initial_xsec_scaling_factor()
                : incoming_particles_[1].initial_xsec_scaling_factor();
        for (size_t i = 0; i < outgoing_particles_.size(); i++) {
          const double tform_out = outgoing_particles_[i].formation_time();
          const double fout =
              outgoing_particles_[i].initial_xsec_scaling_factor();
          /* The new cross section scaling factor will be the product of the
           * cross section scaling factor of the ingoing particles and of the
           * outgoing ones (since the outgoing ones are also string fragments
           * and thus take time to form). */
          outgoing_particles_[i].set_cross_section_scaling_factor(fin * fout);
          /* If the unformed incoming particles' formation time is larger than
           * the current outgoing particle's formation time, then the latter
           * is overwritten by the former*/
          if (tform_in > tform_out) {
            outgoing_particles_[i].set_slow_formation_times(time_of_execution_,
                                                            tform_in);
          }
        }
      }
      /* Check momentum difference for debugging */
      FourVector out_mom;
      for (ParticleData data : outgoing_particles_) {
        out_mom += data.momentum();
      }
      log.debug("Incoming momenta string:", total_momentum());
      log.debug("Outgoing momenta string:", out_mom);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool smash::ScatterAction::is_elastic ( ) const

private

Check if the scattering is elastic.

Returns

whether the scattering is elastic.

void smash::ScatterAction::resonance_formation ( )

private

Perform a 2->1 resonance-formation process.

Exceptions

InvalidResonanceFormation

Definition at line 425 of file scatteraction.cc.

                                        {
  const auto &log = logger<LogArea::ScatterAction>();

  if (outgoing_particles_.size() != 1) {
    std::string s =
        "resonance_formation: "
        "Incorrect number of particles in final state: ";
    s += std::to_string(outgoing_particles_.size()) + " (";
    s += incoming_particles_[0].pdgcode().string() + " + ";
    s += incoming_particles_[1].pdgcode().string() + ")";
    throw InvalidResonanceFormation(s);
  }
  // Set the momentum of the formed resonance in its rest frame.
  outgoing_particles_[0].set_4momentum(
      total_momentum_of_outgoing_particles().abs(), 0., 0., 0.);
  /* Set the formation time of the resonance to the larger formation time of the
   * incoming particles, if it is larger than the execution time; execution time
   * is otherwise taken to be the formation time */
  const double t0 = incoming_particles_[0].formation_time();
  const double t1 = incoming_particles_[1].formation_time();

  const size_t index_tmax = (t0 > t1) ? 0 : 1;
  const double begin_form_time =
      incoming_particles_[index_tmax].begin_formation_time();
  const double sc =
      incoming_particles_[index_tmax].initial_xsec_scaling_factor();
  if (t0 > time_of_execution_ || t1 > time_of_execution_) {
    outgoing_particles_[0].set_slow_formation_times(begin_form_time,
                                                    std::max(t0, t1));
    outgoing_particles_[0].set_cross_section_scaling_factor(sc);
  } else {
    outgoing_particles_[0].set_formation_time(time_of_execution_);
  }
  /* this momentum is evaluated in the computational frame. */
  log.debug("Momentum of the new particle: ",
            outgoing_particles_[0].momentum());
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

CollisionBranchList smash::ScatterAction::collision_channels_

protected

List of possible collisions.

Definition at line 221 of file scatteraction.h.

double smash::ScatterAction::total_cross_section_

protected

Total hadronic cross section.

Definition at line 224 of file scatteraction.h.

double smash::ScatterAction::partial_cross_section_

protected

Partial cross-section to the chosen outgoing channel.

Definition at line 227 of file scatteraction.h.

bool smash::ScatterAction::isotropic_ = false

protected

Do this collision isotropically?

Definition at line 230 of file scatteraction.h.

double smash::ScatterAction::string_formation_time_ = 1.0

protected

Time fragments take to be fully formed in hard string excitation.

Definition at line 233 of file scatteraction.h.

StringProcess* smash::ScatterAction::string_process_ = nullptr

private

Pointer to interface class for strings.

Definition at line 250 of file scatteraction.h.

---

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

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