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 {}
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 {}
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
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)
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
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)
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
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
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
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
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)
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)
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$.")
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):
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"])
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).")
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)
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$.")
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)
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")
- `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)
# ... 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")
def get_ckm(par_dict): return AuxiliaryQuantity.get_instance('CKM matrix').prediction(par_dict=par_dict, wc_obj=None)
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).")
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)
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).")
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'])