def __init__(self, wc, parameters=None, qed_order=1, qcd_order=1):
"""Initialize the instance.
Parameters:
- wc: instance of `wcxf.WC` representing Wilson coefficient values
at a given (input) scale. The EFT must be one of `WET`, `WET-4`,
or `WET-3`; the basis must be `JMS`.
- parameters: optional. If provided, must be a dictionary containing
values for the input parameters as defined in `run.wet.parameters`.
Default values are used for all parameters not provided.
- `qcd_order`: order of QCD ADMs. 0: neglect. 1 (default): LO.
- `qed_order`: order of QED ADMs. 0: neglect. 1 (default): LO.
"""
assert isinstance(wc, wcxf.WC)
assert wc.basis == 'JMS', \
"Wilson coefficients must be given in the 'JMS' basis"
self.eft = wc.eft
# number of quark flavours
if self.eft == 'WET':
self.f = 5
elif self.eft == 'WET-4':
self.f = 4
elif self.eft == 'WET-3':
self.f = 3
self.scale_in = wc.scale
self.C_in = wc.dict
self.parameters = default_parameters.copy()
self.qed_order = qed_order
self.qcd_order = qcd_order
if parameters is not None:
self.parameters.update(parameters)
def warsaw_to_warsawmass(C, parameters=None, sectors=None):
"""Translate from the Warsaw basis to the 'Warsaw mass' basis.
Parameters used:
- `Vus`, `Vub`, `Vcb`, `gamma`: elements of the unitary CKM matrix (defined
as the mismatch between left-handed quark mass matrix diagonalization
matrices).
"""
p = default_parameters.copy()
if parameters is not None:
# if parameters are passed in, overwrite the default values
p.update(parameters)
# start out with a 1:1 copy
C_out = C.copy()
# rotate left-handed up-type quark fields in uL-uR operator WCs
C_rotate_u = ['uphi', 'uG', 'uW', 'uB']
for name in C_rotate_u:
_array = smeft_toarray(name, C)
V = ckmutil.ckm.ckm_tree(p["Vus"], p["Vub"], p["Vcb"], p["delta"])
UuL = V.conj().T
_array = UuL.conj().T @ _array
_dict = smeft_fromarray(name, _array)
C_out.update(_dict)
# diagonalize dimension-5 Weinberg operator
_array = smeft_toarray('llphiphi', C)
_array = np.diag(ckmutil.diag.msvd(_array)[1])
_dict = smeft_fromarray('llphiphi', _array)
C_out.update(_dict)
return C_out
def match_all(d_SMEFT, parameters=None):
"""Match the SMEFT Warsaw basis onto the WET JMS basis."""
p = default_parameters.copy()
if parameters is not None:
# if parameters are passed in, overwrite the default values
p.update(parameters)
C = wilson.util.smeftutil.wcxf2arrays_symmetrized(d_SMEFT)
C['vT'] = 246.22
C_WET = match_all_array(C, p)
C_WET = wilson.translate.wet.rotate_down(C_WET, p)
C_WET = wetutil.unscale_dict_wet(C_WET)
d_WET = wilson.util.smeftutil.arrays2wcxf(C_WET)
basis = wcxf.Basis['WET', 'JMS']
keys = set(d_WET.keys()) & set(basis.all_wcs)
d_WET = {k: d_WET[k] for k in keys}
return d_WET
def _get_sm_left(self, scale, f, loop=3):
C_in_SM = {}
parameters = default_parameters.copy()
m_d = qcd.m_s(parameters['m_d'],
scale,
f,
parameters['alpha_s'],
loop=loop)
m_s = qcd.m_s(parameters['m_s'],
scale,
f,
parameters['alpha_s'],
loop=loop)
m_b = qcd.m_b(parameters['m_b'],
scale,
f,
parameters['alpha_s'],
loop=loop)
m_u = qcd.m_s(parameters['m_u'],
scale,
f,
parameters['alpha_s'],
loop=loop)
m_c = qcd.m_c(parameters['m_c'],
scale,
f,
parameters['alpha_s'],
loop=loop)
# running ignored for alpha_e and lepton mass
m_e = parameters['m_e']
m_mu = parameters['m_mu']
m_tau = parameters['m_tau']
C_in_SM['gs'] = sqrt(
4 * pi * qcd.alpha_s(scale, f, parameters['alpha_s'], loop=loop))
C_in_SM['e'] = sqrt(4 * pi * parameters['alpha_e'])
C_in_SM['Me'] = np.array([[m_e, 0, 0], [0, m_mu, 0], [0, 0, m_tau]])
C_in_SM['Md'] = np.array([[m_d, 0, 0], [0, m_s, 0], [0, 0, m_b]])
C_in_SM['Mu'] = np.array([[m_u, 0], [0, m_c]])
C_in_SM['Mnu'] = np.array([[0, 0, 0], [0, 0, 0], [0, 0, 0]]) # update?
return C_in_SM
def warsaw_up_to_warsaw(C, parameters=None, sectors=None):
"""Translate from the 'Warsaw up' basis to the Warsaw basis.
Parameters used:
- `Vus`, `Vub`, `Vcb`, `gamma`: elements of the unitary CKM matrix (defined
as the mismatch between left-handed quark mass matrix diagonalization
matrices).
"""
C_in = smeftutil.wcxf2arrays_symmetrized(C)
p = default_parameters.copy()
if parameters is not None:
# if parameters are passed in, overwrite the default values
p.update(parameters)
Uu = Ud = Ul = Ue = np.eye(3)
V = ckmutil.ckm.ckm_tree(p["Vus"], p["Vub"], p["Vcb"], p["delta"])
Uq = V
C_out = smeft_warsaw.flavor_rotation(C_in, Uq, Uu, Ud, Ul, Ue)
C_out = smeftutil.arrays2wcxf_nonred(C_out)
return C_out
def warsaw_to_warsaw_up(C, parameters=None, sectors=None):
"""Translate from the Warsaw basis to the 'Warsaw mass' basis.
Parameters used:
- `Vus`, `Vub`, `Vcb`, `gamma`: elements of the unitary CKM matrix (defined
as the mismatch between left-handed quark mass matrix diagonalization
matrices).
"""
C_in = smeftutil.wcxf2arrays_symmetrized(C)
p = default_parameters.copy()
if parameters is not None:
# if parameters are passed in, overwrite the default values
p.update(parameters)
Uu = Ud = Ul = Ue = np.eye(3)
V = ckmutil.ckm.ckm_tree(p["Vus"], p["Vub"], p["Vcb"], p["delta"])
Uq = V.conj().T
C_out = smeftutil.flavor_rotation(C_in, Uq, Uu, Ud, Ul, Ue)
C_out = smeftutil.arrays2wcxf_nonred(C_out)
warsawup = wcxf.Basis['SMEFT', 'Warsaw up']
allkeys = set(warsawup.all_wcs) # to speed up lookup
return {k: v for k, v in C_out.items() if k in allkeys}
def warsaw_up_to_higgslike(C, parameters=None, sectors=None):
basis = wcxf.Basis["SMEFT", "Warsaw up"]
W = {k: C.get(k, 0) for k in basis.all_wcs}
H = W.copy()
p = default_parameters.copy()
if parameters is not None:
# if parameters are passed in, overwrite the default values
p.update(parameters)
V = ckmutil.ckm.ckm_tree(p["Vus"], p["Vub"], p["Vcb"], p["delta"])
Vdag = V.T.conjugate()
# parameters
# neglecting dim.-6 corrections here as these are higher-order
# when multiplying dim.-6 WCs!
v = 1 / sqrt(sqrt(2) * p["GF"]) # Higgs VEV
lam = p["m_h"] ** 2 / (2 * v ** 2) # Higgs self-coupling
e = sqrt(4 * pi * p["alpha_e"])
s2w = 1 / 2 * (1 - sqrt(1 - (4 * pi * p['alpha_e']) / (sqrt(2) * p['GF'] * p['m_Z']**2)))
gs = sqrt(4 * pi * p["alpha_s"])
sw = sqrt(s2w)
g = gw = e / sw
c2w = 1 - s2w
cw = sqrt(c2w)
gp = e / cw
gw2 = g ** 2
gp2 = gp ** 2
gs2 = gs ** 2
def f(T3, Q, i, j): # [eqn (4.11)]
if i == j:
Acoeff = -gw * gp / (gw2 - gp2) * W["phiWB"]
Zcoeff = (
W["ll_1221"] / 4
- W["phil3_11"].real / 2
- W["phil3_22"].real / 2
- W["phiD"] / 4
)
return Acoeff * Q + Zcoeff * (T3 + Q * gp2 / (gw2 - gp2))
else:
return 0
# rotate Cphiq3 + Cphiq1 to down basis
Cphiq1 = np.zeros((3, 3), complex)
Cphiq3 = np.zeros((3, 3), complex)
for i in range(3):
for j in range(3):
if j >= i:
ind = "_{}{}".format(i + 1, j + 1)
Cphiq1[i, j] = W["phiq1" + ind]
Cphiq3[i, j] = W["phiq3" + ind]
# symmetrize
Cphiq1 = Cphiq1 + Cphiq1.T.conjugate() - np.diag(np.diag(Cphiq1))
Cphiq3 = Cphiq3 + Cphiq3.T.conjugate() - np.diag(np.diag(Cphiq3))
Cphiq13rot = Vdag @ (Cphiq3 + Cphiq1) @ V
# W/Z chiral coupling deviations
for i in range(3):
for j in range(3):
ind = "_{}{}".format(i + 1, j + 1)
if j >= i:
H["deltagWlL" + ind] = (
W["phil3" + ind] + f(1 / 2, 0, i, j) - f(-1 / 2, -1, i, j)
)
H["deltagZeL" + ind] = (
-1 / 2 * W["phil3" + ind]
- 1 / 2 * W["phil1" + ind]
+ f(-1 / 2, -1, i, j)
)
H["deltagZeR" + ind] = -1 / 2 * W["phie" + ind] + f(0, -1, i, j)
H["deltagZuL" + ind] = (
1 / 2 * W["phiq3" + ind]
- 1 / 2 * W["phiq1" + ind]
+ f(1 / 2, 2 / 3, i, j)
)
H["deltagZdL" + ind] = -1 / 2 * Cphiq13rot[i, j] + f(
-1 / 2, -1 / 3, i, j
)
H["deltagZuR" + ind] = -1 / 2 * W["phiu" + ind] + f(0, 2 / 3, i, j)
H["deltagZdR" + ind] = -1 / 2 * W["phid" + ind] + f(0, -1 / 3, i, j)
H["deltagWqR" + ind] = -W["phiud" + ind] / 2
H["deltalambda3"] = (
lam
* (
3 * W["phiBox"]
- 3 / 4 * W["phiD"]
+ 1 / 4 * W["ll_1221"]
- W["phil3_11"] / 2
- W["phil3_22"] / 2
)
- W["phi"]
)
H["deltacz"] = (
W["phiBox"]
- W["phiD"] / 4
+ 3 / 4 * W["ll_1221"]
- 3 / 2 * W["phil3_11"]
- 3 / 2 * W["phil3_22"]
)
# Two derivative field strength interactions
H["czBox"] = (
-W["ll_1221"] / 2 + W["phiD"] / 2 + W["phil3_11"] + W["phil3_22"]
) / gw2
H["cgg"] = (4 / gs2) * W["phiG"]
H["cgammagamma"] = 4 * (W["phiW"] / gw2 + W["phiB"] / gp2 - W["phiWB"] / gw / gp)
H["czz"] = (
4
* (gw2 * W["phiW"] + gp2 * W["phiB"] + gw * gp * W["phiWB"])
/ (gw2 + gp2) ** 2
)
H["czgamma"] = (
4 * W["phiW"] - 4 * W["phiB"] - 2 * (gw2 - gp2) / (gw * gp) * W["phiWB"]
) / (gw2 + gp2)
H["cggtilde"] = (4 / gs2) * W["phiGtilde"]
H["cgammagammatilde"] = 4 * (
W["phiWtilde"] / gw2 + W["phiBtilde"] / gp2 - W["phiWtildeB"] / gw / gp
)
H["czztilde"] = (
4
* (gw2 * W["phiWtilde"] + gp2 * W["phiBtilde"] + gw * gp * W["phiWtildeB"])
/ (gw2 + gp2) ** 2
)
H["czgammatilde"] = (
4 * W["phiWtilde"]
- 4 * W["phiBtilde"]
- 2 * (gw2 - gp2) / (gw * gp) * W["phiWtildeB"]
) / (gw2 + gp2)
basis = wcxf.Basis["SMEFT", "Higgs-Warsaw up"]
all_wcs = set(basis.all_wcs) # to speed up lookup
return {k: v for k, v in H.items() if k in all_wcs}
def higgslike_to_warsaw_up(C, parameters=None, sectors=None):
"""Translate from the Higgs-Warsaw basis to the Warsaw up
basis."""
basis = wcxf.Basis["SMEFT", "Higgs-Warsaw up"]
H = {k: C.get(k, 0) for k in basis.all_wcs}
p = default_parameters.copy()
if parameters is not None:
# if parameters are passed in, overwrite the default values
p.update(parameters)
V = ckmutil.ckm.ckm_tree(p["Vus"], p["Vub"], p["Vcb"], p["delta"])
Vdag = V.T.conjugate()
W = H.copy()
# parameters
# neglecting dim.-6 corrections here as these are higher-order
# when multiplying dim.-6 WCs!
v = 1 / sqrt(sqrt(2) * p["GF"]) # Higgs VEV
lam = p["m_h"] ** 2 / (2 * v ** 2) # Higgs self-coupling
e = sqrt(4 * pi * p["alpha_e"])
s2w = 1 / 2 * (1 - sqrt(1 - (4 * pi * p['alpha_e']) / (sqrt(2) * p['GF'] * p['m_Z']**2)))
gs = sqrt(4 * pi * p["alpha_s"])
sw = sqrt(s2w)
g = gw = e / sw
c2w = 1 - s2w
cw = sqrt(c2w)
gp = e / cw
gw2 = g ** 2
gp2 = gp ** 2
gs2 = gs ** 2
dM = (
H["deltagWlL_11"] + H["deltagWlL_22"] - H["ll_1221"] / 2
) / 2 # W mass correction
W["phi"] = (
3 * lam * H["deltacz"]
+ 8 * lam * dM
- H["deltalambda3"]
+ (
H["czBox"] * gw2
+ H["czz"] * gp2
- H["czgamma"] * gp2 * (c2w - s2w)
- H["cgammagamma"] * gw2 * s2w ** 2
)
* 4
* gw2
* lam
/ (gw2 - gp2)
)
W["phiBox"] = (
H["deltacz"]
+ 2 * dM
+ (
H["czBox"] * (3 * gw2 - gp2)
+ 2 * H["czz"] * gp2
- 2 * H["czgamma"] * gp2 * (c2w - s2w)
- 2 * H["cgammagamma"] * gw2 * s2w ** 2
)
* gw2
/ (gw2 - gp2)
/ 2
)
W["phiD"] = (
-(
H["czBox"]
+ H["czz"]
- H["czgamma"] * (c2w - s2w)
- H["cgammagamma"] * s2w * c2w
)
* 2
* gw2
* gp2
/ (gw2 - gp2)
- 4 * dM
)
W["phiG"] = H["cgg"] * gs2 / 4
W["phiW"] = (
(H["czz"] + H["czgamma"] * 2 * s2w + H["cgammagamma"] * s2w ** 2) * gw2 / 4
)
W["phiB"] = (
(H["czz"] - H["czgamma"] * 2 * c2w + H["cgammagamma"] * c2w ** 2) * gp2 / 4
)
W["phiWB"] = (
(H["czz"] - H["czgamma"] * (c2w - s2w) - H["cgammagamma"] * c2w * s2w)
* gw
* gp
/ 2
)
W["phiGtilde"] = H["cggtilde"] * gs2 / 4
W["phiWtilde"] = (
(H["czztilde"] + H["czgammatilde"] * 2 * s2w + H["cgammagammatilde"] * s2w ** 2)
* gw2
/ 4
)
W["phiBtilde"] = (
(H["czztilde"] - H["czgammatilde"] * 2 * c2w + H["cgammagammatilde"] * c2w ** 2)
* gp2
/ 4
)
W["phiWtildeB"] = (
(
H["czztilde"]
- H["czgammatilde"] * (c2w - s2w)
- H["cgammagammatilde"] * c2w * s2w
)
* gw
* gp
/ 2
)
C1 = (
(
H["czBox"] * gw2
+ H["czz"] * gp2
- H["czgamma"] * gp2 * (c2w - s2w)
- H["cgammagamma"] * gw2 * s2w ** 2
)
* gw2
/ (gw2 - gp2)
)
C2 = (
(
H["czBox"]
+ H["czz"]
- H["czgamma"] * (c2w - s2w)
- H["cgammagamma"] * s2w * c2w
)
* gw2
* gp2
/ (gw2 - gp2)
)
# rotate deltagZdL to up basis
deltagZdL = np.zeros((3, 3), complex)
for i in range(3):
for j in range(3):
if j >= i:
ind = "_{}{}".format(i + 1, j + 1)
deltagZdL[i, j] = H["deltagZdL" + ind]
# symmetrize
deltagZdL = deltagZdL + deltagZdL.T.conjugate() - np.diag(np.diag(deltagZdL))
deltagZdLrot = V @ deltagZdL @ Vdag
facp = np.eye(3) * C1
fac = np.eye(3) * C2
for i in range(3):
for j in range(3):
ind = "_{}{}".format(i + 1, j + 1)
if j >= i:
W["phil3" + ind] = H["deltagWlL" + ind] + facp[i, j] / 2
W["phiq3" + ind] = (
H["deltagZuL" + ind] - deltagZdLrot[i, j] + facp[i, j] / 2
)
W["phil1" + ind] = (
-2 * H["deltagZeL" + ind] - H["deltagWlL" + ind] + fac[i, j] / 2
)
W["phiq1" + ind] = (
-H["deltagZuL" + ind] - deltagZdLrot[i, j] - fac[i, j] / 6
)
W["phie" + ind] = -2 * H["deltagZeR" + ind] + fac[i, j]
W["phiu" + ind] = -2 * H["deltagZuR" + ind] - 2 / 3 * fac[i, j]
W["phid" + ind] = -2 * H["deltagZdR" + ind] + 1 / 3 * fac[i, j]
W["phiud" + ind] = -2 * H["deltagWqR" + ind]
warsaw = wcxf.Basis["SMEFT", "Warsaw up"]
all_wcs = set(warsaw.all_wcs) # to speed up lookup
return {k: v for k, v in W.items() if k in all_wcs}