def q2_plot_th_bin(obs_name, bin_list, wc=None, divide_binwidth=False, N=50, **kwargs):
r"""Plot the binned theory prediction with uncertainties of a
$q^2$-dependent observable as a function of $q^2$ (in the form of coloured
boxes)."""
obs = flavio.classes.Observable.get_instance(obs_name)
if obs.arguments != ['q2min', 'q2max']:
raise ValueError(r"Only observables that depend on q2min and q2max (and nothing else) are allowed")
if wc is None:
wc = flavio.WilsonCoefficients() # SM Wilson coefficients
obs_dict = {bin_: flavio.sm_prediction(obs_name, *bin_) for bin_ in bin_list}
obs_err_dict = {bin_: flavio.sm_uncertainty(obs_name, *bin_, N=N) for bin_ in bin_list}
else:
wc = flavio.WilsonCoefficients() # SM Wilson coefficients
obs_dict = {bin_:flavio.np_prediction(obs_name, wc, *bin_) for bin_ in bin_list}
ax = plt.gca()
for bin_, central_ in obs_dict.items():
q2min, q2max = bin_
err = obs_err_dict[bin_]
if divide_binwidth:
err = err/(q2max-q2min)
central = central_/(q2max-q2min)
else:
central = central_
if 'fc' not in kwargs and 'facecolor' not in kwargs:
kwargs['fc'] = flavio.plots.colors.pastel[3]
if 'linewidth' not in kwargs and 'lw' not in kwargs:
kwargs['lw'] = 0
ax.add_patch(patches.Rectangle((q2min, central-err), q2max-q2min, 2*err,**kwargs))
def obstable_sm(self):
self._check_sm_cov_loaded()
if self._obstable_sm is None:
info = tree() # nested dict
for flh_name, flh in self.fast_likelihoods.items():
# loop over fast likelihoods: they only have a single "measurement"
m = flh.pseudo_measurement
ml = flh.full_measurement_likelihood
pred_sm = ml.get_predictions_par(self.par_dict_sm,
flavio.WilsonCoefficients())
sm_cov = flh.sm_covariance.get(force=False)
_, exp_cov = flh.exp_covariance.get(force=False)
inspire_dict = self._get_inspire_dict(flh.observables, ml)
for i, obs in enumerate(flh.observables):
info[obs]['lh_name'] = flh_name
info[obs]['name'] = obs if isinstance(obs, str) else obs[0]
info[obs]['th. unc.'] = np.sqrt(sm_cov[i, i])
info[obs]['experiment'] = m.get_central(obs)
info[obs]['exp. unc.'] = np.sqrt(exp_cov[i, i])
info[obs]['exp. PDF'] = NormalDistribution(
m.get_central(obs), np.sqrt(exp_cov[i, i]))
info[obs]['inspire'] = sorted(set(inspire_dict[obs]))
info[obs]['ll_sm'] = m.get_logprobability_single(
obs, pred_sm[obs])
info[obs]['ll_central'] = m.get_logprobability_single(
obs, m.get_central(obs))
for lh_name, lh in self.likelihoods.items():
# loop over "normal" likelihoods
ml = lh.measurement_likelihood
pred_sm = ml.get_predictions_par(self.par_dict_sm,
flavio.WilsonCoefficients())
inspire_dict = self._get_inspire_dict(lh.observables, ml)
for i, obs in enumerate(lh.observables):
obs_dict = flavio.Observable.argument_format(obs, 'dict')
obs_name = obs_dict.pop('name')
with warnings.catch_warnings():
warnings.simplefilter("ignore")
p_comb = flavio.combine_measurements(
obs_name,
include_measurements=ml.get_measurements,
**obs_dict)
info[obs]['experiment'] = p_comb.central_value
info[obs]['exp. unc.'] = max(p_comb.error_left,
p_comb.error_right)
info[obs]['exp. PDF'] = p_comb
info[obs]['inspire'] = sorted(set(inspire_dict[obs]))
info[obs]['th. unc.'] = 0
info[obs]['lh_name'] = lh_name
info[obs]['name'] = obs if isinstance(obs, str) else obs[0]
info[obs]['ll_sm'] = p_comb.logpdf([pred_sm[obs]])
if info[obs]['ll_sm'] == -np.inf:
info[obs]['ll_sm'] = -1e100
info[obs]['ll_central'] = p_comb.logpdf(
[p_comb.central_value])
self._obstable_sm = info
return self._obstable_sm
def test_kpilnu_nu(self):
wc_sm = flavio.WilsonCoefficients()
wc_np_mu = flavio.WilsonCoefficients()
wc_np_mu.set_initial({'CVL_sumunumu': 1}, 4.8)
wc_np_e = flavio.WilsonCoefficients()
wc_np_e.set_initial({'CVL_sumunue': 1}, 4.8)
obs = flavio.Observable["BR(K+->pimunu)"]
br_sm = obs.prediction_central(constraints, wc_sm)
br_mu = obs.prediction_central(constraints, wc_np_mu)
br_e = obs.prediction_central(constraints, wc_np_e)
# with interference: (1 + 1)^2 = 4
self.assertAlmostEqual(br_mu / br_sm, 4, delta=0.06)
# without interference: 1 + 1 = 2
self.assertAlmostEqual(br_e / br_sm, 2, delta=0.03)
def test_bvlnu_nu(self):
wc_sm = flavio.WilsonCoefficients()
wc_np_tau = flavio.WilsonCoefficients()
wc_np_tau.set_initial({'CVL_butaunutau': 1}, 4.8)
wc_np_e = flavio.WilsonCoefficients()
wc_np_e.set_initial({'CVL_butaunue': 1}, 4.8)
obs = flavio.Observable["BR(B+->rhotaunu)"]
br_sm = obs.prediction_central(constraints, wc_sm)
br_tau = obs.prediction_central(constraints, wc_np_tau)
br_e = obs.prediction_central(constraints, wc_np_e)
# with interference: (1 + 1)^2 = 4
self.assertAlmostEqual(br_tau / br_sm, 4, delta=0.04)
# without interference: 1 + 1 = 2
self.assertAlmostEqual(br_e / br_sm, 2, delta=0.02)
def test_dplnu_nu(self):
wc_sm = flavio.WilsonCoefficients()
wc_np_mu = flavio.WilsonCoefficients()
wc_np_mu.set_initial({'CVL_dcmunumu': 1}, 2)
wc_np_e = flavio.WilsonCoefficients()
wc_np_e.set_initial({'CVL_dcmunue': 1}, 2)
obs = flavio.Observable["BR(D+->pimunu)"]
constraints = flavio.default_parameters
br_sm = obs.prediction_central(constraints, wc_sm)
br_mu = obs.prediction_central(constraints, wc_np_mu)
br_e = obs.prediction_central(constraints, wc_np_e)
# with interference: (1 + 1)^2 = 4
self.assertAlmostEqual(br_mu / br_sm, 4, delta=0.04)
# without interference: 1 + 1 = 2
self.assertAlmostEqual(br_e / br_sm, 2, delta=0.02)
def test_bxll(self):
# check whether QED corrections have the right behaviour
wc_obj = flavio.WilsonCoefficients()
par = flavio.default_parameters.get_central_all()
br_1_noqedpc = _bxll_dbrdq2(1, wc_obj, par, 's', 'mu', include_qed=False, include_pc=False)
br_1_qed = _bxll_dbrdq2(1, wc_obj, par, 's', 'mu', include_qed=True, include_pc=False)
br_6_noqedpc = _bxll_dbrdq2(6, wc_obj, par, 's', 'mu', include_qed=False, include_pc=False)
br_6_qed = _bxll_dbrdq2(6, wc_obj, par, 's', 'mu', include_qed=True, include_pc=False)
br_15_noqedpc = _bxll_dbrdq2(15, wc_obj, par, 's', 'mu', include_qed=False, include_pc=False)
br_15_qed = _bxll_dbrdq2(15, wc_obj, par, 's', 'mu', include_qed=True, include_pc=False)
br_21_noqedpc = _bxll_dbrdq2(21, wc_obj, par, 's', 'mu', include_qed=False, include_pc=False)
br_21_qed = _bxll_dbrdq2(21, wc_obj, par, 's', 'mu', include_qed=True, include_pc=False)
self.assertAlmostEqual((br_1_qed+br_6_qed)/(br_1_noqedpc+br_6_noqedpc),
1.02, delta=0.01) # should lead to a 2% enhancement
self.assertAlmostEqual((br_15_qed+br_21_qed)/(br_15_noqedpc+br_21_noqedpc),
0.92, delta=0.03) # should lead to a 8% suppression
# compare SM predictions to arXiv:1503.04849
# to convert to the parameters used there
xi_t = flavio.physics.ckm.xi('t','bs')(par)
Vcb = flavio.physics.ckm.get_ckm(par)[1,2]
r = abs(xi_t)**2/Vcb**2/0.9621*0.574/par['C_BXlnu']*par['BR(B->Xcenu)_exp']/0.1051
self.assertAlmostEqual(1e6*flavio.sm_prediction('<BR>(B->Xsmumu)', 1, 3.5)/r,
0.888, delta=0.02)
self.assertAlmostEqual(1e6*flavio.sm_prediction('<BR>(B->Xsmumu)', 3.5, 6)/r,
0.731, delta=0.01)
self.assertAlmostEqual(1e7*flavio.sm_prediction('<BR>(B->Xsmumu)', 14.4, 25)/r,
2.53, delta=0.6) # larger difference due to Krüger-Sehgal
self.assertAlmostEqual(1e6*flavio.sm_prediction('<BR>(B->Xsee)', 1, 3.5)/r,
0.926, delta=0.04)
self.assertAlmostEqual(1e6*flavio.sm_prediction('<BR>(B->Xsee)', 3.5, 6)/r,
0.744, delta=0.015)
self.assertAlmostEqual(1e7*flavio.sm_prediction('<BR>(B->Xsee)', 14.4, 25)/r,
2.20, delta=0.6) # larger difference due to Krüger-Sehgal
def _setInitVal(dictParams, pred, lepton, _q2min, _q2max):
channel = "B0->K*ee"
if (lepton): channel = "B0->K*mumu"
for key, par in dictParams.items():
if (pred == 'NP'):
wc = flavio.WilsonCoefficients()
if (key == 'AT2'):
par.set_value(
flavio.np_prediction('<P1>(' + channel + ')',
wc,
q2min=float(_q2min),
q2max=float(_q2max)))
else:
par.set_value(
flavio.np_prediction('<' + key + '>(' + channel + ')',
wc,
q2min=float(_q2min),
q2max=float(_q2max)))
else:
if (key == 'AT2'):
par.set_value(
flavio.sm_prediction('<P1>(' + channel + ')',
q2min=float(_q2min),
q2max=float(_q2max)))
else:
par.set_value(
flavio.sm_prediction('<' + key + '>(' + channel + ')',
q2min=float(_q2min),
q2max=float(_q2max)))
def test_bxclnu_np(self):
wc_np = flavio.WilsonCoefficients()
wc_np.set_initial({'CVp_bcenu': 0.1}, scale=4.6)
br_sm = flavio.physics.bdecays.bxlnu.BR_BXclnu(par, wc_obj, 'e')
br_np = flavio.physics.bdecays.bxlnu.BR_BXclnu(par, wc_np, 'e')
# compare to the unnumbered eq. between (13) and (14) in 1407.1320
self.assertAlmostEqual(br_np/br_sm, (1-0.34*0.1)**2, delta=0.1)
def _get_covariance_sm(self, N=100):
par_central = self.par_obj.get_central_all()
def random_nuisance_dict():
arr = self.get_random_nuisance_parameters
nuis_dict = {
par: arr[i]
for i, par in enumerate(self.nuisance_parameters)
}
par = par_central.copy()
par.update(nuis_dict)
return par
par_random = [random_nuisance_dict() for i in range(N)]
pred_arr = np.zeros((len(self.observables), N))
wc_sm = flavio.WilsonCoefficients()
for i, observable in enumerate(self.observables):
if isinstance(observable, tuple):
obs_name = observable[0]
_inst = flavio.classes.Observable.get_instance(obs_name)
pred_arr[i] = np.array([
_inst.prediction_par(par, wc_sm, *observable[1:])
for par in par_random
])
else:
_inst = flavio.classes.Observable.get_instance(observable)
pred_arr[i] = np.array(
[_inst.prediction_par(par, wc_sm) for par in par_random])
return np.cov(pred_arr)
def test_running(self):
c_in = np.array([
0.20910694, 0.77740198, 0.54696337, 0.46407456, 0.42482153,
0.95717777, 0.62733321, 0.87053086
])
wc = flavio.WilsonCoefficients()
wc_names = [
'C{}_bsbs'.format(i)
for i in ['VLL', 'SLL', 'TLL', 'VRR', 'SRR', 'TRR', 'VLR', 'SLR']
]
wc_dict = dict(zip(wc_names, c_in))
wc.set_initial(wc_dict, 173.3)
c_out_dict = wc.get_wc('sbsb', 4.2, par)
c_out = np.array([c_out_dict[k] for k in wc_names])
c_out_U = np.dot(U_mb, c_in)
for i, r in enumerate(c_out / c_out_U):
if 'S' in wc_names[i] or 'T' in wc_names[i]:
self.assertAlmostEqual(r,
1,
delta=0.2,
msg="Failed for {}".format(wc_names[i]))
else: # more precise
self.assertAlmostEqual(r,
1,
delta=0.1,
msg="Failed for {}".format(wc_names[i]))
# compare eta at 2 GeV to the values in table 2 of hep-ph/0102316
par_bju = par.copy()
par_bju['alpha_s'] = 0.118
par_bju['m_b'] = 4.4
c_out_bju_dict = wc.get_wc('sbsb', 2, par_bju, nf_out=5)
c_out_bju = np.array([c_out_bju_dict[k] for k in wc_names])
self.assertAlmostEqual(c_out_bju[0] / c_in[0], 0.788, delta=0.02)
def get_wc_obj(self, x):
wc_obj = flavio.WilsonCoefficients()
# if there are no WCs to be fitted, return the SM WCs
if not self.fit_wc_names:
return wc_obj
d = self.array_to_dict(x)
wc_obj.set_initial(self.fit_wc_function(**d['fit_wc']),
self.input_scale)
return wc_obj
def test_q2_th_diff(self):
# without specifying WCs
q2_plot_th_diff('dBR/dq2(B0->pienu)', 0, 25, q2steps=10)
# with WCs
q2_plot_th_diff('dBR/dq2(B+->pienu)', 0, 25,
wc=flavio.WilsonCoefficients(), q2steps=10)
# check that observable not depending on q2 raises error
with self.assertRaises(ValueError):
q2_plot_th_diff('eps_K', 0, 25)
def test_np(self):
wc = flavio.WilsonCoefficients()
for l in ['e', 'mu', 'tau']:
wc.set_initial({'CSL_bc' + l + 'nu' + l: 1}, 4.8)
self.assertTrue(par['tau_Bc_SM'] / flavio.np_prediction('tau_Bc', wc) > 1.1)
self.assertAlmostEqual(par['tau_Bc_SM'] / flavio.np_prediction('tau_Bc', wc),
1 + flavio.np_prediction('BR(Bc->' + l + 'nu)', wc)
- flavio.sm_prediction('BR(Bc->' + l + 'nu)'),
delta=0.05,
msg="Failed for {}".format(l))
def test_q2_th_bin(self):
bins = [(0, 5), (5, 10)]
# without specifying WCs
q2_plot_th_bin('<BR>(B0->pienu)', bins, N=10)
# with WCs
q2_plot_th_bin('<BR>(B+->pienu)', bins, divide_binwidth=True,
wc=flavio.WilsonCoefficients(), N=10)
# check that observable not depending on q2 raises error
with self.assertRaises(ValueError):
q2_plot_th_bin('eps_K', bins)
def test_bs_timedep(self):
q2 = 3
wc_obj = flavio.WilsonCoefficients()
par = flavio.default_parameters.get_central_all()
B = 'Bs'
V = 'phi'
l = 'mu'
# a set of parameters with y_s=0!
par_y0 = par.copy()
par_y0['DeltaGamma/Gamma_Bs']=0
# compare without lifetime effect: must be equal!
self.assertEqual(
observables.bvll_obs( observables.dGdq2_ave, q2, wc_obj, par_y0, B, V, l),
observables_bs.bsvll_obs( observables_bs.dGdq2_ave_Bs, q2, wc_obj, par_y0, B, V, l))
self.assertEqual(
observables.bvll_obs( observables.FL, q2, wc_obj, par_y0, B, V, l),
observables_bs.bsvll_obs( observables_bs.FL_Bs, q2, wc_obj, par_y0, B, V, l))
for i in [3, 4, 7]: # S3,4,7
self.assertEqual(
observables.bvll_obs( lambda J, J_bar: observables.S_experiment(J, J_bar, i), q2, wc_obj, par_y0, B, V, l),
observables_bs.bsvll_obs( lambda y, J, J_bar, J_h: observables_bs.S_experiment_Bs(y, J, J_bar, J_h, i), q2, wc_obj, par_y0, B, V, l))
# check that the phase phi has the right convention
q_over_p = flavio.physics.mesonmixing.observables.q_over_p(wc_obj, par, B)
phi = cmath.phase(-q_over_p) # the phase of q/p
self.assertAlmostEqual(phi, 0.04, delta=0.01)
# compare WITH lifetime effect: angular observables must be similar
delta = 0.01
self.assertAlmostEqual(
observables.bvll_obs( observables.FL, q2, wc_obj, par, B, V, l)/
observables_bs.bsvll_obs( observables_bs.FL_Bs, q2, wc_obj, par, B, V, l),
1, delta=delta)
for i in [4, 7]: # S4,7
self.assertAlmostEqual(
observables.bvll_obs( lambda J, J_bar: observables.S_experiment(J, J_bar, i), q2, wc_obj, par, B, V, l)/
observables_bs.bsvll_obs( lambda y, J, J_bar, J_h: observables_bs.S_experiment_Bs(y, J, J_bar, J_h, i), q2, wc_obj, par, B, V, l),
1, delta=delta)
for i in [3]: # S3: look at differnece only
self.assertAlmostEqual(
observables.bvll_obs( lambda J, J_bar: observables.S_experiment(J, J_bar, i), q2, wc_obj, par, B, V, l) -
observables_bs.bsvll_obs( lambda y, J, J_bar, J_h: observables_bs.S_experiment_Bs(y, J, J_bar, J_h, i), q2, wc_obj, par, B, V, l),
0, delta=0.01)
# compare WITH lifetime effect: BR suppressed by ~6%!
self.assertAlmostEqual(
observables.bvll_obs( observables.dGdq2_ave, q2, wc_obj, par, B, V, l)/
observables_bs.bsvll_obs( observables_bs.dGdq2_ave_Bs, q2, wc_obj, par, B, V, l),
1.06, delta=0.02)
# and now just check a few observables to see if any errors are raised
flavio.sm_prediction("FL(Bs->phimumu)", q2=1)
flavio.sm_prediction("S3(Bs->phimumu)", q2=1)
flavio.sm_prediction("S4(Bs->phimumu)", q2=1)
flavio.sm_prediction("S7(Bs->phimumu)", q2=1)
def test_wceff(self):
wc_obj = flavio.WilsonCoefficients()
wceff = flavio.physics.betadecays.common.wc_eff(par,
wc_obj,
scale=1,
nu='e')
self.assertAlmostEqual(wceff['V'], 1, delta=0.05)
self.assertAlmostEqual(wceff['A'], -1.27, delta=0.05)
self.assertEqual(wceff['S'], 0)
self.assertEqual(wceff['P'], 0)
self.assertEqual(wceff['T'], 0)
wc_obj = flavio.WilsonCoefficients()
wc_obj.set_initial({'CVL_duenue': 1}, 1, 'WET-3', 'flavio')
wceff = flavio.physics.betadecays.common.wc_eff(par,
wc_obj,
scale=1,
nu='e')
self.assertAlmostEqual(wceff['V'], 2, delta=0.05)
self.assertAlmostEqual(wceff['A'], -1.27 * 2, delta=0.05)
self.assertEqual(wceff['S'], 0)
self.assertEqual(wceff['P'], 0)
self.assertEqual(wceff['T'], 0)
wc_obj.set_initial({'CVR_duenue': 1}, 1, 'WET-3', 'flavio')
wceff = flavio.physics.betadecays.common.wc_eff(par,
wc_obj,
scale=1,
nu='e')
self.assertAlmostEqual(wceff['V'], 2, delta=0.05)
self.assertAlmostEqual(wceff['A'], 0, delta=0.05)
self.assertEqual(wceff['S'], 0)
self.assertEqual(wceff['P'], 0)
self.assertEqual(wceff['T'], 0)
wc_obj.set_initial({'CT_duenue': 1}, 1, 'WET-3', 'flavio')
wceff = flavio.physics.betadecays.common.wc_eff(par,
wc_obj,
scale=1,
nu='e')
self.assertAlmostEqual(wceff['V'], 1, delta=0.05)
self.assertAlmostEqual(wceff['A'], -1.27, delta=0.05)
self.assertEqual(wceff['S'], 0)
self.assertEqual(wceff['P'], 0)
self.assertAlmostEqual(wceff['T'], 4 * 1, delta=0.1)
def test_ft(self):
# compare to exp values in table 4 of 1803.08732
wc_obj = flavio.WilsonCoefficients()
Ft = flavio.physics.betadecays.ft.Ft_superallowed(par, wc_obj, '10C')
self.assertAlmostEqual(Ft / s, 3078, delta=2 * 5)
Ft = flavio.physics.betadecays.ft.Ft_superallowed(par, wc_obj, '26mAl')
self.assertAlmostEqual(Ft / s, 3072.9, delta=3 * 1)
Ft = flavio.physics.betadecays.ft.Ft_superallowed(par, wc_obj, '46V')
self.assertAlmostEqual(Ft / s, 3074.1, delta=2 * 2)
Ft = flavio.sm_prediction('Ft(38Ca)')
self.assertAlmostEqual(Ft / s, 3076.4, delta=2 * 7.2)
def test_bsll_lfv(self):
# test for errors
self.assertEqual(flavio.sm_prediction('BR(B0->emu)'), 0)
self.assertEqual(flavio.sm_prediction('BR(Bs->taumu)'), 0)
self.assertEqual(flavio.sm_prediction('BR(B0->emu,mue)'), 0)
self.assertEqual(flavio.sm_prediction('BR(Bs->mutau,taumu)'), 0)
wc = flavio.WilsonCoefficients()
wc.set_initial({'C10_bdemu': 1, 'C10_bdmue': 2}, scale=4.8)
self.assertEqual(flavio.np_prediction('BR(B0->mue)', wc)
/flavio.np_prediction('BR(B0->emu)', wc), 4)
self.assertEqual(flavio.np_prediction('BR(B0->emu,mue)', wc)
/flavio.np_prediction('BR(B0->emu)', wc), 5)
def test_dmixing(self):
par_D = par.copy()
wc_obj = flavio.WilsonCoefficients()
par_D['M12_D a_bb'] = 0
par_D['M12_D a_bs'] = 10
par_D['M12_D a_ss'] = -0.1
par_D['Gamma12_D a_bb'] = 0
par_D['Gamma12_D a_bs'] = 10
par_D['Gamma12_D a_ss'] = -0.3
x12 = flavio.Observable['x12_D'].prediction_par(par_D, wc_obj)
x12Im = flavio.Observable['x12Im_D'].prediction_par(par_D, wc_obj)
phi12 = flavio.Observable['phi12_D'].prediction_par(par_D, wc_obj)
self.assertAlmostEqual(x12 * sin(phi12), x12Im)
def test_nedm_jms_CEDM(self):
wc = wcxf.WC('WET', 'JMS', 160, {'dG_11': {'Im': 1e-10}})
wcf = flavio.WilsonCoefficients()
wcf.set_initial_wcxf(wc)
wcd = wcf.get_wc('dF=0', scale=2, par=par, eft='WET-3', basis='flavio')
self.assertAlmostEqual(wcd['C8_dd'] / 1j, 0.07, delta=0.02)
par_dG = par.copy()
par_dG['nEDM gT_d'] = 0
par_dG['nEDM beta_G'] = 0
par_dG['nEDM gT_u'] = 0
par_dG['nEDM ~rho_u'] = 0
p = flavio.Observable['d_n'].prediction_par(par_dG, wcf)
self.assertAlmostEqual(p, 2e-10, delta=0.3e-10)
def np_predictions_nockm(self, w=None, **ckm):
"""Return the predictions for the four input observables in the presence
of NP (parametrized by a `wilson.Wilson` instance `w`) with the
CKM prefactor removed."""
fac = self.ckm_fac(**ckm)
par_dict = self.par_central.copy()
par_dict.update(ckm)
if w is None:
w = flavio.WilsonCoefficients()
return [
flavio.classes.Observable[obs].prediction_par(par_dict, w) / fac[i]
for i, obs in enumerate(self.observables)
]
def sm_error_budget(obs_name, *args, N=50, **kwargs):
"""Get the *relative* uncertainty of the Standard Model prediction due to
variation of individual observables.
Parameters
----------
- `obs_name`: name of the observable as a string
- `N` (optional): number of random evaluations of the observable.
The relative accuracy of the uncertainties returned is given by $1/\sqrt{2N}$.
Additional arguments are passed to the observable and are necessary,
depending on the observable (e.g. $q^2$-dependent observables).
"""
obs = flavio.classes.Observable.get_instance(obs_name)
wc_sm = flavio.WilsonCoefficients()
par_central = flavio.default_parameters.get_central_all()
par_random = [flavio.default_parameters.get_random_all() for i in range(N)]
# Step 1: determine the parameters the observable depends on at all.
# to this end, compute the observables once for each parameter with a
# random value for this parameter but central values for all other
# parameters. If the prediction is equal to the central prediction, the
# observable does not depend on the parameter!
pred_central = obs.prediction_par(par_central, wc_sm, *args, **kwargs)
dependent_par = []
for k in par_central.keys():
par_tmp = par_central.copy()
par_tmp[k] = par_random[0][k]
pred_tmp = obs.prediction_par(par_tmp, wc_sm, *args, **kwargs)
if pred_tmp != pred_central:
dependent_par.append(k)
# Step 2: for each of the dependent parameters, determine the error
# analogous to the sm_uncertainty function. Normalize to the central
# prediction (so relative errors are returned)
individual_errors = {}
def make_par_random(key, par_random):
par_tmp = par_central.copy()
par_tmp[key] = par_random[key]
return par_tmp
for p in dependent_par:
par_random_p = [make_par_random(p, pr) for pr in par_random]
all_pred = np.array([
obs.prediction_par(par, wc_sm, *args, **kwargs)
for par in par_random_p
])
individual_errors[p] = np.std(all_pred) / abs(pred_central)
return individual_errors
def test_nedm_jms_G(self):
wc = wcxf.WC('WET', 'JMS', 160, {'Gtilde': 1e-6})
wcf = flavio.WilsonCoefficients()
wcf.set_initial_wcxf(wc)
wcd = wcf.get_wc('dF=0', scale=2, par=par, eft='WET-3', basis='flavio')
self.assertEqual(wcd['CG'], 0)
self.assertAlmostEqual(wcd['CGtilde'], 0.007, delta=0.001)
par_G = par.copy()
par_G['nEDM gT_d'] = 0
par_G['nEDM ~rho_d'] = 0
par_G['nEDM gT_u'] = 0
par_G['nEDM ~rho_u'] = 0
p = flavio.Observable['d_n'].prediction_par(par_G, wcf)
self.assertAlmostEqual(p, 4.5e-9, delta=1e-9)
def tau_Bc(wc_obj, par):
r"""Lifetime of the $B_c$ meson based on the SM OPE estimate plus
the NP contribution to leptonic decays."""
Gamma_SM = 1 / par['tau_Bc_SM']
Gamma_exp = 1 / par['tau_Bc']
Gamma_NP = 0
wc_sm = flavio.WilsonCoefficients()
for l in ['e', 'mu', 'tau']:
_br_SM = flavio.Observable['BR(Bc->{}nu)'.format(l)].prediction_par(
par, wc_sm)
_br_NP = flavio.Observable['BR(Bc->{}nu)'.format(l)].prediction_par(
par, wc_obj)
Gamma_NP += (_br_NP - _br_SM) * Gamma_exp
return 1 / (Gamma_SM + Gamma_NP)
def sm_covariance(obs_list, N=100, par_vary='all', **kwargs):
"""Get the covariance matrix of the Standard Model predictions for a
list of observables.
Parameters
----------
- `obs_list`: a list of observables that should be given either as a string
name (for observables that do not depend on any arguments) or as a tuple
of a string and values for the arguements the observable depends on (e.g.
the values of `q2min` and `q2max` for a binned observable)
- `N` (optional): number of random evaluations of the observables.
The relative accuracy of the uncertainties returned is given by $1/\sqrt{2N}$.
- `par_vary`: a list of parameters to vary. Defaults to 'all', i.e. all
parameters are varied according to their probability distributions.
"""
wc_sm = flavio.WilsonCoefficients()
par_central_all = flavio.default_parameters.get_central_all()
par_random_all = [
flavio.default_parameters.get_random_all() for i in range(N)
]
def par_random_some(par_random, par_central):
# take the central values for the parameters not to be varied
par1 = {k: v for k, v in par_central.items() if k not in par_vary}
# take the random values for the parameters to be varied
par2 = {k: v for k, v in par_random.items() if k in par_vary}
par1.update(par2) # merge them
return par1
if par_vary == 'all':
par_random = par_random_all
else:
par_random = [
par_random_some(par_random_all[i], par_central_all)
for i in range(N)
]
def get_prediction(obs, par):
if isinstance(obs, str):
obs_obj = flavio.classes.Observable.get_instance(obs)
return obs_obj.prediction_par(par, wc_sm, **kwargs)
elif isinstance(obs, tuple):
obs_obj = flavio.classes.Observable.get_instance(obs[0])
return obs_obj.prediction_par(par, wc_sm, *obs[1:], **kwargs)
all_pred = np.array([[get_prediction(obs, par) for par in par_random]
for obs in obs_list])
return np.cov(all_pred)
def testkpinunu(self):
self.assertAlmostEqual(
flavio.sm_prediction('BR(K+->pinunu)')/1e-10,
1, delta=0.2)
self.assertAlmostEqual(
flavio.sm_prediction('BR(KL->pinunu)')/3e-11,
1, delta=0.2)
obs = flavio.classes.Observable['BR(K+->pinunu)']
wc_sm = flavio.WilsonCoefficients()
# confirm that deltaPcu leads to an enhancement of the K+->pinunu BR
# by 6% as stated in the abstract of hep-ph/0503107
self.assertAlmostEqual(
obs.prediction_central(constraints, wc_sm)/obs.prediction_central(constraints_no_deltaPcu, wc_sm),
1.06,
delta=0.01)
def sm_prediction(obs_name, *args, **kwargs):
"""Get the central value of the Standard Model prediction of an observable.
Parameters
----------
- `obs_name`: name of the observable as a string
Additional arguments are passed to the observable and are necessary,
depending on the observable (e.g. $q^2$-dependent observables).
"""
obs = flavio.classes.Observable.get_instance(obs_name)
wc_sm = flavio.WilsonCoefficients()
return obs.prediction_central(flavio.default_parameters, wc_sm, *args,
**kwargs)
def BR(c10, c10p, cS, cSp, cP, cPp):
list_wc = {'C10_bsmumu' : c10,
'C10p_bsmumu': c10p,
'CS_bsmumu' : cS,
'CSp_bsmumu' : cSp,
'CP_bsmumu' : cP,
'CPp_bsmumu' : cPp,
'C9_bsmumu' : 0.,
'C9p_bsmumu' : 0.}
wc = flavio.WilsonCoefficients()
wc.set_initial(list_wc, scale=160 )
BR_flavio = flavio.np_prediction('BR(Bs->mumu)', wc)
BR_Amsterdam = BR_Amsterdam_Bs_mumu(par, list_wc)
return {'flavio': BR_flavio, 'Amsterdam': BR_Amsterdam}
def q2_plot_th_diff(obs_name, q2min, q2max, wc=None, q2steps=100, **kwargs):
r"""Plot the central theory prediction of a $q^2$-dependent observable
as a function of $q^2$."""
obs = flavio.classes.Observable.get_instance(obs_name)
if obs.arguments != ['q2']:
raise ValueError(r"Only observables that depend on $q^2$ (and nothing else) are allowed")
q2_arr = np.arange(q2min, q2max, (q2max-q2min)/(q2steps-1))
if wc is None:
wc = flavio.WilsonCoefficients() # SM Wilson coefficients
obs_arr = [flavio.sm_prediction(obs_name, q2) for q2 in q2_arr]
else:
obs_arr = [flavio.np_prediction(obs_name, wc, q2) for q2 in q2_arr]
ax = plt.gca()
if 'c' not in kwargs and 'color' not in kwargs:
kwargs['c'] = 'k'
ax.plot(q2_arr, obs_arr, **kwargs)
def test_dmixing(self):
par_D = par.copy()
wc_obj = flavio.WilsonCoefficients()
# check correct limiting cases for vanishing mixing
par_D['M12_D a_bb'] = 0
par_D['M12_D a_bs'] = 0
par_D['M12_D a_ss'] = 0
par_D['Gamma12_D a_bb'] = 0
par_D['Gamma12_D a_bs'] = 0
par_D['Gamma12_D a_ss'] = 0
self.assertEqual(
flavio.Observable['x_D'].prediction_par(par_D, wc_obj), 0)
self.assertEqual(
flavio.Observable['y_D'].prediction_par(par_D, wc_obj), 0)
self.assertEqual(
flavio.Observable['phi_D'].prediction_par(par_D, wc_obj), 0)
self.assertEqual(
flavio.Observable['q/p_D'].prediction_par(par_D, wc_obj), 1)