def M12_u_SM(par):
xi_b = ckm.xi('b', 'uc')(par)
xi_s = ckm.xi('s', 'uc')(par)
a_bb = par['M12_D a_bb']
a_bs = par['M12_D a_bs']
a_ss = par['M12_D a_ss']
return (a_ss * xi_s**2 + a_bs * xi_b * xi_s + a_bb * xi_b**2) / _ps
def br_inst(par, wc, B, l1, l2):
r"""Branching ratio of $B_q\to\ell_1^+\ell_2^-$ in the absence of mixing.
Parameters
----------
- `par`: parameter dictionary
- `B`: should be `'Bs'` or `'B0'`
- `lep`: should be `'e'`, `'mu'`, or `'tau'`
"""
# paramaeters
GF = par['GF']
alphaem = running.get_alpha(par, 4.8)['alpha_e']
ml1 = par['m_' + l1]
ml2 = par['m_' + l2]
mB = par['m_' + B]
tauB = par['tau_' + B]
fB = par['f_' + B]
# appropriate CKM elements
if B == 'Bs':
xi_t = ckm.xi('t', 'bs')(par)
elif B == 'B0':
xi_t = ckm.xi('t', 'bd')(par)
N = xi_t * 4 * GF / sqrt(2) * alphaem / (4 * pi)
beta = sqrt(lambda_K(mB**2, ml1**2, ml2**2)) / mB**2
prefactor = abs(N)**2 / 32. / pi * mB**3 * tauB * beta * fB**2
P, S = amplitudes(par, wc, B, l1, l2)
return prefactor * (abs(P)**2 + abs(S)**2)
def Kpipi_amplitudes_SM(par,
include_VmA=True, include_VpA=True,
scale_ImA0EW=False):
r"""Compute the SM contribution to the two isospin amplitudes of
the $K\to\pi\pi$ transition."""
scale = config['renormalization scale']['kpipi']
pref = par['GF'] / sqrt(2) * ckm.xi('u', 'ds')(par) # GF/sqrt(2) Vus* Vud
me = Kpipi_matrixelements_SM(par, scale)
# Wilson coefficients
wc = wilsoncoefficients_sm_fourquark(par, scale)
tau = -ckm.xi('t', 'ds')(par) / ckm.xi('u', 'ds')(par)
k = [1, 2]
if include_VmA:
k = k + [3, 4, 9, 10]
if include_VpA:
k = k + [5, 6, 7, 8]
A = {0: 0, 2: 0}
for i in [0, 2]:
for j in k:
m = me[i][str(j)]
yj = wc.get('y{}'.format(j), 0)
zj = wc.get('z{}'.format(j), 0)
dA = pref * m * (zj + tau * yj)
if scale_ImA0EW and i == 0 and j in [7, 8, 9, 10]:
b = 1 / par['epsp a'] / (1 - par['Omegahat_eff'])
dA = dA.real + 1j * b * dA.imag
A[i] += dA
return A
def br_inst(par, wc, B, l1, l2):
r"""Branching ratio of $B_q\to\ell_1^+\ell_2^-$ in the absence of mixing.
Parameters
----------
- `par`: parameter dictionary
- `B`: should be `'Bs'` or `'B0'`
- `lep`: should be `'e'`, `'mu'`, or `'tau'`
"""
# paramaeters
GF = par['GF']
alphaem = running.get_alpha(par, 4.8)['alpha_e']
ml1 = par['m_'+l1]
ml2 = par['m_'+l2]
mB = par['m_'+B]
tauB = par['tau_'+B]
fB = par['f_'+B]
# appropriate CKM elements
if B == 'Bs':
xi_t = ckm.xi('t','bs')(par)
elif B == 'B0':
xi_t = ckm.xi('t','bd')(par)
N = xi_t * 4*GF/sqrt(2) * alphaem/(4*pi)
beta = sqrt(lambda_K(mB**2,ml1**2,ml2**2))/mB**2
beta_p = sqrt(1 - (ml1 + ml2)**2/mB**2)
beta_m = sqrt(1 - (ml1 - ml2)**2/mB**2)
prefactor = abs(N)**2 / 32. / pi * mB**3 * tauB * beta * fB**2
P, S = amplitudes(par, wc, B, l1, l2)
return prefactor * ( beta_m**2 * abs(P)**2 + beta_p**2 * abs(S)**2 )
def get_wceff(q2, wc, par, B, M, lep, scale):
r"""Get a dictionary with the effective $\Delta F=1$ Wilson coefficients
in the convention appropriate for the generalized angular distributions.
"""
xi_u = ckm.xi('u',meson_quark[(B,M)])(par)
xi_t = ckm.xi('t',meson_quark[(B,M)])(par)
qiqj=meson_quark[(B,M)]
Yq2 = matrixelements.Y(q2, wc, par, scale, qiqj) + (xi_u/xi_t)*matrixelements.Yu(q2, wc, par, scale, qiqj)
# b) NNLO Q1,2
delta_C7 = matrixelements.delta_C7(par=par, wc=wc, q2=q2, scale=scale, qiqj=qiqj)
delta_C9 = matrixelements.delta_C9(par=par, wc=wc, q2=q2, scale=scale, qiqj=qiqj)
mb = running.get_mb(par, scale)
ll = lep + lep
c = {}
c['7'] = wc['C7eff_'+qiqj] + delta_C7
c['7p'] = wc['C7effp_'+qiqj]
c['v'] = wc['C9_'+qiqj+ll] + delta_C9 + Yq2
c['vp'] = wc['C9p_'+qiqj+ll]
c['a'] = wc['C10_'+qiqj+ll]
c['ap'] = wc['C10p_'+qiqj+ll]
c['s'] = mb * wc['CS_'+qiqj+ll]
c['sp'] = mb * wc['CSp_'+qiqj+ll]
c['p'] = mb * wc['CP_'+qiqj+ll]
c['pp'] = mb * wc['CPp_'+qiqj+ll]
c['t'] = 0
c['tp'] = 0
return c
def Kpipi_amplitudes_SM(par,
include_VmA=True,
include_VpA=True,
scale_ImA0EW=False):
r"""Compute the SM contribution to the two isospin amplitudes of
the $K\to\pi\pi$ transition."""
scale = config['renormalization scale']['kpipi']
pref = par['GF'] / sqrt(2) * ckm.xi('u', 'ds')(par) # GF/sqrt(2) Vus* Vud
me = Kpipi_matrixelements_SM(par, scale)
# Wilson coefficients
wc = wilsoncoefficients_sm_fourquark(par, scale)
tau = -ckm.xi('t', 'ds')(par) / ckm.xi('u', 'ds')(par)
k = [1, 2]
if include_VmA:
k = k + [3, 4, 9, 10]
if include_VpA:
k = k + [5, 6, 7, 8]
A = {0: 0, 2: 0}
for i in [0, 2]:
for j in k:
m = me[i][str(j)]
yj = wc.get('y{}'.format(j), 0)
zj = wc.get('z{}'.format(j), 0)
dA = pref * m * (zj + tau * yj)
if scale_ImA0EW and i == 0 and j in [7, 8, 9, 10]:
b = 1 / par['epsp a'] / (1 - par['Omegahat_eff'])
dA = dA.real + 1j * b * dA.imag
A[i] += dA
return A
def G12_d_SM(par, meson):
di_dj = meson_quark[meson]
xi_t = ckm.xi('t',di_dj)(par)
xi_u = ckm.xi('u',di_dj)(par)
c = par['Gamma12_'+meson+'_c']
a = par['Gamma12_'+meson+'_a']
M12 = M12_d_SM(par, meson)
return M12*( c + a * xi_u/xi_t )*1e-4
def wc_LQ(yy, MS):
"Wilson coefficients as functions of Leptoquark couplings"
alpha = get_alpha(par, MS)['alpha_e']
return {
'C9_bsmumu': pi/(sq2* GF * MS**2 *alpha) * yy/ckm.xi('t', 'bs')(par),
'C10_bsmumu': -pi/(sq2* GF * MS**2 *alpha) * yy/ckm.xi('t', 'bs')(par),
'CVLL_bsbs': - (yy/MS)**2 * 5 /(64*pi**2) #flavio defines the effective Lagrangian as L = CVLL (bbar gamma d)^2, with NO prefactors
}
def G12_d_SM(par, meson):
di_dj = meson_quark[meson]
xi_t = ckm.xi('t',di_dj)(par)
xi_u = ckm.xi('u',di_dj)(par)
c = par['Gamma12_'+meson+'_c']
a = par['Gamma12_'+meson+'_a']
M12 = M12_d_SM(par, meson)
return M12*( c + a * xi_u/xi_t )*1e-4
def wc_Z(lambdaQ, MZp):
"Wilson coefficients as functions of Z' couplings"
alpha = get_alpha(par, MZp)['alpha_e']
return {
'C9_bsmumu': -pi/(sq2* GF * MZp**2 *alpha) * lambdaQ/ckm.xi('t', 'bs')(par),
'C10_bsmumu': pi/(sq2* GF * MZp**2 *alpha) * lambdaQ/ckm.xi('t', 'bs')(par),
'CVLL_bsbs': - (lambdaQ/MZp )**2 #flavio defines the effective Lagrangian as L = CVLL (bbar gamma d)^2, with NO prefactors
}
def G12_d_SM(par, meson):
flavio.citations.register("Beneke:2003az")
di_dj = meson_quark[meson]
xi_t = ckm.xi('t', di_dj)(par)
xi_u = ckm.xi('u', di_dj)(par)
c = par['Gamma12_' + meson + '_c']
a = par['Gamma12_' + meson + '_a']
M12 = M12_d_SM(par, meson)
return M12 * (c + a * xi_u / xi_t) * 1e-4
def test_ksmm_sd_sm(self):
# compare to 1707.06999
# correct for different CKM choice
my_xi_t = ckm.xi('t', 'sd')(par)
xi_t = ckm.xi('t', 'sd')({'Vus': 0.22508, 'Vub': 0.003715, 'Vcb': 0.04181,
'delta': 65.4 / 180 * pi})
r = (my_xi_t.imag / xi_t.imag)**2
self.assertAlmostEqual(br_kll(par, wc_obj, 'KS', 'mu', 'mu', ld=False),
r * 0.19e-12,
delta=0.02e-12)
def test_ksmm_sd_sm(self):
# compare to 1707.06999
# correct for different CKM choice
my_xi_t = ckm.xi('t', 'sd')(par)
xi_t = ckm.xi('t', 'sd')({
'Vus': 0.22508,
'Vub': 0.003715,
'Vcb': 0.04181,
'delta': 65.4 / 180 * pi
})
r = (my_xi_t.imag / xi_t.imag)**2
self.assertAlmostEqual(br_kll(par, wc_obj, 'KS', 'mu', 'mu', ld=False),
r * 0.19e-12,
delta=0.02e-12)
def get_input(par, B, V, scale):
mB = par['m_' + B]
mb = running.get_mb_pole(par)
mc = running.get_mc_pole(par)
alpha_s = running.get_alpha(par, scale)['alpha_s']
q = meson_spectator[(B, V)] # spectator quark flavour
qiqj = meson_quark[(B, V)]
eq = quark_charge[q] # charge of the spectator quark
ed = -1 / 3.
eu = 2 / 3.
xi_t = ckm.xi('t', qiqj)(par)
xi_u = ckm.xi('u', qiqj)(par)
eps_u = xi_u / xi_t
return mB, mb, mc, alpha_s, q, eq, ed, eu, eps_u, qiqj
def get_wc(wc_obj, par, l1, l2):
scale = config['renormalization scale']['kdecays']
label = 'sd' + l1 + l2
wcnp = wc_obj.get_wc(label, scale, par)
if l1 == l2:
# include SM contributions for LF conserving decay
_c = wilsoncoefficients_sm_sl(par, scale)
xi_t = ckm.xi('t', 'sd')(par)
xi_c = ckm.xi('c', 'sd')(par)
wcsm = {'C10_sd' + l1 + l2: _c['C10_t'] + xi_c / xi_t * _c['C10_c']}
else:
wcsm = {}
return add_dict((wcsm, wcnp))
def get_wc(wc_obj, par, l1, l2):
scale = config['renormalization scale']['kdecays']
label = 'sd' + l1 + l2
wcnp = wc_obj.get_wc(label, scale, par)
if l1 == l2:
# include SM contributions for LF conserving decay
_c = wilsoncoefficients_sm_sl(par, scale)
xi_t = ckm.xi('t', 'sd')(par)
xi_c = ckm.xi('c', 'sd')(par)
wcsm = {'C10_sd' + l1 + l2: _c['C10_t'] + xi_c / xi_t * _c['C10_c']}
else:
wcsm = {}
return add_dict((wcsm, wcnp))
def get_input(par, B, V, scale):
mB = par['m_'+B]
mb = running.get_mb_pole(par)
mc = running.get_mc_pole(par)
alpha_s = running.get_alpha(par, scale)['alpha_s']
q = meson_spectator[(B,V)] # spectator quark flavour
qiqj = meson_quark[(B,V)]
eq = quark_charge[q] # charge of the spectator quark
ed = -1/3.
eu = 2/3.
xi_t = ckm.xi('t', qiqj)(par)
xi_u = ckm.xi('u', qiqj)(par)
eps_u = xi_u/xi_t
return mB, mb, mc, alpha_s, q, eq, ed, eu, eps_u, qiqj
def amplitudes(par, wc, l1, l2):
r"""Amplitudes P and S entering the $K\to\ell_1^+\ell_2^-$ observables.
Parameters
----------
- `par`: parameter dictionary
- `wc`: Wilson coefficient dictionary
- `K`: should be `'KL'` or `'KS'`
- `l1` and `l2`: should be `'e'` or `'mu'`
"""
# masses
ml1 = par['m_'+l1]
ml2 = par['m_'+l2]
mK = par['m_K0']
# Wilson coefficients
qqll = 'sd' + l1 + l2
# For LFV expressions see arXiv:1602.00881 eq. (5)
C9m = wc['C9_'+qqll] - wc['C9p_'+qqll] # only relevant for l1 != l2
C10m = wc['C10_'+qqll] - wc['C10p_'+qqll]
CPm = wc['CP_'+qqll] - wc['CPp_'+qqll]
CSm = wc['CS_'+qqll] - wc['CSp_'+qqll]
P = (ml2 + ml1)/mK * C10m + mK * CPm # neglecting mu, md
S = (ml2 - ml1)/mK * C9m + mK * CSm # neglecting mu, md
xi_t = ckm.xi('t', 'sd')(par)
return xi_t * P, xi_t * S
def amplitudes(par, wc, l1, l2):
r"""Amplitudes P and S entering the $K\to\ell_1^+\ell_2^-$ observables.
Parameters
----------
- `par`: parameter dictionary
- `wc`: Wilson coefficient dictionary
- `K`: should be `'KL'` or `'KS'`
- `l1` and `l2`: should be `'e'` or `'mu'`
"""
# masses
ml1 = par['m_'+l1]
ml2 = par['m_'+l2]
mK = par['m_K0']
# Wilson coefficients
qqll = 'sd' + l1 + l2
# For LFV expressions see arXiv:1602.00881 eq. (5)
C9m = wc['C9_'+qqll] - wc['C9p_'+qqll] # only relevant for l1 != l2
C10m = wc['C10_'+qqll] - wc['C10p_'+qqll]
CPm = wc['CP_'+qqll] - wc['CPp_'+qqll]
CSm = wc['CS_'+qqll] - wc['CSp_'+qqll]
P = (ml2 + ml1)/mK * C10m + mK * CPm # neglecting mu, md
S = (ml2 - ml1)/mK * C9m + mK * CSm # neglecting mu, md
xi_t = ckm.xi('t', 'sd')(par)
return xi_t * P, xi_t * S
def prefactor(q2, par, B, P):
GF = par['GF']
scale = config['renormalization scale']['bpll']
alphaem = running.get_alpha(par, scale)['alpha_e']
di_dj = meson_quark[(B,P)]
xi_t = ckm.xi('t',di_dj)(par)
return 4*GF/sqrt(2)*xi_t*alphaem/(4*pi)
def amplitudes_weak_eigst(par, wc, l1, l2):
r"""Amplitudes P and S for the decay $\bar K^0\to\ell_1^+\ell_2^-$.
Parameters
----------
- `par`: parameter dictionary
- `wc`: Wilson coefficient dictionary
- `l1` and `l2`: should be `'e'` or `'mu'`
"""
# masses
ml1 = par['m_'+l1]
ml2 = par['m_'+l2]
mK = par['m_K0']
# Wilson coefficient postfix
qqll = 'sd' + l1 + l2
# For LFV expressions see arXiv:1602.00881 eq. (5)
C9m = wc['C9_'+qqll] - wc['C9p_'+qqll] # only relevant for l1 != l2
C10m = wc['C10_'+qqll] - wc['C10p_'+qqll]
CPm = wc['CP_'+qqll] - wc['CPp_'+qqll]
CSm = wc['CS_'+qqll] - wc['CSp_'+qqll]
P = (ml2 + ml1)/mK * C10m + mK * CPm # neglecting mu, md
S = (ml2 - ml1)/mK * C9m + mK * CSm # neglecting mu, md
# Include complex part of the eff. operator prefactor. Phases matter.
xi_t = ckm.xi('t', 'sd')(par)
return xi_t * P, xi_t * S
def prefactor(q2, par, B, V):
GF = par['GF']
scale = config['renormalization scale']['bvll']
alphaem = running.get_alpha(par, scale)['alpha_e']
di_dj = meson_quark[(B, V)]
xi_t = ckm.xi('t', di_dj)(par)
return 4 * GF / sqrt(2) * xi_t * alphaem / (4 * pi)
def get_wc(wc_obj, par, l1, l2):
scale = config['renormalization scale']['kdecays']
if l1 == l2: # (l1,l2) == ('e','e') or ('mu','mu')
label = 'sd' + l1 + l2
wcnp = wc_obj.get_wc(label, scale, par)
# include SM contributions for LF conserving decay
_c = wilsoncoefficients_sm_sl(par, scale)
xi_t = ckm.xi('t', 'sd')(par)
xi_c = ckm.xi('c', 'sd')(par)
wcsm = {'C10_sd' + l1 + l2: _c['C10_t'] + xi_c / xi_t * _c['C10_c']}
elif {l1,l2} == {'e','mu'}:
# Both flavor combinations relevant due to K0-K0bar mixing
wcnp = {**wc_obj.get_wc('sdemu', scale, par),
**wc_obj.get_wc('sdmue', scale, par)}
wcsm = {}
return add_dict((wcsm, wcnp))
def myDeltaMS(wc_obj, par):
DMs_SM = par['Delta M_S']
if wc_obj.wc is None:
return DMs_SM
else:
Cbs = -sq2 / (4 * GF *
ckm.xi('t', 'bs')(par)**2) * wc_obj.wc['CVLL_bsbs']
return DMs_SM * abs(1 + Cbs / (1.3397e-3))
def prefactor(s, par, B, ff, lep, wc):
GF = par['GF']
scale = config['renormalization scale']['bllgamma']
alphaem = running.get_alpha(par, scale)['alpha_e']
bq = meson_quark[B]
xi_t = ckm.xi('t', bq)(par)
return GF**2 / (2**10 * pi**4) * abs(xi_t)**2 * alphaem**3 * par['m_' +
B]**5
def br_taupl(wc_obj, par, P, lep):
r"""Branching ratio of $\tau^+\to p^0\ell^+$."""
scale = flavio.config['renormalization scale']['taudecays']
GF = par['GF']
alphaem = running.get_alpha(par, 4.8)['alpha_e']
mP = par['m_' + P]
mtau = par['m_tau']
mu = par['m_u']
md = par['m_d']
mlep = par['m_' + lep]
fP = par['f_' + P]
if P == 'pi0':
sec = wcxf_sector_names['tau', lep]
wc = wc_obj.get_wc(sec, scale, par, nf_out=4)
F = {}
S = {}
for q in 'ud':
F['LL' + q] = wc['CVLL_tau{}{}'.format(lep, 2 * q)] # FLL
F['RR' + q] = wc['CVRR_tau{}{}'.format(lep, 2 * q)] # FRR
F['LR' + q] = wc['CVLR_tau{}{}'.format(lep, 2 * q)] # FLR
F['RL' + q] = wc['CVLR_{}tau{}'.format(2 * q, lep)] # FLRqq
S['RR' + q] = wc['CSRR_tau{}{}'.format(lep, 2 * q)] # SRR
S['RL' + q] = wc['CSRL_tau{}{}'.format(lep, 2 * q)] # SLR
S['LL' + q] = wc['CSRR_{}tau{}'.format(lep, 2 * q)].conjugate() # SRRqq
S['LR' + q] = wc['CSRL_{}tau{}'.format(lep, 2 * q)].conjugate() # SLRqq
vL = fP*((F['LRu'] - F['LLu'])/2 - (F['LRd'] - F['LLd'])/2 )/sqrt(2)
vR = fP*((F['RRu'] - F['RLu'])/2 - (F['RRd'] - F['RLd'])/2 )/sqrt(2)
sL = fP*mP**2/(mu+md)*((S['LRu']-S['LLu'])/2 - (S['LRd']-S['LLd'])/2)/sqrt(2)
sR = fP*mP**2/(mu+md)*((S['RRu']-S['RLu'])/2 - (S['RRd']-S['RLd'])/2)/sqrt(2)
gL = sL+ (-vL*mlep + vR*mtau)
gR = sR+ (-vR*mlep + vL*mtau)
elif P == 'K0':
xi_t = ckm.xi('t','ds')(par)
qqll = 'sdtau' + lep
wc = wc_obj.get_wc(qqll, scale, par, nf_out=4)
mq1 = flavio.physics.running.running.get_md(par, scale)
mq2 = flavio.physics.running.running.get_ms(par, scale)
C9m = -wc['C9_'+qqll] + wc['C9p_'+qqll]
C10m = -wc['C10_'+qqll] + wc['C10p_'+qqll]
CSm = wc['CS_'+qqll] - wc['CSp_'+qqll]
CPm = wc['CP_'+qqll] - wc['CPp_'+qqll]
Kv = xi_t * 4*GF/sqrt(2) * alphaem/(4*pi)
Ks = Kv * mq2
gV = - fP* Kv * C9m/2
gA = - fP* Kv * C10m/2
gS = - fP* Ks * mP**2 * CSm/2 / (mq1+mq2)
gP = - fP* Ks * mP**2 * CPm/2 / (mq1+mq2)
gVS = gS + gV*(mtau -mlep)
gAP = gP - gA*(mtau +mlep)
gL = gVS - gAP
gR = gVS + gAP
return par['tau_tau'] * common.GammaFsf(mtau, mP, mlep, gL, gR)
def delta_C7(par, wc, q2, scale, qiqj):
alpha_s = running.get_alpha(par, scale)['alpha_s']
mb = running.get_mb_pole(par)
mc = par['m_c BVgamma']
xi_t = ckm.xi('t', qiqj)(par)
xi_u = ckm.xi('u', qiqj)(par)
muh = scale/mb
sh = q2/mb**2
z = mc**2/mb**2
Lmu = log(scale/mb)
# computing this once to save time
delta_tmp = wc['C1_'+qiqj] * F_17(muh, z, sh) + wc['C2_'+qiqj] * F_27(muh, z, sh)
delta_t = wc['C8eff_'+qiqj] * F_87(Lmu, sh) + delta_tmp
delta_u = delta_tmp + wc['C1_'+qiqj] * Fu_17(q2, mb, scale) + wc['C2_'+qiqj] * Fu_27(q2, mb, scale)
# note the minus sign between delta_t and delta_u. This is because of a sign
# switch in the definition of the "Fu" functions between hep-ph/0403185
# (used here) and hep-ph/0412400, see footnote 5 of 0811.1214.
return -alpha_s/(4*pi) * (delta_t - xi_u/xi_t * delta_u)
def prefactor(par, B, V):
mB = par["m_" + B]
mV = par["m_" + V]
scale = config["renormalization scale"]["bvgamma"]
alphaem = running.get_alpha(par, scale)["alpha_e"]
mb = running.get_mb(par, scale)
GF = par["GF"]
bq = meson_quark[(B, V)]
xi_t = ckm.xi("t", bq)(par)
return sqrt((GF ** 2 * alphaem * mB ** 3 * mb ** 2) / (32 * pi ** 4) * (1 - mV ** 2 / mB ** 2) ** 3) * xi_t
def prefactor(q2, par, B, P, l1, l2):
GF = par['GF']
ml1 = par['m_' + l1]
ml2 = par['m_' + l2]
scale = config['renormalization scale']['bpll']
alphaem = running.get_alpha(par, scale)['alpha_e']
di_dj = meson_quark[(B, P)]
xi_t = ckm.xi('t', di_dj)(par)
if q2 <= (ml1 + ml2)**2:
return 0
return 4 * GF / sqrt(2) * xi_t * alphaem / (4 * pi)
def prefactor(par, B, V):
mB = par['m_'+B]
mV = par['m_'+V]
scale = config['renormalization scale']['bvgamma']
alphaem = running.get_alpha(par, scale)['alpha_e']
mb = running.get_mb(par, scale)
GF = par['GF']
bq = meson_quark[(B,V)]
xi_t = ckm.xi('t',bq)(par)
return ( sqrt((GF**2 * alphaem * mB**3 * mb**2)/(32 * pi**4)
* (1-mV**2/mB**2)**3) * xi_t )
def prefactor(par, B, V):
mB = par['m_'+B]
mV = par['m_'+V]
scale = config['renormalization scale']['bvgamma']
alphaem = running.get_alpha(par, scale)['alpha_e']
mb = running.get_mb(par, scale)
GF = par['GF']
bq = meson_quark[(B,V)]
xi_t = ckm.xi('t',bq)(par)
return ( sqrt((GF**2 * alphaem * mB**3 * mb**2)/(32 * pi**4)
* (1-mV**2/mB**2)**3) * xi_t )
def Kpipi_amplitudes_NP(wc_obj, par):
r"""Compute the new physics contribution to the two isospin amplitudes
of the $K\to\pi\pi$ transition."""
scale = config['renormalization scale']['kpipi']
pref = 4 * par['GF'] / sqrt(2) * ckm.xi('t', 'ds')(par) # 4GF/sqrt(2) Vts* Vtd
me = Kpipi_matrixelements_NP(par, scale)
wc = wc_obj.get_wc(sector='sd', scale=scale, par=par, eft='WET-3')
A = {0: 0, 2: 0}
for i in [0, 2]:
for j, m in me[i].items():
A[i] += -pref * m * complex(wc[j]).conjugate() # conjugate!
return A
def Kpipi_amplitudes_NP(wc_obj, par):
r"""Compute the new physics contribution to the two isospin amplitudes
of the $K\to\pi\pi$ transition."""
scale = config['renormalization scale']['kpipi']
pref = 4 * par['GF'] / sqrt(2) * ckm.xi('t', 'ds')(
par) # 4GF/sqrt(2) Vts* Vtd
me = Kpipi_matrixelements_NP(par, scale)
wc = wc_obj.get_wc(sector='sd', scale=scale, par=par, eft='WET-3')
A = {0: 0, 2: 0}
for i in [0, 2]:
for j, m in me[i].items():
A[i] += -pref * m * complex(wc[j]).conjugate() # conjugate!
return A
def get_wceff(q2, wc, par, B, M, lep, scale):
r"""Get a dictionary with the effective $\Delta F=1$ Wilson coefficients
in the convention appropriate for the generalized angular distributions.
"""
xi_u = ckm.xi('u', meson_quark[(B, M)])(par)
xi_t = ckm.xi('t', meson_quark[(B, M)])(par)
qiqj = meson_quark[(B, M)]
Yq2 = matrixelements.Y(
q2, wc, par, scale,
qiqj) + (xi_u / xi_t) * matrixelements.Yu(q2, wc, par, scale, qiqj)
# b) NNLO Q1,2
delta_C7 = matrixelements.delta_C7(par=par,
wc=wc,
q2=q2,
scale=scale,
qiqj=qiqj)
delta_C9 = matrixelements.delta_C9(par=par,
wc=wc,
q2=q2,
scale=scale,
qiqj=qiqj)
mb = running.get_mb(par, scale)
ll = lep + lep
c = {}
c['7'] = wc['C7eff_' + qiqj] + delta_C7
c['7p'] = wc['C7effp_' + qiqj]
c['v'] = wc['C9_' + qiqj + ll] + delta_C9 + Yq2
c['vp'] = wc['C9p_' + qiqj + ll]
c['a'] = wc['C10_' + qiqj + ll]
c['ap'] = wc['C10p_' + qiqj + ll]
c['s'] = mb * wc['CS_' + qiqj + ll]
c['sp'] = mb * wc['CSp_' + qiqj + ll]
c['p'] = mb * wc['CP_' + qiqj + ll]
c['pp'] = mb * wc['CPp_' + qiqj + ll]
c['t'] = 0
c['tp'] = 0
return c
def cvll_d(par, meson, scale=160):
r"""Contributions to the Standard Model Wilson coefficient $C_V^{LL}$
for $B^0$, $B_s$, and $K$ mixing at the matching scale.
The Hamiltonian is defined as
$$\mathcal H_{\mathrm{eff}} = - C_V^{LL} O_V^{LL},$$
where $O_V^{LL} = (\bar d_L^i\gamma^\mu d_L^j)^2$ with $i<j$.
Parameters
----------
- `par`:
parameter dictionary
- `meson`:
should be one of `'B0'`, `'Bs'`, or `'K0'`
Returns
-------
a tuple of three complex numbers `(C_tt, C_cc, C_ct)` that contain the top-,
charm-, and charm-top-contribution to the Wilson coefficient. This
separation is necessary as they run differently.
"""
mt = flavio.physics.running.running.get_mt(par, scale)
mc = flavio.physics.running.running.get_mc(par, scale)
mu = flavio.physics.running.running.get_mu(par, scale)
mW = par['m_W']
xt = mt**2/mW**2
xc = mc**2/mW**2
xu = mu**2/mW**2
di_dj = meson_quark[meson]
xi_t = ckm.xi('t',di_dj)(par)
xi_c = ckm.xi('c',di_dj)(par)
N = df2_prefactor(par)
C_cc = N * xi_c**2 * S0_box(xc, xc, xu)
C_tt = N * xi_t**2 * S0_box(xt, xt, xu)
C_ct = N * 2*xi_c*xi_t * S0_box(xc, xt, xu)
return (C_tt, C_cc, C_ct)
def cvll_d(par, meson, scale=80):
r"""Contributions to the Standard Model Wilson coefficient $C_V^{LL}$
for $B^0$, $B_s$, and $K$ mixing at the matching scale.
The Hamiltonian is defined as
$$\mathcal H_{\mathrm{eff}} = - C_V^{LL} O_V^{LL},$$
where $O_V^{LL} = (\bar d_L^i\gamma^\mu d_L^j)^2$ with $i<j$.
Parameters
----------
- `par`:
parameter dictionary
- `meson`:
should be one of `'B0'`, `'Bs'`, or `'K0'`
Returns
-------
a tuple of three complex numbers `(C_tt, C_cc, C_ct)` that contain the top-,
charm-, and charm-top-contribution to the Wilson coefficient. This
separation is necessary as they run differently.
"""
mt = flavio.physics.running.running.get_mt(par, scale)
mc = flavio.physics.running.running.get_mc(par, scale)
mu = flavio.physics.running.running.get_mu(par, scale)
mW = par['m_W']
xt = mt**2/mW**2
xc = mc**2/mW**2
xu = mu**2/mW**2
di_dj = meson_quark[meson]
xi_t = ckm.xi('t',di_dj)(par)
xi_c = ckm.xi('c',di_dj)(par)
N = df2_prefactor(par)
C_cc = N * xi_c**2 * S0_box(xc, xc, xu)
C_tt = N * xi_t**2 * S0_box(xt, xt, xu)
C_ct = N * 2*xi_c*xi_t * S0_box(xc, xt, xu)
return (C_tt, C_cc, C_ct)
def amplitude_Bspsiphi(par):
xi_c = ckm.xi('c', 'bs')(par) # V_cb V_cs*
return xi_c
def amplitude_BJpsiK(par):
xi_c = ckm.xi('c', 'bd')(par) # V_cb V_cd*
return xi_c
def amplitude_BJpsiK(par):
xi_c = ckm.xi('c', 'bd')(par) # V_cb V_cd*
return xi_c
def br_taupl(wc_obj, par, P, lep):
r"""Branching ratio of $\tau^+\to p^0\ell^+$."""
scale = flavio.config['renormalization scale']['taudecays']
GF = par['GF']
alphaem = running.get_alpha(par, 4.8)['alpha_e']
mP = par['m_' + P]
mtau = par['m_tau']
mu = par['m_u']
md = par['m_d']
mlep = par['m_' + lep]
fP = par['f_' + P]
if P == 'pi0':
sec = wcxf_sector_names['tau', lep]
wc = wc_obj.get_wc(sec, scale, par, nf_out=4)
F = {}
S = {}
for q in 'ud':
F['LL' + q] = wc['CVLL_tau{}{}'.format(lep, 2 * q)] # FLL
F['RR' + q] = wc['CVRR_tau{}{}'.format(lep, 2 * q)] # FRR
F['LR' + q] = wc['CVLR_tau{}{}'.format(lep, 2 * q)] # FLR
F['RL' + q] = wc['CVLR_{}tau{}'.format(2 * q, lep)] # FLRqq
S['RR' + q] = wc['CSRR_tau{}{}'.format(lep, 2 * q)] # SRR
S['RL' + q] = wc['CSRL_tau{}{}'.format(lep, 2 * q)] # SLR
S['LL' + q] = wc['CSRR_{}tau{}'.format(lep,
2 * q)].conjugate() # SRRqq
S['LR' + q] = wc['CSRL_{}tau{}'.format(lep,
2 * q)].conjugate() # SLRqq
vL = fP * ((F['LRu'] - F['LLu']) / 2 -
(F['LRd'] - F['LLd']) / 2) / sqrt(2)
vR = fP * ((F['RRu'] - F['RLu']) / 2 -
(F['RRd'] - F['RLd']) / 2) / sqrt(2)
sL = fP * mP**2 / (mu + md) * ((S['LRu'] - S['LLu']) / 2 -
(S['LRd'] - S['LLd']) / 2) / sqrt(2)
sR = fP * mP**2 / (mu + md) * ((S['RRu'] - S['RLu']) / 2 -
(S['RRd'] - S['RLd']) / 2) / sqrt(2)
gL = sL + (-vL * mlep + vR * mtau)
gR = sR + (-vR * mlep + vL * mtau)
elif P == 'K0':
xi_t = ckm.xi('t', 'ds')(par)
qqll = 'sdtau' + lep
wc = wc_obj.get_wc(qqll, scale, par, nf_out=4)
mq1 = flavio.physics.running.running.get_md(par, scale)
mq2 = flavio.physics.running.running.get_ms(par, scale)
C9m = -wc['C9_' + qqll] + wc['C9p_' + qqll]
C10m = -wc['C10_' + qqll] + wc['C10p_' + qqll]
CSm = wc['CS_' + qqll] - wc['CSp_' + qqll]
CPm = wc['CP_' + qqll] - wc['CPp_' + qqll]
Kv = xi_t * 4 * GF / sqrt(2) * alphaem / (4 * pi)
Ks = Kv * mq2
gV = -fP * Kv * C9m / 2
gA = -fP * Kv * C10m / 2
gS = -fP * Ks * mP**2 * CSm / 2 / (mq1 + mq2)
gP = -fP * Ks * mP**2 * CPm / 2 / (mq1 + mq2)
gVS = gS + gV * (mtau - mlep)
gAP = gP - gA * (mtau + mlep)
gL = gVS - gAP
gR = gVS + gAP
return par['tau_tau'] * common.GammaFsf(mtau, mP, mlep, gL, gR)
def amplitude_Bspsiphi(par):
xi_c = ckm.xi('c', 'bs')(par) # V_cb V_cs*
return xi_c