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

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

◆ ThreeBodyDecayDilepton()

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 306 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!");
   }
 }

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.

                                                                     {
   return mother == mother_;
 }

◆ 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 [63], eq. (30)-(36).

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

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:1985gaz [35], equation (3.8)

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

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

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

Definition at line 337 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;
         }
       }
       case pdg::N1520_p:
       case -pdg::N1520_p:
       case pdg::N1520_z:
       case -pdg::N1520_z: {
         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 = 1.08;
           const double gamma_vi = t1 * t2 * 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());
   }
 }

◆ width()

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 448 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_ = std::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);
 }

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

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

Public Member Functions

Static Public Member Functions

Protected Attributes

Constructor & Destructor Documentation

◆ ThreeBodyDecayDilepton()

Member Function Documentation

◆ has_mother()

◆ diff_width()

◆ width()

◆ is_dilepton_decay()

Member Data Documentation

◆ tabulation_

◆ mother_