Exemplo n.º 1
0
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
Exemplo n.º 2
0
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)
Exemplo n.º 3
0
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
Exemplo n.º 4
0
Arquivo: bll.py Projeto: nsahoo/flavio
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 )
Exemplo n.º 5
0
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
Exemplo n.º 6
0
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
Exemplo n.º 7
0
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
Exemplo n.º 8
0
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
	}
Exemplo n.º 9
0
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
Exemplo n.º 10
0
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
	}
Exemplo n.º 11
0
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
Exemplo n.º 12
0
 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)
Exemplo n.º 13
0
 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)
Exemplo n.º 14
0
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
Exemplo n.º 15
0
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))
Exemplo n.º 16
0
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))
Exemplo n.º 17
0
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
Exemplo n.º 18
0
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
Exemplo n.º 19
0
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
Exemplo n.º 20
0
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)
Exemplo n.º 21
0
Arquivo: kll.py Projeto: hoodyn/flavio
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
Exemplo n.º 22
0
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)
Exemplo n.º 23
0
Arquivo: kll.py Projeto: hoodyn/flavio
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))
Exemplo n.º 24
0
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))
Exemplo n.º 25
0
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
Exemplo n.º 26
0
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)
Exemplo n.º 27
0
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)
Exemplo n.º 28
0
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
Exemplo n.º 29
0
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)
Exemplo n.º 30
0
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 )
Exemplo n.º 31
0
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 )
Exemplo n.º 32
0
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
Exemplo n.º 33
0
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
Exemplo n.º 34
0
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
Exemplo n.º 35
0
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)
Exemplo n.º 36
0
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)
Exemplo n.º 37
0
def amplitude_Bspsiphi(par):
    xi_c = ckm.xi('c', 'bs')(par) # V_cb V_cs*
    return xi_c
Exemplo n.º 38
0
def amplitude_BJpsiK(par):
    xi_c = ckm.xi('c', 'bd')(par) # V_cb V_cd*
    return xi_c
Exemplo n.º 39
0
def amplitude_BJpsiK(par):
    xi_c = ckm.xi('c', 'bd')(par) # V_cb V_cd*
    return xi_c
Exemplo n.º 40
0
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)
Exemplo n.º 41
0
def amplitude_Bspsiphi(par):
    xi_c = ckm.xi('c', 'bs')(par) # V_cb V_cs*
    return xi_c