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)