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 270 of file decaytype.h.

Inheritance diagram for smash::ThreeBodyDecayDilepton:

Collaboration diagram for smash::ThreeBodyDecayDilepton:

Public Member Functions
	ThreeBodyDecayDilepton (ParticleTypePtr mother, ParticleTypePtrList part_types, int l)
	Construct a ThreeBodyDecayDilepton. More...
bool	has_mother (ParticleTypePtr mother) const override
double	width (double m0, double G0, double m) 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...
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< Tabulation >	tabulation_
	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

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

Construct a ThreeBodyDecayDilepton.

Parameters

[in]	mother	Type of the mother particle.
[in]	part_types	Final-state particles of the decay.
[in]	l	Angular momentum of the decay.

Returns

The constructed object.

Definition at line 310 of file decaytype.cc.

    : ThreeBodyDecay(part_types, l), tabulation_(nullptr), mother_(mother) {
  if (!has_lepton_pair(particle_types_[0]->pdgcode(),
                       particle_types_[1]->pdgcode(),
                       particle_types_[2]->pdgcode())) {
    throw std::runtime_error(
        "Error: No dilepton in ThreeBodyDecayDilepton constructor: " +
        part_types[0]->pdgcode().string() + " " +
        part_types[1]->pdgcode().string() + " " +
        part_types[2]->pdgcode().string());
  }

  int non_lepton_position = -1;
  for (int i = 0; i < 3; ++i) {
    if (!particle_types_[i]->is_lepton()) {
      non_lepton_position = i;
      break;
    }
  }

  if (mother->pdgcode() == pdg::invalid || non_lepton_position == -1) {
    throw std::runtime_error("Error: Unsupported dilepton Dalitz decay!");
  }
}

Here is the call graph for this function:

Member Function Documentation

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

overridevirtual

Returns

if this decay type has the right mother (most decays do not depend on the mother type).

Parameters

[in]

mother

Particle type to be checked.

Reimplemented from smash::DecayType.

Definition at line 337 of file decaytype.cc.

                                                                    {
  return mother == mother_;
}

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, eq. (30)-(36).

Todo:

{Cite SMASH dilepton paper.}

Parameters

[in]	m_par	Mass of the parent.
[in]	m_l	Mass of the lepton species.
[in]	m_dil	Invariant mass of the dilepton pair [GeV].
[in]	m_other	Mass of the third, non-leptonic, particle.
[in]	other	Type of the third particle.
[in]	t	Type of the parent particle.

Returns

Mass differential width.

see Landsberg:1986fd, equation (3.8)

see Landsberg:1986fd, equation (3.4)

see Krivoruchenko:2001hs

Definition at line 341 of file decaytype.cc.

                                                             {
  // check threshold
  if (m_par < m_dil + m_other) {
    return 0;
  }

  // abbreviations
  const double m_dil_sqr = m_dil * m_dil;
  const double m_par_sqr = m_par * m_par;
  const double m_par_cubed = m_par * m_par * m_par;
  const double m_other_sqr = m_other * m_other;
  const double ph_sp_factor = std::sqrt(1. - 4. * m_l * m_l / m_dil_sqr) *
                              (1. + 2. * m_l * m_l / m_dil_sqr);

  PdgCode pdg = t->pdgcode();
  if (pdg.is_meson()) {
    const ParticleType& photon = ParticleType::find(pdg::photon);
    switch (pdg.spin()) {
      case 0: /* pseudoscalars: π⁰, η, η' */ {
        // width for decay into 2γ
        const double gamma_2g = t->get_partial_width(m_par, photon, photon);
        double ff = em_form_factor_ps(pdg, m_dil);  // form factor
        return (4. * fine_structure / (3. * M_PI)) * gamma_2g / m_dil *
               pow_int(1. - m_dil / m_par * m_dil / m_par, 3) * ff * ff *
               ph_sp_factor;
      }
      case 2: /* vectors: ω, φ */ {
        // width for decay into Pγ with P = π,η
        const double gamma_pg = t->get_partial_width(m_par, *other, photon);
        double ff_sqr =
            em_form_factor_sqr_vec(pdg, m_dil);  // form factor squared
        const double n1 = m_par_sqr - m_other_sqr;
        const double rad = pow_int(1. + m_dil_sqr / n1, 2) -
                           4. * m_par_sqr * m_dil_sqr / (n1 * n1);
        if (rad < 0.) {
          assert(rad > -1E-5);
          return 0.;
        } else {
          return (2. * fine_structure / (3. * M_PI)) * gamma_pg / m_dil *
                 std::pow(rad, 3. / 2.) * ff_sqr * ph_sp_factor;
        }
      }
      default:
        throw std::runtime_error("Bad meson in ThreeBodyDecayDilepton: " +
                                 pdg.string());
    }
  } else if (pdg.is_baryon()) {
    switch (pdg.code()) {
      case pdg::Delta_p:
      case -pdg::Delta_p:
      case pdg::Delta_z:
      case -pdg::Delta_z: /* Δ⁺, Δ⁰ (and antiparticles) */ {
        const double rad1 = (m_par + m_other) * (m_par + m_other) - m_dil_sqr;
        const double rad2 = (m_par - m_other) * (m_par - m_other) - m_dil_sqr;
        if (rad1 < 0.) {
          assert(rad1 > -1E-5);
          return 0.;
        } else if (rad2 < 0.) {
          assert(rad2 > -1E-5);
          return 0.;
        } else {
          const double t1 = fine_structure / 16. * (m_par + m_other) *
                            (m_par + m_other) / (m_par_cubed * m_other_sqr) *
                            std::sqrt(rad1);
          const double t2 = pow_int(std::sqrt(rad2), 3);
          const double ff = form_factor_delta(m_dil);
          const double gamma_vi = t1 * t2 * ff * ff;
          return 2. * fine_structure / (3. * M_PI) * gamma_vi / m_dil *
                 ph_sp_factor;
        }
      }
      default:
        throw std::runtime_error("Bad baryon in ThreeBodyDecayDilepton: " +
                                 pdg.string());
    }
  } else {
    throw std::runtime_error("Non-hadron in ThreeBodyDecayDilepton: " +
                             pdg.string());
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

double smash::ThreeBodyDecayDilepton::width ( double  m0, double  G0, double  m  ) const

overridevirtual

Returns

the mass-dependent width of the decay.

Parameters

[in]	m0	Pole mass of the decaying particle [GeV].
[in]	G0	Partial width at the pole mass [GeV].
[in]	m	Actual mass of the decaying particle [GeV].

Reimplemented from smash::ThreeBodyDecay.

Definition at line 428 of file decaytype.cc.

                                                                      {
  if (mother_->is_stable()) {
    return G0;
  }

  if (!tabulation_) {
    int non_lepton_position = -1;
    for (int i = 0; i < 3; ++i) {
      if (!particle_types_[i]->is_lepton()) {
        non_lepton_position = i;
        break;
      }
    }
    // lepton mass
    const double m_l = particle_types_[(non_lepton_position + 1) % 3]->mass();
    // mass of non-leptonic particle in final state
    const double m_other = particle_types_[non_lepton_position]->mass();

    // integrate differential width to obtain partial width
    double M0 = mother_->mass();
    double G0tot = mother_->width_at_pole();
    tabulation_ = make_unique<Tabulation>(
        m_other + 2 * m_l, M0 + 10 * G0tot, num_tab_pts, [&](double m_parent) {
          const double bottom = 2 * m_l;
          const double top = m_parent - m_other;
          if (top < bottom) {  // numerical problems at lower bound
            return 0.;
          }
          return integrate(bottom, top,
                           [&](double m_dil) {
                             return diff_width(
                                 m_parent, m_l, m_dil, m_other,
                                 particle_types_[non_lepton_position], mother_);
                           })
              .value();
        });
  }

  return tabulation_->get_value_linear(m, Extrapolation::Const);
}

Here is the call graph for this function:

Member Data Documentation

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

mutableprotected

Tabulation of the resonance integrals.

Definition at line 309 of file decaytype.h.

ParticleTypePtr smash::ThreeBodyDecayDilepton::mother_

protected

Type of the mother particle.

Definition at line 312 of file decaytype.h.

---

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

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