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 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 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 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 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 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 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 get_CVSM(par, scale):
r"""Get the Wilson coefficient of the operator $C_V$ in $d_i\to d_j\ell\nu$
in the SM including EW corrections."""
if scale > 2: # for B physics
alpha_e = running.get_alpha(par, scale)['alpha_e']
return 1 + alpha_e/pi * log(par['m_Z']/scale)
else: # for K and pi physocs
# Marciano & Sirlin 1993
return 1.0232
def get_CVSM(par, scale, nf):
r"""Get the Wilson coefficient of the operator $C_V$ in $d_i\to d_j\ell\nu$
in the SM including EW corrections."""
if nf >= 4: # for B and D physics
alpha_e = running.get_alpha(par, scale)['alpha_e']
return 1 + alpha_e / pi * log(par['m_Z'] / scale)
else: # for K and pi physics
# Marciano & Sirlin 1993
return sqrt(1.0232)
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 prefactor(q2, par, B, P, lep):
GF = par['GF']
ml = par['m_'+lep]
scale = config['renormalization scale']['bpll']
alphaem = running.get_alpha(par, scale)['alpha_e']
di_dj = meson_quark[(B,P)]
qi_qj = meson_quark[(B, P)]
if qi_qj == 'bu':
Vij = ckm.get_ckm(par)[0,2] # V_{ub} for b->u transitions
if qi_qj == 'bc':
Vij = ckm.get_ckm(par)[1,2] # V_{cb} for b->c transitions
if q2 <= ml**2:
return 0
return 4*GF/sqrt(2)*Vij
def get_hqet_parameters(par, scale):
p = {}
alphas = running.get_alpha(par, scale, nf_out=5)['alpha_s']
p['ash'] = alphas / pi
p['mb'] = running.get_mb_pole(par)
p['mc'] = p['mb'] - 3.4
p['mb1S'] = running.get_mb_1S(par)
mBbar = (par['m_B0'] + 3 * par['m_B*0']) / 4
# eq. (25); note the comment about the renormalon cancellation thereafter
p['Lambdabar'] = mBbar - p['mb1S'] + par['lambda_1'] / (2 * p['mb1S'])
p['epsc'] = p['Lambdabar'] / (2 * p['mc'])
p['epsb'] = p['Lambdabar'] / (2 * p['mb'])
p['zc'] = p['mc'] / p['mb']
return p
def get_hqet_parameters(par, scale):
p = {}
alphas = running.get_alpha(par, scale, nf_out=5)['alpha_s']
p['ash'] = alphas / pi
p['mb'] = running.get_mb_pole(par)
p['mc'] = p['mb'] - 3.4
p['mb1S'] = running.get_mb_1S(par, scale)
mBbar = (par['m_B0'] + 3 * par['m_B*0']) / 4
# eq. (25); note the comment about the renormalon cancellation thereafter
p['Lambdabar'] = mBbar - p['mb1S'] + par['lambda_1'] / (2 * p['mb1S'])
p['epsc'] = p['Lambdabar'] / (2 * p['mc'])
p['epsb'] = p['Lambdabar'] / (2 * p['mb'])
p['zc'] = p['mc'] / p['mb']
return p
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 prefactor(q2, par, B, P, lep):
GF = par['GF']
ml = par['m_' + lep]
scale = config['renormalization scale']['bpll']
alphaem = running.get_alpha(par, scale)['alpha_e']
di_dj = meson_quark[(B, P)]
qi_qj = meson_quark[(B, P)]
if qi_qj == 'bu':
Vij = ckm.get_ckm(par)[0, 2] # V_{ub} for b->u transitions
if qi_qj == 'bc':
Vij = ckm.get_ckm(par)[1, 2] # V_{cb} for b->c transitions
if q2 <= ml**2:
return 0
return 4 * GF / sqrt(2) * Vij
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_hqet_parameters(par):
p = {}
# The scale here is fixed to 2.7 GeV ~ sqrt(m_b^pole * m_c^pole)
alphas = running.get_alpha(par, scale=2.7, nf_out=5)['alpha_s']
p['ash'] = alphas / pi
p['mb1S'] = running.get_mb_1S(par)
p['mb'] = p['mb1S'] * (1 + 2 * alphas**2 / 9)
p['mc'] = p['mb'] - 3.4
mBbar = (par['m_B0'] + 3 * par['m_B*0']) / 4
# eq. (25); note the comment about the renormalon cancellation thereafter
p['Lambdabar'] = mBbar - p['mb'] + par['lambda_1'] / (2 * p['mb1S'])
p['epsc'] = p['Lambdabar'] / (2 * p['mc'])
p['epsb'] = p['Lambdabar'] / (2 * p['mb'])
p['zc'] = p['mc'] / p['mb']
return p
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 M12_d_SM(par, meson):
r"""Standard model contribution to the mixing amplitude $M_{12}$ of
meson $K^0$, $B^0$, or $B_s$.
Defined as
$$M_{12}^M = \frac{\langle M | \mathcal H_{\mathrm{eff}}|\bar M\rangle}{2M_M}$$
(Attention: $M_{12}$ is sometimes defined with the meson and anti-meson
switched in the above definition, leading to a complex conjugation.)
"""
me = matrixelements(par, meson)
scale = config['renormalization scale'][meson + ' mixing']
alpha_s = running.get_alpha(par, scale)['alpha_s']
me_rgi = me['CVLL'] * bag_msbar2rgi(alpha_s, meson)
C_tt, C_cc, C_ct = cvll_d(par, meson)
eta_tt = par['eta_tt_'+meson]
M12 = - (eta_tt*C_tt) * me_rgi
# charm contribution only needed for K mixing! Negligible for B and Bs.
if meson == 'K0':
eta_cc = par['eta_cc_'+meson]
eta_ct = par['eta_ct_'+meson]
M12 = M12 - (eta_cc*C_cc + eta_ct*C_ct) * me_rgi
return M12
def M12_d_SM(par, meson):
r"""Standard model contribution to the mixing amplitude $M_{12}$ of
meson $K^0$, $B^0$, or $B_s$.
Defined as
$$M_{12}^M = \frac{\langle M | \mathcal H_{\mathrm{eff}}|\bar M\rangle}{2M_M}$$
(Attention: $M_{12}$ is sometimes defined with the meson and anti-meson
switched in the above definition, leading to a complex conjugation.)
"""
me = matrixelements(par, meson)
scale = config['renormalization scale'][meson + ' mixing']
alpha_s = running.get_alpha(par, scale)['alpha_s']
me_rgi = me['CVLL'] * bag_msbar2rgi(alpha_s, meson)
C_tt, C_cc, C_ct = cvll_d(par, meson)
eta_tt = par['eta_tt_' + meson]
M12 = -(eta_tt * C_tt) * me_rgi
# charm contribution only needed for K mixing! Negligible for B and Bs.
if meson == 'K0':
eta_cc = par['eta_cc_' + meson]
eta_ct = par['eta_ct_' + meson]
M12 = M12 - (eta_cc * C_cc + eta_ct * C_ct) * me_rgi
return M12
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)
