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}