Version: SMASH-3.1
smash::ThreeBodyDecayDilepton Class Reference

#include <decaytype.h>

ThreeBodyDecayDilepton represents a decay type with three final-state particles, two of which are leptons.

Definition at line 317 of file decaytype.h.

Inheritance diagram for smash::ThreeBodyDecayDilepton:
smash::ThreeBodyDecay smash::DecayType

Public Member Functions

 ThreeBodyDecayDilepton (ParticleTypePtr mother, ParticleTypePtrList part_types, int l)
 Construct a ThreeBodyDecayDilepton. More...
 
bool has_mother (ParticleTypePtr mother) const override
 See DecayType::has_mother. More...
 
double width (double m0, double G0, double m) const override
 
bool is_dilepton_decay () const override
 
- Public Member Functions inherited from smash::ThreeBodyDecay
 ThreeBodyDecay (ParticleTypePtrList part_types, int l)
 Construct a ThreeBodyDecay. More...
 
unsigned int particle_number () const override
 
bool has_particles (ParticleTypePtrList list) const override
 
double in_width (double m0, double G0, double m, double m1, double m2) const override
 
- Public Member Functions inherited from smash::DecayType
 DecayType (ParticleTypePtrList part_types, int l)
 Construct a DecayType. More...
 
virtual ~DecayType ()=default
 Virtual Destructor. More...
 
virtual bool has_mother ([[maybe_unused]] ParticleTypePtr mother) const
 
const ParticleTypePtrList & particle_types () const
 
int angular_momentum () const
 

Static Public Member Functions

static double diff_width (double m_par, double m_l, double m_dil, double m_other, ParticleTypePtr other, ParticleTypePtr t)
 Get the mass-differential width \( d\Gamma / dm \) for a dilepton Dalitz decay, where \( m \) is the invariant mass of the lepton pair. More...
 

Protected Attributes

std::unique_ptr< Tabulationtabulation_
 Tabulation of the resonance integrals. More...
 
ParticleTypePtr mother_
 Type of the mother particle. More...
 
- Protected Attributes inherited from smash::DecayType
ParticleTypePtrList particle_types_
 final-state particles of the decay More...
 
int L_
 angular momentum of the decay More...
 

Constructor & Destructor Documentation

◆ ThreeBodyDecayDilepton()

smash::ThreeBodyDecayDilepton::ThreeBodyDecayDilepton ( ParticleTypePtr  mother,
ParticleTypePtrList  part_types,
int  l 
)

Construct a ThreeBodyDecayDilepton.

Parameters
[in]motherType of the mother particle.
[in]part_typesFinal-state particles of the decay.
[in]lAngular momentum of the decay.
Returns
The constructed object.

Definition at line 306 of file decaytype.cc.

309  : ThreeBodyDecay(part_types, l), tabulation_(nullptr), mother_(mother) {
310  if (!has_lepton_pair(particle_types_[0]->pdgcode(),
311  particle_types_[1]->pdgcode(),
312  particle_types_[2]->pdgcode())) {
313  throw std::runtime_error(
314  "Error: No dilepton in ThreeBodyDecayDilepton constructor: " +
315  part_types[0]->pdgcode().string() + " " +
316  part_types[1]->pdgcode().string() + " " +
317  part_types[2]->pdgcode().string());
318  }
319 
320  int non_lepton_position = -1;
321  for (int i = 0; i < 3; ++i) {
322  if (!particle_types_[i]->is_lepton()) {
323  non_lepton_position = i;
324  break;
325  }
326  }
327 
328  if (mother->pdgcode() == pdg::invalid || non_lepton_position == -1) {
329  throw std::runtime_error("Error: Unsupported dilepton Dalitz decay!");
330  }
331 }
ParticleTypePtrList particle_types_
final-state particles of the decay
Definition: decaytype.h:86
ParticleTypePtr mother_
Type of the mother particle.
Definition: decaytype.h:365
std::unique_ptr< Tabulation > tabulation_
Tabulation of the resonance integrals.
Definition: decaytype.h:362
ThreeBodyDecay(ParticleTypePtrList part_types, int l)
Construct a ThreeBodyDecay.
Definition: decaytype.cc:274
constexpr int invalid
Invalid particle.
bool has_lepton_pair(const PdgCode pdg1, const PdgCode pdg2, const PdgCode pdg3)
Definition: pdgcode.h:1129

Member Function Documentation

◆ has_mother()

bool smash::ThreeBodyDecayDilepton::has_mother ( ParticleTypePtr  mother) const
override

See DecayType::has_mother.

Definition at line 333 of file decaytype.cc.

333  {
334  return mother == mother_;
335 }

◆ diff_width()

double smash::ThreeBodyDecayDilepton::diff_width ( double  m_par,
double  m_l,
double  m_dil,
double  m_other,
ParticleTypePtr  other,
ParticleTypePtr  t 
)
static

Get the mass-differential width \( d\Gamma / dm \) for a dilepton Dalitz decay, where \( m \) is the invariant mass of the lepton pair.

This differential width is used directly for the dilepton shining weights. It is calculated according to Weil:2013mya [60], eq. (30)-(36).

Also see Staudenmaier:2017vtq [55] for a description of dilepton production in SMASH.

Parameters
[in]m_parMass of the parent.
[in]m_lMass of the lepton species.
[in]m_dilInvariant mass of the dilepton pair [GeV].
[in]m_otherMass of the third, non-leptonic, particle.
[in]otherType of the third particle.
[in]tType of the parent particle.
Returns
Mass differential width.

π⁰, η, η': see Landsberg:1985gaz [33], equation (3.8)

ω, φ: see Landsberg:1985gaz [33], equation (3.4)

Δ(1232): see Krivoruchenko:2001hs [30], equations (2) - (4)

N*(1520): see Krivoruchenko:2001jk [31], equation (III.22)

Definition at line 337 of file decaytype.cc.

340  {
341  // check threshold
342  if (m_par < m_dil + m_other) {
343  return 0;
344  }
345 
346  // abbreviations
347  const double m_dil_sqr = m_dil * m_dil;
348  const double m_par_sqr = m_par * m_par;
349  const double m_par_cubed = m_par * m_par * m_par;
350  const double m_other_sqr = m_other * m_other;
351  const double ph_sp_factor = std::sqrt(1. - 4. * m_l * m_l / m_dil_sqr) *
352  (1. + 2. * m_l * m_l / m_dil_sqr);
353 
354  PdgCode pdg = t->pdgcode();
355  if (pdg.is_meson()) {
356  const ParticleType& photon = ParticleType::find(pdg::photon);
357  switch (pdg.spin()) {
358  case 0: /* pseudoscalars: π⁰, η, η' */ {
359  // width for decay into 2γ
360  const double gamma_2g = t->get_partial_width(m_par, {&photon, &photon});
361  double ff = em_form_factor_ps(pdg, m_dil); // form factor
363  return (4. * fine_structure / (3. * M_PI)) * gamma_2g / m_dil *
364  pow_int(1. - m_dil / m_par * m_dil / m_par, 3) * ff * ff *
365  ph_sp_factor;
366  }
367  case 2: /* vectors: ω, φ */ {
368  // width for decay into Pγ with P = π,η
369  const double gamma_pg = t->get_partial_width(m_par, {other, &photon});
370  double ff_sqr =
371  em_form_factor_sqr_vec(pdg, m_dil); // form factor squared
373  const double n1 = m_par_sqr - m_other_sqr;
374  const double rad = pow_int(1. + m_dil_sqr / n1, 2) -
375  4. * m_par_sqr * m_dil_sqr / (n1 * n1);
376  if (rad < 0.) {
377  assert(rad > -1E-5);
378  return 0.;
379  } else {
380  return (2. * fine_structure / (3. * M_PI)) * gamma_pg / m_dil *
381  std::pow(rad, 3. / 2.) * ff_sqr * ph_sp_factor;
382  }
383  }
384  default:
385  throw std::runtime_error("Bad meson in ThreeBodyDecayDilepton: " +
386  pdg.string());
387  }
388  } else if (pdg.is_baryon()) {
389  switch (pdg.code()) {
390  case pdg::Delta_p:
391  case -pdg::Delta_p:
392  case pdg::Delta_z:
393  case -pdg::Delta_z: /* Δ⁺, Δ⁰ (and antiparticles) */ {
395  const double rad1 = (m_par + m_other) * (m_par + m_other) - m_dil_sqr;
396  const double rad2 = (m_par - m_other) * (m_par - m_other) - m_dil_sqr;
397  if (rad1 < 0.) {
398  assert(rad1 > -1E-5);
399  return 0.;
400  } else if (rad2 < 0.) {
401  assert(rad2 > -1E-5);
402  return 0.;
403  } else {
404  const double t1 = fine_structure / 16. * (m_par + m_other) *
405  (m_par + m_other) / (m_par_cubed * m_other_sqr) *
406  std::sqrt(rad1);
407  const double t2 = pow_int(std::sqrt(rad2), 3);
408  const double ff = form_factor_delta(m_dil);
409  const double gamma_vi = t1 * t2 * ff * ff;
410  return 2. * fine_structure / (3. * M_PI) * gamma_vi / m_dil *
411  ph_sp_factor;
412  }
413  }
414  case pdg::N1520_p:
415  case -pdg::N1520_p:
416  case pdg::N1520_z:
417  case -pdg::N1520_z: {
419  const double rad1 = (m_par - m_other) * (m_par - m_other) - m_dil_sqr;
420  const double rad2 = (m_par + m_other) * (m_par + m_other) - m_dil_sqr;
421  if (rad1 < 0.) {
422  assert(rad1 > -1E-5);
423  return 0.;
424  } else if (rad2 < 0.) {
425  assert(rad2 > -1E-5);
426  return 0.;
427  } else {
428  const double t1 = fine_structure / 16. * (m_par - m_other) *
429  (m_par - m_other) / (m_par_cubed * m_other_sqr) *
430  std::sqrt(rad1);
431  const double t2 = pow_int(std::sqrt(rad2), 3);
432  const double ff = 1.08;
433  const double gamma_vi = t1 * t2 * ff;
434  return 2. * fine_structure / (3. * M_PI) * gamma_vi / m_dil *
435  ph_sp_factor;
436  }
437  }
438  default:
439  throw std::runtime_error("Bad baryon in ThreeBodyDecayDilepton: " +
440  pdg.string());
441  }
442  } else {
443  throw std::runtime_error("Non-hadron in ThreeBodyDecayDilepton: " +
444  pdg.string());
445  }
446 }
static const ParticleType & find(PdgCode pdgcode)
Returns the ParticleType object for the given pdgcode.
Definition: particletype.cc:99
constexpr int Delta_p
Δ⁺.
constexpr int N1520_z
N(1520)⁰.
constexpr int photon
Photon.
constexpr int N1520_p
N(1520)⁺.
constexpr int Delta_z
Δ⁰.
double em_form_factor_sqr_vec(PdgCode pdg, double mass)
Definition: formfactors.h:122
double form_factor_delta([[maybe_unused]] double m)
Definition: formfactors.h:146
constexpr T pow_int(const T base, unsigned const exponent)
Efficient template for calculating integer powers using squaring.
Definition: pow.h:23
constexpr double fine_structure
Fine-struture constant, approximately 1/137.
Definition: constants.h:95
double em_form_factor_ps(PdgCode pdg, double mass)
Definition: formfactors.h:99

◆ width()

double smash::ThreeBodyDecayDilepton::width ( double  m0,
double  G0,
double  m 
) const
overridevirtual
Returns
the mass-dependent width of the decay.
Parameters
[in]m0Pole mass of the decaying particle [GeV].
[in]G0Partial width at the pole mass [GeV].
[in]mActual mass of the decaying particle [GeV].

Reimplemented from smash::ThreeBodyDecay.

Definition at line 448 of file decaytype.cc.

448  {
449  if (mother_->is_stable()) {
450  return G0;
451  }
452 
453  if (!tabulation_) {
454  int non_lepton_position = -1;
455  for (int i = 0; i < 3; ++i) {
456  if (!particle_types_[i]->is_lepton()) {
457  non_lepton_position = i;
458  break;
459  }
460  }
461  // lepton mass
462  const double m_l = particle_types_[(non_lepton_position + 1) % 3]->mass();
463  // mass of non-leptonic particle in final state
464  const double m_other = particle_types_[non_lepton_position]->mass();
465 
466  // integrate differential width to obtain partial width
467  double M0 = mother_->mass();
468  double G0tot = mother_->width_at_pole();
469  tabulation_ = std::make_unique<Tabulation>(
470  m_other + 2 * m_l, M0 + 10 * G0tot, num_tab_pts, [&](double m_parent) {
471  const double bottom = 2 * m_l;
472  const double top = m_parent - m_other;
473  if (top < bottom) { // numerical problems at lower bound
474  return 0.;
475  }
476  return integrate(bottom, top,
477  [&](double m_dil) {
478  return diff_width(
479  m_parent, m_l, m_dil, m_other,
480  particle_types_[non_lepton_position], mother_);
481  })
482  .value();
483  });
484  }
485 
486  return tabulation_->get_value_linear(m, Extrapolation::Const);
487 }
bool is_stable() const
Definition: particletype.h:246
double width_at_pole() const
Definition: particletype.h:151
double mass() const
Definition: particletype.h:145
static double diff_width(double m_par, double m_l, double m_dil, double m_other, ParticleTypePtr other, ParticleTypePtr t)
Get the mass-differential width for a dilepton Dalitz decay, where is the invariant mass of the lep...
Definition: decaytype.cc:337
static Integrator integrate
Definition: decaytype.cc:143
constexpr size_t num_tab_pts
Number of tabulation points.
Definition: decaytype.cc:142

◆ is_dilepton_decay()

bool smash::ThreeBodyDecayDilepton::is_dilepton_decay ( ) const
inlineoverridevirtual
Returns
whether the decay is a dilepton decay (most decays are hadronic)

Reimplemented from smash::DecayType.

Definition at line 358 of file decaytype.h.

358 { return true; }

Member Data Documentation

◆ tabulation_

std::unique_ptr<Tabulation> smash::ThreeBodyDecayDilepton::tabulation_
mutableprotected

Tabulation of the resonance integrals.

Definition at line 362 of file decaytype.h.

◆ mother_

ParticleTypePtr smash::ThreeBodyDecayDilepton::mother_
protected

Type of the mother particle.

Definition at line 365 of file decaytype.h.


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