def generate_f_0_amplitude(coefficients, pole):
chebyshev = cheb.chebval(omega_1(pole), coefficients)
loop_kaon = loop_function(pole, KAON_MASS)
loop_pion = loop_function(pole, PION_MASS)
phase_space = rho(PION_MASS, pole)
denominator = (loop_pion * pole).imag - 2.0 * (phase_space * pole).real
cheb_kaon = chebyshev * loop_kaon
g_parameter = -(pole + cheb_kaon).imag / denominator
m_parameter = (cheb_kaon.real +
((loop_pion.imag - 2.0 * phase_space.real) * abs(pole)**2 -
cheb_kaon.imag *
((pole * loop_pion).real + 2.0 *
(pole * phase_space).imag)) / denominator)
def amplitude(s):
chebyshev = cheb.chebval(omega_1(s), coefficients)
loop_1 = loop_function(s, PION_MASS)
loop_2 = loop_function(s, KAON_MASS)
return (
s * g_parameter /
(m_parameter - s - loop_1 * s * g_parameter - loop_2 * chebyshev))
return amplitude
def _tan_phase(mandelstam_s, isospin, pion_mass, peak, coefficients):
threshold = 4.0 * pion_mass**2
param = mandelstam_s / threshold - 1.0
phase_space = rho(pion_mass, mandelstam_s)
polynomial = sum(coeff * param**i for i, coeff in enumerate(coefficients))
peak_factor = (threshold - peak) / (mandelstam_s - peak)
return phase_space * param**to_spin(isospin) * polynomial * peak_factor
def partial_wave(mandelstam_s, resonance_mass, resonance_width,
angular_momentum, mass):
"""The Breit Wigner partial wave with an energy dependent width.
Note
----
This differs from the one in the PDG via one phase space factor that
is introduced in the appropriate place to
1. obtain a unitarity relation of the form
Im(partial_wave) = (phase_space) * abs(partial_wave)**2
2. avoid division by zero at threshold.
Moreover, the coupling is fixed by unitarity.
"""
width = width_energy_dependent(mandelstam_s, resonance_mass,
resonance_width, angular_momentum, mass)
width *= resonance_mass
space = rho(mass, mandelstam_s)
return -width / (mandelstam_s - resonance_mass**2 + width * space * 1j)
def amplitude(*args):
phase_value = phase(*args)
inelastic = inelasticity(args[-1])
numerator = inelastic * np.exp(2j * phase_value) - 1
return numerator / rho(mass, args[-1]) / 2j
def amplitude(*args):
return 1 / (cot_phase(*args) - 1j) / rho(mass, args[-1])
def test_peak(isospin):
peak = literature_values(isospin, pion_mass=1.0)[0]
tan = tan_phase_lit(peak, isospin, pion_mass=1.0)
partial_wave = partial_wave_lit(peak, isospin, pion_mass=1.0)
assert tan == np.inf
assert partial_wave == pytest.approx(1j / rho(1.0, peak))
def test_unitarity():
mandelstam_s = np.linspace(5.0, 40.0, 50) * PION_MASS**2
one = np.imag(nlo(mandelstam_s))
two = rho(PION_MASS, mandelstam_s) * np.abs(nlo(mandelstam_s))**2
assert np.allclose(one, two)
def rho(s):
return kps.rho(MASS, s)
def conformal_amplitude(s):
conf = conformal_polynomial(omega(s, s_0=s_0, alpha=1))
prefactor = PION_MASS**2 / (s - 0.5 * a2)
psi = prefactor * (a2 / PION_MASS / csqrt(s) + conf)
return 1.0 / (psi - 1j * rho(PION_MASS, s))
def wrapper(mandelstam_s):
return 1.0 + 2.0j * rho(mass, mandelstam_s) * func(mandelstam_s)
def momentum(s):
return csqrt(s) * rho(PION_MASS, s) / 2.0
def inelasticity(s):
amp = amplitude(s)
space = rho(PION_MASS, s)
return np.sqrt((2.0 * space * amp.real)**2 +
(1.0 - 2.0 * space * amp.imag)**2)
def phase(s):
amp = amplitude(s)
space = rho(PION_MASS, s)
numerator = 2.0 * space * amp.real
denominator = 1.0 - 2.0 * space * amp.imag
return 0.5 * arctan2_alt(numerator, denominator)
def amplitude(s):
conf = conformal_amplitude(s)
f_0 = f_0_amplitude(s)
return conf + f_0 + 2j * rho(PION_MASS, s) * conf * f_0
def second(*args):
first = amplitude(*args)
return first / (1 + 2j * rho(mass, args[-1]) * first)
def first(*args):
second = amplitude(*args)
return second / (1 - 2j * rho(mass, args[-1]) * second)
def loop_function(s, mass):
phase_space = rho(mass, s)
return ((2.0 + phase_space * clog(
(phase_space - 1) / (phase_space + 1))) / np.pi)