Esempio n. 1
0
def get_subleading(q2, wc_obj, par_dict, B, P, lep, cp_conjugate):
    if q2 <= 9:
        sub_name = B+'->'+P + 'll subleading effects at low q2'
        return AuxiliaryQuantity.get_instance(sub_name).prediction(par_dict=par_dict, wc_obj=wc_obj, q2=q2, cp_conjugate=cp_conjugate)
    elif q2 > 14:
        sub_name = B+'->'+P + 'll subleading effects at high q2'
        return AuxiliaryQuantity.get_instance(sub_name).prediction(par_dict=par_dict, wc_obj=wc_obj, q2=q2, cp_conjugate=cp_conjugate)
    else:
        return {}
Esempio n. 2
0
def get_subleading(q2, wc_obj, par_dict, B, V, cp_conjugate):
    if q2 <= 9:
        sub_name = B + '->' + V + 'll subleading effects at low q2'
        return AuxiliaryQuantity.get_instance(sub_name).prediction(
            par_dict=par_dict, wc_obj=wc_obj, q2=q2, cp_conjugate=cp_conjugate)
    elif q2 > 14:
        sub_name = B + '->' + V + 'll subleading effects at high q2'
        return AuxiliaryQuantity.get_instance(sub_name).prediction(
            par_dict=par_dict, wc_obj=wc_obj, q2=q2, cp_conjugate=cp_conjugate)
    else:
        return {}
Esempio n. 3
0
def amps_subleading(wc_obj, par, B, V, cp_conjugate):
    scale = config['renormalization scale']['bvgamma']
    sub_name = B+'->'+V+ 'll subleading effects at low q2'
    q2=0.001 # away from zero to avoid pole
    amps = AuxiliaryQuantity.get_instance(sub_name).prediction(par_dict=par, wc_obj=wc_obj, q2=q2, cp_conjugate=cp_conjugate)
    N = prefactor_helicityamps(q2, par, B, V)
    a = {}
    a['L'] = -N * amps[('mi' ,'V')]
    a['R'] = +N * amps[('pl' ,'V')]
    return a
Esempio n. 4
0
def get_subleading_high(q2, wc_obj, par_dict, B, V, cp_conjugate):
    if q2 < 14:
        return {
            ('0', 'V'): 0,
            ('pl', 'V'): 0,
            ('mi', 'V'): 0,
        }
    sub_name = B + '->' + V + 'll subleading effects at high q2'
    return AuxiliaryQuantity.get_instance(sub_name).prediction(
        par_dict=par_dict, wc_obj=wc_obj, q2=q2, cp_conjugate=cp_conjugate)
Esempio n. 5
0
def amps_subleading(wc_obj, par, B, V, cp_conjugate):
    scale = config['renormalization scale']['bvgamma']
    sub_name = B + '->' + V + 'll subleading effects at low q2'
    q2 = 0.001  # away from zero to avoid pole
    amps = AuxiliaryQuantity.get_instance(sub_name).prediction(
        par_dict=par, wc_obj=wc_obj, q2=q2, cp_conjugate=cp_conjugate)
    N = prefactor_helicityamps(q2, par, B, V)
    a = {}
    a['L'] = -N * amps[('mi', 'V')]
    a['R'] = +N * amps[('pl', 'V')]
    return a
Esempio n. 6
0
def get_ss(q2, wc_obj, par_dict, B, V, cp_conjugate):
    # this only needs to be done for low q2 - which doesn't exist for taus!
    if q2 >= 8.9:
        return {
            ('0', 'V'): 0,
            ('pl', 'V'): 0,
            ('mi', 'V'): 0,
        }
    ss_name = B + '->' + V + 'll spectator scattering'
    return AuxiliaryQuantity.get_instance(ss_name).prediction(
        par_dict=par_dict, wc_obj=wc_obj, q2=q2, cp_conjugate=cp_conjugate)
Esempio n. 7
0
def amps_subleading(wc_obj, par, B, V, cp_conjugate):
    scale = config["renormalization scale"]["bvgamma"]
    sub_name = B + "->" + V + "ll subleading effects at low q2"
    q2 = 0.001  # away from zero to avoid pole
    amps = AuxiliaryQuantity.get_instance(sub_name).prediction(
        par_dict=par, wc_obj=wc_obj, q2=q2, cp_conjugate=cp_conjugate
    )
    N = prefactor_helicityamps(q2, par, B, V)
    a = {}
    a["L"] = -N * amps[("mi", "V")]
    a["R"] = +N * amps[("pl", "V")]
    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 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. 10
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
    if cp_conjugate:
        par = conjugate_par(par)
    return transversity_amps_deltaC7_polynomial(q2, par)


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)


# AuxiliaryQuantity & Implementatation: subleading effects at LOW q^2

quantity = 'Lambdab->Lambdall subleading effects at low q2'
a = AuxiliaryQuantity(name=quantity, arguments=['q2', 'cp_conjugate'])
a.description = (
    r'Contribution to $\Lambda_b\to \Lambda \ell^+\ell^-$ transversity amplitudes from'
    r' subleading hadronic effects (i.e. all effects not included'
    r' elsewhere) at $q^2$ below the charmonium resonances')

# Implementation: C7-polynomial
iname = 'Lambdab->Lambdall deltaC7 polynomial'
i = Implementation(name=iname,
                   quantity=quantity,
                   function=fct_deltaC7_polynomial)
i.set_description(r"Effective shift in the Wilson coefficient $C_7(\mu_b)$"
                  r" as a first-order polynomial in $q^2$.")

# AuxiliaryQuantity & Implementatation: subleading effects at HIGH q^2
Esempio n. 12
0
def get_ff(q2, par, B, V):
    ff_name = meson_ff[(B, V)] + ' form factor'
    return AuxiliaryQuantity.get_instance(ff_name).prediction(par_dict=par,
                                                              wc_obj=None,
                                                              q2=q2)
Esempio n. 13
0
def get_ss(q2, wc_obj, par_dict, B, V, cp_conjugate):
    # this only needs to be done for low q2 - which doesn't exist for taus!
    if q2 >= 8.9:
        return {('0' ,'V'): 0, ('pl' ,'V'): 0, ('mi' ,'V'): 0, }
    ss_name = B+'->'+V+'ll spectator scattering'
    return AuxiliaryQuantity.get_instance(ss_name).prediction(par_dict=par_dict, wc_obj=wc_obj, q2=q2, cp_conjugate=cp_conjugate)
Esempio n. 14
0
        return HelicityAmpsDeltaC_77p_polynomial(B, V, par, q2)()
    return fct


def fct_deltaC9_constant(B, V):
    def fct(wc_obj, par_dict, q2, cp_conjugate):
        par = par_dict.copy()
        return HelicityAmpsDeltaC_9_shift(B, V, par, q2)()
    return fct

# AuxiliaryQuantity & Implementation: subleading effects at LOW q^2

for had in [('B0','K*0'), ('B+','K*+'), ('Bs','phi'), ]:
    process = had[0] + '->' + had[1] + 'll' # e.g. B0->K*0mumu
    quantity = process + ' subleading effects at low q2'
    a = AuxiliaryQuantity(name=quantity, arguments=['q2', 'cp_conjugate'])
    a.description = ('Contribution to ' + process + ' helicity amplitudes from'
                    ' subleading hadronic effects (i.e. all effects not included'
                    r'elsewhere) at $q^2$ below the charmonium resonances')


    # Implementation: C7-C7'-polynomial
    iname = process + ' deltaC7, 7p polynomial'
    i = Implementation(name=iname, quantity=quantity,
                   function=fct_deltaC7C7p_polynomial(B=had[0], V=had[1]))
    i.set_description(r"Effective shift in the Wilson coefficient $C_7(\mu_b)$"
                      r" (in the $0$ and $-$ helicity amplitudes) and"
                      r" $C_7'(\mu_b)$ (in the $+$ helicity amplitude)"
                      r" as a first-order polynomial in $q^2$.")

Esempio n. 15
0
def tree_to_wolfenstein(Vus, Vub, Vcb, delta):
    return ckmutil.ckm.tree_to_wolfenstein(Vus, Vub, Vcb, delta)


@lru_cache(maxsize=2)
def ckm_wolfenstein(laC, A, rhobar, etabar):
    return ckmutil.ckm.ckm_wolfenstein(laC, A, rhobar, etabar)


@lru_cache(maxsize=2)
def ckm_tree(Vus, Vub, Vcb, delta):
    return ckmutil.ckm.ckm_tree(Vus, Vub, Vcb, delta)


# Auxiliary Quantity instance
a = AuxiliaryQuantity(name='CKM matrix')
a.set_description(
    'Cabibbo-Kobayashi-Maskawa matrix in the standard phase convention')

# Implementation instances


def _func_standard(wc_obj, par):
    return ckm_standard(par['t12'], par['t13'], par['t23'], par['delta'])


def _func_tree(wc_obj, par):
    return ckm_tree(par['Vus'], par['Vub'], par['Vcb'], par['delta'])


def _func_wolfenstein(wc_obj, par):
Esempio n. 16
0
from flavio.physics.bdecays.formfactors.b_v import bsz, sse, cln
from flavio.classes import AuxiliaryQuantity, Implementation
from flavio.config import config

processes = ["B->K*", "B->rho", "B->omega", "Bs->phi", "Bs->K*", "B->D*"]


def ff_function(function, process, **kwargs):
    return lambda wc_obj, par_dict, q2: function(process, q2, par_dict, **kwargs)


for p in processes:
    quantity = p + " form factor"
    a = AuxiliaryQuantity(name=quantity, arguments=["q2"])
    a.set_description("Hadronic form factor for the " + p + " transition")

    iname = p + " BSZ2"
    i = Implementation(name=iname, quantity=quantity, function=ff_function(bsz.ff, p, n=2))
    i.set_description("2-parameter BSZ parametrization (see arXiv:1503.05534)")

    iname = p + " BSZ3"
    i = Implementation(name=iname, quantity=quantity, function=ff_function(bsz.ff, p, n=3))
    i.set_description("3-parameter BSZ parametrization (see arXiv:1503.05534)")

    iname = p + " SSE"
    i = Implementation(name=iname, quantity=quantity, function=ff_function(sse.ff, p, n=2))
    i.set_description("2-parameter simplified series expansion")

    iname = p + " CLN-IW"
    i = Implementation(
        name=iname, quantity=quantity, function=ff_function(cln.ff, p, scale=config["renormalization scale"]["bvll"])
Esempio n. 17
0
def ff(q2, par, B):
    r"""Central value of $B(s)\to \gamma$ form factors

    See hep-ph/0208256.pdf.
    """
    flavio.citations.register("Kruger:2002gf")
    fB = par['f_' + B]
    mB = par['m_' + B]
    name = 'B->gamma KM '
    ff = {}
    ff['v'] = par[name + 'betav'] * fB * mB / (par[name + 'deltav'] + mB / 2 *
                                               (1 - q2 / mB**2))
    ff['a'] = par[name + 'betaa'] * fB * mB / (par[name + 'deltaa'] + mB / 2 *
                                               (1 - q2 / mB**2))
    ff['tv'] = par[name + 'betatv'] * fB * mB / (par[name + 'deltatv'] +
                                                 mB / 2 * (1 - q2 / mB**2))
    ff['ta'] = par[name + 'betata'] * fB * mB / (par[name + 'deltata'] +
                                                 mB / 2 * (1 - q2 / mB**2))
    return ff


quantity = 'B->gamma form factor'
a = AuxiliaryQuantity(name=quantity, arguments=['q2'])
a.set_description('Form factor for the B(s)->gamma transition')

i = Implementation(
    name="B->gamma KM",
    quantity=quantity,
    function=lambda wc_obj, par_dict, q2, B: ff(q2, par_dict, B))
i.set_description("KM parametrization (see hep-ph/0208256.pdf).")
Esempio n. 18
0
def get_subleading_high(q2, wc_obj, par_dict, B, V, cp_conjugate):
    if q2 < 14:
        return {('0' ,'V'): 0,  ('pl' ,'V'): 0, ('mi' ,'V'): 0, }
    sub_name = B+'->'+V + 'll subleading effects at high q2'
    return AuxiliaryQuantity.get_instance(sub_name).prediction(par_dict=par_dict, wc_obj=wc_obj, q2=q2, cp_conjugate=cp_conjugate)
Esempio n. 19
0
    fp_bar = exp(q2/mpi**2 * (Lp + H))
    ff = {}
    ff['f+'] = fp_0 * fp_bar
    ff['f0'] = fp_0 * f0_bar
    return ff

def fT_pole(q2, par):
    # specific parameters
    fT_0 = par['K->pi fT(0)']
    sT = par['K->pi sT']
    ff = {}
    # (4) of 1108.1021
    ff['fT'] = fT_0 / (1- sT * q2)
    return ff

def ff_dispersive_pole(wc_obj, par_dict, q2):
    ff = {}
    ff.update( fp0_dispersive(q2, par_dict) )
    ff.update( fT_pole(q2, par_dict) )
    return ff

quantity = 'K->pi form factor'
a = AuxiliaryQuantity(name=quantity, arguments=['q2'])
a.set_description(r'Hadronic form factor for the $K\to\pi$ transition')

iname = 'K->pi dispersive + pole'
i = Implementation(name=iname, quantity=quantity,
               function=ff_dispersive_pole)
i.set_description(r"Dispersive parametrization (see arXiv:hep-ph/0603202) for "
                  r"$f_+$ and $f_0$ and simple pole for $f_T$.")
Esempio n. 20
0
def get_ff(q2, par):
    ff_aux = AuxiliaryQuantity.get_instance('Lambdab->Lambda form factor')
    return ff_aux.prediction(par_dict=par, wc_obj=None, q2=q2)
Esempio n. 21
0
    return function

# ... and the same for the interpolated version (see qcdf_interpolate.py)
def ha_qcdf_interpolate_function(B, V, contribution='all'):
    scale = config['renormalization scale']['bvll']
    def function(wc_obj, par_dict, q2, cp_conjugate):
        return flavio.physics.bdecays.bvll.qcdf_interpolate.helicity_amps_qcdf(q2, par_dict, B, V, cp_conjugate, contribution)
    return function

# loop over hadronic transitions and lepton flavours
# BTW, it is not necessary to loop over tau: for tautau final states, the minimum
# q2=4*mtau**2 is so high that QCDF is not valid anymore anyway!
for had in [('B0','K*0'), ('B+','K*+'), ('B0','rho0'), ('B+','rho+'), ('Bs','phi'), ]:
    process = had[0] + '->' + had[1] + 'll' # e.g. B0->K*0mumu
    quantity = process + ' spectator scattering'
    a = AuxiliaryQuantity(name=quantity, arguments=['q2', 'cp_conjugate'])
    a.description = ('Contribution to ' + process + ' helicity amplitudes from'
                    ' non-factorizable spectator scattering.')

    # Implementation: QCD factorization
    iname = process + ' QCDF'
    i = Implementation(name=iname, quantity=quantity,
                   function=ha_qcdf_function(B=had[0], V=had[1]))
    i.set_description("QCD factorization")

    # Implementation: interpolated QCD factorization
    iname = process + ' QCDF interpolated'
    i = Implementation(name=iname, quantity=quantity,
                   function=ha_qcdf_interpolate_function(B=had[0], V=had[1]))
    i.set_description("Interpolated version of QCD factorization")
Esempio n. 22
0
    - `Vub`: Absolute value of CKM matrix element $|V_{ub}|$
    - `Vcb`: CKM matrix element $V_{cb}$
    - `gamma`: CKM phase $\gamma=\delta$ in radians
    """
    return np.array([[sqrt(1 - Vub**2)*sqrt(1 - Vus**2/(1 - Vub**2)),
        Vus,
        Vub/exp(1j*gamma)],
        [-((sqrt(1 - Vcb**2/(1 - Vub**2))*Vus)/sqrt(1 - Vub**2)) - (Vub*exp(1j*gamma)*Vcb*sqrt(1 - Vus**2/(1 - Vub**2)))/sqrt(1 - Vub**2),
        -((Vub*exp(1j*gamma)*Vcb*Vus)/(1 - Vub**2)) + sqrt(1 - Vcb**2/(1 - Vub**2))*sqrt(1 - Vus**2/(1 - Vub**2)),
        Vcb],
        [(Vcb*Vus)/(1 - Vub**2) - Vub*exp(1j*gamma)*sqrt(1 - Vcb**2/(1 - Vub**2))*sqrt(1 - Vus**2/(1 - Vub**2)),
        -((Vub*exp(1j*gamma)*sqrt(1 - Vcb**2/(1 - Vub**2))*Vus)/sqrt(1 - Vub**2)) - (Vcb*sqrt(1 - Vus**2/(1 - Vub**2)))/sqrt(1 - Vub**2),
        sqrt(1 - Vub**2)*sqrt(1 - Vcb**2/(1 - Vub**2))]])

# Auxiliary Quantity instance
a = AuxiliaryQuantity(name='CKM matrix')
a.set_description('Cabibbo-Kobayashi-Maskawa matrix in the standard phase convention')

# Implementation instances

def _func_standard(wc_obj, par):
    return ckm_standard(par['t12'], par['t13'], par['t23'], par['delta'])
def _func_tree(wc_obj, par):
    return ckm_tree(par['Vus'], par['Vub'], par['Vcb'], par['gamma'])
def _func_wolfenstein(wc_obj, par):
    return ckm_wolfenstein(par['laC'], par['A'], par['rhobar'], par['etabar'])

i = Implementation(name='Standard', quantity='CKM matrix', function=_func_standard)
i = Implementation(name='Tree', quantity='CKM matrix', function=_func_tree)
i = Implementation(name='Wolfenstein', quantity='CKM matrix', function=_func_wolfenstein)
Esempio n. 23
0
# ... and the same for the interpolated version (see qcdf_interpolate.py)
def ha_qcdf_interpolate_function(B, V, contribution="all"):
    scale = config["renormalization scale"]["bvll"]

    def function(wc_obj, par_dict, q2, cp_conjugate):
        return flavio.physics.bdecays.bvll.qcdf_interpolate.helicity_amps_qcdf(
            q2, par_dict, B, V, cp_conjugate, contribution
        )

    return function


# loop over hadronic transitions and lepton flavours
# BTW, it is not necessary to loop over tau: for tautau final states, the minimum
# q2=4*mtau**2 is so high that QCDF is not valid anymore anyway!
for had in [("B0", "K*0"), ("B+", "K*+"), ("B0", "rho0"), ("B+", "rho+"), ("Bs", "phi")]:
    process = had[0] + "->" + had[1] + "ll"  # e.g. B0->K*0mumu
    quantity = process + " spectator scattering"
    a = AuxiliaryQuantity(name=quantity, arguments=["q2", "cp_conjugate"])
    a.description = "Contribution to " + process + " helicity amplitudes from" " non-factorizable spectator scattering."

    # Implementation: QCD factorization
    iname = process + " QCDF"
    i = Implementation(name=iname, quantity=quantity, function=ha_qcdf_function(B=had[0], V=had[1]))
    i.set_description("QCD factorization")

    # Implementation: interpolated QCD factorization
    iname = process + " QCDF interpolated"
    i = Implementation(name=iname, quantity=quantity, function=ha_qcdf_interpolate_function(B=had[0], V=had[1]))
    i.set_description("Interpolated version of QCD factorization")
Esempio n. 24
0
def get_ckm(par_dict):
    return AuxiliaryQuantity.get_instance('CKM matrix').prediction(par_dict=par_dict, wc_obj=None)
Esempio n. 25
0
from flavio.physics.bdecays.formfactors.b_p import bcl, cln, bsz
from flavio.classes import AuxiliaryQuantity, Implementation
from flavio.config import config

processes_H2L = ['B->K', 'B->pi']  # heavy to light
processes_H2H = ['B->D', ]  # heavy to heavy


def ff_function(function, process, **kwargs):
    return lambda wc_obj, par_dict, q2: function(process, q2, par_dict, **kwargs)


for p in processes_H2L + processes_H2H:
    quantity = p + ' form factor'
    a = AuxiliaryQuantity(name=quantity, arguments=['q2'])
    a.set_description('Hadronic form factor for the ' + p + ' transition')

    iname = p + ' BSZ3'
    i = Implementation(name=iname, quantity=quantity,
                       function=ff_function(bsz.ff, p, n=3))
    i.set_description("3-parameter BSZ parametrization (see arXiv:1811.00983).")

    iname = p + ' BCL3'
    i = Implementation(name=iname, quantity=quantity,
                   function=ff_function(bcl.ff, p, n=3))
    i.set_description("3-parameter BCL parametrization (see arXiv:0807.2722).")

    iname = p + ' BCL4'
    i = Implementation(name=iname, quantity=quantity,
                   function=ff_function(bcl.ff, p, n=4))
    i.set_description("4-parameter BCL parametrization (see arXiv:0807.2722).")
Esempio n. 26
0
def get_ff(q2, par, B, P):
    ff_name = meson_ff[(B,P)] + ' form factor'
    return AuxiliaryQuantity.get_instance(ff_name).prediction(par_dict=par, wc_obj=None, q2=q2)
Esempio n. 27
0
from flavio.config import config

processes_H2L = ['B->K', 'B->pi']  # heavy to light
processes_H2H = [
    'B->D',
]  # heavy to heavy


def ff_function(function, process, **kwargs):
    return lambda wc_obj, par_dict, q2: function(process, q2, par_dict, **
                                                 kwargs)


for p in processes_H2L + processes_H2H:
    quantity = p + ' form factor'
    a = AuxiliaryQuantity(name=quantity, arguments=['q2'])
    a.set_description('Hadronic form factor for the ' + p + ' transition')

    iname = p + ' BSZ3'
    i = Implementation(name=iname,
                       quantity=quantity,
                       function=ff_function(bsz.ff, p, n=3))
    i.set_description(
        "3-parameter BSZ parametrization (see arXiv:1811.00983).")

    iname = p + ' BCL3'
    i = Implementation(name=iname,
                       quantity=quantity,
                       function=ff_function(bcl.ff, p, n=3))
    i.set_description("3-parameter BCL parametrization (see arXiv:0807.2722).")
Esempio n. 28
0
    if cp_conjugate:
        par = conjugate_par(par)
    return transversity_amps_deltaC7_polynomial(q2, par)


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)


# AuxiliaryQuantity & Implementatation: subleading effects at LOW q^2

quantity = 'Lambdab->Lambdall subleading effects at low q2'
a = AuxiliaryQuantity(name=quantity,
                      arguments=['q2', 'cp_conjugate'])
a.description = (r'Contribution to $\Lambda_b\to \Lambda \ell^+\ell^-$ transversity amplitudes from'
                 r' subleading hadronic effects (i.e. all effects not included'
                 r' elsewhere) at $q^2$ below the charmonium resonances')

# Implementation: C7-polynomial
iname = 'Lambdab->Lambdall deltaC7 polynomial'
i = Implementation(name=iname, quantity=quantity,
               function=fct_deltaC7_polynomial)
i.set_description(r"Effective shift in the Wilson coefficient $C_7(\mu_b)$"
                  r" as a first-order polynomial in $q^2$.")

# AuxiliaryQuantity & Implementatation: subleading effects at HIGH q^2

quantity = 'Lambdab->Lambdall subleading effects at high q2'
a = AuxiliaryQuantity(name=quantity, arguments=['q2', 'cp_conjugate'])