Пример #1
0
def helicity_amps_ff(q2, wc_obj, par_dict, B, P, l1, l2, cp_conjugate):
    par = par_dict.copy()
    if cp_conjugate:
        par = conjugate_par(par)
    scale = config['renormalization scale']['bpll']
    label = meson_quark[(B,P)] + l1 + l2 # e.g. bsmumu, bdtautau
    if l1 == l2:
        # include SM contributions for LF conserving decay
        wc = wctot_dict(wc_obj, label, scale, par)
    else:
        wc = wc_obj.get_wc(label, scale, par)
    if cp_conjugate:
        wc = conjugate_wc(wc)
    if l1 == l2:
        wc_eff = get_wceff(q2, wc, par, B, P, l1, scale)
    else:
        wc_eff = get_wceff_lfv(q2, wc, par, B, P, l1, l2, scale)
    ml1 = par['m_'+l1]
    ml2 = par['m_'+l2]
    mB = par['m_'+B]
    mP = par['m_'+P]
    mb = running.get_mb(par, scale)
    N = prefactor(q2, par, B, P)
    ff = get_ff(q2, par, B, P)
    h = angular.helicity_amps_p(q2, mB, mP, mb, 0, ml1, ml2, ff, wc_eff, N)
    return h
Пример #2
0
def _get_angularcoeff(q2, wc_obj, par, B, V, lep, nu):
    scale = config['renormalization scale']['bvll']
    mb = running.get_mb(par, scale)
    wc = get_wceff_fccc(wc_obj,
                        par,
                        meson_quark[(B, V)],
                        lep,
                        nu,
                        mb,
                        scale,
                        nf=5)
    if lep != nu and all(C == 0 for C in wc.values()):
        # if all WCs vanish, so does the AC!
        return {
            k: 0
            for k in ['1s', '1c', '2s', '2c', '6s', '6c', 3, 4, 5, 7, 8, 9]
        }
    ml = par['m_' + lep]
    mB = par['m_' + B]
    mV = par['m_' + V]
    qi_qj = meson_quark[(B, V)]
    if qi_qj == 'bu':
        mlight = 0.  # neglecting the up quark mass
    if qi_qj == 'bc':
        mlight = running.get_mc(
            par, scale)  # this is needed for scalar contributions
    N = prefactor(q2, par, B, V, lep)
    ff = get_ff(q2, par, B, V)
    h = angular.helicity_amps_v(q2, mB, mV, mb, mlight, ml, 0, ff, wc, N)
    J = angular.angularcoeffs_general_v(h, q2, mB, mV, mb, mlight, ml, 0)
    return J
Пример #3
0
def helicity_amps_ff(q2, wc_obj, par_dict, B, P, l1, l2, cp_conjugate):
    par = par_dict.copy()
    if cp_conjugate:
        par = conjugate_par(par)
    scale = config['renormalization scale']['bpll']
    label = meson_quark[(B,P)] + l1 + l2 # e.g. bsmumu, bdtautau
    if l1 == l2:
        # include SM contributions for LF conserving decay
        wc = wctot_dict(wc_obj, label, scale, par)
    else:
        wc = wc_obj.get_wc(label, scale, par)
    if cp_conjugate:
        wc = conjugate_wc(wc)
    if l1 == l2:
        wc_eff = get_wceff(q2, wc, par, B, P, l1, scale)
    else:
        wc_eff = get_wceff_lfv(q2, wc, par, B, P, l1, l2, scale)
    ml1 = par['m_'+l1]
    ml2 = par['m_'+l2]
    mB = par['m_'+B]
    mP = par['m_'+P]
    mb = running.get_mb(par, scale)
    N = prefactor(q2, par, B, P)
    ff = get_ff(q2, par, B, P)
    h = angular.helicity_amps_p(q2, mB, mP, mb, 0, ml1, ml2, ff, wc_eff, N)
    return h
Пример #4
0
def wctot_dict(wc_obj, sector, scale, par, nf_out=5):
    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)
    if nf_out == 5:
        wc_sm = wcsm_nf5(scale)
    else:
        raise NotImplementedError(
            "DeltaF=1 Wilson coefficients only implemented for B physics")
    # fold in approximate m_t-dependence of C_10 (see eq. 4 of arXiv:1311.0903)
    flavio.citations.register("Bobeth:2013uxa")
    wc_sm[9] = wc_sm[9] * (par['m_t'] / 173.1)**1.53
    # go from the effective to the "non-effective" WCs for C7 and C8
    yi = np.array([0, 0, -1 / 3., -4 / 9., -20 / 3., -80 / 9.])
    zi = np.array([0, 0, 1, -1 / 6., 20, -10 / 3.])
    wc_sm[6] = wc_sm[6] - np.dot(yi, wc_sm[:6])  # c7 (not effective!)
    wc_sm[7] = wc_sm[7] - np.dot(zi, wc_sm[:6])  # c8 (not effective!)
    wc_labels = fcnclabels[sector]
    wc_sm_dict = dict(zip(wc_labels, wc_sm))
    # 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':
        eps_s = running.get_ms(par, scale) / running.get_mb(par, scale)
        wc_sm_dict['C7p_bs'] = eps_s * wc_sm_dict['C7_bs']
        wc_sm_dict['C8p_bs'] = eps_s * wc_sm_dict['C8_bs']
    tot_dict = add_dict((wc_np_dict, wc_sm_dict))
    # add C7eff(p) and C8eff(p)
    tot_dict.update(get_C78eff(tot_dict, sector[:2]))
    return tot_dict
Пример #5
0
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))
Пример #6
0
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))
Пример #7
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
Пример #8
0
def getfft(s, par, B, ff, ff0, lep, wc):
    scale = config['renormalization scale']['bllgamma']
    mb = running.get_mb(par, scale, nf_out=5)
    bq = meson_quark[B]
    a1 = -wc['C1_' + bq] - wc[
        'C2_' + bq] / 3  #minus sign comes from WC sign convention
    fftv = ff['tv'] + ff0['tv'] + 16 / 3 * a1 / wc['C7_' + bq] * par['f_' +
                                                                     B] / mb
    ffta = ff['ta'] + ff0['ta']

    #Add light meson resonances
    resonances = {'Bs': ['phi'], 'B0': ['rho0', 'omega']}
    flavio.citations.register("Kozachuk:2017mdk")
    fVtofVemfactors = {
        'phi': -1 / 3,
        'rho0': 1 / sqrt(2),
        'omega': 1 / (3 * sqrt(2))
    }  # Given in Sec. 8.A.3 of 1712.07926
    #We use the general B->rho and B->omega parameters, hence the isotopic factors
    resgV = {
        ('Bs', 'phi'): -par['Bs->phi BSZ a0_T1'],
        ('B0', 'rho0'): 1 / sqrt(2) * par['B->rho BSZ a0_T1'],
        ('B0', 'omega'): -1 / sqrt(2) * par['B->omega BSZ a0_T1'],
    }
    for V in resonances[B]:
        gV = resgV[(B, V)]
        fV = fVtofVemfactors[V] * par['f_' + V]
        fftv -= 2 * fV * gV * par['m_' + B]**2 * s / par['m_' + V] / (
            par['m_' + B]**2 * s - par['m_' + V]**2 +
            1j * par['m_' + V] / par['tau_' + V])
        ffta -= 2 * fV * gV * par['m_' + B]**2 * s / par['m_' + V] / (
            par['m_' + B]**2 * s - par['m_' + V]**2 +
            1j * par['m_' + V] / par['tau_' + V])

    return (fftv, ffta)
Пример #9
0
def _get_angularcoeff(q2, wc_obj, par, B, V, lep, nu):
    scale = config['renormalization scale']['bvll']
    mb = running.get_mb(par, scale)
    wc = get_wceff_fccc2(wc_obj,
                         par,
                         meson_quark[(B, V)],
                         lep,
                         nu,
                         mb,
                         scale,
                         nf=5)
    ml = par['m_' + lep]
    mB = par['m_' + B]
    mV = par['m_' + V]
    qi_qj = meson_quark[(B, V)]
    if qi_qj == 'bu':
        mlight = 0.  # neglecting the up quark mass
    if qi_qj == 'bc':
        mlight = running.get_mc(
            par, scale)  # this is needed for scalar contributions
    N = prefactor(q2, par, B, V, lep)
    ff = get_ff(q2, par, B, V)
    h = angular.helicity_amps_v(q2, mB, mV, mb, mlight, ml, 0, ff, wc, N)
    J = angular.angularcoeffs_general_v(h, q2, mB, mV, mb, mlight, ml, 0)
    return J
Пример #10
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
Пример #11
0
def getF1(s, par, B, ff, ff0, lep, wc):
    scale = config['renormalization scale']['bllgamma']
    mb = running.get_mb(par, scale, nf_out=5)
    mbh = mb / par['m_' + B]
    bq = meson_quark[B]
    label = bq + lep + lep
    fftv, ffta = getfft(s, par, B, ff, ff0, lep, wc)
    return (abs(wc['C9_' + label])**2 +
            abs(wc['C10_' + label])**2) * ff['v']**2 + 4 * mbh**2 / s**2 * abs(
                wc['C7_' + bq] * fftv)**2 + 4 * mbh / s * ff['v'] * _Re(
                    wc['C7_' + bq] * ffta * _Co(wc['C9_' + label]))
Пример #12
0
def B120(s, par, B, ff, ff0, lep, wc):
    scale = config['renormalization scale']['bllgamma']
    mb = running.get_mb(par, scale, nf_out=5)
    mbh = mb / par['m_' + B]
    mlh = par['m_' + lep] / par['m_' + B]
    bq = meson_quark[B]
    label = bq + lep + lep
    fftv, ffta = getfft(s, par, B, ff, ff0, lep, wc)
    return -16 * mlh**2 * (1 - s) * (
        ff['v'] * _Re(wc['C9_' + label] * _Co(wc['C10_' + label])) +
        2 * mbh / s * _Re(_Co(wc['C10_' + label]) * fftv * wc['C7_' + bq]))
Пример #13
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 )
Пример #14
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 )
Пример #15
0
def bpll_obs(function, q2, wc, par, B, P, l1, l2):
    ml1 = par['m_'+l1]
    ml2 = par['m_'+l2]
    mB = par['m_'+B]
    mP = par['m_'+P]
    if q2 <= (ml1+ml2)**2 or q2 > (mB-mP)**2:
        return 0
    scale = config['renormalization scale']['bpll']
    mb = running.get_mb(par, scale)
    h     = helicity_amps(q2, wc, par, B, P, l1, l2)
    J     = angular.angularcoeffs_general_p(h, q2, mB, mP, mb, 0, ml1, ml2)
    return function(J)
Пример #16
0
def helicity_amps(q2, wc, par_dict, B, P, l1, l2):
    par = par_dict.copy()
    scale = config['renormalization scale']['bpll']
    wc_eff = get_wceff_lfv(q2, wc, par, B, P, l1, l2, scale)
    ml1 = par['m_'+l1]
    ml2 = par['m_'+l2]
    mB = par['m_'+B]
    mP = par['m_'+P]
    mb = running.get_mb(par, scale)
    N = prefactor(q2, par, B, P)
    ff = get_ff(q2, par, B, P)
    h = angular.helicity_amps_p(q2, mB, mP, mb, 0, ml1, ml2, ff, wc_eff, N)
    return h
Пример #17
0
def B120(s, par, B, ff, ff0, lep, wc):
    flavio.citations.register("Melikhov:2004mk")
    flavio.citations.register("Guadagnoli:2016erb")
    scale = config['renormalization scale']['bllgamma']
    mb = running.get_mb(par, scale, nf_out=5)
    mbh = mb / par['m_' + B]
    mlh = par['m_' + lep] / par['m_' + B]
    bq = meson_quark[B]
    label = bq + lep + lep
    fftv, ffta = getfft(s, par, B, ff, ff0, lep, wc)
    return -16 * mlh**2 * (1 - s) * (
        ff['v'] * _Re(wc['C9_' + label] * _Co(wc['C10_' + label])) +
        2 * mbh / s * _Re(_Co(wc['C10_' + label]) * fftv * wc['C7_' + bq]))
Пример #18
0
def bvll_obs(function, q2, wc_obj, par, B, V, lep):
    ml = par['m_'+lep]
    mB = par['m_'+B]
    mV = par['m_'+V]
    if q2 < 4*ml**2 or q2 > (mB-mV)**2:
        return 0
    scale = config['renormalization scale']['bvll']
    mb = running.get_mb(par, scale)
    ff = get_ff(q2, par, B, V)
    h = helicity_amps(q2, wc_obj, par, B, V, lep)
    h_bar = helicity_amps_bar(q2, wc_obj, par, B, V, lep)
    J = angular.angularcoeffs_general_v(h, q2, mB, mV, mb, 0, ml, ml)
    J_bar = angular.angularcoeffs_general_v(h_bar, q2, mB, mV, mb, 0, ml, ml)
    return function(J, J_bar)
Пример #19
0
def bvll_obs(function, q2, wc_obj, par, B, V, lep):
    ml = par['m_' + lep]
    mB = par['m_' + B]
    mV = par['m_' + V]
    if q2 < 4 * ml**2 or q2 > (mB - mV)**2:
        return 0
    scale = config['renormalization scale']['bvll']
    mb = running.get_mb(par, scale)
    ff = get_ff(q2, par, B, V)
    h = helicity_amps(q2, wc_obj, par, B, V, lep)
    h_bar = helicity_amps_bar(q2, wc_obj, par, B, V, lep)
    J = angular.angularcoeffs_general_v(h, q2, mB, mV, mb, 0, ml, ml)
    J_bar = angular.angularcoeffs_general_v(h_bar, q2, mB, mV, mb, 0, ml, ml)
    return function(J, J_bar)
Пример #20
0
def helicity_amps_ff(q2, ff, wc_obj, par_dict, B, V, lep, cp_conjugate):
    par = par_dict.copy()
    if cp_conjugate:
        par = conjugate_par(par)
    scale = config['renormalization scale']['bvll']
    label = meson_quark[(B,V)] + lep + lep # e.g. bsmumu, bdtautau
    wc = wctot_dict(wc_obj, label, scale, par)
    if cp_conjugate:
        wc = conjugate_wc(wc)
    wc_eff = get_wceff(q2, wc, par, B, V, lep, scale)
    ml = par['m_'+lep]
    mB = par['m_'+B]
    mV = par['m_'+V]
    mb = running.get_mb(par, scale)
    N = prefactor(q2, par, B, V)
    h = angular.helicity_amps_v(q2, mB, mV, mb, 0, ml, ml, ff, wc_eff, N)
    return h
Пример #21
0
def get_angularcoeff(q2, wc_obj, par, B, V, lep):
    scale = config['renormalization scale']['bvll']
    mb = running.get_mb(par, scale)
    wc = get_wceff_fccc(wc_obj, par, meson_quark[(B,V)], lep, mb, scale, nf=5)
    ml = par['m_'+lep]
    mB = par['m_'+B]
    mV = par['m_'+V]
    qi_qj = meson_quark[(B, V)]
    if qi_qj == 'bu':
        mlight = 0. # neglecting the up quark mass
    if qi_qj == 'bc':
        mlight = running.get_mc(par, scale) # this is needed for scalar contributions
    N = prefactor(q2, par, B, V, lep)
    ff = get_ff(q2, par, B, V)
    h = angular.helicity_amps_v(q2, mB, mV, mb, mlight, ml, 0, ff, wc, N)
    J = angular.angularcoeffs_general_v(h, q2, mB, mV, mb, mlight, ml, 0)
    return J
Пример #22
0
def helicity_amps_ff(q2, ff, wc_obj, par_dict, B, V, lep, cp_conjugate):
    par = par_dict.copy()
    if cp_conjugate:
        par = conjugate_par(par)
    scale = config['renormalization scale']['bvll']
    label = meson_quark[(B, V)] + lep + lep  # e.g. bsmumu, bdtautau
    wc = wctot_dict(wc_obj, label, scale, par)
    if cp_conjugate:
        wc = conjugate_wc(wc)
    wc_eff = get_wceff(q2, wc, par, B, V, lep, scale)
    ml = par['m_' + lep]
    mB = par['m_' + B]
    mV = par['m_' + V]
    mb = running.get_mb(par, scale)
    N = prefactor(q2, par, B, V)
    h = angular.helicity_amps_v(q2, mB, mV, mb, 0, ml, ml, ff, wc_eff, N)
    return h
Пример #23
0
def bpll_obs(function, q2, wc_obj, par, B, P, lep):
    ml = par['m_'+lep]
    mB = par['m_'+B]
    mP = par['m_'+P]
    if q2 <= (ml+ml)**2 or q2 > (mB-mP)**2:
        return 0
    scale = config['renormalization scale']['bpll']
    mb = running.get_mb(par, scale)
    h     = helicity_amps(q2, wc_obj, par, B, P, lep)
    J     = angular.angularcoeffs_general_p(h, q2, mB, mP, mb, 0, ml, ml)
    if lep == lep:
        h_bar = helicity_amps_bar(q2, wc_obj, par, B, P, lep)
        J_bar = angular.angularcoeffs_general_p(h_bar, q2, mB, mP, mb, 0, ml, ml)
    else:
        # for LFV decays, don't bother about the CP average. There is no strong phase.
        J_bar = J
    return function(J, J_bar)
Пример #24
0
def get_angularcoeff(q2, wc_obj, par, B, P, lep):
    ml = par['m_' + lep]
    mB = par['m_' + B]
    mP = par['m_' + P]
    scale = config['renormalization scale']['bpll']
    mb = running.get_mb(par, scale)
    wc = get_wceff_fccc(wc_obj, par, meson_quark[(B, P)], lep, mb, scale)
    N = prefactor(q2, par, B, P, lep)
    ff = get_ff(q2, par, B, P)
    qi_qj = meson_quark[(B, P)]
    if qi_qj == 'bu':
        mlight = 0.  # neglecting the up quark mass
    if qi_qj == 'bc':
        mlight = running.get_mc(
            par, scale)  # this is needed for scalar contributions
    h = angular.helicity_amps_p(q2, mB, mP, mb, mlight, ml, 0, ff, wc, N)
    J = angular.angularcoeffs_general_p(h, q2, mB, mP, mb, mlight, ml, 0)
    return J
Пример #25
0
def bpll_obs(function, q2, wc_obj, par, B, P, lep):
    ml = par['m_' + lep]
    mB = par['m_' + B]
    mP = par['m_' + P]
    if q2 <= (ml + ml)**2 or q2 > (mB - mP)**2:
        return 0
    scale = config['renormalization scale']['bpll']
    mb = running.get_mb(par, scale)
    h = helicity_amps(q2, wc_obj, par, B, P, lep)
    J = angular.angularcoeffs_general_p(h, q2, mB, mP, mb, 0, ml, ml)
    if lep == lep:
        h_bar = helicity_amps_bar(q2, wc_obj, par, B, P, lep)
        J_bar = angular.angularcoeffs_general_p(h_bar, q2, mB, mP, mb, 0, ml,
                                                ml)
    else:
        # for LFV decays, don't bother about the CP average. There is no strong phase.
        J_bar = J
    return function(J, J_bar)
Пример #26
0
def _get_angularcoeff(q2, wc_obj, par, B, P, lep, nu):
    scale = config['renormalization scale']['bpll']
    mb = running.get_mb(par, scale)
    wc = get_wceff_fccc(wc_obj, par, meson_quark[(B,P)], lep, nu, mb, scale, nf=5)
    if lep != nu and all(C == 0 for C in wc.values()):
        return {'a': 0, 'b': 0, 'c': 0}  # if all WCs vanish, so does the AC!
    ml = par['m_'+lep]
    mB = par['m_'+B]
    mP = par['m_'+P]
    N = prefactor(q2, par, B, P, lep)
    ff = get_ff(q2, par, B, P)
    qi_qj = meson_quark[(B, P)]
    if qi_qj == 'bu':
        mlight = 0. # neglecting the up quark mass
    if qi_qj == 'bc':
        mlight = running.get_mc(par, scale) # this is needed for scalar contributions
    h = angular.helicity_amps_p(q2, mB, mP, mb, mlight, ml, 0, ff, wc, N)
    J = angular.angularcoeffs_general_p(h, q2, mB, mP, mb, mlight, ml, 0)
    return J
Пример #27
0
def amplitudes(par, wc, B, l1, l2):
    r"""Amplitudes P and S entering the $B_q\to\ell_1^+\ell_2^-$ observables.

    Parameters
    ----------

    - `par`: parameter dictionary
    - `B`: should be `'Bs'` or `'B0'`
    - `l1` and `l2`: should be `'e'`, `'mu'`, or `'tau'`

    Returns
    -------

    `(P, S)` where for the special case `l1 == l2` one has

    - $P = \frac{2m_\ell}{m_{B_q}} (C_{10}-C_{10}') + m_{B_q} (C_P-C_P')$
    - $S = m_{B_q} (C_S-C_S')$
    """
    scale = config['renormalization scale']['bll']
    # masses
    ml1 = par['m_' + l1]
    ml2 = par['m_' + l2]
    mB = par['m_' + B]
    mb = running.get_mb(par, scale, nf_out=5)
    #   get the mass of the spectator quark
    if B == 'Bs':
        mspec = running.get_ms(par, scale, nf_out=5)
    elif B == 'B0':
        mspec = running.get_md(par, scale, nf_out=5)
    # Wilson coefficients
    qqll = meson_quark[B] + 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]
    beta_m = sqrt(1 - (ml1 - ml2)**2 / mB**2)
    beta_p = sqrt(1 - (ml1 + ml2)**2 / mB**2)
    P = beta_m * ((ml2 + ml1) / mB * C10m + mB * mb / (mb + mspec) * CPm)
    S = beta_p * ((ml2 - ml1) / mB * C9m + mB * mb / (mb + mspec) * CSm)
    return P, S
Пример #28
0
def get_wceff_lfv(q2, wc, par, B, M, l1, l2, scale):
    r"""Get a dictionary with the effective $\Delta F=1$ Wilson coefficients
    with lepton flavour violation
    in the convention appropriate for the generalized angular distributions.
    """
    mb = running.get_mb(par, scale)
    qiqj=meson_quark[(B,M)]
    c = {}
    c['7']  = 0
    c['7p'] = 0
    c['v']  = wc['C9_'+qiqj+l1+l2]
    c['vp'] = wc['C9p_'+qiqj+l1+l2]
    c['a']  = wc['C10_'+qiqj+l1+l2]
    c['ap'] = wc['C10p_'+qiqj+l1+l2]
    c['s']  = mb * wc['CS_'+qiqj+l1+l2]
    c['sp'] = mb * wc['CSp_'+qiqj+l1+l2]
    c['p']  = mb * wc['CP_'+qiqj+l1+l2]
    c['pp'] = mb * wc['CPp_'+qiqj+l1+l2]
    c['t']  = 0
    c['tp'] = 0
    return c
Пример #29
0
def get_wceff_lfv(q2, wc, par, B, M, l1, l2, scale):
    r"""Get a dictionary with the effective $\Delta F=1$ Wilson coefficients
    with lepton flavour violation
    in the convention appropriate for the generalized angular distributions.
    """
    mb = running.get_mb(par, scale)
    qiqj = meson_quark[(B, M)]
    c = {}
    c['7'] = 0
    c['7p'] = 0
    c['v'] = wc['C9_' + qiqj + l1 + l2]
    c['vp'] = wc['C9p_' + qiqj + l1 + l2]
    c['a'] = wc['C10_' + qiqj + l1 + l2]
    c['ap'] = wc['C10p_' + qiqj + l1 + l2]
    c['s'] = mb * wc['CS_' + qiqj + l1 + l2]
    c['sp'] = mb * wc['CSp_' + qiqj + l1 + l2]
    c['p'] = mb * wc['CP_' + qiqj + l1 + l2]
    c['pp'] = mb * wc['CPp_' + qiqj + l1 + l2]
    c['t'] = 0
    c['tp'] = 0
    return c
Пример #30
0
def _get_angularcoeff(q2, wc_obj, par, B, V, lep, nu):
    scale = config['renormalization scale']['bvll']
    mb = running.get_mb(par, scale)
    wc = get_wceff_fccc(wc_obj, par, meson_quark[(B,V)], lep, nu, mb, scale, nf=5)
    if lep != nu and all(C == 0 for C in wc.values()):
        # if all WCs vanish, so does the AC!
        return {k: 0 for k in
                ['1s', '1c', '2s', '2c', '6s', '6c', 3, 4, 5, 7, 8, 9]}
    ml = par['m_'+lep]
    mB = par['m_'+B]
    mV = par['m_'+V]
    qi_qj = meson_quark[(B, V)]
    if qi_qj == 'bu':
        mlight = 0. # neglecting the up quark mass
    if qi_qj == 'bc':
        mlight = running.get_mc(par, scale) # this is needed for scalar contributions
    N = prefactor(q2, par, B, V, lep)
    ff = get_ff(q2, par, B, V)
    h = angular.helicity_amps_v(q2, mB, mV, mb, mlight, ml, 0, ff, wc, N)
    J = angular.angularcoeffs_general_v(h, q2, mB, mV, mb, mlight, ml, 0)
    return J
Пример #31
0
def amplitudes(par, wc, B, l1, l2):
    r"""Amplitudes P and S entering the $B_q\to\ell_1^+\ell_2^-$ observables.

    Parameters
    ----------

    - `par`: parameter dictionary
    - `B`: should be `'Bs'` or `'B0'`
    - `l1` and `l2`: should be `'e'`, `'mu'`, or `'tau'`

    Returns
    -------

    `(P, S)` where for the special case `l1 == l2` one has

    - $P = \frac{2m_\ell}{m_{B_q}} (C_{10}-C_{10}') + m_{B_q} (C_P-C_P')$
    - $S = m_{B_q} (C_S-C_S')$
    """
    scale = config['renormalization scale']['bll']
    # masses
    ml1 = par['m_'+l1]
    ml2 = par['m_'+l2]
    mB = par['m_'+B]
    mb = running.get_mb(par, scale, nf_out=5)
    #   get the mass of the spectator quark
    if B=='Bs':
        mspec = running.get_ms(par, scale, nf_out=5)
    elif B=='B0':
        mspec = running.get_md(par, scale, nf_out=5)
    # Wilson coefficients
    qqll = meson_quark[B] + 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)/mB * C10m + mB * mb/(mb + mspec) * CPm
    S = (ml2 - ml1)/mB * C9m  + mB * mb/(mb + mspec) * CSm
    return P, S
Пример #32
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
Пример #33
0
 def __init__(self, B, V, lep, wc_obj, par):
     """Initialize the class and cache results needed more often."""
     self.B = B
     self.V = V
     self.lep = lep
     self.wc_obj = wc_obj
     self.par = par
     self.par_conjugate = conjugate_par(par)
     self.prefactor = prefactor(None, self.par, B, V)
     self.prefactor_conjugate = prefactor(None, self.par_conjugate, B, V)
     self.scale = config['renormalization scale']['bvll']
     self.label = meson_quark[(B,V)] + lep + lep # e.g. bsmumu, bdtautau
     self.wctot_dict = wctot_dict(wc_obj, self.label, self.scale, par)
     self._ff = {}
     self._wceff = {}
     self._wceff_bar = {}
     self._ha = {}
     self._ha_bar = {}
     self._j = {}
     self._j_bar = {}
     self.ml = par['m_'+lep]
     self.mB = par['m_'+B]
     self.mV = par['m_'+V]
     self.mb = running.get_mb(par, self.scale)
Пример #34
0
 def __init__(self, B, V, lep, wc_obj, par):
     """Initialize the class and cache results needed more often."""
     self.B = B
     self.V = V
     self.lep = lep
     self.wc_obj = wc_obj
     self.par = par
     self.par_conjugate = conjugate_par(par)
     self.prefactor = prefactor(None, self.par, B, V)
     self.prefactor_conjugate = prefactor(None, self.par_conjugate, B, V)
     self.scale = config['renormalization scale']['bvll']
     self.label = meson_quark[(B,V)] + lep + lep # e.g. bsmumu, bdtautau
     self.wctot_dict = wctot_dict(wc_obj, self.label, self.scale, par)
     self._ff = {}
     self._wceff = {}
     self._wceff_bar = {}
     self._ha = {}
     self._ha_bar = {}
     self._j = {}
     self._j_bar = {}
     self.ml = par['m_'+lep]
     self.mB = par['m_'+B]
     self.mV = par['m_'+V]
     self.mb = running.get_mb(par, self.scale)