def wctot_dict(wc_obj, sector, scale, par, nf_out=None):
r"""Get a dictionary with the total (SM + new physics) values of the
$\Delta F=1$ Wilson coefficients at a given scale, given a
WilsonCoefficients instance."""
wc_np_dict = wc_obj.get_wc(sector, scale, par, nf_out=nf_out)
wcsm_120 = _wcsm_120.copy()
# fold in approximate m_t-dependence of C_10 (see eq. 4 of arXiv:1311.0903)
wcsm_120[9] = wcsm_120[9] * (par['m_t'] / 173.1)**1.53
wc_sm = running.get_wilson(par,
wcsm_120,
wc_obj.rge_derivative[sector],
120.,
scale,
nf_out=nf_out)
# now here comes an ugly fix. If we have b->s transitions, we should take
# into account the fact that C7' = C7*ms/mb, and the same for C8, which is
# not completely negligible. To find out whether we have b->s, we look at
# the "sector" string.
if sector[:2] == 'bs':
# go from the effective to the "non-effective" WCs
yi = np.array([0, 0, -1 / 3., -4 / 9., -20 / 3., -80 / 9.])
zi = np.array([0, 0, 1, -1 / 6., 20, -10 / 3.])
c7 = wc_sm[6] - np.dot(yi, wc_sm[:6]) # c7 (not effective!)
c8 = wc_sm[7] - np.dot(zi, wc_sm[:6]) # c8 (not effective!)
eps_s = running.get_ms(par, scale) / running.get_mb(par, scale)
c7p = eps_s * c7
c8p = eps_s * c8
# go back to the effective WCs
wc_sm[21] = c7p + np.dot(yi, wc_sm[15:21]) # c7p_eff
wc_sm[22] = c8p + np.dot(zi, wc_sm[15:21]) # c8p_eff
wc_labels = wc_obj.coefficients[sector]
wc_sm_dict = dict(zip(wc_labels, wc_sm))
return add_dict((wc_np_dict, wc_sm_dict))
def wctot_dict(wc_obj, sector, scale, par, nf_out=None):
r"""Get a dictionary with the total (SM + new physics) values of the
$\Delta F=1$ Wilson coefficients at a given scale, given a
WilsonCoefficients instance."""
wc_np_dict = wc_obj.get_wc(sector, scale, par, nf_out=nf_out)
wcsm_120 = _wcsm_120.copy()
wc_sm = running.get_wilson(par, wcsm_120, wc_obj.rge_derivative[sector], 120., scale, nf_out=nf_out)
# now here comes an ugly fix. If we have b->s transitions, we should take
# into account the fact that C7' = C7*ms/mb, and the same for C8, which is
# not completely negligible. To find out whether we have b->s, we look at
# the "sector" string.
if sector[:2] == 'bs':
# go from the effective to the "non-effective" WCs
yi = np.array([0, 0, -1/3., -4/9., -20/3., -80/9.])
zi = np.array([0, 0, 1, -1/6., 20, -10/3.])
c7 = wc_sm[6] - np.dot(yi, wc_sm[:6]) # c7 (not effective!)
c8 = wc_sm[7] - np.dot(zi, wc_sm[:6]) # c8 (not effective!)
eps_s = running.get_ms(par, scale)/running.get_mb(par, scale)
c7p = eps_s * c7
c8p = eps_s * c8
# go back to the effective WCs
wc_sm[21] = c7p + np.dot(yi, wc_sm[15:21]) # c7p_eff
wc_sm[22] = c7p + np.dot(zi, wc_sm[15:21]) # c8p_eff
wc_labels = wc_obj.coefficients[sector]
wc_sm_dict = dict(zip(wc_labels, wc_sm))
return add_dict((wc_np_dict, wc_sm_dict))
def get_wc(self, sector, scale, par, nf_out=None):
# intialize with complex zeros
values_in = np.zeros(len(self.coefficients[sector]), dtype=complex)
# see if an initial value exists
scale_in = None
for idx, name in enumerate(self.coefficients[sector]):
if name in self.initial.keys():
scale_in_new = self.initial[name][0]
# make sure that if there are several initial values, they are at the same scale
if scale_in is not None and scale_in_new != scale_in:
raise ValueError(
"You cannot define initial values at different scales for Wilson coefficients that mix under renormalization"
)
else:
scale_in = scale_in_new
values_in[idx] = self.initial[name][1]
if scale_in is None:
# if no initial values have been given, no need to run anyway!
return dict(zip(self.coefficients[sector],
values_in)) # these are all zero
if self.rge_derivative[sector] is None:
# if the sector has vanishing anomalous dimensions, nno need to run!
return dict(zip(self.coefficients[sector],
values_in)) # these are just the initial values
# otherwise, run
values_out = running.get_wilson(par,
values_in,
self.rge_derivative[sector],
scale_in,
scale,
nf_out=nf_out)
return dict(zip(self.coefficients[sector], values_out))
def get_wc(self, sector, scale, par, nf_out=None):
# intialize with complex zeros
values_in = np.zeros(len(self.coefficients[sector]), dtype=complex)
# see if an initial value exists
scale_in = None
for idx, name in enumerate(self.coefficients[sector]):
if name in self.initial.keys():
scale_in_new = self.initial[name][0]
# make sure that if there are several initial values, they are at the same scale
if scale_in is not None and scale_in_new != scale_in:
raise ValueError("You cannot define initial values at different scales for Wilson coefficients that mix under renormalization")
else:
scale_in = scale_in_new
values_in[idx] = self.initial[name][1]
if scale_in is None:
# if no initial values have been given, no need to run anyway!
return dict(zip(self.coefficients[sector],values_in)) # these are all zero
if self.rge_derivative[sector] is None:
# if the sector has vanishing anomalous dimensions, nno need to run!
return dict(zip(self.coefficients[sector],values_in)) # these are just the initial values
# otherwise, run
values_out = running.get_wilson(par, values_in, self.rge_derivative[sector], scale_in, scale, nf_out=nf_out)
return dict(zip(self.coefficients[sector],values_out))
def run_wc_df1(par, c_in, scale_in, scale_out):
adm = gamma_all
return running.get_wilson(par, c_in,
running.make_wilson_rge_derivative(adm),
scale_in, scale_out)
def run_wc_df2(par, c_in, scale_in, scale_out):
return running.get_wilson(par, c_in, df2_rge_derivative, scale_in,
scale_out)
def run_wc_df1(par, c_in, scale_in, scale_out):
adm = gamma_all
return running.get_wilson(par, c_in, running.make_wilson_rge_derivative(adm), scale_in, scale_out)
def run_wc_df2(par, c_in, scale_in, scale_out):
adm = lambda nf, alpha_s, alpha_e: gamma_df2_array(nf, alpha_s)
return running.get_wilson(par, c_in, running.make_wilson_rge_derivative(adm), scale_in, scale_out)
def run_wc_df2(par, c_in, scale_in, scale_out):
return running.get_wilson(par, c_in, df2_rge_derivative, scale_in, scale_out)
def run_wc_df2(par, c_in, scale_in, scale_out):
adm = lambda nf, alpha_s, alpha_e: gamma_df2_array(nf, alpha_s)
return running.get_wilson(par, c_in,
running.make_wilson_rge_derivative(adm),
scale_in, scale_out)
