def jspecgram(snd, nt=1000, starttime=None, endtime=None,
nperseg=512, freqsmoothing=1, cmap='viridis', dynrange=(-90., -40.),
maxfreq=10e3):
nfft = int(nperseg*freqsmoothing)
d = sndplot.Spectrogram(snd, nt=nt, starttime=starttime, endtime=endtime,
nperseg=nperseg, nfft=nfft, cmap=cmap, dynrange=dynrange,
maxfreq=maxfreq)
button_play = widgets.Button(description='play')
button_play.on_click(d.play)
button_stop = widgets.Button(description='stop')
button_stop.on_click(d.stop_playing)
display(widgets.HBox((button_play, button_stop)))
drs = widgets.FloatRangeSlider(value=(-75, -35), min=-120, max=0, step=1, description='dynamic range (dB)')
drs.observe(lambda change: d.set_clim(change['new']), names='value')
display(drs)
freqs = widgets.FloatRangeSlider(value=(0, 10), min=0, max=snd.fs/2e3, step=0.1,
description='frequency range (kHz)')
freqs.observe(lambda change: d.set_freqrange(change['new']), names='value')
display(freqs)
npersegw = widgets.IntText(value=nperseg, min=1, max=4096 * 2,
description='nperseg')
npersegw.observe(lambda change: d.set_nperseg(change['new']),
names='value')
display(npersegw)
return d
def range_slider(self,
callback_method,
_analyser,
variable="",
description="",
range=(0, 0),
max=500,
step=1,
readout_format='d'):
_analyser.data[variable] = range
range_slider = widgets.FloatRangeSlider(
value=range,
min=0,
max=max,
step=step,
description=description,
disabled=False,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format=readout_format,
layout=widgets.Layout(width='{}px'.format(self.slider_width),
grid_area=variable))
range_slider.style.description_width = '{}px'.format(self.desc_width)
range_slider.observe(callback_method, ['value'])
return range_slider
def float_range_controller(tmin, tmax, start_value=None):
if start_value is None:
start_value = [tmin, min(tmin + 50, tmax)]
slider = widgets.FloatRangeSlider(
value=start_value,
min=tmin,
max=tmax,
step=0.1,
description='time window',
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.1f',
layout=Layout(width='90%'))
forward_button = widgets.Button(description='▶', layout=Layout(width='50px'))
forward_button.on_click(lambda b: move_range_slider_up(slider))
backwards_button = widgets.Button(description='◀', layout=Layout(width='50px'))
backwards_button.on_click(lambda b: move_range_slider_down(slider))
button_box = widgets.HBox(children=[backwards_button, forward_button])
button_box.layout.align_items = 'center'
controller = widgets.VBox(
layout=Layout(width='250px'),
children=[slider, button_box])
return controller
def make_range_slider(self, **kwargs):
"""
Parameters
----------
kwargs: passed into RangeSlider constructor
Returns
-------
"""
slider_kwargs = dict(value=self.start_value,
min=self.vmin,
max=self.vmax,
continuous_update=False,
readout=True,
style={'description_width': 'initial'},
orientation=self.orientation)
if self.dtype == 'float':
slider_kwargs.update(readout_format='.1f',
step=0.1,
description='time window (s)',
layout=Layout(width='100%'))
slider_kwargs.update(kwargs)
return widgets.FloatRangeSlider(**slider_kwargs)
elif self.dtype == 'int':
slider_kwargs.update(description='unit window',
layout=Layout(height='100%'))
slider_kwargs.update(kwargs)
return widgets.IntRangeSlider(**slider_kwargs)
else:
raise ValueError('Unrecognized dtype: {}'.format(self.dtype))
def _build_strat_form(self):
label_width = '20rem'
control_width = '35rem'
ap_label = widgets.Label('Aperture radius:')
ap_label.layout.width = label_width
self.ap_size = widgets.FloatSlider(
value=0.1,
min=self.APERTURE_MIN,
max=self.APERTURE_MAX,
step=self.APERTURE_INCREMENT,
)
self.ap_size.layout.width = control_width
self.ap_size.observe(self.check_ann, names='value')
self.overplot = widgets.Checkbox(description="Overlay apertures?", value=True)
self.overplot.observe(self._trigger_update_plots, names='value')
extraction_aperture = widgets.HBox([
ap_label,
self.ap_size,
widgets.Label('arcsec'),
])
background_annulus_label = widgets.Label("Background annulus radii:")
background_annulus_label.layout.width = label_width
self.background_annulus = widgets.FloatRangeSlider(
value=[self.ap_size.value + 0.1, self.ap_size.value + 0.2],
min=0,
max=2.0,
step=self.APERTURE_INCREMENT,
)
self.background_annulus.layout.width = control_width
self.background_annulus.observe(self.check_ann, 'value')
background_estimation = widgets.HBox([
background_annulus_label,
self.background_annulus,
widgets.Label("arcsec"),
])
background_estimation.layout.width = '100%'
return widgets.VBox([
extraction_aperture,
background_estimation,
self.overplot
])
def create_qubit_params_widgets(self):
"""Creates all the widgets that will be used
for changing the parameter values for the specified qubit.
"""
# We need to clear qubit_params_widgets since the previous widgets from the
# old qubit will still be initialized otherwise.
self.qubit_params_widgets.clear()
for param_name, param_val in self.qubit_base_params.items():
if param_name == "grid":
grid_min = self.qubit_current_params["grid"].min_val
grid_max = self.qubit_current_params["grid"].max_val
self.qubit_params_widgets[param_name] = widgets.FloatRangeSlider(
min=-12 * np.pi,
max=12 * np.pi,
value=[grid_min, grid_max],
step=0.05,
description="Grid range",
continuous_update=False,
layout=Layout(width="300px"),
)
elif isinstance(param_val, int):
kwargs = (
self.active_defaults.get(param_name) or self.active_defaults["int"]
)
self.qubit_params_widgets[param_name] = widgets.IntSlider(
**kwargs,
value=param_val,
description="{}:".format(param_name),
continuous_update=False,
layout=Layout(width="300px")
)
else:
kwargs = (
self.active_defaults.get(param_name)
or self.active_defaults["float"]
)
self.qubit_params_widgets[param_name] = widgets.FloatSlider(
**kwargs,
value=param_val,
step=0.01,
description="{}:".format(param_name),
continuous_update=False,
layout=Layout(width="300px")
)
def __init__(self,
on_interact=None,
output=None,
overwrite_previous_output=True,
feedback=False,
run=True,
action_kws={},
*args,
**kwargs):
super().__init__(on_interact=on_interact,
output=output,
overwrite_previous_output=overwrite_previous_output,
feedback=feedback,
action_kws=action_kws)
self.widget = widgets.FloatRangeSlider(*args, **kwargs)
if run:
self.run()
def make_range_slider(self, **kwargs):
"""
Parameters
----------
kwargs: passed into RangeSlider constructor
Returns
-------
"""
slider_kwargs = dict(
value=self.start_value,
min=self.vmin,
max=self.vmax,
continuous_update=False,
readout=True,
style={"description_width": "initial"},
orientation=self.orientation,
)
if self.dtype == "float":
slider_kwargs.update(
readout_format=".1f",
step=0.1,
description="time window (s)",
layout=Layout(width="100%"),
)
slider_kwargs.update(kwargs)
return widgets.FloatRangeSlider(**slider_kwargs)
elif self.dtype == "int":
slider_kwargs.update(description="unit window",
layout=Layout(height="100%"))
slider_kwargs.update(kwargs)
return widgets.IntRangeSlider(**slider_kwargs)
else:
raise ValueError("Unrecognized dtype: {}".format(self.dtype))
def __init__(self, img_stack):
self.img_stack = img_stack
self.fig, self.axes = plt.subplots()
self.img_mpl = self.axes.imshow(self.img_stack[0])
self.idx = 0
vbox = widgets.VBox()
frame_slider = widgets.IntSlider(value=0,
min=0,
max=len(img_stack),
step=1,
disabled=False,
continuous_update=True,
orientation='horizontal',
readout=True,
readout_format='d')
frame_slider.observe(self.update, names='value')
vmin = self.img_stack[0].min()
vmax = self.img_stack[0].max()
self.vrange_slider = widgets.FloatRangeSlider(
value=[vmin, vmax],
min=vmin,
max=vmax,
step=(vmax - vmin) / 1000,
disabled=False,
continuous_update=True,
orientation='horizontal',
readout=True,
readout_format='.1f',
)
self.vrange_slider.observe(self.v_update, names='value')
vbox.children = [frame_slider, self.vrange_slider]
display(vbox)
def RandomWave():
""" Main function called by notebook
"""
noWaves_sldr = widgets.IntSlider(value=10,
min=2,
max=20,
step=1,
description='No. Waves',
continuous_update=False)
seed_Text = widgets.IntText(123, description='Seed')
filter_sldr = widgets.FloatRangeSlider(value=[minf, minf],
min=minf,
max=maxf,
description="Filter Range",
continuous_update=False)
return widgets.VBox([
widgets.HBox([noWaves_sldr, filter_sldr, seed_Text]),
widgets.interactive_output(runWaves, {
'noWaves': noWaves_sldr,
'seed': seed_Text,
'filterRange': filter_sldr
})
])
def _add_widgets(self):
"""Add widgets to the layout."""
# Slider for the max, vmin view
self.val_slider = widgets.FloatRangeSlider(
value=[self.vmin, self.vmax],
min=self.vmin - np.fabs(self.vmax - self.vmin),
max=self.vmax + np.fabs(self.vmax - self.vmin),
step=0.1,
description='Boost:',
disabled=False,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='d',
layout=Layout(width='70%'))
self.cmap_sel = widgets.Dropdown(options=Defaults.cmaps,
value=Defaults.cmaps[0],
description='Color Map:',
disabled=False,
layout=Layout(width='200px'))
self.cmap_sel.observe(self._set_cmap)
self.val_slider.observe(self._set_clim)
self._add_tabs()
def add_range_slider(self):
"""
Add another range slider to the list of range sliders, that, when its
value changes, updates the combined range of the current object.
"""
# a new range slider is requested, but don't show description again
slider = widgets.FloatRangeSlider(
min=self.min,
max=self.max,
step=self.step,
disabled=self.disabled,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.1f',
)
if not self.range_slider_list:
# first slider gets a description
slider.description = "MultiRangeSlider"
# when its value changes, update internal selection of combined range
slider.observe(self.update_selected_values, names='value')
self.range_slider_list.append(slider)
def _set_widgets(self):
min_v = []
max_v = []
if self._link:
n_links = 1
else:
n_links = self._num_dsets
for i in range(n_links):
try:
min_v.append(
(self.vmin[i] - np.fabs(self.vmax[i] - self.vmin[i]),
self.vmin[i]))
except TypeError:
min_v.append((0, -1))
try:
max_v.append(
(self.vmax[i] + np.fabs(self.vmax[i] - self.vmin[i]),
self.vmax[i]))
except TypeError:
max_v.append((1000, 11000))
self.val_sliders = [
widgets.FloatRangeSlider(value=[min_v[i][-1], max_v[i][-1]],
min=min_v[i][0],
max=max_v[i][0],
step=self.mag[i],
description='Range:',
disabled=False,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='0.4f',
layout=Layout(width='100%'))
for i in range(n_links)
]
self.cmap_sel = [
widgets.Dropdown(options=self.cmaps,
value=self.cmaps[0],
description='CMap:',
disabled=False,
layout=Layout(width='200px'))
for i in range(n_links)
]
self.t_step = widgets.BoundedFloatText(value=0,
min=0,
max=10000,
step=1,
disabled=False,
description=self.step_variable,
layout=Layout(width='200px',
height='30px'))
self.t_step.observe(self._tstep_observer, names='value')
for n in range(n_links):
self.val_sliders[n].observe(self._clim_observer, names='value')
self.cmap_sel[n].observe(self._cmap_observer, names='value')
self.val_sliders[n].num = n
self.cmap_sel[n].num = n
if n_links > 1:
self.val_sliders[n].description = 'Range #{}:'.format(n + 1)
self.cmap_sel[n].description = 'CMap #{}:'.format(n + 1)
if self._link and n > 0:
_ = widgets.jslink((self.val_sliders[0], 'value'),
(self.val_sliders[n], 'value'))
def orthoslices_3D(data, normalize=True, continuous_update=False, **kwargs):
if not isnotebook:
print('Function not suited for working outside of Jupyter notebooks!')
else:
get_ipython().magic('matplotlib notebook')
get_ipython().magic('matplotlib notebook')
e_range, x_range, y_range = data.shape
dmin = np.amin(data)
dmax = np.amax(data)
w_e = widgets.IntSlider(value=e_range // 2,
min=0,
max=e_range - 1,
step=1,
description='Energy:',
disabled=False,
continuous_update=continuous_update,
orientation='horizontal',
readout=True,
readout_format='d')
w_kx = widgets.IntSlider(value=x_range // 2,
min=0,
max=x_range - 1,
step=1,
description='kx:',
disabled=False,
continuous_update=continuous_update,
orientation='horizontal',
readout=True,
readout_format='d')
w_ky = widgets.IntSlider(value=y_range // 2,
min=0,
max=y_range - 1,
step=1,
description='ky:',
disabled=False,
continuous_update=continuous_update,
orientation='horizontal',
readout=True,
readout_format='d')
w_clim = widgets.FloatRangeSlider(value=[.1, .9],
min=0,
max=1,
step=0.001,
description='Contrast:',
disabled=False,
continuous_update=continuous_update,
orientation='horizontal',
readout=True,
readout_format='.1f')
w_cmap = widgets.Dropdown(options=cmaps,
value='terrain',
description='colormap:',
disabled=False)
w_bin = widgets.BoundedIntText(value=1,
min=1,
max=min(data.shape),
step=1,
description='resample:',
disabled=False)
w_interpolate = widgets.Checkbox(value=True,
description='Interpolate',
disabled=False)
w_grid = widgets.Checkbox(value=False, description='Grid', disabled=False)
w_trackers = widgets.Checkbox(value=True,
description='Trackers',
disabled=False)
w_trackercol = widgets.ColorPicker(concise=False,
description='tracker line color',
value='orange')
ui_pos = widgets.HBox([w_e, w_kx, w_ky])
ui_color = widgets.HBox([
widgets.VBox([w_clim, w_cmap]),
widgets.VBox([w_bin, w_interpolate, w_grid]),
widgets.VBox([w_trackers, w_trackercol]),
])
children = [ui_pos, ui_color]
tab = widgets.Tab(children=children, )
tab.set_title(0, 'data select')
tab.set_title(1, 'colormap')
figsize = kwargs.pop('figsize', (5, 5))
fig = plt.figure(figsize=figsize, **kwargs)
plt.tight_layout()
# [left, bottom, width, height]
# fig.locator_params(nbins=4)
# cbar_ax = fig.add_axes([.05,.4,.05,4], xticklabels=[], yticklabels=[])
# cbar_ax.yaxis.set_major_locator(plt.LinearLocator(5))
img_ax = fig.add_axes([.15, .4, .4, .4], xticklabels=[], yticklabels=[])
img_ax.xaxis.set_major_locator(plt.LinearLocator(5))
img_ax.yaxis.set_major_locator(plt.LinearLocator(5))
xproj_ax = fig.add_axes([.15, .1, .4, .28], xticklabels=[], yticklabels=[])
xproj_ax.set_xlabel('$k_x$')
xproj_ax.xaxis.set_major_locator(plt.LinearLocator(5))
yproj_ax = fig.add_axes([.57, .4, .28, .4], xticklabels=[], yticklabels=[])
yproj_ax.yaxis.set_label_position("right")
yproj_ax.set_ylabel('$k_y$')
yproj_ax.yaxis.set_major_locator(plt.LinearLocator(5))
for ax in [img_ax, yproj_ax, xproj_ax]: # ,cbar_ax]:
ax.tick_params(axis="both",
direction="in",
bottom=True,
top=True,
left=True,
right=True,
which='both')
clim_ = 0.01, .99
e_img = norm_img(data[data.shape[0] // 2, :, :])
y_img = norm_img(data[:, data.shape[1] // 2, :])
x_img = norm_img(data[:, :, data.shape[2] // 2].T)
e_plot = img_ax.imshow(
e_img,
cmap='terrain',
aspect='auto',
interpolation='gaussian',
clim=clim_,
) # origin='lower')
x_plot = yproj_ax.imshow(
x_img,
cmap='terrain',
aspect='auto',
interpolation='gaussian',
clim=clim_,
) # origin='lower')
y_plot = xproj_ax.imshow(
y_img,
cmap='terrain',
aspect='auto',
interpolation='gaussian',
clim=clim_,
) # origin='lower')
pe_x = img_ax.axvline(x_range / 2, c='orange')
pe_y = img_ax.axhline(y_range / 2, c='orange')
px_x = xproj_ax.axvline(x_range / 2, c='orange')
px_e = xproj_ax.axhline(e_range / 2, c='orange')
py_y = yproj_ax.axhline(y_range / 2, c='orange')
py_e = yproj_ax.axvline(e_range / 2, c='orange')
def update(e, kx, ky, clim, cmap, binning, interpolate, grid, trackers,
trackerscol):
if normalize:
e_img = norm_img(data[e, :, :][::binning, ::binning])
y_img = norm_img(data[:, ky, :][::binning, ::binning])
x_img = norm_img(data[:, :, kx][::binning, ::binning])
else:
e_img = data[e, :, :][::binning, ::binning]
y_img = data[:, ky, :][::binning, ::binning]
x_img = data[:, :, kx][::binning, ::binning]
for axis, plot, img in zip([img_ax, yproj_ax, xproj_ax],
[e_plot, x_plot, y_plot],
[e_img, x_img.T, y_img]):
plot.set_data(img)
plot.set_clim(clim)
plot.set_cmap(cmap)
axis.grid(grid)
if interpolate:
plot.set_interpolation('gaussian')
else:
plot.set_interpolation(None)
if trackers:
pe_x.set_xdata(kx)
pe_x.set_color(trackerscol)
pe_y.set_ydata(ky)
pe_y.set_color(trackerscol)
px_x.set_xdata(kx)
px_x.set_color(trackerscol)
px_e.set_ydata(e)
px_e.set_color(trackerscol)
py_y.set_ydata(ky)
py_y.set_color(trackerscol)
py_e.set_xdata(e)
py_e.set_color(trackerscol)
interactive_plot = interactive_output(
update, {
'e': w_e,
'kx': w_kx,
'ky': w_ky,
'clim': w_clim,
'cmap': w_cmap,
'binning': w_bin,
'interpolate': w_interpolate,
'grid': w_grid,
'trackers': w_trackers,
'trackerscol': w_trackercol,
})
display(interactive_plot, tab)
def orthoslices_4D(data,
axis_order=['E', 'kx', 'ky', 'kz'],
normalize=True,
continuous_update=True,
**kwargs):
if not isnotebook:
raise EnvironmentError(
'Function not suited for working outside of Jupyter notebooks!')
else:
get_ipython().magic('matplotlib notebook')
get_ipython().magic('matplotlib notebook')
assert len(
data.shape
) == 4, 'Data should be 4-dimensional, but data has {} dimensions'.format(
data.shape)
# make controls for data slicers
# slicers = []
# for shape, name in zip(data.shape, axis_order):
# slicers.append(widgets.IntSlider(value=shape // 2,
# min=0,
# max=shape - 1,
# step=1,
# description=name,
# disabled=False,
# continuous_update=False,
# orientation='horizontal',
# readout=True,
# readout_format='d'
# ))
e_range, x_range, y_range, z_range = data.shape
w_e = widgets.IntSlider(value=e_range // 2,
min=0,
max=e_range - 1,
step=1,
description='Energy:',
disabled=False,
continuous_update=continuous_update,
orientation='horizontal',
readout=True,
readout_format='d')
w_kx = widgets.IntSlider(value=x_range // 2,
min=0,
max=x_range - 1,
step=1,
description='kx:',
disabled=False,
continuous_update=continuous_update,
orientation='horizontal',
readout=True,
readout_format='d')
w_ky = widgets.IntSlider(value=y_range // 2,
min=0,
max=y_range - 1,
step=1,
description='ky:',
disabled=False,
continuous_update=continuous_update,
orientation='horizontal',
readout=True,
readout_format='d')
w_kz = widgets.IntSlider(value=z_range // 2,
min=0,
max=z_range - 1,
step=1,
description='kz:',
disabled=False,
continuous_update=continuous_update,
orientation='horizontal',
readout=True,
readout_format='d')
slicers = [w_e, w_kx, w_ky, w_kz]
ui_slicers = widgets.HBox(slicers)
# make controls for graphics appearance
w_clim = widgets.FloatRangeSlider(value=[.1, .9],
min=0,
max=1,
step=0.001,
description='Contrast:',
disabled=False,
continuous_update=True,
orientation='horizontal',
readout=True,
readout_format='.1f')
w_cmap = widgets.Dropdown(options=cmaps,
value='terrain',
description='colormap:',
disabled=False)
w_bin = widgets.BoundedIntText(value=1,
min=1,
max=min(data.shape),
step=1,
description='resample:',
disabled=False)
w_interpolate = widgets.Checkbox(value=True,
description='Interpolate',
disabled=False)
w_grid = widgets.Checkbox(value=False, description='Grid', disabled=False)
w_trackers = widgets.Checkbox(value=True,
description='Trackers',
disabled=False)
w_trackercol = widgets.ColorPicker(concise=False,
description='tracker line color',
value='orange')
ui_color = widgets.HBox([
widgets.VBox([w_clim, w_cmap]),
widgets.VBox([w_bin, w_interpolate, w_grid]),
widgets.VBox([w_trackers, w_trackercol]),
])
tab = widgets.Tab(children=[ui_slicers, ui_color], )
tab.set_title(0, 'Data slicing')
tab.set_title(1, 'Graphics')
figsize = kwargs.pop('figsize', (5, 5))
fig = plt.figure(figsize=figsize, **kwargs)
plt.tight_layout()
img_ax = fig.add_axes([.15, .4, .4, .4], xticklabels=[], yticklabels=[])
img_ax.xaxis.set_major_locator(plt.LinearLocator(5))
img_ax.yaxis.set_major_locator(plt.LinearLocator(5))
xproj_ax = fig.add_axes([.15, .1, .4, .28], xticklabels=[], yticklabels=[])
xproj_ax.set_xlabel('$k_x$')
xproj_ax.xaxis.set_major_locator(plt.LinearLocator(5))
yproj_ax = fig.add_axes([.57, .4, .28, .4], xticklabels=[], yticklabels=[])
yproj_ax.yaxis.set_label_position("right")
yproj_ax.set_ylabel('$k_y$')
yproj_ax.yaxis.set_major_locator(plt.LinearLocator(5))
for ax in [img_ax, yproj_ax, xproj_ax]: # ,cbar_ax]:
ax.tick_params(axis="both",
direction="in",
bottom=True,
top=True,
left=True,
right=True,
which='both')
clim_ = 0.01, .99
e_img = norm_img(data[data.shape[0] // 2, :, :, data.shape[3] // 2])
y_img = norm_img(data[:, data.shape[1] // 2, :, data.shape[3] // 2])
x_img = norm_img(data[:, :, data.shape[2] // 2, data.shape[3] // 2].T)
e_plot = img_ax.imshow(
e_img,
cmap='terrain',
aspect='auto',
interpolation='gaussian',
clim=clim_,
) # origin='lower')
x_plot = yproj_ax.imshow(
x_img,
cmap='terrain',
aspect='auto',
interpolation='gaussian',
clim=clim_,
) # origin='lower')
y_plot = xproj_ax.imshow(
y_img,
cmap='terrain',
aspect='auto',
interpolation='gaussian',
clim=clim_,
) # origin='lower')
pe_x = img_ax.axvline(x_range / 2, c='orange')
pe_y = img_ax.axhline(y_range / 2, c='orange')
px_x = xproj_ax.axvline(x_range / 2, c='orange')
px_e = xproj_ax.axhline(e_range / 2, c='orange')
py_y = yproj_ax.axhline(y_range / 2, c='orange')
py_e = yproj_ax.axvline(e_range / 2, c='orange')
def update(e, kx, ky, kz, clim, cmap, binning, interpolate, grid, trackers,
trackerscol):
if normalize:
e_img = norm_img(data[e, :, :, kz][::binning, ::binning])
y_img = norm_img(data[:, ky, :, kz][::binning, ::binning])
x_img = norm_img(data[:, :, kx, kz][::binning, ::binning])
else:
e_img = data[e, :, :, kz][::binning, ::binning]
y_img = data[:, ky, :, kz][::binning, ::binning]
x_img = data[:, :, kx, kz][::binning, ::binning]
for axis, plot, img in zip([img_ax, yproj_ax, xproj_ax],
[e_plot, x_plot, y_plot],
[e_img, x_img.T, y_img]):
plot.set_data(img)
plot.set_clim(clim)
plot.set_cmap(cmap)
axis.grid(grid)
if interpolate:
plot.set_interpolation('gaussian')
else:
plot.set_interpolation(None)
if trackers:
pe_x.set_xdata(kx)
pe_x.set_color(trackerscol)
pe_y.set_ydata(ky)
pe_y.set_color(trackerscol)
px_x.set_xdata(kx)
px_x.set_color(trackerscol)
px_e.set_ydata(e)
px_e.set_color(trackerscol)
py_y.set_ydata(ky)
py_y.set_color(trackerscol)
py_e.set_xdata(e)
py_e.set_color(trackerscol)
interactive_plot = interactive_output(
update, {
'e': w_e,
'kx': w_kx,
'ky': w_ky,
'kz': w_kz,
'clim': w_clim,
'cmap': w_cmap,
'binning': w_bin,
'interpolate': w_interpolate,
'grid': w_grid,
'trackers': w_trackers,
'trackerscol': w_trackercol,
})
display(interactive_plot, tab)
def make_tabulated_sandbox(num_experiments=1):
# We create many copies of the same widget objects in order to isolate our experimental areas.
num_samples = [widgets.IntSlider(value=1500, continuous_update=False,
orientation='vertical', disable=False,
min=int(5E2), max=int(2.5E4), step=500,
description='Samples $N$') for k in range(num_experiments)]
sd = [widgets.FloatSlider(value=0.25, continuous_update=False,
orientation='vertical', disable=False,
min=0.05, max=1.75, step=0.05,
description='$\sigma$') for k in range(num_experiments)]
lam_min, lam_max = 2.0, 7.0
lam_bound = [widgets.FloatRangeSlider(value=[0,1], continuous_update=False,
orientation='horizontal', disable=False,
min=lam_min, max = lam_max, step=0.5,
description='$\Lambda \in$') for k in range(num_experiments)]
lam_0 = [widgets.FloatSlider(value=4.5, continuous_update=False,
orientation='horizontal', disable=False,
min=lam_bound[k].value[0], max=lam_bound[k].value[1], step=0.1,
description='IC: $\lambda_0$') for k in range(num_experiments)]
t_0 = [widgets.FloatSlider(value=0.5, continuous_update=False,
orientation='horizontal', disable=False,
min=0.1, max=2.0, step=0.05,
description='$t_0$ =', readout_format='.2f') for k in range(num_experiments)]
Delta_t = [widgets.FloatSlider(value=0.1, continuous_update=False,
orientation='horizontal', disable=False,
min=0.05, max=0.5, step=0.05,
description='$\Delta_t$ =', readout_format='1.2e') for k in range(num_experiments)]
num_observations = [widgets.IntSlider(value=50, continuous_update=False,
orientation='horizontal', disable=False,
min=1, max=100,
description='# Obs. =') for k in range(num_experiments)]
compare = [widgets.Checkbox(value=False, disable=False,
description='Observed v. Q(Post)') for k in range(num_experiments)]
smooth_post = [widgets.Checkbox(value=False, disable=False,
description='Smooth Posterior') for k in range(num_experiments)]
fixed_noise = [widgets.Checkbox(value=False, disable=False,
description='Fixed Noise Model') for k in range(num_experiments)]
num_trials = [widgets.IntSlider(value=1, continuous_update=False,
orientation='vertical', disable=False,
min=1, max=25,
description='Num. Trials') for k in range(num_experiments)]
# IF YOU ADD MORE FUNCTIONS to cb_sandbox.py, increase max below.
fun_choice = [widgets.IntSlider(value=0, continuous_update=False,
orientation='horizontal', disable=False,
min=0, max=2,
description='Fun. Choice') for k in range(num_experiments)]
fixed_obs_window = [widgets.Checkbox(value=False, disable=False,
description='Fixed Obs. Window') for k in range(num_experiments)]
Keys = [{'num_samples': num_samples[k],
'lam_bound': lam_bound[k],
'lam_0': lam_0[k],
't_0': t_0[k],
'Delta_t': Delta_t[k],
'num_observations': num_observations[k],
'sd': sd[k],
'compare': compare[k],
'smooth_post': smooth_post[k],
'fixed_noise': fixed_noise[k],
'num_trials': num_trials[k],
'fun_choice': fun_choice[k]} for k in range(num_experiments)]
# Make all the interactive outputs for each tab and store them in a vector called out. (for output)
out = [widgets.interactive_output(sandbox, Keys[k]) for k in range(num_experiments)]
### LINK WIDGETS TOGETHER (dependent variables) ###
# Different ranges for different problems
def update_lam_bound(*args):
k = tab_nest.selected_index
if fun_choice[k].value == 2: # fixed frequency
lam_bound[k].min = 0.0
lam_bound[k].max = 10.0
lam_bound[k].value = [0, 1]
lam_0[k].value = 0.5
if fun_choice[k].value == 1: # fixed initial condition
lam_bound[k].min = -1.0
lam_bound[k].max = 1.0
lam_bound[k].value = [-1, 1]
lam_0[k].value = 0
[fun_choice[k].observe(update_lam_bound, 'value') for k in range(num_experiments)]
# if you change the bounds on the parameter space, update the bounds of lambda_0
def update_lam_0(*args):
k = tab_nest.selected_index
# lam_0[k].value = np.minimum(lam_0[k].value, lam_bound[k].value[1] )
# lam_0[k].value = np.maximum(lam_0[k].value, lam_bound[k].value[0] )
lam_0[k].min = lam_bound[k].value[0]
lam_0[k].max = lam_bound[k].value[1]
[lam_bound[k].observe(update_lam_0, 'value') for k in range(num_experiments)]
current_window_size = [ num_observations[k].value*Delta_t[k].value for k in range(num_experiments)]
def lock_window_size(*args): # if you want to lock the window
k = tab_nest.selected_index
if fixed_obs_window[k].value:
current_window_size[k] = num_observations[k].value*Delta_t[k].value # record the present value for later use.
def update_num_obs(*args): # update num obs if Delta_t changes
k = tab_nest.selected_index
if fixed_obs_window[k].value:
num_observations[k].value = current_window_size[k]/Delta_t[k].value
def update_delta_t(*args): # update num obs if Delta_t changes
k = tab_nest.selected_index
if fixed_obs_window[k].value:
Delta_t[k].value = current_window_size[k]/num_observations[k].value
[fixed_obs_window[k].observe(lock_window_size, 'value') for k in range(num_experiments)]
[Delta_t[k].observe(update_num_obs, 'value') for k in range(num_experiments)]
[num_observations[k].observe(update_delta_t, 'value') for k in range(num_experiments)]
### GENERATE USER INTERFACE ###
lbl = widgets.Label("UQ Sandbox", disabled=False)
# horizontal and vertical sliders are grouped together, displayed in one horizontal box.
# This HBox lives in a collapsable accordion below which the results are displayed.
h_sliders = [widgets.VBox([lam_bound[k], lam_0[k],
t_0[k], Delta_t[k],
num_observations[k] ]) for k in range(num_experiments) ]
v_sliders = [widgets.HBox([ num_samples[k], num_trials[k],
sd[k] ]) for k in range(num_experiments) ]
options = [ widgets.VBox([widgets.Text('Model Options', disabled=True),
fixed_noise[k], fixed_obs_window[k], fun_choice[k],
widgets.Text('Plotting Options', disabled=True),
compare[k], smooth_post[k]]) for k in range(num_experiments)]
user_interface = [widgets.HBox([h_sliders[k], options[k], v_sliders[k]]) for k in range(num_experiments)]
# format the widgets layout (non-default options)
for k in range(num_experiments):
h_sliders[k].layout.justify_content = 'center'
v_sliders[k].layout.justify_content = 'center'
user_interface[k].layout.justify_content = 'center'
### MAKE TABULATED NOTEBOOK ###
# Create our pages
pages = [widgets.HBox() for k in range(num_experiments)]
# instantiate notebook with tabs (accordions) representing experiments
tab_nest = widgets.Tab()
tab_nest.children = [pages[k] for k in range(num_experiments)]
# title your notebooks
experiment_names = ['Experiment %d'%k for k in range(num_experiments)]
for k in range(num_experiments):
tab_nest.set_title(k, experiment_names[k])
# Spawn the children!!!
for k in range(num_experiments):
# content = widgets.VBox( [user_interface[k], out[k]] )
A = widgets.Accordion(children=[ user_interface[k] ])
A.set_title(0,lbl.value)
A.layout.justify_content = 'center'
content = widgets.VBox([ A, out[k] ])
content.layout.justify_content = 'center'
tab_nest.children[k].children = [content]
return tab_nest, Keys, fixed_obs_window
def create_plot_settings_widgets(self):
"""Creates all the widgets that will be used for general plotting options."""
self.qubit_plot_options_widgets = {}
std_layout = Layout(width="300px")
operator_dropdown_list = self.get_operators()
scan_dropdown_list = self.qubit_scan_params.keys()
mode_dropdown_list = [
("Re(·)", "real"),
("Im(·)", "imag"),
("|·|", "abs"),
(u"|\u00B7|\u00B2", "abs_sqr"),
]
file = open(self.active_qubit._image_filename, "rb")
image = file.read()
self.qubit_plot_options_widgets = {
"qubit_info_image_widget":
widgets.Image(value=image,
format="jpg",
layout=Layout(width="700px")),
"save_button":
widgets.Button(icon="save", layout=widgets.Layout(width="35px")),
"filename_text":
widgets.Text(
value=str(Path.cwd().joinpath("plot.pdf")),
description="",
disabled=False,
layout=Layout(width="500px"),
),
"scan_dropdown":
widgets.Dropdown(
options=scan_dropdown_list,
value=self.active_defaults["scan_param"],
description="Scan over",
disabled=False,
layout=std_layout,
),
"mode_dropdown":
widgets.Dropdown(
options=mode_dropdown_list,
description="Plot as:",
disabled=False,
layout=std_layout,
),
"operator_dropdown":
widgets.Dropdown(
options=operator_dropdown_list,
value=self.active_defaults["operator"],
description="Operator",
disabled=False,
layout=std_layout,
),
"scan_range_slider":
widgets.FloatRangeSlider(
min=self.active_defaults[
self.active_defaults["scan_param"]]["min"],
max=self.active_defaults[self.active_defaults["scan_param"]]
["max"],
value=[
self.active_defaults[self.active_defaults["scan_param"]]
["min"],
self.active_defaults[
self.active_defaults["scan_param"]]["max"],
],
step=0.05,
description="{} range".format(
self.active_defaults["scan_param"]),
continuous_update=False,
layout=std_layout,
),
"eigenvalue_state_slider":
widgets.IntSlider(
min=1,
max=10,
value=7,
description="Highest state",
continuous_update=False,
layout=std_layout,
),
"matrix_element_state_slider":
widgets.IntSlider(
min=1,
max=6,
value=4,
description="Highest state",
continuous_update=False,
layout=std_layout,
),
"wavefunction_single_state_selector":
widgets.IntSlider(
min=0,
max=10,
value=0,
description="State no.",
continuous_update=False,
layout=std_layout,
),
"wavefunction_scale_slider":
widgets.FloatSlider(
min=0.1,
max=4,
value=self.active_defaults["scale"],
description="\u03c8 ampl.",
continuous_update=False,
layout=std_layout,
),
"wavefunction_multi_state_selector":
widgets.SelectMultiple(
options=range(0, 10),
value=[0, 1, 2, 3, 4],
description="States",
disabled=False,
continuous_update=False,
layout=std_layout,
),
"show_numbers_checkbox":
widgets.Checkbox(value=False,
description="Show values",
disabled=False),
"show3d_checkbox":
widgets.Checkbox(value=True, description="Show 3D",
disabled=False),
"subtract_ground_checkbox":
widgets.Checkbox(value=False,
description="Subtract E\u2080",
disabled=False),
"manual_scale_checkbox":
widgets.Checkbox(value=False,
description="Manual Scaling",
disabled=False),
}
self.qubit_plot_options_widgets["save_button"].on_click(
self.save_button_clicked_action)
self.qubit_plot_options_widgets["scan_dropdown"].observe(
self.scan_dropdown_eventhandler, names="value")
def __init__(self, data_handler, output_dir, scale=1):
super().__init__()
assert data_handler.data_ready
self.data_handler = data_handler
self.output_dir = output_dir
if not os.path.isdir(self.output_dir):
os.makedirs(self.output_dir)
# always use batch size of 1
self.data_handler.batch_size = 1
# this is the number of 2d plots we need to draw
n_slices = self.data_handler.crop_size[0]
self.n_rows = int(np.sqrt(n_slices))
self.n_cols = n_slices // self.n_rows
if n_slices % self.n_rows > 0:
self.n_cols += 1
width = self.n_cols * scale
height = self.n_rows * scale
self.fig_ori, self.ax_ori = plt.subplots(self.n_rows,
self.n_cols,
figsize=(width, height),
squeeze=False)
self.fig_aug, self.ax_aug = plt.subplots(self.n_rows,
self.n_cols,
figsize=(width, height),
squeeze=False)
self.fig_ori.tight_layout()
self.fig_aug.tight_layout()
for axes in [self.ax_ori, self.ax_aug]:
for i in range(self.n_rows):
for j in range(self.n_cols):
axes[i, j].axis("off")
# axes[i, j].set_title(f"Slice {i*n_cols + j}")
# "do_rotation" true/false
self.do_rotation = widgets.Checkbox(value=True,
description='do_rotation',
disabled=False,
indent=False)
# p_rot_per_sample float 0.5
self.p_rot_per_sample = widgets.FloatSlider(
value=0.5,
min=0,
max=1.0,
description="p_rot_per_sample",
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.2f')
# rotation angles
self.augment_slider_rot = widgets.FloatSlider(
value=15., min=0., max=360, description="rotation angle")
# "do_elastic_deform" true/false
self.do_elastic_deform = widgets.Checkbox(
value=True,
description='do_elastic_deform',
disabled=False,
indent=False)
# p_el_per_sample float 0.5
self.p_el_per_sample = widgets.FloatSlider(
value=0.5,
min=0,
max=1.0,
description="p_el_per_sample",
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.2f')
# "deformation_scale" tuple (0, 0.25)
self.deformation_scale = widgets.FloatRangeSlider(
value=[0, 0.25],
min=0,
max=1.0,
step=0.05,
description='deformation_scale',
# disabled=False,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.2f')
# "do_scale" true/false
self.do_scale = widgets.Checkbox(value=True,
description='do_scale',
disabled=False,
indent=False)
# p_scale_per_sample float 0.5
self.p_scale_per_sample = widgets.FloatSlider(
value=0.5,
min=0,
max=1.0,
description="p_scale_per_sample",
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.2f')
# "scale" tuple (0.75, 1.25)
self.scale = widgets.FloatRangeSlider(
value=[0.75, 1.25],
min=0,
max=5.0,
step=0.1,
description='scale',
# disabled=False,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.2f')
# "do_mirror", true/false
self.do_mirror = widgets.Checkbox(value=True,
description='do_mirror',
disabled=False,
indent=False)
# "p_per_sample" float 0.15
# for gamma, gaussian noise, brightness,
self.p_per_sample = widgets.FloatSlider(value=0.15,
min=0,
max=1.0,
description="p_per_sample",
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.2f')
# "brightness_range" tuple (0.7, 1.5)
self.brightness_range = widgets.FloatRangeSlider(
value=[0.7, 1.5],
min=0,
max=5.0,
step=0.1,
description='brightness_range',
# disabled=False,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.2f')
# "gaussian_noise_variance" tuple (0, 0.05)
self.gaussian_noise_variance = widgets.FloatRangeSlider(
value=[0., 0.05],
min=0,
max=1.0,
step=0.05,
description='gaussian_noise_variance',
# disabled=False,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.2f')
# "gamma_range" tuple (0.5, 2)
self.gamma_range = widgets.FloatRangeSlider(
value=[0.5, 2.0],
min=0,
max=5.0,
step=0.1,
description='gamma_range',
# disabled=False,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.2f')
self.arg_to_widget_map = {
# rotations
"do_rotation": self.do_rotation,
"p_rot_per_sample": self.p_rot_per_sample,
"angle_x": self.augment_slider_rot,
"angle_y": self.augment_slider_rot,
"angle_z": self.augment_slider_rot,
# elastic deforms
"do_elastic_deform": self.do_elastic_deform,
"p_el_per_sample": self.p_el_per_sample,
"deformation_scale": self.deformation_scale,
# scaling
"do_scale": self.do_scale,
"p_scale_per_sample": self.p_scale_per_sample,
"scale": self.scale,
# mirroring
"do_mirror": self.do_mirror,
# all others
"p_per_sample": self.p_per_sample,
"brightness_range": self.brightness_range,
"gaussian_noise_variance": self.gaussian_noise_variance,
"gamma_range": self.gamma_range,
}
self.patient_dropdown = widgets.Dropdown(
options=self.data_handler.patient_ids, value=None)
self.patient_dropdown.observe(self._init_patient_cb, names="value")
self.apply_aug_button = widgets.Button(description="Augment",
button_style="success")
self.apply_aug_button.on_click(self._plot_augmented_batch_cb)
self.output_widget = widgets.Output(
layout={'border': '1px solid black'})
self.children = [
widgets.VBox(children=[
self.patient_dropdown,
widgets.HBox(children=[
self.fig_ori.canvas,
widgets.VBox(children=[
widgets.Label("Augmentation args"),
# rotation children
widgets.VBox(children=[
self.do_rotation,
self.p_rot_per_sample,
self.augment_slider_rot,
],
layout={'border': '1px solid black'}),
# elastic deform children
widgets.VBox(children=[
self.do_elastic_deform,
self.p_el_per_sample,
self.deformation_scale,
],
layout={'border': '1px solid black'}),
# scaling
widgets.VBox(children=[
self.do_scale,
self.p_scale_per_sample,
self.scale,
],
layout={'border': '1px solid black'}),
# mirroring
widgets.VBox(children=[
self.do_mirror,
],
layout={'border': '1px solid black'}),
# all others
widgets.VBox(children=[
self.p_per_sample, self.brightness_range,
self.gaussian_noise_variance, self.gamma_range
],
layout={'border': '1px solid black'})
]),
self.fig_aug.canvas,
]),
self.apply_aug_button,
self.output_widget
]),
]
self.generator = None
self.output_widget.clear_output()
with self.output_widget:
print(self.ax_ori.shape, self.ax_aug.shape)
def draw_workflow(self, start_end, workflow, name):
assert isinstance(workflow, Workflow)
start_s = start_end["seconds"]["start"]
last_s = start_end["seconds"]["last"]
start_t = start_end["time"]["start"]
last_t = start_end["time"]["last"]
# 1. get main stacked axis list
main_stacked_results = []
main_stacked_results.append(("BLANK", "#eeeeee", [
(0, c.from_seconds) for c in chain.from_iterable(
s.intervals for s in workflow.start_group.iter_nxtgroups())
]))
for group in workflow.sort_topologically():
_name = group.desc
color = getcolor_byint(group.intervals[0], ignore_lr=True)
main_stacked_results.append(
(_name, color, [(c.from_seconds, c.to_seconds)
for c in group.intervals]))
# 2. calc main_x_list from main_stacked_results
types, colors, main_x_list, main_ys_list =\
_generate_stackeddata(main_stacked_results)
# 3. calc and check the arguments
x_start_default = 0
y_start_default = 0
x_end_default = last_s * 1.05
y_end_default = workflow.len_reqs
def _interact(x, y, selects, color):
with self._build_fig("workflowplot", name, figsize=(30, 6)) as fig:
ax = fig.add_subplot(1, 1, 1)
ax.set_xlabel("lapse (seconds)")
ax.set_ylabel("requests")
ax.set_xlim(x[0], x[1])
ax.set_ylim(y[0], y[1])
plot_colors = colors[:]
if color:
for s in selects:
plot_colors[s] = color
ax.annotate(start_t, xy=(0, 0), xytext=(0, 0))
ax.annotate(last_t, xy=(last_s, 0), xytext=(last_s, 0))
ax.plot([0, last_s], [0, 0], 'r*')
ax.stackplot(main_x_list,
*main_ys_list,
colors=plot_colors,
edgecolor="black",
linewidth=.1)
# ax.legend((mpatches.Patch(color=color) for color in colors), types)
if self.out_path:
_interact((x_start_default, x_end_default),
(y_start_default, y_end_default), [], None)
else:
from ipywidgets import widgets, interactive_output, fixed, Layout
from IPython.display import display
layout = Layout(width="99%")
w_lapse = widgets.FloatRangeSlider(
value=[x_start_default, x_end_default],
min=x_start_default,
max=x_end_default,
step=0.0001,
description='x-lapse:',
continuous_update=False,
readout_format='.4f',
layout=layout)
w_requests = widgets.IntRangeSlider(
value=[y_start_default, y_end_default],
min=y_start_default,
max=y_end_default,
description='y-requests:',
continuous_update=False,
layout=layout)
w_range = widgets.VBox([w_lapse, w_requests])
w_color = widgets.ColorPicker(concise=True,
description='Highlight:',
value='#ff40ff',
layout=layout)
options = [types[i] for i in range(1, len(types) - 1)]
dedup = defaultdict(lambda: -1)
for i, o in enumerate(options):
dedup[o] += 1
if dedup[o]:
options[i] = ("%s (%d)" % (options[i], dedup[o]))
options = [(v, i + 1) for i, v in enumerate(options)]
w_select = widgets.SelectMultiple(options=options,
rows=min(10, len(options)),
description='Steps:',
layout=layout)
w_highlight = widgets.VBox([w_color, w_select])
w_tab = widgets.Tab()
w_tab.children = [w_range, w_highlight]
w_tab.set_title(0, "range")
w_tab.set_title(1, "highlight")
out = widgets.interactive_output(
_interact, {
'x': w_lapse,
'y': w_requests,
'selects': w_select,
'color': w_color
})
display(w_tab, out)
def slider(self,
figsize=(8, 8),
exclude_particle_records=['charge', 'mass'],
**kw):
"""
Navigate the simulation using a slider
Parameters:
-----------
figsize: tuple
Size of the figures
exclude_particle_records: list of strings
List of particle quantities that should not be displayed
in the slider (typically because they are less interesting)
kw: dict
Extra arguments to pass to matplotlib's imshow
"""
# -----------------------
# Define useful functions
# -----------------------
def refresh_field(change=None, force=False):
"""
Refresh the current field figure
Parameters :
------------
change: dictionary
Dictionary passed by the widget to a callback functions
whenever a change of a widget happens
(see docstring of ipywidgets.Widget.observe)
This is mainline a place holder ; not used in this function
force: bool
Whether to force the update
"""
# Determine whether to do the refresh
do_refresh = False
if (self.avail_fields is not None):
if force or fld_refresh_toggle.value:
do_refresh = True
# Do the refresh
if do_refresh:
plt.figure(fld_figure_button.value, figsize=figsize)
plt.clf()
# When working in inline mode, in an ipython notebook,
# clear the output (prevents the images from stacking
# in the notebook)
if 'inline' in matplotlib.get_backend():
clear_output()
if fld_use_button.value:
i_power = fld_magnitude_button.value
vmin = fld_range_button.value[0] * 10**i_power
vmax = fld_range_button.value[1] * 10**i_power
else:
vmin = None
vmax = None
self.get_field(t=self.current_t,
output=False,
plot=True,
field=fieldtype_button.value,
coord=coord_button.value,
m=convert_to_int(mode_button.value),
slicing=slicing_button.value,
theta=theta_button.value,
slicing_dir=slicing_dir_button.value,
vmin=vmin,
vmax=vmax,
cmap=fld_color_button.value)
def refresh_ptcl(change=None, force=False):
"""
Refresh the current particle figure
Parameters :
------------
change: dictionary
Dictionary passed by the widget to a callback functions
whenever a change of a widget happens
(see docstring of ipywidgets.Widget.observe)
This is mainline a place holder ; not used in this function
force: bool
Whether to force the update
"""
# Determine whether to do the refresh
do_refresh = False
if self.avail_species is not None:
if force or ptcl_refresh_toggle.value:
do_refresh = True
# Do the refresh
if do_refresh:
plt.figure(ptcl_figure_button.value, figsize=figsize)
plt.clf()
# When working in inline mode, in an ipython notebook,
# clear the output (prevents the images from stacking
# in the notebook)
if 'inline' in matplotlib.get_backend():
clear_output()
if ptcl_use_button.value:
i_power = ptcl_magnitude_button.value
vmin = ptcl_range_button.value[0] * 10**i_power
vmax = ptcl_range_button.value[1] * 10**i_power
else:
vmin = None
vmax = None
if ptcl_yaxis_button.value == 'None':
# 1D histogram
self.get_particle(t=self.current_t,
output=False,
var_list=[ptcl_xaxis_button.value],
select=ptcl_select_widget.to_dict(),
species=ptcl_species_button.value,
plot=True,
vmin=vmin,
vmax=vmax,
cmap=ptcl_color_button.value,
nbins=ptcl_bins_button.value)
else:
# 2D histogram
self.get_particle(t=self.current_t,
output=False,
var_list=[
ptcl_xaxis_button.value,
ptcl_yaxis_button.value
],
select=ptcl_select_widget.to_dict(),
species=ptcl_species_button.value,
plot=True,
vmin=vmin,
vmax=vmax,
cmap=ptcl_color_button.value,
nbins=ptcl_bins_button.value)
def refresh_field_type(change):
"""
Refresh the field type and disable the coordinates buttons
if the field is scalar.
Parameter
---------
change: dictionary
Dictionary passed by the widget to a callback functions
whenever a change of a widget happens
(see docstring of ipywidgets.Widget.observe)
"""
if self.avail_fields[change['new']] == 'scalar':
coord_button.disabled = True
elif self.avail_fields[change['new']] == 'vector':
coord_button.disabled = False
refresh_field()
def refresh_species(change=None):
"""
Refresh the particle species buttons by populating them
with the available records for the current species
Parameter
---------
change: dictionary
Dictionary passed by the widget to a callback functions
whenever a change of a widget happens
(see docstring of ipywidgets.Widget.observe)
"""
# Deactivate the particle refreshing to avoid callback
# while modifying the widgets
saved_refresh_value = ptcl_refresh_toggle.value
ptcl_refresh_toggle.value = False
# Get available records for this species
avail_records = [
q for q in self.avail_record_components[
ptcl_species_button.value]
if q not in exclude_particle_records
]
# Update the plotting buttons
ptcl_xaxis_button.options = avail_records
ptcl_yaxis_button.options = avail_records + ['None']
if ptcl_xaxis_button.value not in ptcl_xaxis_button.options:
ptcl_xaxis_button.value = avail_records[0]
if ptcl_yaxis_button.value not in ptcl_yaxis_button.options:
ptcl_yaxis_button.value = 'None'
# Update the selection widgets
for dropdown_button in ptcl_select_widget.quantity:
dropdown_button.options = avail_records
# Put back the previous value of the refreshing button
ptcl_refresh_toggle.value = saved_refresh_value
def change_t(change):
"Plot the result at the required time"
self.current_t = 1.e-15 * change['new']
refresh_field()
refresh_ptcl()
def step_fw(b):
"Plot the result one iteration further"
if self.current_i < len(self.t) - 1:
self.current_t = self.t[self.current_i + 1]
else:
self.current_t = self.t[self.current_i]
slider.value = self.current_t * 1.e15
def step_bw(b):
"Plot the result one iteration before"
if self.current_t > 0:
self.current_t = self.t[self.current_i - 1]
else:
self.current_t = self.t[self.current_i]
slider.value = self.current_t * 1.e15
# ---------------
# Define widgets
# ---------------
# Slider
slider = widgets.FloatSlider(
min=math.ceil(1.e15 * self.tmin),
max=math.ceil(1.e15 * self.tmax),
step=math.ceil(1.e15 * (self.tmax - self.tmin)) / 20.,
description="t (fs)")
slider.observe(change_t, names='value', type='change')
# Forward button
button_p = widgets.Button(description="+")
button_p.on_click(step_fw)
# Backward button
button_m = widgets.Button(description="-")
button_m.on_click(step_bw)
# Display the time widgets
container = widgets.HBox(children=[button_m, button_p, slider])
display(container)
# Field widgets
# -------------
if (self.avail_fields is not None):
# Field type
# ----------
# Field button
fieldtype_button = widgets.ToggleButtons(
description='Field:', options=sorted(self.avail_fields.keys()))
fieldtype_button.observe(refresh_field_type, 'value', 'change')
# Coord button
if self.geometry == "thetaMode":
coord_button = widgets.ToggleButtons(
description='Coord:', options=['x', 'y', 'z', 'r', 't'])
elif self.geometry in ["2dcartesian", "3dcartesian"]:
coord_button = widgets.ToggleButtons(description='Coord:',
options=['x', 'y', 'z'])
coord_button.observe(refresh_field, 'value', 'change')
# Mode and theta button (for thetaMode)
mode_button = widgets.ToggleButtons(description='Mode:',
options=self.avail_circ_modes)
mode_button.observe(refresh_field, 'value', 'change')
theta_button = widgets.FloatSlider(width=140,
value=0.,
description=r'Theta:',
min=-math.pi / 2,
max=math.pi / 2)
theta_button.observe(refresh_field, 'value', 'change')
# Slicing buttons (for 3D)
slicing_dir_button = widgets.ToggleButtons(
value=self.axis_labels[1],
options=self.axis_labels,
description='Slicing direction:')
slicing_dir_button.observe(refresh_field, 'value', 'change')
slicing_button = widgets.FloatSlider(width=150,
description='Slicing:',
min=-1.,
max=1.,
value=0.)
slicing_button.observe(refresh_field, 'value', 'change')
# Plotting options
# ----------------
# Figure number
fld_figure_button = widgets.IntText(description='Figure ',
value=0,
width=50)
# Range of values
fld_range_button = widgets.FloatRangeSlider(min=-10,
max=10,
width=220)
fld_range_button.observe(refresh_field, 'value', 'change')
# Order of magnitude
fld_magnitude_button = widgets.IntText(description='x 10^',
value=9,
width=50)
fld_magnitude_button.observe(refresh_field, 'value', 'change')
# Use button
fld_use_button = widgets.Checkbox(description=' Use this range',
value=False)
fld_use_button.observe(refresh_field, 'value', 'change')
# Colormap button
fld_color_button = widgets.Select(options=sorted(
plt.cm.datad.keys()),
height=50,
width=200,
value='jet')
fld_color_button.observe(refresh_field, 'value', 'change')
# Resfresh buttons
fld_refresh_toggle = widgets.ToggleButton(
description='Always refresh', value=True)
fld_refresh_button = widgets.Button(description='Refresh now!')
fld_refresh_button.on_click(partial(refresh_field, force=True))
# Containers
# ----------
# Field type container
if self.geometry == "thetaMode":
container_fields = widgets.VBox(width=260,
children=[
fieldtype_button,
coord_button, mode_button,
theta_button
])
elif self.geometry == "2dcartesian":
container_fields = widgets.VBox(
width=260, children=[fieldtype_button, coord_button])
elif self.geometry == "3dcartesian":
container_fields = widgets.VBox(width=260,
children=[
fieldtype_button,
coord_button,
slicing_dir_button,
slicing_button
])
# Plotting options container
container_fld_plots = widgets.VBox(width=260,
children=[
fld_figure_button,
fld_range_button,
widgets.HBox(children=[
fld_magnitude_button,
fld_use_button
],
height=50),
fld_color_button
])
# Accordion for the field widgets
accord1 = widgets.Accordion(
children=[container_fields, container_fld_plots])
accord1.set_title(0, 'Field type')
accord1.set_title(1, 'Plotting options')
# Complete field container
container_fld = widgets.VBox(
width=300,
children=[
accord1,
widgets.HBox(
children=[fld_refresh_toggle, fld_refresh_button])
])
# Particle widgets
# ----------------
if (self.avail_species is not None):
# Particle quantities
# -------------------
# Species selection
ptcl_species_button = widgets.Dropdown(width=250,
options=self.avail_species)
ptcl_species_button.observe(refresh_species, 'value', 'change')
# Get available records for this species
avail_records = [
q for q in self.avail_record_components[
ptcl_species_button.value]
if q not in exclude_particle_records
]
# Particle quantity on the x axis
ptcl_xaxis_button = widgets.ToggleButtons(options=avail_records)
ptcl_xaxis_button.observe(refresh_ptcl, 'value', 'change')
# Particle quantity on the y axis
ptcl_yaxis_button = widgets.ToggleButtons(options=avail_records +
['None'],
value='None')
ptcl_yaxis_button.observe(refresh_ptcl, 'value', 'change')
# Particle selection
# ------------------
# 3 selection rules at maximum
ptcl_select_widget = ParticleSelectWidget(3, avail_records,
refresh_ptcl)
# Plotting options
# ----------------
# Figure number
ptcl_figure_button = widgets.IntText(description='Figure ',
value=1,
width=50)
# Number of bins
ptcl_bins_button = widgets.IntText(description='nbins:',
value=100,
width=100)
ptcl_bins_button.observe(refresh_ptcl, 'value', 'change')
# Colormap button
ptcl_color_button = widgets.Select(options=sorted(
plt.cm.datad.keys()),
height=50,
width=200,
value='Blues')
ptcl_color_button.observe(refresh_ptcl, 'value', 'change')
# Range of values
ptcl_range_button = widgets.FloatRangeSlider(min=0,
max=10,
width=220,
value=(0, 5))
ptcl_range_button.observe(refresh_ptcl, 'value', 'change')
# Order of magnitude
ptcl_magnitude_button = widgets.IntText(description='x 10^',
value=9,
width=50)
ptcl_magnitude_button.observe(refresh_ptcl, 'value', 'change')
# Use button
ptcl_use_button = widgets.Checkbox(description=' Use this range',
value=False)
ptcl_use_button.observe(refresh_ptcl, 'value', 'change')
# Resfresh buttons
ptcl_refresh_toggle = widgets.ToggleButton(
description='Always refresh', value=True)
ptcl_refresh_button = widgets.Button(description='Refresh now!')
ptcl_refresh_button.on_click(partial(refresh_ptcl, force=True))
# Containers
# ----------
# Particle quantity container
container_ptcl_quantities = widgets.VBox(width=310,
children=[
ptcl_species_button,
ptcl_xaxis_button,
ptcl_yaxis_button
])
# Particle selection container
container_ptcl_select = ptcl_select_widget.to_container()
# Plotting options container
container_ptcl_plots = widgets.VBox(width=310,
children=[
ptcl_figure_button,
ptcl_bins_button,
ptcl_range_button,
widgets.HBox(children=[
ptcl_magnitude_button,
ptcl_use_button
],
height=50),
ptcl_color_button
])
# Accordion for the field widgets
accord2 = widgets.Accordion(children=[
container_ptcl_quantities, container_ptcl_select,
container_ptcl_plots
])
accord2.set_title(0, 'Particle quantities')
accord2.set_title(1, 'Particle selection')
accord2.set_title(2, 'Plotting options')
# Complete particle container
container_ptcl = widgets.VBox(
width=370,
children=[
accord2,
widgets.HBox(
children=[ptcl_refresh_toggle, ptcl_refresh_button])
])
# Global container
if (self.avail_fields is not None) and \
(self.avail_species is not None):
global_container = widgets.HBox(
children=[container_fld, container_ptcl])
display(global_container)
elif self.avail_species is None:
display(container_fld)
elif self.avail_fields is None:
display(container_ptcl)
def do_plots_gui():
year = dt.datetime.now().year
last_dates = check_dates()
product = "TAMSAT"
product_sel = widgets.RadioButtons(
options=["TAMSAT", "ERA5", "MODIS"],
value="TAMSAT",
description="Product family",
)
variable_sel = widgets.Dropdown(options=variable_lists[product],
description="Variable")
months_this_year = widgets.Select(
options=range(1, last_dates[product] + 1),
description="Month current year",
)
anomaly_calc = widgets.Checkbox(value=True,
description="Do anomaly calculations")
sel_cmap = widgets.Dropdown(options=diverging_cmaps, value="Spectral")
sel_boundz = widgets.FloatRangeSlider(
value=[-2.5, 2.5],
min=-6,
max=6,
step=0.1,
description="Scale for anomaly colormap",
)
sel_period = widgets.RadioButtons(options=periods,
description="LTA temporal window",
disabled=False)
def on_value_change(change):
product = change.new
variable_sel.options = variable_lists[product]
def on_value_change2(change):
product = change.new
months_this_year.options = range(1, last_dates[product] + 1)
product_sel.observe(on_value_change, "value")
product_sel.observe(on_value_change2, "value")
def on_value_change3(change):
anomaly = change.new
if anomaly:
sel_cmap.options = diverging_cmaps
else:
sel_cmap.options = uniform_cmaps
def on_value_change4(change):
anomaly = change.new
if anomaly:
sel_boundz.min = -6
sel_boundz.max = 6
sel_boundz.value = [-2.5, 2.5]
sel_boundz.step = 0.1
else:
sel_boundz.min = 0
sel_boundz.max = 100
sel_boundz.value = [5, 95]
sel_boundz.step = 1
def on_value_change5(change):
anomaly = change.new
if anomaly:
sel_period.layout.visibility = "visible"
else:
sel_period.layout.visibility = "hidden"
anomaly_calc.observe(on_value_change3, "value")
anomaly_calc.observe(on_value_change4, "value")
anomaly_calc.observe(on_value_change5, "value")
def do_plots(**kwds):
if kwds["anomaly"]:
plot_anomaly(
kwds["product"],
kwds["variable"],
year,
kwds["month"],
kwds["cmap"],
kwds["boundz"],
kwds["lta_period"],
)
else:
plot_field(
kwds["product"],
kwds["variable"],
year,
kwds["month"],
kwds["cmap"],
kwds["boundz"],
)
widgets.interact_manual(
do_plots,
anomaly=anomaly_calc,
product=product_sel,
variable=variable_sel,
cmap=sel_cmap,
boundz=sel_boundz,
month=months_this_year,
lta_period=sel_period,
)
def _generate_widgets_macro_stress_strain(self):
data = [{
'x': self.exp_tensile_test.eng_strain,
'y': self.exp_tensile_test.eng_stress,
'name': 'Experimental',
'line': {
'color': DEFAULT_PLOTLY_COLORS[0],
},
}, {
'x': [self.exp_tensile_test.plastic_range[0]] * 2 + [None] +
[self.exp_tensile_test.plastic_range[1]] * 2,
'y': [
-HardeningLawFitter.FIG_PAD[1],
HardeningLawFitter.FIG_PAD[1] +
self.exp_tensile_test.max_stress,
None,
-HardeningLawFitter.FIG_PAD[1],
HardeningLawFitter.FIG_PAD[1] +
self.exp_tensile_test.max_stress,
],
'mode':
'lines',
'line': {
'color': '#888',
'width': 2,
},
'showlegend':
False,
}]
layout = {
'title': 'Experimental Data',
'width': HardeningLawFitter.FIG_WIDTH,
'height': HardeningLawFitter.FIG_HEIGHT,
'margin': HardeningLawFitter.FIG_MARG,
'xaxis': {
'title':
'Engineering strain, ε',
'range': [
-HardeningLawFitter.FIG_PAD[0],
HardeningLawFitter.FIG_PAD[0] +
self.exp_tensile_test.max_strain
],
},
'yaxis': {
'title':
'Engineering stress, σ / MPa',
'range': [
-HardeningLawFitter.FIG_PAD[1],
HardeningLawFitter.FIG_PAD[1] +
self.exp_tensile_test.max_stress
],
},
}
widget_ss_type = widgets.RadioButtons(
options=['Engineering', 'True'],
description='Stress/strain:',
value='Engineering',
)
plastic_range_widget = widgets.FloatRangeSlider(
value=self.exp_tensile_test.plastic_range,
step=0.005,
min=self.exp_tensile_test.min_true_strain,
max=self.exp_tensile_test.max_true_strain,
description='Plastic range:',
disabled=False,
continuous_update=False,
orientation='horizontal',
readout_format='.4f',
layout=widgets.Layout(width='90%'),
)
widget_ss_type.observe(self._update_widgets_stress_strain_type,
names='value')
plastic_range_widget.observe(self._update_widgets_plastic_range,
names='value')
out = {
'fig': go.FigureWidget(data=data, layout=layout),
'fig_trace_idx': {
'macro_stress_strain': [0],
'plastic_range_boundaries': [1],
},
'controls': {
'stress_strain_type': widget_ss_type,
'plastic_range': plastic_range_widget,
},
}
return out
import numpy as np
py.init_notebook_mode()
# load fig
fig = plotly.plotly.get_figure("https://plot.ly/~jordanpeterson/889")
# find the range of the slider.
xmin, xmax = fig['layout']['xaxis']['range']
# create FigureWidget from fig
f = go.FigureWidget(data=fig.data, layout=fig.layout)
slider = widgets.FloatRangeSlider(
min=xmin,
max=xmax,
step=(xmax - xmin) / 1000.0,
readout=False,
description='Time')
slider.layout.width = '800px'
# our function that will modify the xaxis range
def update_range(y):
f.layout.xaxis.range = [y[0], y[1]]
# display the FigureWidget and slider with center justification
vb = VBox((f, interactive(update_range, y=slider)))
vb.layout.align_items = 'center'
vb
def slider(self, figsize=(10, 10), **kw):
"""
Navigate the simulation using a slider
Parameters :
------------
figsize: tuple
Size of the figures
kw: dict
Extra arguments to pass to matplotlib's imshow
"""
# -----------------------
# Define useful functions
# -----------------------
def refresh_field(force=False):
"Refresh the current field figure"
# Determine whether to do the refresh
do_refresh = False
if (self.avail_fields is not None):
if force == True or fld_refresh_toggle.value == True:
do_refresh = True
# Do the refresh
if do_refresh == True:
plt.figure(fld_figure_button.value, figsize=figsize)
plt.clf()
# When working in inline mode, in an ipython notebook,
# clear the output (prevents the images from stacking
# in the notebook)
if 'inline' in matplotlib.get_backend():
clear_output()
if fld_use_button.value == True:
i_power = fld_magnitude_button.value
vmin = fld_range_button.value[0] * 10**i_power
vmax = fld_range_button.value[1] * 10**i_power
else:
vmin = None
vmax = None
self.get_field(t=self.current_t,
output=False,
plot=True,
field=fieldtype_button.value,
coord=coord_button.value,
m=convert_to_int(mode_button.value),
slicing=slicing_button.value,
theta=theta_button.value,
slicing_dir=slicing_dir_button.value,
vmin=vmin,
vmax=vmax,
cmap=fld_color_button.value)
def refresh_ptcl(force=False):
"Refresh the current particle figure"
# Determine whether to do the refresh
do_refresh = False
if self.avail_species is not None:
if force == True or ptcl_refresh_toggle.value == True:
do_refresh = True
# Do the refresh
if do_refresh == True:
plt.figure(ptcl_figure_button.value, figsize=figsize)
plt.clf()
# When working in inline mode, in an ipython notebook,
# clear the output (prevents the images from stacking
# in the notebook)
if 'inline' in matplotlib.get_backend():
clear_output()
if ptcl_use_button.value == True:
i_power = ptcl_magnitude_button.value
vmin = ptcl_range_button.value[0] * 10**i_power
vmax = ptcl_range_button.value[1] * 10**i_power
else:
vmin = None
vmax = None
if ptcl_yaxis_button.value == 'None':
# 1D histogram
self.get_particle(t=self.current_t,
output=False,
var_list=[ptcl_xaxis_button.value],
select=ptcl_select_widget.to_dict(),
species=ptcl_species_button.value,
plot=True,
vmin=vmin,
vmax=vmax,
cmap=ptcl_color_button.value,
nbins=ptcl_bins_button.value)
else:
# 2D histogram
self.get_particle(t=self.current_t,
output=False,
var_list=[
ptcl_xaxis_button.value,
ptcl_yaxis_button.value
],
select=ptcl_select_widget.to_dict(),
species=ptcl_species_button.value,
plot=True,
vmin=vmin,
vmax=vmax,
cmap=ptcl_color_button.value,
nbins=ptcl_bins_button.value)
def refresh_ptcl_now(b):
"Refresh the particles immediately"
refresh_ptcl(force=True)
def refresh_fld_now(b):
"Refresh the fields immediately"
refresh_field(force=True)
def change_t(name, value):
"Plot the result at the required time"
self.current_t = 1.e-15 * value
refresh_field()
refresh_ptcl()
def step_fw(b):
"Plot the result one iteration further"
if self.current_i < len(self.t) - 1:
self.current_t = self.t[self.current_i + 1]
else:
print("Reached last iteration.")
self.current_t = self.t[self.current_i]
slider.value = self.current_t * 1.e15
def step_bw(b):
"Plot the result one iteration before"
if self.current_t > 0:
self.current_t = self.t[self.current_i - 1]
else:
print("Reached first iteration.")
self.current_t = self.t[self.current_i]
slider.value = self.current_t * 1.e15
# ---------------
# Define widgets
# ---------------
# Slider
slider = widgets.FloatSlider(
min=math.ceil(1.e15 * self.tmin),
max=math.ceil(1.e15 * self.tmax),
step=math.ceil(1.e15 * (self.tmax - self.tmin)) / 20.,
description="t (fs)")
slider.on_trait_change(change_t, 'value')
# Forward button
button_p = widgets.Button(description="+")
button_p.on_click(step_fw)
# Backward button
button_m = widgets.Button(description="-")
button_m.on_click(step_bw)
# Display the time widgets
container = widgets.HBox(children=[button_m, button_p, slider])
display(container)
# Field widgets
# -------------
if (self.avail_fields is not None):
# Field type
# ----------
# Field button
fieldtype_button = widgets.ToggleButtons(
description='Field:', options=sorted(self.avail_fields.keys()))
fieldtype_button.on_trait_change(refresh_field)
# Coord button
if self.geometry == "thetaMode":
coord_button = widgets.ToggleButtons(
description='Coord:', options=['x', 'y', 'z', 'r', 't'])
elif self.geometry in ["2dcartesian", "3dcartesian"]:
coord_button = widgets.ToggleButtons(description='Coord:',
options=['x', 'y', 'z'])
coord_button.on_trait_change(refresh_field)
# Mode and theta button (for thetaMode)
mode_button = widgets.ToggleButtons(description='Mode:',
options=self.avail_circ_modes)
mode_button.on_trait_change(refresh_field)
theta_button = widgets.FloatSlider(width=140,
value=0.,
description=r'Theta:',
min=-math.pi / 2,
max=math.pi / 2)
theta_button.on_trait_change(refresh_field)
# Slicing buttons (for 3D)
slicing_dir_button = widgets.ToggleButtons(
value='y',
description='Slicing direction:',
options=['x', 'y', 'z'])
slicing_dir_button.on_trait_change(refresh_field)
slicing_button = widgets.FloatSlider(width=150,
description='Slicing:',
min=-1.,
max=1.,
value=0.)
slicing_button.on_trait_change(refresh_field)
# Plotting options
# ----------------
# Figure number
fld_figure_button = widgets.IntText(description='Figure ',
value=0,
width=50)
# Range of values
fld_range_button = widgets.FloatRangeSlider(min=-10,
max=10,
width=220)
fld_range_button.on_trait_change(refresh_field)
# Order of magnitude
fld_magnitude_button = widgets.IntText(description='x 10^',
value=9,
width=50)
fld_magnitude_button.on_trait_change(refresh_field)
# Use button
fld_use_button = widgets.Checkbox(description=' Use this range',
value=False)
fld_use_button.on_trait_change(refresh_field)
# Colormap button
fld_color_button = widgets.Select(options=sorted(
plt.cm.datad.keys()),
height=50,
width=200,
value='jet')
fld_color_button.on_trait_change(refresh_field)
# Resfresh buttons
fld_refresh_toggle = widgets.ToggleButton(
description='Always refresh', value=True)
fld_refresh_button = widgets.Button(description='Refresh now!')
fld_refresh_button.on_click(refresh_fld_now)
# Containers
# ----------
# Field type container
if self.geometry == "thetaMode":
container_fields = widgets.VBox(width=260,
children=[
fieldtype_button,
coord_button, mode_button,
theta_button
])
elif self.geometry == "2dcartesian":
container_fields = widgets.VBox(
width=260, children=[fieldtype_button, coord_button])
elif self.geometry == "3dcartesian":
container_fields = widgets.VBox(width=260,
children=[
fieldtype_button,
coord_button,
slicing_dir_button,
slicing_button
])
# Plotting options container
container_fld_plots = widgets.VBox(width=260,
children=[
fld_figure_button,
fld_range_button,
widgets.HBox(children=[
fld_magnitude_button,
fld_use_button
],
height=50),
fld_color_button
])
# Accordion for the field widgets
accord1 = widgets.Accordion(
children=[container_fields, container_fld_plots])
accord1.set_title(0, 'Field type')
accord1.set_title(1, 'Plotting options')
# Complete field container
container_fld = widgets.VBox(
width=300,
children=[
accord1,
widgets.HBox(
children=[fld_refresh_toggle, fld_refresh_button])
])
# Particle widgets
# ----------------
if (self.avail_species is not None):
# Particle quantities
# -------------------
# Species selection
ptcl_species_button = widgets.Dropdown(width=250,
options=self.avail_species)
ptcl_species_button.on_trait_change(refresh_ptcl)
# Remove charge and mass (less interesting)
avail_ptcl_quantities = [ q for q in self.avail_ptcl_quantities \
if (q in ['charge', 'mass'])==False ]
# Particle quantity on the x axis
ptcl_xaxis_button = widgets.ToggleButtons(
value='z', options=avail_ptcl_quantities)
ptcl_xaxis_button.on_trait_change(refresh_ptcl)
# Particle quantity on the y axis
ptcl_yaxis_button = widgets.ToggleButtons(
value='x', options=avail_ptcl_quantities + ['None'])
ptcl_yaxis_button.on_trait_change(refresh_ptcl)
# Particle selection
# ------------------
# 3 selection rules at maximum
ptcl_select_widget = ParticleSelectWidget(3, avail_ptcl_quantities,
refresh_ptcl)
# Plotting options
# ----------------
# Figure number
ptcl_figure_button = widgets.IntText(description='Figure ',
value=1,
width=50)
# Number of bins
ptcl_bins_button = widgets.IntSlider(description='nbins:',
min=50,
max=300,
value=100,
width=150)
ptcl_bins_button.on_trait_change(refresh_ptcl)
# Colormap button
ptcl_color_button = widgets.Select(options=sorted(
plt.cm.datad.keys()),
height=50,
width=200,
value='Blues')
ptcl_color_button.on_trait_change(refresh_ptcl)
# Range of values
ptcl_range_button = widgets.FloatRangeSlider(min=0,
max=10,
width=220,
value=(0, 5))
ptcl_range_button.on_trait_change(refresh_ptcl)
# Order of magnitude
ptcl_magnitude_button = widgets.IntText(description='x 10^',
value=9,
width=50)
ptcl_magnitude_button.on_trait_change(refresh_ptcl)
# Use button
ptcl_use_button = widgets.Checkbox(description=' Use this range',
value=False)
ptcl_use_button.on_trait_change(refresh_ptcl)
# Resfresh buttons
ptcl_refresh_toggle = widgets.ToggleButton(
description='Always refresh', value=True)
ptcl_refresh_button = widgets.Button(description='Refresh now!')
ptcl_refresh_button.on_click(refresh_ptcl_now)
# Containers
# ----------
# Particle quantity container
container_ptcl_quantities = widgets.VBox(width=310,
children=[
ptcl_species_button,
ptcl_xaxis_button,
ptcl_yaxis_button
])
# Particle selection container
container_ptcl_select = ptcl_select_widget.to_container()
# Plotting options container
container_ptcl_plots = widgets.VBox(width=310,
children=[
ptcl_figure_button,
ptcl_bins_button,
ptcl_range_button,
widgets.HBox(children=[
ptcl_magnitude_button,
ptcl_use_button
],
height=50),
ptcl_color_button
])
# Accordion for the field widgets
accord2 = widgets.Accordion(children=[
container_ptcl_quantities, container_ptcl_select,
container_ptcl_plots
])
accord2.set_title(0, 'Particle quantities')
accord2.set_title(1, 'Particle selection')
accord2.set_title(2, 'Plotting options')
# Complete particle container
container_ptcl = widgets.VBox(
width=370,
children=[
accord2,
widgets.HBox(
children=[ptcl_refresh_toggle, ptcl_refresh_button])
])
# Global container
if (self.avail_fields is not None) and \
(self.avail_species is not None):
global_container = widgets.HBox(
children=[container_fld, container_ptcl])
display(global_container)
elif self.avail_species is None:
display(container_fld)
elif self.avail_fields is None:
display(container_ptcl)
def __init__(self, parent):
"""Set all widgets for the tab.
Parameters:
parent (ipywidget) : The parent widget object embeding this tab
"""
self.parent = parent
self.title = 'Set Calibrant'
self.alpha = 0.5 # The transparency value of the overlay
self.clim = (0.5, 0.9) # Standard clim (max alwys 1)
self.img = None # Image to be overlayed
energy = 10e3 # [eV] Photon energy, default value can be overwirtten
# Convert the energy to wave-length
self.wave_length = self._energy2lambda(energy)
self.calibrant = 'None' # Calibrant material
self.pxsize = 0.2 / 1000 # [mm] Standard detector pixel size
self.cdist = 0.2 # [m] Standard probe distance
# Get all calibrants defined in pyFAI
self.calibrants = [self.calibrant] + calibrants
# Calibrant selection
self.calib_btn = widgets.Dropdown(options=self.calibrants,
value='None',
description='Calibrant',
disabled=False,
layout=Layout(width='250px',
height='30px'))
# Probe distance selection
self.dist_btn = widgets.BoundedFloatText(value=self.cdist,
min=0,
max=10000,
layout=Layout(width='150px',
height='30px'),
step=0.01,
disabled=False,
description='Distance [m]')
# Photon energy selection
self.energy_btn = widgets.BoundedFloatText(value=energy,
min=3000,
max=100000,
layout=Layout(
width='200px',
height='30px'),
step=1,
disabled=False,
description='Energy [eV]')
# Pixel size selection
self.pxsize_btn = widgets.BoundedFloatText(
value=self.cdist,
min=0,
max=20,
layout=Layout(width='150px', height='30px'),
step=0.01,
disabled=False,
description='Pixel Size [mm]')
# Apply button to display the ring structure
self.aply_btn = widgets.Button(description='Apply',
disabled=False,
button_style='',
icon='',
tooltip='Apply Material',
layout=Layout(width='100px',
height='30px'))
# Clear button to delete overlay
self.clr_btn = widgets.Button(description='Clear',
tooltip='Do not show overlay',
disabled=False,
button_style='',
icon='',
layout=Layout(width='100px',
height='30px'))
# Set transparency value
self.alpha_slider = widgets.FloatSlider(value=self.alpha,
min=0,
max=1,
step=0.01,
description='Transparancy:',
orientation='horizontal',
readout=True,
readout_format='.2f',
layout=Layout(width='40%'))
# Set clim
self.val_slider = widgets.FloatRangeSlider(value=self.clim,
min=0,
max=1,
step=0.01,
description='Range:',
disabled=False,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.2f',
layout=Layout(width='40%'))
# Arange the buttons
self.row1 = widgets.HBox(
[self.calib_btn, self.dist_btn, self.energy_btn, self.pxsize_btn])
self.row2 = widgets.HBox(
[self.val_slider, self.alpha_slider, self.aply_btn, self.clr_btn])
# Connect all methods to the buttons
self.val_slider.observe(self._set_clim, names='value')
self.alpha_slider.observe(self._set_alpha, names='value')
self.clr_btn.on_click(self._clear_overlay)
self.aply_btn.on_click(self._draw_overlay)
self.calib_btn.observe(self._set_calibrant, names='value')
self.pxsize_btn.observe(self._set_pxsize, names='value')
self.energy_btn.observe(self._set_wavelength, names='value')
self.dist_btn.observe(self._set_cdist, names='value')
super(widgets.VBox, self).__init__([self.row1, self.row2])
