Module flavio.physics.bdecays.bplnu

Functions for exclusive $B\to P\ell\nu$ decays.

Functions

def BR_binned(q2min, q2max, wc_obj, par, B, P, lep)

Expand source code

def BR_binned(q2min, q2max, wc_obj, par, B, P, lep):
    def integrand(q2):
        return dBRdq2(q2, wc_obj, par, B, P, lep)
    return flavio.math.integrate.nintegrate(integrand, q2min, q2max)

def BR_binned_function(B, P, lep)

Expand source code

def BR_binned_function(B, P, lep):
    return lambda wc_obj, par, q2min, q2max: BR_binned(q2min, q2max, wc_obj, par, B, P, lep)

def BR_binned_leptonflavour(q2min, q2max, wc_obj, par, B, P, lnum, lden)

Expand source code

def BR_binned_leptonflavour(q2min, q2max, wc_obj, par, B, P, lnum, lden):
    num = BR_binned(q2min, q2max, wc_obj, par, B, P, lnum)
    if num == 0:
        return 0
    den = BR_binned(q2min, q2max, wc_obj, par, B, P, lden)
    return num/den

def BR_binned_leptonflavour_function(B, P, lnum, lden)

Expand source code

def BR_binned_leptonflavour_function(B, P, lnum, lden):
    return lambda wc_obj, par, q2min, q2max: BR_binned_leptonflavour(q2min, q2max, wc_obj, par, B, P, lnum, lden)

def BR_binned_tot_function(B, P, lep)

Expand source code

def BR_binned_tot_function(B, P, lep):
    def f(wc_obj, par, q2min, q2max):
        num = BR_binned(q2min, q2max, wc_obj, par, B, P, lep)
        if num == 0:
            return 0
        den = BR_tot(wc_obj, par, B, P, lep)
        return num / den
    return f

def BR_tot(wc_obj, par, B, P, lep)

Expand source code

def BR_tot(wc_obj, par, B, P, lep):
    if lep == 'l':
        # average of e and mu!
        return (_BR_tot(wc_obj, par, B, P, 'e')+_BR_tot(wc_obj, par, B, P, 'mu'))/2.
    else:
        return _BR_tot(wc_obj, par, B, P, lep)

def BR_tot_function(B, P, lep)

Expand source code

def BR_tot_function(B, P, lep):
    return lambda wc_obj, par: BR_tot(wc_obj, par, B, P, lep)

def BR_tot_leptonflavour(wc_obj, par, B, P, lnum, lden)

Expand source code

def BR_tot_leptonflavour(wc_obj, par, B, P, lnum, lden):
    num = BR_tot(wc_obj, par, B, P, lnum)
    if num == 0:
        return 0
    den = BR_tot(wc_obj, par, B, P, lden)
    return num/den

def BR_tot_leptonflavour_function(B, P, lnum, lden)

Expand source code

def BR_tot_leptonflavour_function(B, P, lnum, lden):
    return lambda wc_obj, par: BR_tot_leptonflavour(wc_obj, par, B, P, lnum, lden)

def dBRdq2(q2, wc_obj, par, B, P, lep)

Expand source code

def dBRdq2(q2, wc_obj, par, B, P, lep):
    if lep == 'l':
        # average of e and mu!
        return (dBRdq2_lep(q2, wc_obj, par, B, P, 'e') + dBRdq2_lep(q2, wc_obj, par, B, P, 'mu'))/2
    else:
        return dBRdq2_lep(q2, wc_obj, par, B, P, lep)

def dBRdq2_function(B, P, lep)

Expand source code

def dBRdq2_function(B, P, lep):
    return lambda wc_obj, par, q2: dBRdq2(q2, wc_obj, par, B, P, lep)

def dBRdq2_lep(q2, wc_obj, par, B, P, lep)

Expand source code

def dBRdq2_lep(q2, wc_obj, par, B, P, lep):
    ml = par['m_'+lep]
    mB = par['m_'+B]
    mP = par['m_'+P]
    if q2 < ml**2 or q2 > (mB-mP)**2:
        return 0
    tauB = par['tau_'+B]
    J = get_angularcoeff(q2, wc_obj, par, B, P, lep)
    if P == 'pi0':
        # factor of 1/2 for neutral pi due to pi = (uubar-ddbar)/sqrt(2)
        return tauB * dGdq2(J) / 2.
    return tauB * dGdq2(J)

def dGdq2(J)

Expand source code

def dGdq2(J):
    return 2 * (J['a'] + J['c']/3.)

def get_angularcoeff(q2, wc_obj, par, B, P, lep)

Expand source code

def get_angularcoeff(q2, wc_obj, par, B, P, lep):
    Jlist = [_get_angularcoeff(q2, wc_obj, par, B, P, lep, nu)
             for nu in ['e', 'mu', 'tau']]
    J = {}
    J['a'] = sum([JJ['a'] for JJ in Jlist])
    J['b'] = sum([JJ['b'] for JJ in Jlist])
    J['c'] = sum([JJ['c'] for JJ in Jlist])
    return J

def get_ff(q2, par, B, P)

Expand source code

def get_ff(q2, par, B, P):
    ff_name = meson_ff[(B,P)] + ' form factor'
    return AuxiliaryQuantity[ff_name].prediction(par_dict=par, wc_obj=None, q2=q2)

def prefactor(q2, par, B, P, lep)

Expand source code

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