def _show_sunset_hour(df, geoloc):
hover = HoverTool(tooltips=[
('Date', '@datetime{%m/%d}'),
('Hour of Sunset', '@hour{0.1f}'),
('Length of Day', '@daylight{0.1f}'),
],
formatters={
'datetime': 'datetime',
},
mode='vline')
sunset_df = df.copy()
sunset_df = df.loc[df['sun_down'] == False, :]
sunset_df = sunset_df.assign(**{
'hour': sunset_df['hour'] - 12,
'hour_24': sunset_df['hour_24'] - 12
})
lat, lon = geoloc.latitude, geoloc.longitude
address = geoloc.address
sunset_curve = sunset_df.hvplot('datetime',
'hour',
hover_cols=['daylight'],
responsive=True)
sunset_curve = sunset_curve.opts(
invert_yaxis=True,
color='darkblue',
xlabel='Date',
ylabel='PM Hour of Sunset [Local Time]',
title=f'Yearly Sunset Hour at {address} ({lat:.1f} N, {lon:.1f} E)',
hooks=[_format_datetime_axis],
show_grid=True,
gridstyle={'ygrid_line_alpha': 0},
tools=[hover],
ylim=(4, 9))
sun_up = hv.Area(df.loc[df['sun_down'] == False], 'datetime', 'hour')
sun_up = sun_up.opts(color='tan', alpha=0.15, responsive=True)
sun_down = hv.Area(sunset_df, 'datetime', ['hour', 'hour_24'])
sun_down = sun_down.opts(color='darkblue', alpha=0.15, responsive=True)
five_pm_line = hv.HLine(5).opts(color='black',
alpha=0.1,
line_dash='dotted',
responsive=True)
five_pm_txt = hv.Text(pd.datetime(2020, 7, 4), 5, '5 PM')
five_pm_txt = five_pm_txt.opts(text_font_size='1.5em',
text_alpha=0.2,
text_baseline='bottom',
text_align='left',
responsive=True)
overlay = (sunset_curve * sun_up * sun_down * five_pm_line * five_pm_txt)
return overlay
def modify_doc(doc):
X = np.linspace(0, 3, 200)
Y = X**2 + 3
Y2 = np.exp(X) + 2
Y3 = np.cos(X)
final = hv.Area((X, Y, Y2), vdims=['y', 'y2']) * hv.Area(
(X, Y, Y3), vdims=['y', 'y3'])
plot = renderer.get_plot(final)
layout = row(plot.state)
# renderer.server_doc(layout)
doc.add_root(layout)
def area(self, x, y):
if x and y:
return hv.Area(self.data, kdims=[x],
vdims=[y]).opts(plot=self._plot_opts)
index = self.data.index.name or 'index'
df = self.data.reset_index()
areas = []
for c in self.data.columns:
areas.append(hv.Area(df, kdims=[index], vdims=[c], label=c))
areas = hv.Overlay(areas)
if self.stacked:
return hv.Area.stack(areas)
else:
return areas
def plot_1d_min_max_with_region_bar(
run_diags: RunDiagnostics,
varfilter_min: str,
varfilter_max: str,
) -> HVPlot:
"""Plot all diagnostics whose name includes varfilter. Plot is overlaid across runs.
All matching diagnostics must be 1D."""
p = hv.Cycle("Colorblind")
hmap = hv.HoloMap(kdims=["variable", "region", "run"])
variables_to_plot = run_diags.matching_variables(varfilter_min)
for run in run_diags.runs:
for min_var in variables_to_plot:
max_var = min_var.replace(varfilter_min, varfilter_max)
vmin = run_diags.get_variable(run, min_var).rename("min")
vmax = run_diags.get_variable(run, max_var).rename("max")
style = "solid" if run_diags.is_baseline(run) else "dashed"
long_name = vmin.long_name
region = min_var.split("_")[-1]
# Area plot doesn't automatically add correct y label
ylabel = f'{vmin.attrs["long_name"]} {vmin.attrs["units"]}'
hmap[(long_name, region, run)] = hv.Area(
(vmin.time, vmin, vmax), label="Min/max",
vdims=["y", "y2"]).options(line_dash=style,
color=p,
alpha=0.6,
ylabel=ylabel)
return HVPlot(_set_opts_and_overlay(hmap))
def integrated_charge(limit_a, limit_b, y, iteration):
# compute 1D histogram
energy_hist, bin_edges, nbins = particle_energy_histogram(
tseries=time_series,
it=iteration,
cutoff=np.inf, # no cutoff
energy_max=e_max,
)
histogram = hv.Histogram((bin_edges, energy_hist),
kdims=energy,
vdims=count)
curve = hv.Curve(histogram)
e_min = histogram.edges[0]
limit_a = e_min if limit_a is None else np.clip(limit_a, e_min, e_max)
limit_b = e_max if limit_b is None else np.clip(limit_b, e_min, e_max)
area = hv.Area((curve.dimension_values('energy'),
curve.dimension_values('frequency')))[limit_a:limit_b]
charge = np.sum(
np.diff(histogram[limit_a:limit_b].edges) *
histogram[limit_a:limit_b].values)
return curve * area * hv.VLine(limit_a) * hv.VLine(limit_b) * hv.Text(
limit_b - 2., 5, 'Q = %.0f pC' % charge)
def _make_area_static(self):
"""Создаем диаграммы с выбором диапазона дат"""
for dim in self._ddims:
df = self._get_count(dim)
diagram = hv.Area(df, kdims=[dim], vdims=['count'])
selector = (hv.streams.BoundsX(source=diagram).rename(boundsx=dim))
self._diagrams[dim] = _Plot(selector, diagram)
def select_series(boundsy):
test = df.columns.values[0] == boundsy[0]
def plot_series(df, i):
data = {"x": df.index.values, "y": df.iloc[:, i].values}
return hv.Area(data) #* hv.Curve(data).opts(tools=["hover"])
low, high = boundsy
low, high = int(np.floor(low)), int(np.ceil(high))
overlay = hv.NdOverlay({
df.columns[i]: hv.Area(df.iloc[:, i].values)
#* hv.Curve(df.iloc[:, i].values).opts(tools=["hover"]))
for i in range(low, high)
}).opts(legend_position='left', fontsize={'legend': '6pt'})
ticks = list(
zip(range(len(df.index)),
[pd.to_datetime(x).strftime("%Y-%m-%d") for x in df.index]))
return hv.Area.stack(
overlay.opts(
xticks=ticks[::len(df.index) // 15],
ylim=(
0, None
), #df.iloc[:, list(range(low,high))].values.max()*1.05),
xlabel="Date",
ylabel="Commits",
xrotation=45))
def integral(limit_a, limit_b, y, time):
limit_a = -3 if limit_a is None else np.clip(limit_a, -3, 3)
limit_b = 3 if limit_b is None else np.clip(limit_b, -3, 3)
curve = hv.Curve((xs, function(xs, time)))
area = hv.Area((xs, function(xs, time)))[limit_a:limit_b]
summed = area.dimension_values('y').sum() * 0.015 # Numeric approximation
return (area * curve * hv.VLine(limit_a) * hv.VLine(limit_b) *
hv.Text(limit_b - 0.8, 2.0, '%.2f' % summed))
def regression(df: DataFrame,
x_val: str,
y_val: str,
vdims: List[str] = None,
ci: int = 95,
title: str = None) -> hv.NdOverlay:
"""
Seaborn's regplot implemented in Holoviews
Args:
df: Input dataframe
x_val: Column name for x-variable
y_val: Column name for y-variable
vdims: Additional vdims to include that will display using the hover tool (optional)
ci: Confidence interval to calculate for regression [0, 100]
title: Title for plot (optional)
Returns:
Combined plot of scatter points, regression line, and CI interval
"""
# Define grid for x-axis
xmin, xmax = df[x_val].min(), df[x_val].max()
grid = np.linspace(xmin, xmax)
# Seaborn Fit and CI via Bootstrapping
yhat, yhat_boots = _fit_fast(grid, df[x_val], df[y_val])
ci = sns.utils.ci(yhat_boots, which=ci, axis=0)
# Define plot Elements
vdims = [y_val] + vdims if vdims else [y_val]
scatter = hv.Scatter(data=df, kdims=[x_val],
vdims=vdims).options(tools=['hover'],
width=700,
height=300,
color='blue',
size=5,
alpha=0.50)
regline = hv.Curve((grid, yhat)).options(color='red')
lower = hv.Area((grid, yhat, ci[0]), vdims=['y',
'y2']).options(color='red',
alpha=0.15)
upper = hv.Area((grid, yhat, ci[1]), vdims=['y',
'y2']).options(color='red',
alpha=0.15)
return (scatter * regline * lower * upper).relabel(title)
def beta_plots(
wins: Iterable,
losses: Iterable,
labels: Iterable,
legend_position='right',
alpha=.5,
normed=False,
xlabel=None,
ylabel=None):
"""
Make beta plots for win/loss type scenarios. The wins/losses are provided in arrays.
Each element of the array corresponds to a specific win/loss scenario you want plotted.
So, to just determine the beta distirbution of a single scenario, these should be
one-element arrays.
Args:
wins: the number of "wins"
losses: the number of "losses"
labels: The label for each scenario
legend_postion: Where to put the legend
alpha: the opacity of the area plots
xlabel: The x label [default "Win Perdentage"]
ylabel: The y label [default, "Density"]
"""
from scipy.stats import beta
import numpy as np
import holoviews as hv
if xlabel is None:
xlabel = 'Win Percentage'
if ylabel is None:
ylabel = 'Density'
c_list = []
x = np.linspace(0, 1, 500)
xpoints = []
ypoints = []
for (won, lost, label) in zip(wins, losses, labels):
dist = beta(won + 1, lost + 1)
y = dist.pdf(x)
if normed:
y_max = np.max(y)
else:
y_max = 1.
y = y / y_max
win_frac = won / (won + lost + 1e-12)
xpoints.append(win_frac * 100)
ypoints.append(dist.pdf(win_frac) / y_max)
c = hv.Area((100 * x, y), xlabel, ylabel, label=label).options(alpha=alpha)
c_list.append(c)
c1 = hv.Overlay(c_list).options(legend_position='right')
c2 = hv.Scatter((xpoints, ypoints), xlabel, ylabel).options(color='black', size=8, tools=['hover'])
return (c1 * c2).options(legend_position=legend_position)
def test_template_can_use_non_panels():
header = "[Header Link](https://panel.holoviz.org)"
sidebar = "[Menu Item](https://panel.holoviz.org)<br/>" * 5
xs = np.linspace(0, np.pi * 4, 40)
main = hv.Area((xs, np.sin(xs)))
template = VanillaTemplate(title="My App")
template.header.append(header)
template.sidebar.append(sidebar)
template.main.append(main)
template.show()
def isotonic(df, predict, target, calibrations_data=None):
"""Визуализация точности прогноза вероятности
**Аргументы**
df : pandas.DataFrame
таблица с данными
predict : str
прогнозная вероятность
target : str
бинарная (0, 1) целевая переменная
calibrations_data : pandas.DataFrame
таблица с калибровками
**Результат**
area * curve * [curve] : holoviews.Overlay
"""
df_agg = _aggregate_data_for_isitonic(df, predict, target)
confident_intervals = hv.Area(df_agg,
kdims=['predict'],
vdims=['ci_l', 'ci_h'],
group='Confident Intervals')
curve = hv.Curve(df_agg,
kdims=['predict'],
vdims=['isotonic'],
group='Isotonic')
if calibrations_data is not None and target in calibrations_data.columns:
calibration = hv.Curve(data=calibrations_data[['predict',
target]].values,
kdims=['predict'],
vdims=['target'],
group='Calibration',
label='calibration')
return hv.Overlay(items=[curve, confident_intervals, calibration],
group='Isotonic',
label=predict)
return hv.Overlay(items=[curve, confident_intervals],
group='Isotonic',
label=predict)
def xarray_to_interactive_dispatch_plot(results, tune, producer, time):
"""
Creates a tunable dispatch plot from an xarray.
Parameters
----------
results :
tune_dims
producer
time
Returns
-------
dispatch_hmap : HoloMap
"""
tune_coords = {k: results.coords[k].data for k in tune}
tune_sample = it.product(*tune_coords.values())
producer_coord = results.coords[producer]
time_coord = results.coords[time]
dispatch_hmap = hv.HoloMap({t:
hv.Area.stack(
hv.Overlay([hv.Area(results.loc[dict(zip(tune_coords.keys(), t))].loc[{producer: s}])
for s in producer_coord]
))
for t in tune_sample},
kdims=list(tune_coords.keys()))\
.options(width=500, height=200)
## https://github.com/ioam/holoviews/issues/1819
renderer = hv.renderer('bokeh')
# Using renderer save
renderer.save(dispatch_hmap, 'example_sampling_and_plotting')
def create_interactive_plot(data_dispatch, data_bars):
"""
"""
dispatch_hmap = hv.HoloMap(
{(i, k): hv.Area.stack(
hv.Overlay(
[hv.Area(data_dispatch[k, i, :, j]) for j in range(n_stack)]))
for i in range(n_i) for k in range(n_k)},
kdims=['price pv', 'price wind'])
bar_hmap = hv.HoloMap(
{(i, k): hv.Bars(data_bars, hv.Dimension('Technology'),
'Installed capacity')
for i in range(n_i) for k in range(n_k)},
kdims=['price pv', 'price wind'])
layout = hv.Layout(dispatch_hmap + bar_hmap).cols(1)
## https://github.com/ioam/holoviews/issues/1819
renderer = hv.renderer('bokeh')
# Using renderer save
renderer.save(dispatch_hmap + bar_hmap, 'interactive_modeling')
def wiggle_plot(self, gather, time_slice, wiggle_buttons):
"""
NAME
----
wiggle_plot.
DESCRIPTION
-----------
Plots the amplitudes of a single angle gather.
The plot will vary according to the following parameters:
- time_slice will set the time window for the plot.
- wiggle_button value will modify the way the amplitudes are displayed. More
details in wiggle_buttons argument.
ARGUMENTS
---------
gather : (Numpy)ndarray
Amplitude array given by Segyio's gather method. Can be given manually.
time_slice : list
Time slice of interest. Can be given manually or by Panel's range slider widget.
wiggle_buttons : str
Desired amplitude's plot type. Can be given manually or by Panel's radio button
widget. "Wavelet" will plot amplitudes using only a sine curve, "Black wiggle"
will fill with black the area between the sin curve and time_axis and "Colored
wiggle", will fill with blue/red the positive/negative area between the sin curve
and time_axis.
WiggleMethod.interpolation : bool
Whether the amplitudes will be interpolated to improve wiggle display or not.
False by default.
RETURN
------
wiggle_display : Holviews element [Overlay]
Compilation of traces within the angle gather.
"""
amp_df = WiggleModule.amp_dataframe(self, gather, time_slice,
wiggle_buttons)
# Initializing the plot
wiggle_display = hv.Curve((0, 0))
# Computing scale factor for the X axis
WiggleModule.plot_xticks = [
(angle_position * self.scaling_fac,
Survey.angle_list[angle_position])
for angle_position in range(len(Survey.angle_list))
]
# making the data to plot according a scaled value
for trace in range(gather.shape[0]):
# Hover designation
hover_w = HoverTool(
tooltips=[('Time', '@time_axis'),
('Amplitude',
f"@amplitude_{Survey.angle_list[trace]}"
), ("Angle", f"{Survey.angle_list[trace]}")])
# Plotting the wiggle
wiggle = hv.Curve(
amp_df,
["time_axis", f"s_amplitude_{Survey.angle_list[trace]}"],
[f"amplitude_{Survey.angle_list[trace]}"],
label="W")
wiggle.opts(color="black", line_width=2, tools=[hover_w])
if wiggle_buttons != "Wavelet":
if wiggle_buttons == "Black wiggle":
WiggleModule.positive_amp, WiggleModule.negative_amp = "black", "black"
else:
WiggleModule.positive_amp, WiggleModule.negative_amp = "blue", "red"
# Making the area plot more comfortable
x = amp_df["time_axis"]
y = self.scaling_fac * trace
y2 = amp_df[f"s_negative_amplitude_{Survey.angle_list[trace]}"]
y3 = amp_df[f"s_positive_amplitude_{Survey.angle_list[trace]}"]
# Fill in between: Holoviews Element
negative = hv.Area((x, y, y2), vdims=['y', 'y2'],
label="-").opts(color=self.negative_amp,
line_width=0)
positive = hv.Area((x, y, y3), vdims=['y', 'y3'],
label="+").opts(color=self.positive_amp,
line_width=0)
# Overlying the colored areas + the zero phase wavelet
wiggle_display *= wiggle * negative * positive
else:
wiggle_display *= wiggle
# Adding final customizations
wiggle_display.opts(xaxis="top",
invert_axes=True,
invert_yaxis=True,
xlabel="Time [ms]",
ylabel=" ",
xticks=self.plot_xticks,
xlim=(time_slice[0], time_slice[-1]))
return (wiggle_display)
def get_individual_plot(current_file):
ds = open_files[current_file]
# get reference flowline for true values
rgi_id = ds.attrs['rgi_id']
# rgi_id = translate_name_rgi[glacier_select.value]
for gdir in gdirs:
if gdir.rgi_id == rgi_id:
fl_ref = gdir.read_pickle('model_flowlines',
filesuffix='_combine_true_init')[0]
# now calculate data for delta bed_h and w0_m
data_bed_h = []
d_bed_h_lim = 0
data_w0_m = []
d_w0_m_lim = 0
for i, fl in enumerate(ds.flowlines.values):
x_all = ds.coords['x'][ds.ice_mask].values
# bed_h
d_bed_h = (fl.bed_h - fl_ref.bed_h)[ds.ice_mask]
d_bed_h_lim = np.max([d_bed_h_lim, np.max(np.abs(d_bed_h))])
for el in [(x, i, v) for x, v in zip(x_all, d_bed_h)]:
data_bed_h.append(el)
# w0_m
d_w0_m = (fl._w0_m - fl_ref._w0_m)[ds.ice_mask]
d_w0_m_lim = np.max([d_w0_m_lim, np.max(np.abs(d_w0_m))])
for el in [(x, i, v) for x, v in zip(x_all, d_w0_m)]:
data_w0_m.append(el)
def get_heatmap(data,
lim,
title,
kdim='x',
vdim='Iteration',
height=200):
return hv.HeatMap(data, kdims=[kdim, vdim]).opts(
opts.HeatMap(tools=['hover'],
colorbar=True,
width=350,
height=height,
invert_yaxis=True,
ylabel='Iteration',
title=title,
clim=(-lim, lim),
cmap='RdBu'))
# plots for delta bed_h and w0_m
delta_bed_h_plot = get_heatmap(data_bed_h,
d_bed_h_lim,
'Delta bed_h',
kdim='ice_mask_x',
height=200)
delta_w0_m_plot = get_heatmap(data_w0_m,
d_w0_m_lim,
'Delta w0_m',
kdim='ice_mask_x',
height=200)
parameter_indices = ds.attrs['parameter_indices']
# plot for height shift spinup if there
if 'height_shift_spinup' in parameter_indices.keys():
height_shift_data = []
for i, unknown_p in enumerate(ds.unknown_parameters.values):
height_shift_data.append(
(i, unknown_p[parameter_indices['height_shift_spinup']]))
height_shift_spinup_plot = hv.Curve(
height_shift_data,
kdims='Iterations',
vdims='shift (m)',
).opts(
opts.Curve(title='spinup height shift',
tools=['hover'],
height=200))
else:
height_shift_spinup_plot = None
# get gradients
data_grad_bed_h = None
data_grad_area_bed_h = None
data_grad_w0_m = None
data_grad_surface_h = None
data_grad_height_shift_spinup = None
if 'bed_h' in parameter_indices.keys():
data_grad_bed_h = []
grad_bed_h_lim = 0
if 'area_bed_h' in parameter_indices.keys():
data_grad_area_bed_h = []
grad_area_bed_h_lim = 0
if 'w0_m' in parameter_indices.keys():
data_grad_w0_m = []
grad_w0_m_lim = 0
if 'surface_h' in parameter_indices.keys():
data_grad_surface_h = []
grad_surface_h_lim = 0
if 'height_shift_spinup' in parameter_indices.keys():
data_grad_height_shift_spinup = []
for i, grad in enumerate(ds.grads.values):
x_ice_mask = ds.coords['x'][ds.ice_mask].values
x_all = ds.coords['x'].values
# bed_h
if 'bed_h' in parameter_indices.keys():
grad_bed_h = grad[parameter_indices['bed_h']]
grad_bed_h_lim = np.max(
[grad_bed_h_lim,
np.max(np.abs(grad_bed_h))])
for el in [(x, i, v) for x, v in zip(x_ice_mask, grad_bed_h)]:
data_grad_bed_h.append(el)
if 'area_bed_h' in parameter_indices.keys():
grad_area_bed_h = grad[parameter_indices['area_bed_h']]
grad_area_bed_h_lim = np.max(
[grad_area_bed_h_lim,
np.max(np.abs(grad_area_bed_h))])
for el in [(x, i, v)
for x, v in zip(x_ice_mask, grad_area_bed_h)]:
data_grad_area_bed_h.append(el)
if 'w0_m' in parameter_indices.keys():
grad_w0_m = grad[parameter_indices['w0_m']]
grad_w0_m_lim = np.max(
[grad_w0_m_lim, np.max(np.abs(grad_w0_m))])
for el in [(x, i, v) for x, v in zip(x_ice_mask, grad_w0_m)]:
data_grad_w0_m.append(el)
if 'surface_h' in parameter_indices.keys():
grad_surface_h = grad[parameter_indices['surface_h']]
grad_surface_h_lim = np.max(
[grad_surface_h_lim,
np.max(np.abs(grad_surface_h))])
for el in [(x, i, v) for x, v in zip(x_all, grad_surface_h)]:
data_grad_surface_h.append(el)
if 'height_shift_spinup' in parameter_indices.keys():
data_grad_height_shift_spinup.append(
(i, grad[parameter_indices['height_shift_spinup']]))
grad_plots = None
if 'bed_h' in parameter_indices.keys():
grad_plots = pn.Column(get_heatmap(data_grad_bed_h,
grad_bed_h_lim,
'Grad bed_h',
kdim='ice_mask_x',
height=200),
sizing_mode='stretch_width')
elif 'area_bed_h' in parameter_indices.keys():
grad_plots = pn.Column(get_heatmap(data_grad_area_bed_h,
grad_area_bed_h_lim,
'Grad area_bed_h',
kdim='ice_mask_x',
height=200),
sizing_mode='stretch_width')
if 'w0_m' in parameter_indices.keys():
grad_plots.append(
get_heatmap(data_grad_w0_m,
grad_w0_m_lim,
'Grad w0_m',
kdim='ice_mask_x',
height=200))
if 'surface_h' in parameter_indices.keys():
grad_plots.append(
get_heatmap(data_grad_surface_h,
grad_surface_h_lim,
'Grad surface_h',
kdim='total_distance_x',
height=200))
if 'height_shift_spinup' in parameter_indices.keys():
grad_plots.append(
hv.Curve(
data_grad_height_shift_spinup,
kdims='Iterations',
vdims='gradient',
).opts(
opts.Curve(title='spinup height shift gradient',
tools=['hover'],
height=200)))
# convert c_terms
c_terms_conv = {}
hover_height = 0
for term in ds.c_terms_description.values:
# term = ds.c_terms_description.values[0]
for var in term.keys():
var_use = var.replace(':', '_')
var_use = var_use.replace('-', '')
if type(term[var]) == dict:
yr = list(term[var].keys())[0]
yr_use = yr.replace('-', '_')
if var_use + '_' + yr_use not in c_terms_conv.keys():
c_terms_conv[var_use + '_' + yr_use] = []
c_terms_conv[var_use + '_' + yr_use].append(term[var][yr])
hover_height = np.max(
[hover_height, np.max(term[var][yr])])
else:
if var_use not in c_terms_conv.keys():
c_terms_conv[var_use] = []
c_terms_conv[var_use].append(term[var])
hover_height = np.max([hover_height, np.max(term[var])])
c_term_area = []
for one_c_term in c_terms_conv.keys():
c_term_area.append(
hv.Area(
(ds.coords['iteration'].values, c_terms_conv[one_c_term]),
kdims='Iterations',
vdims='c_terms',
label=one_c_term))
overlay_c_terms = hv.Overlay(c_term_area)
stack_c_terms = hv.Area.stack(overlay_c_terms)
df_c_terms = pd.DataFrame(c_terms_conv)
df_c_terms['Iteration'] = ds.coords['iteration'].values
df_c_terms['hover_height'] = np.repeat(
hover_height / 2, len(ds.coords['iteration'].values))
tooltips_c_terms = [('Iteration', '@{Iteration}')]
tooltips_c_terms += [(key, '@{' + key + '}{%0.4f}')
for key in c_terms_conv.keys()]
hover_c_terms = HoverTool(tooltips=tooltips_c_terms,
formatters=dict([
('@{' + key + '}', 'printf')
for key in c_terms_conv.keys()
]),
mode='vline')
vdims_curve_c_terms = ['hover_height']
for key in c_terms_conv.keys():
vdims_curve_c_terms.append(key)
curve_c_terms = hv.Curve(df_c_terms,
kdims='Iteration',
vdims=vdims_curve_c_terms).opts(
tools=[hover_c_terms], line_alpha=0)
c_terms_plot = (stack_c_terms * curve_c_terms).opts(
width=500, height=200, legend_position='left', title='Cost Terms')
# calculate differences of surface height at start, rgi and end
for gdir in gdirs:
if gdir.rgi_id == rgi_id:
fl_ref_rgi = gdir.read_pickle(
'model_flowlines', filesuffix='_combine_true_init')[0]
fl_ref_start = gdir.read_pickle('model_flowlines',
filesuffix='_spinup')[0]
fl_ref_end = gdir.read_pickle(
'model_flowlines', filesuffix='_combine_true_end')[0]
def get_performance_sfc_h_array(fct, data, ref_val):
return [np.around(fct(val, ref_val), decimals=2) for val in data]
def get_sfc_h_table(data, ref_val, title):
df = pd.DataFrame({
'RMSE':
get_performance_sfc_h_array(RMSE, data, ref_val),
'BIAS':
get_performance_sfc_h_array(BIAS, data, ref_val),
'DIFF':
get_performance_sfc_h_array(DIFF, data, ref_val),
'AERR':
get_performance_sfc_h_array(AERR, data, ref_val),
})
return pn.Column(pn.pane.Markdown('Statistics ' + title),
pn.widgets.Tabulator(df,
titles={'index': 'I'},
height=200),
sizing_mode='stretch_width')
# sfc_h_end
d_sfc_h_end_lim = 0.
data_sfc_h_end = []
table_data_sfc_h_end = []
for i, fl in enumerate(ds.flowlines.values):
x_all = ds.coords['x'].values
d_sfc_h_end = (fl.surface_h - fl_ref_end.surface_h)
d_sfc_h_end_lim = np.max(
[d_sfc_h_end_lim, np.max(np.abs(d_sfc_h_end))])
table_data_sfc_h_end.append(fl.surface_h)
for el in [(x, i, v) for x, v in zip(x_all, d_sfc_h_end)]:
data_sfc_h_end.append(el)
delta_sfc_h_end_plot = get_heatmap(data_sfc_h_end,
d_sfc_h_end_lim,
'Delta sfc_h_end',
kdim='total_distance_x',
height=150)
delta_sfc_h_end_table = get_sfc_h_table(table_data_sfc_h_end,
fl_ref_end.surface_h,
'sfc_h_end')
# sfc_h_rgi
if 'fl_surface_h:m' in ds.observations_mdl.values[0].keys():
d_sfc_h_rgi_lim = 0.
data_sfc_h_rgi = []
table_data_sfc_h_rgi = []
for i, obs in enumerate(ds.observations_mdl.values):
x_all = ds.coords['x'].values
d_sfc_h_rgi = (list(obs['fl_surface_h:m'].values())[0] -
fl_ref_rgi.surface_h)
d_sfc_h_rgi_lim = np.max(
[d_sfc_h_rgi_lim,
np.max(np.abs(d_sfc_h_rgi))])
table_data_sfc_h_rgi.append(
list(obs['fl_surface_h:m'].values())[0])
for el in [(x, i, v) for x, v in zip(x_all, d_sfc_h_rgi)]:
data_sfc_h_rgi.append(el)
delta_sfc_h_rgi_plot = get_heatmap(data_sfc_h_rgi,
d_sfc_h_rgi_lim,
'Delta sfc_h_rgi',
kdim='total_distance_x',
height=150)
delta_sfc_h_rgi_table = get_sfc_h_table(table_data_sfc_h_rgi,
fl_ref_rgi.surface_h,
'sfc_h_rgi')
else:
delta_sfc_h_rgi_plot = None
delta_sfc_h_rgi_table = None
# sfc_h_start
d_sfc_h_start_lim = 0.
data_sfc_h_start = []
table_data_sfc_h_start = []
for i, tmp_sfc_h in enumerate(ds.sfc_h_start.values):
x_all = ds.coords['x'].values
d_sfc_h_start = (tmp_sfc_h - fl_ref_start.surface_h)
d_sfc_h_start_lim = np.max(
[d_sfc_h_start_lim,
np.max(np.abs(d_sfc_h_start))])
table_data_sfc_h_start.append(tmp_sfc_h)
for el in [(x, i, v) for x, v in zip(x_all, d_sfc_h_start)]:
data_sfc_h_start.append(el)
delta_sfc_h_start_plot = get_heatmap(data_sfc_h_start,
d_sfc_h_start_lim,
'Delta sfc_h_start',
kdim='total_distance_x',
height=150)
delta_sfc_h_start_table = get_sfc_h_table(table_data_sfc_h_start,
fl_ref_start.surface_h,
'sfc_h_start')
# create Table with performance measures (bed_h, w0_m, sfc_h_start, sfc_h_end, sfc_h_rgi,
# fct_calls, time, device)
def get_performance_array(fct, attr):
return [
np.around(fct(val,
getattr(fl_ref, attr)[ds.ice_mask]),
decimals=2) for val in [
getattr(fl.values.item(), attr)[ds.ice_mask]
for fl in ds.flowlines
]
]
def get_performance_table(attr):
df = pd.DataFrame({
'RMSE': get_performance_array(RMSE, attr),
'BIAS': get_performance_array(BIAS, attr),
'DIFF': get_performance_array(DIFF, attr),
'AERR': get_performance_array(AERR, attr),
})
return pn.Column(pn.pane.Markdown('Statistics ' + attr),
pn.widgets.Tabulator(df,
titles={'index': 'I'},
height=200),
sizing_mode='stretch_width')
def get_minimise_performance_table():
df = pd.DataFrame({
'forward runs':
ds.fct_calls.values,
'computing time':
ds.time_needed.values,
'device':
np.repeat(ds.attrs['device'], len(ds.time_needed.values))
})
return pn.widgets.Tabulator(df)
performance_tables = \
pn.Column(get_performance_table('bed_h'),
get_performance_table('_w0_m'),
get_minimise_performance_table(),
sizing_mode='stretch_width')
# create plot for exploration of geometry
# thickness at end time
data_thick_end = []
thick_end_lim = 0.
for i, fl in enumerate(ds.flowlines.values):
x_all = ds.coords['x'].values
thick_end = fl.thick
thick_end_lim = np.max([thick_end_lim, np.max(np.abs(thick_end))])
for el in [(x, i, v) for x, v in zip(x_all, thick_end)]:
data_thick_end.append(el)
thick_end_plot = get_heatmap(data_thick_end,
thick_end_lim,
'Ice thickness at end time',
kdim='total_distance_x',
height=150)
thick_end_true = fl_ref_end.thick
thick_end_true_lim = np.max(np.abs(thick_end_true))
x_all = ds.coords['x'].values
data_thick_end_true = []
for el in [(x, 0, v) for x, v in zip(x_all, thick_end_true)]:
data_thick_end_true.append(el)
thick_end_true_plot = get_heatmap(data_thick_end_true,
thick_end_true_lim,
'Ice thickness at end time TRUE',
kdim='total_distance_x',
vdim='true',
height=100)
# surface widths
def get_width_curve(x, width, label, color, height=150):
return (hv.Curve(
(x, width / 2),
kdims='total_distance_x',
vdims='widths',
label=label,
) * hv.Curve(
(x, -width / 2),
kdims='total_distance_x',
vdims='widths',
label=label,
)).opts(opts.Curve(color=color, tools=['hover'], height=height))
x_all = ds.coords['x'].values
surface_widths_rgi_true_plot = get_width_curve(x_all,
fl_ref_rgi.widths_m,
'RGI', 'blue')
surface_widths_start_true_plot = get_width_curve(
x_all, fl_ref_start.widths_m, 'Start', 'red')
surface_widths_end_true_plot = get_width_curve(x_all,
fl_ref_end.widths_m,
'End', 'gray')
widths_plot = (surface_widths_start_true_plot *
surface_widths_rgi_true_plot *
surface_widths_end_true_plot).opts(
title='Surface widths',
# legend_position='right',
show_legend=False)
# Surface_h with bed_h
x_all = ds.coords['x'].values
def get_curve(x, y, label, color, height=200):
return hv.Curve((x, y),
kdims='total_distance_x',
vdims='heights',
label=label).opts(
opts.Curve(color=color,
tools=['hover'],
height=height))
surface_height_start_true_plot = get_curve(x_all,
fl_ref_start.surface_h,
'Start', 'red')
surface_height_rgi_true_plot = get_curve(x_all, fl_ref_rgi.surface_h,
'RGI', 'blue')
surface_height_end_true_plot = get_curve(x_all, fl_ref_end.surface_h,
'End', 'gray')
bed_height_true_plot = get_curve(x_all, fl_ref_rgi.bed_h, 'bed_h',
'black')
surface_height_plot = (bed_height_true_plot *
surface_height_start_true_plot *
surface_height_rgi_true_plot *
surface_height_end_true_plot).opts(
title='Surface heights',
legend_position='bottom',
legend_cols=2)
return pn.Column('## ' + current_file,
pn.Row(
pn.Column(
pn.Row(
pn.Column(delta_bed_h_plot,
delta_w0_m_plot,
height_shift_spinup_plot,
sizing_mode='stretch_width'),
grad_plots),
pn.Row(c_terms_plot,
sizing_mode='stretch_width'),
),
pn.Column(delta_sfc_h_start_plot,
delta_sfc_h_rgi_plot,
delta_sfc_h_end_plot,
delta_sfc_h_start_table,
delta_sfc_h_rgi_table,
delta_sfc_h_end_table,
sizing_mode='stretch_width'),
pn.Column(thick_end_plot,
thick_end_true_plot,
widths_plot,
surface_height_plot,
performance_tables,
sizing_mode='stretch_width'),
),
sizing_mode='stretch_width')
production = production.redim.unit(Florida="MMcf") production # ### Layout # Create a layout in holoviews is very easy. First, let's try a few other types of plots to visualise the same data. print(production) spikes = hv.Spikes(production) spikes scatter = hv.Scatter(production) scatter area = hv.Area(production) area # In holoviews, creating a layout is much easier. You just simply create a layout by adding up the plots! production + spikes + scatter + area # To make it look better we can specify the number of columns. layout = production + spikes + scatter + area layout.cols(2) print(layout) # The object `layout` has all the plots in it. This means we can easily access each plot and even create a new layout. Note the name of the elements in the layout.
def make_area(boundsy):
return hv.Area(
(xs, np.minimum(ys, boundsy[0]), np.minimum(ys, boundsy[1])),
vdims=['min', 'max'])
def plot_pozos_tipo():
dims_eur_baja = dict(kdims='mes', vdims=['EUR_baja_L','EUR_baja_H'])
env_eur_baja = hv.Area(perfil, label='EUR Baja', **dims_eur_baja)
env_eur_baja.opts(alpha=0.3,
color='red',
fontscale=1.5)
linea_eur_baja = hv.Curve(perfil.EUR_baja_M)
linea_eur_baja.opts(color='red',
line_dash='dotted')
dims_eur_media = dict(kdims='mes', vdims=['EUR_media_L','EUR_media_H'])
env_eur_media= hv.Area(perfil, label='EUR Media', **dims_eur_media)
env_eur_media.opts(alpha=0.3,
color='blue',
fontscale=1.5)
linea_eur_media = hv.Curve(perfil.EUR_media_M)
linea_eur_media.opts(color='blue',
line_dash='dotted')
dims_eur_alta = dict(kdims='mes', vdims=['EUR_alta_L','EUR_alta_H'])
env_eur_alta = hv.Area(perfil, label='EUR Alta', **dims_eur_alta)
env_eur_alta.opts(alpha=0.3,
color='green',
fontscale=1.5)
linea_eur_alta = hv.Curve(perfil.EUR_alta_M)
linea_eur_alta.opts(color='green',
line_dash='dotted')
elementos_tabla=dict(indice=resumen.index[6:13], valores=resumen[6:13])
tabla_resumen = hv.Table(elementos_tabla,'indice','valores')
tabla_resumen.opts(height=500,fontscale=20)
plot_eur = env_eur_baja * linea_eur_baja * env_eur_media * linea_eur_media * env_eur_alta * linea_eur_alta
plot_eur.opts(legend_position='top_left')
elementos_tipos = dict(tipo=pd.unique(tipos.tipo), numero=tipos.tipo.value_counts())
plot_tipos = hv.Bars(elementos_tipos,'tipo','numero')
plot_tipos.opts(color='tipo',
cmap='Set1',
fontscale=1.5)
#fill_color=factor_cmap('tipo', palette=Spectral6, factors=elementos_tipos['tipo']))
layout = plot_eur + plot_tipos + tabla_resumen
fig1 = hv.render(layout)
hv.output(layout, backend='bokeh', fig='html', size=200)
hv.save(layout, 'resumen_produccion.html')
dims_baja = dict(kdims='mes', vdims=['baja_L','baja_H'])
env_baja = hv.Area(perfil, label='Envolvente', **dims_baja)
env_baja.opts(alpha=0.3,color='red',fontscale=1.5,title='Perfil BAJA Qoi')
linea_baja = hv.Curve(perfil.baja_M,label='P50')
linea_baja.opts(color='red',line_dash='dotted')
dims_media = dict(kdims='mes', vdims=['media_L','media_H'])
env_media= hv.Area(perfil, label='Envolvente', **dims_media)
env_media.opts(alpha=0.3,color='blue',fontscale=1.5,title='Perfil MEDIA Qoi')
linea_media = hv.Curve(perfil.media_M,label='P50')
linea_media.opts(color='blue',line_dash='dotted')
dims_alta = dict(kdims='mes', vdims=['alta_L','alta_H'])
env_alta = hv.Area(perfil, label='Envolvente', **dims_alta)
env_alta.opts(alpha=0.3,color='green',fontscale=1.5,title='Perfil ALTA Qoi')
linea_alta = hv.Curve(perfil.alta_M,label='P50')
linea_alta.opts(color='green',line_dash='dotted')
plots_perfiles = env_baja * linea_baja + env_media * linea_media + env_alta * linea_alta
fig2 = hv.render(plots_perfiles)
hv.output(plots_perfiles, backend='bokeh', fig='html', size=200)
hv.save(plots_perfiles, 'curvas_tipo.html')
return
opts_curve_1 = {'Curve': dict(color=col_2, width=350, height=400)}
opts_curve_2 = {'Curve': dict(color='red', width=350, height=400)}
opts_point = {'Points': dict(color='black', marker='+', size=11)}
# create rectangle from starting point with width and height
def hv_rectangle(x=0, y=0, width=.05, height=.05):
return hv.Polygons([
np.array([(x, y), (x + width, y), (x + width, y + height),
(x, y + height)])
]).options(opts_poly)
# Create curve and integral
hv_curve = hv.Curve((x, y), 'x', 'f(x)').options(opts_curve_1)
hv_int = hv.Area((x, y), 'x', 'f(x)').options(
color=col_1) # create integral polygone from input vector x and y
hv_rectangle_0 = hv_rectangle(x=0, y=0, width=10, height=(fct((0 + 10) / 2)))
int_approx_viz_0 = (hv_rectangle_0 * hv_curve).redim.range(y=(0, 1.08))
# number of steps to approximate the integral with
n_steps = np.arange(3, 31)
# create empty list to store all integral approximations for all n_steps
hv_int_box_approx = []
approx_int = [] # value of approximated integral for all n_steps
# calculate approximation for each step
for j in range(len(n_steps)):
x_steps = np.linspace(0, 10, num=n_steps[j] + 1)
hv_int_box_approx_j = [
def get_data(region, prediction_for=1, **kwargs):
data = input_data[prediction_for -
1][input_data[prediction_for -
1].region == region].sort_values("time")
return hv.Area((data.time, data.trips), 'Time', 'Trips') * hv.Area(
(data.time, data.predictions), 'Time', 'Pred')
def _get_bokeh_chart(self,
x_field,
y_field,
chart_type,
label,
opts,
style,
options={},
**kwargs):
"""
Get a Bokeh chart object
"""
if isinstance(x_field, list):
kdims = x_field
else:
kdims = [x_field]
if isinstance(y_field, list):
vdims = y_field
else:
vdims = [y_field]
args = kwargs
args["data"] = self.df
args["kdims"] = kdims
args["vdims"] = vdims
if label is not None:
args["label"] = label
else:
if self.label is not None:
args["label"] = self.label
chart = None
try:
if chart_type == "line":
chart = hv.Curve(**args)
if chart_type == "hline":
chart = self._hline_bokeh_(y_field)
elif chart_type == "point":
chart = hv.Scatter(**args)
elif chart_type == "area":
chart = hv.Area(**args)
elif chart_type == "bar":
chart = hv.Bars(**args)
elif chart_type == "hist":
chart = hv.Histogram(**args)
elif chart_type == "errorBar":
chart = hv.ErrorBars(**args)
elif chart_type == "heatmap":
chart = hv.HeatMap(**args)
elif chart_type == "lreg":
chart = self._lreg_bokeh(**args)
elif chart_type == "sline":
window_size, y_label = options["window_size"],
options["y_label"]
chart = self._sline_bokeh(window_size, y_label)
if chart is None:
self.err("Chart type " + chart_type + " unknown",
self._get_bokeh_chart)
return
endchart = chart(plot=opts, style=style)
return endchart
except DataError as e:
msg = "Column not found in " + x_field + " and " + y_field
self.err(e, self._get_bokeh_chart, msg)
except Exception as e:
self.err(e)
def plot_series(df, i):
data = {"x": df.index.values, "y": df.iloc[:, i].values}
return hv.Area(data) #* hv.Curve(data).opts(tools=["hover"])