def mass_matrix(right: S) -> np.ndarray:
if right == S.UR:
(left, a_species, mf) = (S.QL, A.U, self.output.sm.mass_u())
dl, dr, mu = (1 / 2 - 2 / 3 * sw2), 2 / 3 * sw2, mu_cot_b
vev = self.output.sm.vev() * tan2sin(self.output.ewsb.tan_beta)
elif right == S.DR:
(left, a_species, mf) = (S.QL, A.D, self.output.sm.mass_d())
dl, dr, mu = -(1 / 2 - 1 / 3 * sw2), -1 / 3 * sw2, mu_tan_b
vev = self.output.sm.vev() * tan2cos(self.output.ewsb.tan_beta)
elif right == S.ER:
(left, a_species, mf) = (S.LL, A.E, self.output.sm.mass_e())
dl, dr, mu = -(1 / 2 - sw2), -sw2, mu_tan_b
vev = self.output.sm.vev() * tan2cos(self.output.ewsb.tan_beta)
else:
raise NotImplementedError
msl2 = self.output.get_matrix(left.slha2_output)
if right == S.UR:
msl2 = ckm @ msl2 @ dag(ckm)
msr2 = self.output.get_matrix(right.slha2_output)
mf = np.diag(mf)
t = self.output.get_matrix(a_species.out_t)
# SLHA Eq.23-25 and SUSY Primer (8.4.18)
return m_join(
msl2 + mf**2 + dl * mz2_cos2b,
vev / (2**0.5) * dag(t) - mf * mu,
vev / (2**0.5) * t - mf * np.conjugate(mu),
msr2 + mf**2 + dr * mz2_cos2b,
)
def _calculate_neutralino(self):
assert self.output.sm is not None
assert self.output.ewsb.is_set()
cb = tan2cos(self.output.ewsb.tan_beta)
sb = tan2sin(self.output.ewsb.tan_beta)
sw = self.output.sm.sin_w_sq()**0.5
cw = sin2cos(sw)
mz = self.output.sm.mz()
m1 = self.output.get_float("MSOFT", 1)
m2 = self.output.get_float("MSOFT", 2)
mu = self.output.ewsb.mu
# Since CPV is not supported, m_psi0 is real and nmix will be real.
m_psi0 = np.array([
[m1, 0, -mz * cb * sw, mz * sb * sw],
[0, m2, mz * cb * cw, -mz * sb * cw],
[-mz * cb * sw, mz * cb * cw, 0, -mu],
[mz * sb * sw, -mz * sb * cw, -mu, 0],
]) # SLHA (21)
masses, nmix = autonne_takagi(m_psi0, try_real_mixing=True)
self.output.set_mass(1000022, masses[0])
self.output.set_mass(1000023, masses[1])
self.output.set_mass(1000025, masses[2])
self.output.set_mass(1000035, masses[3])
self.output.set_matrix("NMIX", nmix)
def test_trigonometric_random(self):
sin_regions = [i * math.pi / 4 for i in [-2, -1, 0, 1, 2]]
cos_regions = [i * math.pi / 4 for i in [0, 1, 2, 3, 4]]
for i in range(0, 4):
# for sin2xxx and tan2xxx, where -pi/2 < theta < pi/2
theta = random.uniform(sin_regions[i], sin_regions[i + 1])
sin = math.sin(theta)
cos = math.cos(theta)
tan = math.tan(theta)
sin2 = math.sin(2 * theta)
cos2 = math.cos(2 * theta)
tan2 = math.tan(2 * theta)
self.assertAlmostEqual(cos, u.sin2cos(sin))
self.assertAlmostEqual(tan, u.sin2tan(sin))
self.assertAlmostEqual(sin, u.tan2sin(tan))
self.assertAlmostEqual(cos, u.tan2cos(tan))
self.assertAlmostEqual(sin2, u.tan2sintwo(tan))
self.assertAlmostEqual(cos2, u.tan2costwo(tan))
self.assertAlmostEqual(tan2, u.tan2tantwo(tan))
# for cos2xxx, where 0 < theta < pi
theta = random.uniform(cos_regions[i], cos_regions[i + 1])
sin = math.sin(theta)
cos = math.cos(theta)
tan = math.tan(theta)
self.assertAlmostEqual(sin, u.cos2sin(cos))
self.assertAlmostEqual(tan, u.cos2tan(cos))
def _calculate_chargino(self):
assert self.output.sm is not None
assert self.output.ewsb.is_set()
cb = tan2cos(self.output.ewsb.tan_beta)
sb = tan2sin(self.output.ewsb.tan_beta)
sqrt2_mw = 2**0.5 * self.output.sm.mw()
m2 = self.output.get_float("MSOFT", 2)
mu = self.output.ewsb.mu
m_psi_plus = np.array([[m2, sqrt2_mw * sb], [sqrt2_mw * cb,
mu]]) # SLHA (22)
masses, umix, vmix = singular_value_decomposition(m_psi_plus)
self.output.set_mass(1000024, masses[0])
self.output.set_mass(1000037, masses[1])
self.output.set_matrix("UMIX", umix)
self.output.set_matrix("VMIX", vmix)
def ye(self) -> List[float]:
assert isinstance(self.tan_beta, float)
return [(2**0.5) * mass / self.sm.vev() / tan2cos(self.tan_beta)
for mass in self.sm.mass_e()]