Esempio n. 1
0
def S(wc_obj, par, meson, amplitude, etaCP):
    M12, G12 = get_M12_G12(wc_obj, par, meson)
    qp = common.q_over_p(M12, G12)
    A = amplitude(par)
    A_bar = amplitude(conjugate_par(par))
    xi = etaCP * qp * A / A_bar
    return -2*xi.imag / ( 1 + abs(xi)**2 )
Esempio n. 2
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
Esempio n. 3
0
 def function(wc_obj, par_dict, q2, cp_conjugate):
     par = par_dict.copy()
     if cp_conjugate:
         par = conjugate_par(par)
     wc = wctot_dict(wc_obj, label, scale, par)
     if cp_conjugate:
         wc = conjugate_wc(wc)
     return flavio.physics.bdecays.bvll.qcdf.helicity_amps_qcdf(q2, wc, par, B, V)
Esempio n. 4
0
def S(wc_obj, par, meson, amplitude, etaCP):
    M12, G12 = get_M12_G12(wc_obj, par, meson)
    qp = common.q_over_p(M12, G12)
    DM = common.DeltaM(M12, G12)
    if DM < 0:
        qp = -qp  # switch the sign of q/p to keep DeltaM > 0
    A = amplitude(par)
    A_bar = amplitude(conjugate_par(par))
    xi = etaCP * qp * A / A_bar
    return -2*xi.imag / ( 1 + abs(xi)**2 )
Esempio n. 5
0
def get_transverity_amps_ff(q2, wc_obj, par_dict, lep, cp_conjugate):
    par = par_dict.copy()
    if cp_conjugate:
        par = conjugate_par(par)
    scale = flavio.config['renormalization scale']['lambdab']
    mLb = par['m_Lambdab']
    mL = par['m_Lambda']
    mb = flavio.physics.running.running.get_mb(par, scale)
    ff = get_ff(q2, par)
    wc = flavio.physics.bdecays.wilsoncoefficients.wctot_dict(wc_obj, 'bs' + lep + lep, scale, par)
    wc_eff = flavio.physics.bdecays.wilsoncoefficients.get_wceff(q2, wc, par, 'Lambdab', 'Lambda', lep, scale)
    ha = helicity_amps(q2, mLb, mL, ff)
    N = prefactor(q2, par, scale)
    ta_ff = transverity_amps(ha, q2, mLb, mL, mb, 0, wc_eff, N)
    return ta_ff
Esempio n. 6
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
Esempio n. 7
0
def amps_ff(wc_obj, par_dict, B, V, cp_conjugate):
    par = par_dict.copy()
    if cp_conjugate:
        par = conjugate_par(par)
    N = prefactor(par, B, V)
    bq = meson_quark[(B, V)]
    ff_name = meson_ff[(B, V)] + " form factor"
    ff = AuxiliaryQuantity.get_instance(ff_name).prediction(par_dict=par, wc_obj=None, q2=0.0)
    scale = config["renormalization scale"]["bvgamma"]
    # these are the b->qee Wilson coefficients - they contain the b->qgamma ones as a subset
    wc = wctot_dict(wc_obj, bq + "ee", scale, par)
    if cp_conjugate:
        wc = conjugate_wc(wc)
    delta_C7 = flavio.physics.bdecays.matrixelements.delta_C7(par=par, wc=wc, q2=0, scale=scale, qiqj=bq)
    a = {}
    a["L"] = N * (wc["C7eff_" + bq] + delta_C7) * ff["T1"]
    a["R"] = N * wc["C7effp_" + bq] * ff["T1"]
    return a
Esempio n. 8
0
def amps_ff(wc_obj, par_dict, B, V, cp_conjugate):
    par = par_dict.copy()
    if cp_conjugate:
        par = conjugate_par(par)
    N = prefactor(par, B, V)
    bq = meson_quark[(B,V)]
    ff_name = meson_ff[(B,V)] + ' form factor'
    ff = AuxiliaryQuantity.get_instance(ff_name).prediction(par_dict=par, wc_obj=None, q2=0.)
    scale = config['renormalization scale']['bvgamma']
    # these are the b->qee Wilson coefficients - they contain the b->qgamma ones as a subset
    wc = wctot_dict(wc_obj, bq+'ee', scale, par)
    if cp_conjugate:
        wc = conjugate_wc(wc)
    delta_C7 = flavio.physics.bdecays.matrixelements.delta_C7(par=par, wc=wc, q2=0, scale=scale, qiqj=bq)
    a = {}
    a['L'] = N * (wc['C7eff_'+bq] + delta_C7)  * ff['T1']
    a['R'] = N * wc['C7effp_'+bq] * ff['T1']
    return a
Esempio n. 9
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)
Esempio n. 10
0
from flavio.config import config
from flavio.physics.bdecays.common import meson_quark
from flavio.physics.common import conjugate_par

# we will interpolate from 0 to 9 GeV^2 (above, QCDF is not applicable)
# shifted by 10^-6 to avoid the q2=0 singularity but be below the e+e- threshold
q2_arr = np.arange(0 + 1e-6, 9 + 1e-6, 0.1)

# NP contributions to QCDF corrections will be neglected throughout!
wcsm = flavio.WilsonCoefficients()

# central default values are assumed by all parameters

par = flavio.default_parameters.copy()
par_dict = par.get_central_all()
par_dict_cpconj = conjugate_par(par_dict)


array_dict = {}
i = 0
contributions_dict = {
    "all": {"include_WA": True, "include_O8": True, "include_QSS": True},
    "WA": {"include_WA": True, "include_O8": False, "include_QSS": False},
    "O8": {"include_WA": False, "include_O8": True, "include_QSS": False},
    "QSS": {"include_WA": False, "include_O8": False, "include_QSS": True},
}
for had in [("B0", "K*0"), ("B+", "K*+"), ("Bs", "phi")]:  # , ('B0','rho0'), ('B+','rho+') ]:
    for cp_conjugate in [False, True]:  # compute it for the decay and its CP conjugate
        for contribution_name, contribution_dict in contributions_dict.items():
            l = "e"
            process = had[0] + "->" + had[1]  # e.g. B0->K*0
Esempio n. 11
0
 def fct(wc_obj, par_dict, q2, cp_conjugate):
     par = par_dict.copy()
     if cp_conjugate:
         par = conjugate_par(par)
     return helicity_amps_deltaC9_constant(q2, par_dict, B, V)
Esempio n. 12
0
 def fct(wc_obj, par_dict, q2, cp_conjugate):
     par = par_dict.copy()
     if cp_conjugate:
         par = conjugate_par(par)
     return helicity_amps_deltaC9C7C7p_polynomial(q2, par, B, V)
Esempio n. 13
0
def fct_deltaC9_constant(wc_obj, par_dict, q2, cp_conjugate):
    par = par_dict.copy()
    if cp_conjugate:
        par = conjugate_par(par)
    return transversity_amps_deltaC9_constant(q2, par_dict)
Esempio n. 14
0
def fct_deltaC7_polynomial(wc_obj, par_dict, q2, cp_conjugate):
    par = par_dict.copy()
    if cp_conjugate:
        par = conjugate_par(par)
    return transversity_amps_deltaC7_polynomial(q2, par)