def pvalue_plot(x, y, fill_y=None, col=None, color=None, label=None,
plotargs={}, fillargs={}):
"""Plot of a 1D confidence level distribution, where the y axis is 1-CL.
Parameters:
- `x`: x values
- `y`: y values
- `fill_y`: for x-values where y is larger than this number, the area
between the x-axis and the curve will be filled
- `col`: (optional) integer to select one of the colours from the default
palette
- `plotargs`: keyword arguments passed to the `plot` function
- `fillargs`: keyword arguments passed to the `fill_between` function
"""
ax = plt.gca()
_plotargs = {}
_fillargs = {}
# default values
_plotargs['linewidth'] = 0.6
if label is not None:
_plotargs['label'] = label
color = get_color(col=col, color=color)
_plotargs['color'] = color
_fillargs['facecolor'] = lighten_color(color, 0.5)
_fillargs.update(fillargs)
_plotargs.update(plotargs)
ax.plot(x, y, **_plotargs)
if fill_y is not None:
x_zoom = scipy.ndimage.zoom(x, zoom=10, order=1)
y_zoom = scipy.ndimage.zoom(y, zoom=10, order=1)
ax.fill_between(x_zoom, 0, y_zoom,
where=y_zoom > fill_y,
**_fillargs)
ax.set_ylim([0, 1])
def contour(x, y, z, levels,
interpolation_factor=1,
interpolation_order=2,
col=None, color=None, label=None,
filled=True,
contour_args={}, contourf_args={}):
r"""Plot coloured confidence contours (or bands) given numerical input
arrays.
Parameters:
- `x`, `y`: 2D arrays containg x and y values as returned by numpy.meshgrid
- `z` value of the function to plot. 2D array in the same shape as `x` and
`y`. The lowest value of the function should be 0 (i.e. the best fit
point).
- levels: list of function values where to draw the contours. They should
be positive and in ascending order.
- `interpolation factor` (optional): in between the points on the grid,
the functioncan be interpolated to get smoother contours.
This parameter sets the number of subdivisions (default: 1, i.e. no
interpolation). It should be larger than 1.
- `col` (optional): number between 0 and 9 to choose the color of the plot
from a predefined palette
- `label` (optional): label that will be added to a legend created with
maplotlib.pyplot.legend()
- `filled` (optional): if False, contours will be drawn without shading
- `contour_args`: dictionary of additional options that will be passed
to matplotlib.pyplot.contour() (that draws the contour lines)
- `contourf_args`: dictionary of additional options that will be passed
to matplotlib.pyplot.contourf() (that paints the contour filling).
Ignored if `filled` is false.
"""
if interpolation_factor > 1:
x = scipy.ndimage.zoom(x, zoom=interpolation_factor, order=1)
y = scipy.ndimage.zoom(y, zoom=interpolation_factor, order=1)
z = scipy.ndimage.zoom(z, zoom=interpolation_factor, order=interpolation_order)
_contour_args = {}
_contourf_args = {}
color = get_color(col=col, color=color)
_contour_args['colors'] = color
if filled:
_contour_args['linewidths'] = 0.6
else:
_contour_args['linewidths'] = 0.8
N = len(levels)
_contourf_args['colors'] = [lighten_color(color, 0.5)# RGB
+ (max(1-n/N, 0),) # alpha, decreasing for contours
for n in range(N)]
_contour_args['linestyles'] = 'solid'
_contour_args.update(contour_args)
_contourf_args.update(contourf_args)
# for the filling, need to add zero contour
levelsf = [np.min(z)] + list(levels)
ax = plt.gca()
if filled:
ax.contourf(x, y, z, levels=levelsf, **_contourf_args)
CS = ax.contour(x, y, z, levels=levels, **_contour_args)
if label is not None:
CS.collections[0].set_label(label)
return CS
def error_budget_pie(err_dict, other_cutoff=0.03):
"""Pie chart of an observable's error budget.
Parameters:
- `err_dict`: Dictionary as return from `flavio.sm_error_budget`
- `other_cutoff`: If an individual error contribution divided by the total
error is smaller than this number, it is lumped under "other". Defaults
to 0.03.
Note that for uncorrelated parameters, the total uncertainty is the squared
sum of the individual uncertainties, so the relative size of the wedges does
not correspond to the relative contribution to the total uncertainty.
If the uncertainties of individual parameters are correlated, the total
uncertainty can be larger or smaller than the squared sum of the individual
uncertainties, so the representation can be misleading.
"""
err_tot = sum(err_dict.values()) # linear sum of individual errors
err_dict_sorted = OrderedDict(sorted(err_dict.items(),
key=lambda t: -t[1]))
labels = []
fracs = []
small_frac = []
for key, value in err_dict_sorted.items():
frac = value / err_tot
if frac > other_cutoff:
if isinstance(key, str):
try:
labels.append(flavio.Parameter[key].tex)
except KeyError:
# if 'key' is not actually a parameter (e.g. manually set by the user)
labels.append(key)
elif isinstance(key, tuple):
key_strings = [flavio.Parameter[k].tex for k in key]
labels.append(', '.join(key_strings))
fracs.append(frac)
else:
small_frac.append(frac)
if small_frac:
labels.append('other')
# the fraction for the "other" errors is obtained by adding them in quadrature
fracs.append(np.sqrt(np.sum(np.array(small_frac)**2)))
# initially, the fractions had been calculated assuming that they add to
# one, but adding the "other" errors in quadrature changed that - correct
# all the fractions to account for this
corr = sum(fracs)
fracs = [f / corr for f in fracs]
def my_autopct(pct):
return r'{p:.2g}\%'.format(p=pct * err_tot)
plt.axis('equal')
return plt.pie(
fracs,
labels=labels,
autopct=my_autopct,
wedgeprops={'linewidth': 0.5},
colors=[lighten_color('C{}'.format(i), 0.5) for i in range(10)])
def likelihood_plot(x,
y,
fill_x=None,
col=None,
color=None,
label=None,
plotargs={},
fillargs={},
flipped=False):
"""Plot of a 1D probability density function.
Parameters:
- `x`: x values
- `y`: y values
- `fill_x`: 2-tuple of x-values in between which the curve will be filled
- `col`: (optional) integer to select one of the colours from the default
palette
- `plotargs`: keyword arguments passed to the `plot` function
- `fillargs`: keyword arguments passed to the `fill_between` function
- `flipped`: exchange x and y axes (needed for `density_contour_joint`)
"""
ax = plt.gca()
_plotargs = {}
_fillargs = {}
# default values
_plotargs['linewidth'] = 0.6
if label is not None:
_plotargs['label'] = label
color = get_color(col=col, color=color)
_plotargs['color'] = color
_fillargs['facecolor'] = lighten_color(color, 0.5)
_fillargs.update(fillargs)
_plotargs.update(plotargs)
if not flipped:
ax.plot(x, y, **_plotargs)
if fill_x is not None:
ax.fill_between(x,
0,
y,
where=np.logical_and(fill_x[0] < x, x < fill_x[1]),
**_fillargs)
else:
ax.plot(y, x, **_plotargs)
if fill_x is not None:
ax.fill_betweenx(x,
0,
y,
where=np.logical_and(fill_x[0] < x,
x < fill_x[1]),
**_fillargs)
def contour(x,
y,
z,
levels,
*,
z_min=None,
interpolation_factor=1,
interpolation_order=2,
col=None,
color=None,
label=None,
filled=True,
contour_args={},
contourf_args={},
**kwargs):
r"""Plot coloured confidence contours (or bands) given numerical input
arrays.
Parameters:
- `x`, `y`: 2D arrays containg x and y values as returned by numpy.meshgrid
- `z` value of the function to plot. 2D array in the same shape as `x` and
`y`.
- levels: list of function values where to draw the contours. They should
be positive and in ascending order.
- `z_min` (optional): lowest value of the function to plot (i.e. value at
the best fit point). If not provided, the smallest value on the grid is
used.
- `interpolation factor` (optional): in between the points on the grid,
the functioncan be interpolated to get smoother contours.
This parameter sets the number of subdivisions (default: 1, i.e. no
interpolation). It should be larger than 1.
- `col` (optional): number between 0 and 9 to choose the color of the plot
from a predefined palette
- `label` (optional): label that will be added to a legend created with
maplotlib.pyplot.legend()
- `filled` (optional): if False, contours will be drawn without shading
- `contour_args`: dictionary of additional options that will be passed
to matplotlib.pyplot.contour() (that draws the contour lines)
- `contourf_args`: dictionary of additional options that will be passed
to matplotlib.pyplot.contourf() (that paints the contour filling).
Ignored if `filled` is false.
"""
if z_min is None:
warnings.warn(
"The smallest `z` value on the grid will be used as the "
"minimum of the function to plot. This can lead to "
"undesired results if the actual minimum is considerably "
"different from the minimum on the grid. For better "
"precision, the actual minimum should be provided in the "
"`z_min` argument.")
z_min = np.min(z) # use minmum on the grid
elif np.min(z) < z_min:
raise ValueError("The provided minimum `z_min` has to be smaller than "
"the smallest `z` value on the grid.")
z = z - z_min # subtract z minimum to make value of new z minimum 0
if interpolation_factor > 1:
x = scipy.ndimage.zoom(x, zoom=interpolation_factor, order=1)
y = scipy.ndimage.zoom(y, zoom=interpolation_factor, order=1)
z = scipy.ndimage.zoom(z,
zoom=interpolation_factor,
order=interpolation_order)
_contour_args = {}
_contourf_args = {}
color = get_color(col=col, color=color)
_contour_args['colors'] = color
if filled:
_contour_args['linewidths'] = 0.6
else:
_contour_args['linewidths'] = 0.8
N = len(levels)
_contourf_args['colors'] = [
lighten_color(color, 0.5) # RGB
+ (max(1 - n / N, 0), ) # alpha, decreasing for contours
for n in range(N)
]
_contour_args['linestyles'] = 'solid'
_contour_args.update(contour_args)
_contourf_args.update(contourf_args)
# for the filling, need to add zero contour
zero_contour = min(np.min(z), np.min(levels) * (1 - 1e-16))
levelsf = [zero_contour] + list(levels)
ax = plt.gca()
if filled:
ax.contourf(x, y, z, levels=levelsf, **_contourf_args)
CS = ax.contour(x, y, z, levels=levels, **_contour_args)
if label is not None:
CS.collections[0].set_label(label)
return CS