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)