Esempio n. 1
0
 def test_lattice(self):
     c = copy.deepcopy(default_parameters)
     lattice_parameters.lattice_load(c)
     fflatt = Implementation.get_instance('B->K* SSE').get_central(constraints_obj=c, wc_obj=None, q2=12.)
     self.assertAlmostEqual(fflatt['V'], 0.84, places=2)
     self.assertAlmostEqual(fflatt['A0'], 0.861, places=3)
     self.assertAlmostEqual(fflatt['A1'], 0.440, places=3)
     self.assertAlmostEqual(fflatt['A12'], 0.339, places=3)
     self.assertAlmostEqual(fflatt['T1'], 0.711, places=3)
     self.assertAlmostEqual(fflatt['T2'], 0.433, places=3)
     self.assertAlmostEqual(fflatt['T23'], 0.809, places=3)
     fflatt = Implementation.get_instance('Bs->phi SSE').get_central(constraints_obj=c, wc_obj=None, q2=12.)
     self.assertAlmostEqual(fflatt['V'], 0.767, places=2)
     self.assertAlmostEqual(fflatt['A0'], 0.907, places=2)
     self.assertAlmostEqual(fflatt['A1'], 0.439, places=2)
     self.assertAlmostEqual(fflatt['A12'], 0.321, places=2)
     self.assertAlmostEqual(fflatt['T1'], 0.680, places=2)
     self.assertAlmostEqual(fflatt['T2'], 0.439, places=2)
     self.assertAlmostEqual(fflatt['T23'], 0.810, places=2)
     fflatt = Implementation.get_instance('Bs->K* SSE').get_central(constraints_obj=c, wc_obj=None, q2=12.)
     self.assertAlmostEqual(fflatt['V'], 0.584, places=3)
     self.assertAlmostEqual(fflatt['A0'], 0.884, places=3)
     self.assertAlmostEqual(fflatt['A1'], 0.370, places=3)
     self.assertAlmostEqual(fflatt['A12'], 0.321, places=3)
     self.assertAlmostEqual(fflatt['T1'], 0.605, places=3)
     self.assertAlmostEqual(fflatt['T2'], 0.383, places=3)
     self.assertAlmostEqual(fflatt['T23'], 0.743, places=3)
Esempio n. 2
0
 def test_lattice(self):
     # compare to digitized fig. 18 of 1509.06235v1
     ff_latt = Implementation.get_instance('B->K BCL3').get_central(
         constraints_obj=c, wc_obj=None, q2=0)
     self.assertAlmostEqual(ff_latt['f+'], 0.33, places=1)
     self.assertAlmostEqual(ff_latt['f0'], 0.33, places=1)
     self.assertAlmostEqual(ff_latt['fT'], 0.26, places=1)
     ff_latt = Implementation.get_instance('B->K BCL3').get_central(
         constraints_obj=c, wc_obj=None, q2=5)
     self.assertAlmostEqual(ff_latt['f+'], 0.42, places=1)
     self.assertAlmostEqual(ff_latt['f0'], 0.36, places=1)
     self.assertAlmostEqual(ff_latt['fT'], 0.37, places=1)
     ff_latt = Implementation.get_instance('B->K BCL3').get_central(
         constraints_obj=c, wc_obj=None, q2=10)
     self.assertAlmostEqual(ff_latt['f+'], 0.64, places=1)
     self.assertAlmostEqual(ff_latt['f0'], 0.44, places=1)
     self.assertAlmostEqual(ff_latt['fT'], 0.57, places=1)
     ff_latt = Implementation.get_instance('B->K BCL3').get_central(
         constraints_obj=c, wc_obj=None, q2=15)
     self.assertAlmostEqual(ff_latt['f+'], 0.98, places=1)
     self.assertAlmostEqual(ff_latt['f0'], 0.56, places=1)
     self.assertAlmostEqual(ff_latt['fT'], 0.96, places=1)
     ff_latt = Implementation.get_instance('B->K BCL3').get_central(
         constraints_obj=c, wc_obj=None, q2=20)
     self.assertAlmostEqual(ff_latt['f+'], 1.7, places=1)
     self.assertAlmostEqual(ff_latt['f0'], 0.71, places=1)
     self.assertAlmostEqual(ff_latt['fT'], 1.74, places=1)
Esempio n. 3
0
 def test_lattice(self):
     # compare to digitized fig. 18 of 1509.06235v1
     ff_latt = Implementation.get_instance('B->K BCL3').get_central(constraints_obj=c, wc_obj=None, q2=0)
     self.assertAlmostEqual(ff_latt['f+'], 0.33, places=1)
     self.assertAlmostEqual(ff_latt['f0'], 0.33, places=1)
     self.assertAlmostEqual(ff_latt['fT'], 0.26, places=1)
     ff_latt = Implementation.get_instance('B->K BCL3').get_central(constraints_obj=c, wc_obj=None, q2=5)
     self.assertAlmostEqual(ff_latt['f+'], 0.42, places=1)
     self.assertAlmostEqual(ff_latt['f0'], 0.36, places=1)
     self.assertAlmostEqual(ff_latt['fT'], 0.37, places=1)
     ff_latt = Implementation.get_instance('B->K BCL3').get_central(constraints_obj=c, wc_obj=None, q2=10)
     self.assertAlmostEqual(ff_latt['f+'], 0.64, places=1)
     self.assertAlmostEqual(ff_latt['f0'], 0.44, places=1)
     self.assertAlmostEqual(ff_latt['fT'], 0.57, places=1)
     ff_latt = Implementation.get_instance('B->K BCL3').get_central(constraints_obj=c, wc_obj=None, q2=15)
     self.assertAlmostEqual(ff_latt['f+'], 0.98, places=1)
     self.assertAlmostEqual(ff_latt['f0'], 0.56, places=1)
     self.assertAlmostEqual(ff_latt['fT'], 0.96, places=1)
     ff_latt = Implementation.get_instance('B->K BCL3').get_central(constraints_obj=c, wc_obj=None, q2=20)
     self.assertAlmostEqual(ff_latt['f+'], 1.7, places=1)
     self.assertAlmostEqual(ff_latt['f0'], 0.71, places=1)
     self.assertAlmostEqual(ff_latt['fT'], 1.74, places=1)
Esempio n. 4
0
 def test_bsz3(self):
     c = copy.deepcopy(default_parameters)
     bsz_parameters.bsz_load_v1_lcsr(c)
     # compare to numbers in table 4 of arXiv:1503.05534v1
     # B->K* all FFs
     ffbsz3 = Implementation.get_instance('B->K* BSZ3').get_central(constraints_obj=c, wc_obj=None, q2=0)
     self.assertAlmostEqual(ffbsz3['A0'], 0.391, places=2)
     self.assertAlmostEqual(ffbsz3['A1'], 0.289, places=3)
     self.assertAlmostEqual(ffbsz3['A12'], 0.281, places=3)
     self.assertAlmostEqual(ffbsz3['V'], 0.366, places=3)
     self.assertAlmostEqual(ffbsz3['T1'], 0.308, places=3)
     self.assertAlmostEqual(ffbsz3['T23'], 0.793, places=3)
     self.assertAlmostEqual(ffbsz3['T1'], ffbsz3['T2'], places=16)
     # A1 for the remaining transitions
     ffbsz3 = Implementation.get_instance('B->rho BSZ3').get_central(constraints_obj=c, wc_obj=None, q2=0)
     self.assertAlmostEqual(ffbsz3['A1'], 0.267, places=3)
     ffbsz3 = Implementation.get_instance('B->omega BSZ3').get_central(constraints_obj=c, wc_obj=None, q2=0)
     self.assertAlmostEqual(ffbsz3['A1'], 0.237, places=3)
     ffbsz3 = Implementation.get_instance('Bs->phi BSZ3').get_central(constraints_obj=c, wc_obj=None, q2=0)
     self.assertAlmostEqual(ffbsz3['A1'], 0.315, places=3)
     ffbsz3 = Implementation.get_instance('Bs->K* BSZ3').get_central(constraints_obj=c, wc_obj=None, q2=0)
     self.assertAlmostEqual(ffbsz3['A1'], 0.246, places=3)
Esempio n. 5
0
 def test_lambdab_lambda_ff(self):
     ff_obj = Implementation.get_instance('Lambdab->Lambda SSE2')
     par = flavio.default_parameters
     mL = par.get_central('m_Lambda')
     mLb = par.get_central('m_Lambdab')
     q2max = (mLb-mL)**2
     ff_max = ff_obj.get_central(constraints_obj=par, wc_obj=None, q2=q2max)
     ff_0 = ff_obj.get_central(constraints_obj=par, wc_obj=None, q2=0)
     # g_perp(q2_max) = g_+(q2_max)
     self.assertAlmostEqual(ff_max['fAperp'], ff_max['fA0'], delta=0.001)
     # htilde_perp(q2_max) = htilde_+(q2_max)
     self.assertAlmostEqual(ff_max['fT5perp'], ff_max['fT50'], delta=0.001)
     # f_0(0) = f+(0)
     self.assertAlmostEqual(ff_0['fVt'], ff_0['fV0'], delta=0.05) # this constraint is poorly satisfied
     # g_0(0) = g+(0)
     self.assertAlmostEqual(ff_0['fAt'], ff_0['fA0'], delta=0.1) # this constraint is poorly satisfied
Esempio n. 6
0
 def test_bcl_iw(self):
     c = copy.deepcopy(default_parameters)
     par = c.get_central_all()
     bcl.ff_isgurwise('B->D', 1, par, 4.8, n=3)
     Implementation.get_instance('B->D BCL3-IW').get_central(
         constraints_obj=c, wc_obj=None, q2=1)
Esempio n. 7
0
 def test_cln(self):
     c = copy.deepcopy(default_parameters)
     par = c.get_central_all()
     cln.ff('B->D*', 1, par, 4.8)
     Implementation.get_instance('B->D* CLN-IW').get_central(constraints_obj=c, wc_obj=None, q2=1)
    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. 9
0
processes = ['D->pi', 'D->K']


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:1811.00983).")

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

    iname = p + ' BSZ3'
    i = Implementation(name=iname,
                       quantity=quantity,
                       function=ff_function(bsz.ff, p, n=3))
    i.set_description(
Esempio n. 10
0
    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$.")


# AuxiliaryQuantity & Implementation: subleading effects at HIGH 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 high 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$ above the charmonium resonances')
Esempio n. 11
0

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 + ' 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")
Esempio n. 12
0
from flavio.physics.bdecays.formfactors.lambdab_12 import sse
from flavio.classes import AuxiliaryQuantity, Implementation
from flavio.config import config

processes = ['Lambdab->Lambda',]

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 + ' SSE2'
    i = Implementation(name=iname, quantity=quantity,
                   function=ff_function(sse.ff, p, n=2))
    i.set_description("2-parameter simplified series expansion")

    iname = p + ' SSE3'
    i = Implementation(name=iname, quantity=quantity,
                   function=ff_function(sse.ff, p, n=2))
    i.set_description("3-parameter simplified series expansion")
Esempio n. 13
0
        return helicity_amps_deltaC9_constant(q2, par_dict, B, P)
    return fct

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

for had in [('B0','K0'), ('B+','K+'),]:
    process = had[0] + '->' + had[1] + 'll' # e.g. B0->K*0ll
    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-polynomial
    iname = process + ' deltaC7 polynomial'
    i = Implementation(name=iname, quantity=quantity,
                   function=fct_deltaC7_polynomial(B=had[0], P=had[1]))
    i.set_description(r"Effective shift in the Wilson coefficient $C_7(\mu_b)$"
                      r" as a first-order polynomial in $q^2$.")

    # Implementation: C9-polynomial
    iname = process + ' deltaC9 polynomial'
    i = Implementation(name=iname, quantity=quantity,
                   function=fct_deltaC9_polynomial(B=had[0], P=had[1]))
    i.set_description(r"Effective shift in the Wilson coefficient $C_9(\mu_b)$"
                      r" as a first-order polynomial in $q^2$.")


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

for had in [('B0','K0'), ('B+','K+'), ]:
    for l in ['e', 'mu', 'tau']:
Esempio n. 14
0
from flavio.physics.bdecays.formfactors.lambdab_12 import sse
from flavio.classes import AuxiliaryQuantity, Implementation
from flavio.config import config

processes = [
    'Lambdab->Lambda',
]


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 + ' SSE2'
    i = Implementation(name=iname,
                       quantity=quantity,
                       function=ff_function(sse.ff, p, n=2))
    i.set_description("2-parameter simplified series expansion")

    iname = p + ' SSE3'
    i = Implementation(name=iname,
                       quantity=quantity,
                       function=ff_function(sse.ff, p, n=2))
    i.set_description("3-parameter simplified series expansion")
Esempio n. 15
0
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"])
    )
    i.set_description("CLN parametrization using improved Isgur-Wise relations" " for the tensor form factors")
Esempio n. 16
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. 17
0
    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. 18
0

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):
    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)


def get_ckm(par_dict):
    return AuxiliaryQuantity['CKM matrix'].prediction(par_dict=par_dict,
                                                      wc_obj=None)


def get_ckmangle_beta(par):
    r"""Returns the CKM angle $\beta$."""
    V = get_ckm(par)
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
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).")

    iname = p + ' BCL3-IW'
    i = Implementation(name=iname, quantity=quantity,
                   function=ff_function(bcl.ff_isgurwise, p,
Esempio n. 21
0
 def test_bcl_iw(self):
     c = copy.deepcopy(default_parameters)
     par = c.get_central_all()
     bcl.ff_isgurwise('B->D', 1, par, 4.8, n=3)
     Implementation.get_instance('B->D BCL3-IW').get_central(constraints_obj=c, wc_obj=None, q2=1)
Esempio n. 22
0
]  # 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. 23
0
    return fct

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

for had in [('B0','K0'), ('B+','K+'),]:
    for l in ['e', 'mu', ]:
        process = had[0] + '->' + had[1] + l+l # 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-polynomial
        iname = process + ' deltaC7 polynomial'
        i = Implementation(name=iname, quantity=quantity,
                       function=fct_deltaC7_polynomial(B=had[0], P=had[1], lep=l))
        i.set_description(r"Effective shift in the Wilson coefficient $C_7(\mu_b)$"
                          r" as a first-order polynomial in $q^2$.")

        # Implementation: C9-polynomial
        iname = process + ' deltaC9 polynomial'
        i = Implementation(name=iname, quantity=quantity,
                       function=fct_deltaC9_polynomial(B=had[0], P=had[1], lep=l))
        i.set_description(r"Effective shift in the Wilson coefficient $C_9(\mu_b)$"
                          r" as a first-order polynomial in $q^2$.")


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

for had in [('B0','K0'), ('B+','K+'), ]:
    for l in ['e', 'mu', 'tau']: