def euler_tammann_interactive_phase_plane(ql=(600.0, 10.0, 50000.0),
qr=(50.0, -10.0, 25000.0),
paramsl=(1.4, 0.0),
paramsr=(7.0, 100.0)):
"Create the GUI and output the interact app."
# Create plot function for interact
pp_plot = euler_tammann_phase_plane_plot()
# Declare all widget sliders
ql1_widget = widgets.FloatSlider(value=ql[0],
min=0.01,
max=1000.0,
description=r'$\rho_l$')
ql2_widget = widgets.FloatSlider(value=ql[1],
min=-15,
max=15.0,
description='$u_l$')
ql3_widget = widgets.FloatSlider(value=ql[2],
min=1,
max=200000.0,
description='$p_l$')
qr1_widget = widgets.FloatSlider(value=qr[0],
min=0.01,
max=1000.0,
description=r'$\rho_r$')
qr2_widget = widgets.FloatSlider(value=qr[1],
min=-15,
max=15.0,
description='$u_r$')
qr3_widget = widgets.FloatSlider(value=qr[2],
min=1,
max=200000.0,
description='$p_r$')
gamml_widget = widgets.FloatSlider(value=paramsl[0],
min=0.01,
max=10.0,
description='$\gamma_l$')
gammr_widget = widgets.FloatSlider(value=paramsr[0],
min=0.01,
max=10.0,
description='$\gamma_r$')
pinfl_widget = widgets.FloatSlider(value=paramsl[1],
min=0.0,
max=300000.0,
description='$p_{\infty l}$')
pinfr_widget = widgets.FloatSlider(value=paramsr[1],
min=0.0,
max=300000.0,
description='$p_{\infty r}$')
xmin_widget = widgets.BoundedFloatText(value=0.0000001,
description='$p_{min}:$')
xmax_widget = widgets.FloatText(value=200000, description='$p_{max}:$')
ymin_widget = widgets.FloatText(value=-15, description='$u_{min}:$')
ymax_widget = widgets.FloatText(value=15, description='$u_{max}:$')
show_physical = widgets.Checkbox(value=True,
description='Physical solution')
show_unphysical = widgets.Checkbox(value=True,
description='Unphysical solution')
# Additional control widgets not called by function
rhomax_widget = widgets.FloatText(value=1000, description=r'$\rho_{max}$')
gammax_widget = widgets.FloatText(value=10, description='$\gamma_{max}$')
pinfmax_widget = widgets.FloatText(value=300000,
description='$p_{\infty max}$')
# Allow for dependent widgets to update
def update_xmin(*args):
ql3_widget.min = xmin_widget.value
qr3_widget.min = xmin_widget.value
def update_xmax(*args):
ql3_widget.max = xmax_widget.value
qr3_widget.max = xmax_widget.value
def update_ymin(*args):
ql2_widget.min = ymin_widget.value
qr2_widget.min = ymin_widget.value
def update_ymax(*args):
ql2_widget.max = ymax_widget.value
qr2_widget.max = ymax_widget.value
def update_rhomax(*args):
ql1_widget.max = rhomax_widget.value
qr1_widget.max = rhomax_widget.value
def update_gammax(*args):
gamml_widget.max = gammax_widget.value
gammr_widget.max = gammax_widget.value
def update_pinfmax(*args):
pinfl_widget.max = pinfmax_widget.value
pinfr_widget.max = pinfmax_widget.value
xmin_widget.observe(update_xmin, 'value')
xmax_widget.observe(update_xmax, 'value')
ymin_widget.observe(update_ymin, 'value')
ymax_widget.observe(update_ymax, 'value')
rhomax_widget.observe(update_rhomax, 'value')
gammax_widget.observe(update_gammax, 'value')
pinfmax_widget.observe(update_pinfmax, 'value')
# Organize slider widgets into boxes
qleftright = widgets.VBox([
widgets.HBox([ql1_widget, ql2_widget, ql3_widget]),
widgets.HBox([qr1_widget, qr2_widget, qr3_widget])
])
params = widgets.HBox([
widgets.VBox([gamml_widget, gammr_widget]),
widgets.VBox([pinfl_widget, pinfr_widget])
])
plot_opts = widgets.HBox([
widgets.VBox([show_physical, xmin_widget, ymin_widget]),
widgets.VBox([show_unphysical, xmax_widget, ymax_widget]),
widgets.VBox([rhomax_widget, gammax_widget, pinfmax_widget])
])
# Set up interactive GUI (tab style)
interact_gui = widgets.Tab(children=[qleftright, params, plot_opts])
interact_gui.set_title(0, 'Left and right states')
interact_gui.set_title(1, 'Tammann EOS')
interact_gui.set_title(2, 'Plot options')
# Define interactive widget and run GUI
ppwidget = interact(pp_plot,
rhol=ql1_widget,
ul=ql2_widget,
pl=ql3_widget,
rhor=qr1_widget,
ur=qr2_widget,
pr=qr3_widget,
gammal=gamml_widget,
pinfl=pinfl_widget,
gammar=gammr_widget,
pinfr=pinfr_widget,
xmin=xmin_widget,
xmax=xmax_widget,
ymin=ymin_widget,
ymax=ymax_widget,
show_phys=show_physical,
show_unphys=show_unphysical)
ppwidget.widget.close()
display(interact_gui)
display(ppwidget.widget.out)
def acousticsInterface_interactive_phase_plane(ql=(10.0, -5.0),
qr=(40.0, 5.0),
paramsl=(1.0, 2.0),
paramsr=(2.0, 8.0)):
"Create the GUI and output the interact app."
# Create plot function for interact
pp_plot = acousticsInterface_phase_plane_plot()
# Declare all widget sliders
ql1_widget = widgets.FloatSlider(value=ql[0],
min=0.01,
max=50.0,
description='$p_l$')
ql2_widget = widgets.FloatSlider(value=ql[1],
min=-30,
max=30.0,
description='$u_l$')
qr1_widget = widgets.FloatSlider(value=qr[0],
min=0.01,
max=50.0,
description='$p_r$')
qr2_widget = widgets.FloatSlider(value=qr[1],
min=-30,
max=30.0,
description='$u_r$')
rhol_widget = widgets.FloatSlider(value=paramsl[0],
min=0.01,
max=10.0,
description=r'$\rho_l$')
bulkl_widget = widgets.FloatSlider(value=paramsl[1],
min=0.01,
max=10.0,
description='$K_l$')
rhor_widget = widgets.FloatSlider(value=paramsr[0],
min=0.01,
max=10.0,
description=r'$\rho_r$')
bulkr_widget = widgets.FloatSlider(value=paramsr[1],
min=0.01,
max=10.0,
description='$K_r$')
xmin_widget = widgets.BoundedFloatText(value=0.0000001,
description='$p_{min}:$')
xmax_widget = widgets.FloatText(value=50, description='$p_{max}:$')
ymin_widget = widgets.FloatText(value=-30, description='$u_{min}:$')
ymax_widget = widgets.FloatText(value=30, description='$u_{max}:$')
rhomax_widget = widgets.FloatText(value=10, description=r'$\rho_{max}:$')
bulkmax_widget = widgets.FloatText(value=10, description='$K_{max}:$')
show_physical = widgets.Checkbox(value=True,
description='Physical solution')
show_unphysical = widgets.Checkbox(value=True,
description='Unphysical solution')
# Allow for dependent widgets to update
def update_xmin(*args):
ql3_widget.min = xmin_widget.value
qr3_widget.min = xmin_widget.value
def update_xmax(*args):
ql3_widget.max = xmax_widget.value
qr3_widget.max = xmax_widget.value
def update_ymin(*args):
ql2_widget.min = ymin_widget.value
qr2_widget.min = ymin_widget.value
def update_ymax(*args):
ql2_widget.max = ymax_widget.value
qr2_widget.max = ymax_widget.value
def update_rhomax(*args):
rhol_widget.max = rhomax_widget.value
rhor_widget.max = rhomax_widget.value
def update_bulkmax(*args):
bulkl_widget.max = bulkmax_widget.value
bulkr_widget.max = bulkmax_widget.value
xmin_widget.observe(update_xmin, 'value')
xmax_widget.observe(update_xmax, 'value')
ymin_widget.observe(update_ymin, 'value')
ymax_widget.observe(update_ymax, 'value')
rhomax_widget.observe(update_rhomax, 'value')
bulkmax_widget.observe(update_bulkmax, 'value')
# Organize slider widgets into boxes
qleftright = widgets.VBox([
widgets.HBox([ql1_widget, ql2_widget]),
widgets.HBox([qr1_widget, qr2_widget])
])
paramswidg = widgets.VBox([
widgets.HBox([rhol_widget, rhor_widget]),
widgets.HBox([bulkl_widget, bulkr_widget])
])
plot_opts = widgets.VBox([
widgets.HBox([show_physical, show_unphysical]),
widgets.HBox([xmin_widget, xmax_widget, rhomax_widget]),
widgets.HBox([ymin_widget, ymax_widget, bulkmax_widget])
])
# Set up interactive GUI (tab style)
interact_gui = widgets.Tab(children=[qleftright, paramswidg, plot_opts])
interact_gui.set_title(0, 'Left and right states')
interact_gui.set_title(1, 'Material parameters')
interact_gui.set_title(2, 'Plot options')
# Define interactive widget and run GUI
ppwidget = interact(pp_plot,
pl=ql1_widget,
ul=ql2_widget,
pr=qr1_widget,
ur=qr2_widget,
rhol=rhol_widget,
bulkl=bulkl_widget,
rhor=rhor_widget,
bulkr=bulkr_widget,
xmin=xmin_widget,
xmax=xmax_widget,
ymin=ymin_widget,
ymax=ymax_widget,
show_phys=show_physical,
show_unphys=show_unphysical)
ppwidget.widget.close()
display(interact_gui)
display(ppwidget.widget.out)
def __init__(self,
tmax,
tmin=0,
start_value=None,
description='start (s)',
**kwargs):
"""
Parameters
----------
tmax: float
in seconds
tmin: float
in seconds
start_value: (float, float)
start and stop in seconds
description: str
kwargs: dict
"""
if tmin > tmax:
raise ValueError(
'tmax and tmin were probably entered in the wrong order. tmax should be first'
)
super().__init__(tmin, tmax, start_value, description, **kwargs)
self.slider = widgets.FloatSlider(
value=start_value,
min=tmin,
max=tmax,
step=0.01,
description=description,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.2f',
style={'description_width': 'initial'},
layout=Layout(width='100%', min_width='250px'))
link((self.slider, 'description'), (self, 'description'))
if start_value is None:
duration = min(self.DEFAULT_DURATION, tmax - tmin)
else:
duration = start_value[1] - start_value[0]
self.duration = widgets.BoundedFloatText(
value=duration,
min=0,
max=tmax - tmin,
step=0.1,
description='duration (s):',
style={'description_width': 'initial'},
layout=Layout(max_width='140px'))
self.value = (self.slider.value,
self.slider.value + self.duration.value)
self.slider.observe(self.monitor_slider)
self.duration.observe(self.monitor_duration)
self.children = self.get_children()
style_mini = {'description_width': '5px'}
style_short = {'description_width': '100px'}
style_med = {'description_width': '200px'}
style_long = {'description_width': '200px'}
layout_mini = Layout(width='18.75%')
layout_50 = Layout(width='50%')
layout_med = Layout(width='70%')
widget_layout = Layout(width='100%')
A = widgets.BoundedFloatText( ## fraction of new borns
value=0.0355,
min=0,
max=2,
step=0.0001,
disabled=False,
description='Productivity',
style=style_med,
layout=Layout(width='70%'))
alpha_k = widgets.BoundedFloatText( ## death rate
value=0.025,
min=0,
max=1,
step=0.0001,
disabled=False,
description='Depreciation',
style=style_med,
layout=Layout(width='70%'))
phi1 = widgets.BoundedFloatText( ## death rate
value=0.0125,
def factor_slider(minv,maxv,step,val=0):
return widgets.BoundedFloatText(value=val,min=minv,max=maxv,step=step,layout=widgets.Layout(width='auto'),disabled=False)
style_mini = {'description_width': '5px'}
style_short = {'description_width': '100px'}
style_med = {'description_width': '250px'}
style_long = {'description_width': '200px'}
layout_mini = Layout(width='18.75%')
layout_50 = Layout(width='50%')
layout_med = Layout(width='70%')
widget_layout = Layout(width='100%')
ξ_base = widgets.BoundedFloatText(
value=0.01,
min=0,
max=1,
step=0.001,
disabled=False,
description=r'Baseline Quarantine Rate ($\xi_2^u$)',
style=style_med,
layout=layout_med)
A_rel = widgets.BoundedFloatText(
value=0.5,
min=0,
max=1,
step=0.001,
disabled=False,
description=r'Relative Productivity of Quarantined ($A_{rel}$)',
style=style_med,
layout=layout_med)
d_vaccine = widgets.BoundedIntText(value=500,
min=20,
def interactive_phase_plane(ql=(10.0, -5.0), qr=(40.0, 5.0), rho=2.0,
bulk=1.0):
"""Plots interactive phase plane plot."""
# Create plot function for interact
pp_plot = phase_plane_plot()
# Declare all widget sliders
ql1_widget = widgets.FloatSlider(value=ql[0],
min=0.01,
max=10.0,
description='$p_l$')
ql2_widget = widgets.FloatSlider(value=ql[1],
min=-10,
max=10.0,
description='$u_l$')
qr1_widget = widgets.FloatSlider(value=qr[0],
min=0.01,
max=10.0,
description='$p_r$')
qr2_widget = widgets.FloatSlider(value=qr[1],
min=-10,
max=10.0,
description='$u_r$')
rho_widget = widgets.FloatSlider(value=rho,
min=0.01,
max=10.0,
description=r'$\rho$')
bulk_widget = widgets.FloatSlider(value=bulk,
min=0.01,
max=10.0,
description='$K$')
xmin_widget = widgets.BoundedFloatText(value=0.0000001,
description='$p_{min}:$')
xmax_widget = widgets.FloatText(value=10, description='$p_{max}:$')
ymin_widget = widgets.FloatText(value=-5, description='$u_{min}:$')
ymax_widget = widgets.FloatText(value=5, description='$u_{max}:$')
# Allow for dependent widgets to update
def update_xmin(*args):
ql1_widget.min = xmin_widget.value
qr1_widget.min = xmin_widget.value
def update_xmax(*args):
ql1_widget.max = xmax_widget.value
qr1_widget.max = xmax_widget.value
def update_ymin(*args):
ql2_widget.min = ymin_widget.value
qr2_widget.min = ymin_widget.value
def update_ymax(*args):
ql2_widget.max = ymax_widget.value
qr2_widget.max = ymax_widget.value
xmin_widget.observe(update_xmin, 'value')
xmax_widget.observe(update_xmax, 'value')
ymin_widget.observe(update_ymin, 'value')
ymax_widget.observe(update_ymax, 'value')
# Organize slider widgets into boxes
qleftright = widgets.VBox([
widgets.HBox([ql1_widget, ql2_widget, rho_widget]),
widgets.HBox([qr1_widget, qr2_widget, bulk_widget])
])
plot_opts = widgets.VBox([
widgets.HBox([xmin_widget, xmax_widget]),
widgets.HBox([ymin_widget, ymax_widget])
])
# Set up interactive GUI (tab style)
interact_gui = widgets.Tab(children=[qleftright, plot_opts])
interact_gui.set_title(0, 'Left and right states')
interact_gui.set_title(1, 'Plot options')
# Define interactive widget and run GUI
ppwidget = interact(pp_plot,
pl=ql1_widget,
ul=ql2_widget,
pr=qr1_widget,
ur=qr2_widget,
rho=rho_widget,
bulk=bulk_widget,
xmin=xmin_widget,
xmax=xmax_widget,
ymin=ymin_widget,
ymax=ymax_widget)
ppwidget.widget.close()
display(interact_gui)
display(ppwidget.widget.out)
def full_riemann_interactive(
ql=(10.0, -5.0), qr=(40.0, 5.0), rho=2.0, bulk=1.0):
"""Plots interactive full riemann solution with phase plane plot."""
# Create plot function for interact
pp_plot = full_riemann_solution_plot()
# Declare all widget sliders
t_widget = widgets.FloatSlider(value=0,
min=0.0,
max=1.0,
description='$t$')
ql1_widget = widgets.FloatSlider(value=ql[0],
min=0.01,
max=50.0,
description='$p_l$')
ql2_widget = widgets.FloatSlider(value=ql[1],
min=-30,
max=30.0,
description='$u_l$')
qr1_widget = widgets.FloatSlider(value=qr[0],
min=0.01,
max=50.0,
description='$p_r$')
qr2_widget = widgets.FloatSlider(value=qr[1],
min=-30,
max=30.0,
description='$u_r$')
rho_widget = widgets.FloatSlider(value=rho,
min=0.01,
max=10.0,
description=r'$\rho$')
bulk_widget = widgets.FloatSlider(value=bulk,
min=0.01,
max=10.0,
description='$K$')
xmin_widget = widgets.BoundedFloatText(value=0.0000001,
description='$p_{min}:$')
xmax_widget = widgets.FloatText(value=50, description='$p_{max}:$')
ymin_widget = widgets.FloatText(value=-30, description='$u_{min}:$')
ymax_widget = widgets.FloatText(value=30, description='$u_{max}:$')
which_char_widget = widgets.Dropdown(options=[None, 1, 2],
description='Characs.')
# Allow for dependent widgets to update
def update_xmin(*args):
ql1_widget.min = xmin_widget.value
qr1_widget.min = xmin_widget.value
def update_xmax(*args):
ql1_widget.max = xmax_widget.value
qr1_widget.max = xmax_widget.value
def update_ymin(*args):
ql2_widget.min = ymin_widget.value
qr2_widget.min = ymin_widget.value
def update_ymax(*args):
ql2_widget.max = ymax_widget.value
qr2_widget.max = ymax_widget.value
xmin_widget.observe(update_xmin, 'value')
xmax_widget.observe(update_xmax, 'value')
ymin_widget.observe(update_ymin, 'value')
ymax_widget.observe(update_ymax, 'value')
# Organize slider widgets into boxes
qleftright = widgets.VBox([
widgets.HBox([t_widget, which_char_widget]),
widgets.HBox([ql1_widget, ql2_widget, rho_widget]),
widgets.HBox([qr1_widget, qr2_widget, bulk_widget])
])
plot_opts = widgets.VBox([
widgets.HBox([xmin_widget, xmax_widget]),
widgets.HBox([ymin_widget, ymax_widget])
])
# Set up interactive GUI (tab style)
interact_gui = widgets.Tab(children=[qleftright, plot_opts])
interact_gui.set_title(0, 'Left and right states')
interact_gui.set_title(1, 'Plot options')
# Define interactive widget and run GUI
ppwidget = interact(pp_plot,
t=t_widget,
pl=ql1_widget,
ul=ql2_widget,
pr=qr1_widget,
ur=qr2_widget,
rho=rho_widget,
bulk=bulk_widget,
which_char=which_char_widget,
xmin=xmin_widget,
xmax=xmax_widget,
ymin=ymin_widget,
ymax=ymax_widget)
try:
ppwidget.widget.close()
display(interact_gui)
display(ppwidget.widget.out)
except:
pass
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 param_object(self, updateparam):
def onvalchange(p):
# print ("parameter1: {}".format(p))
updateparam['val'] = valtext.value
sleep(1)
self.plothelper()
# print (self.updateparam)
def onmaxchange(p):
sleep(1)
updateparam['max'] = maxtext.value
def onminchange(p):
sleep(1)
updateparam['min'] = mintext.value
def onfrozenchange(p):
# print ("parameter1: {}".format(p))
updateparam['frozen'] = frozen.value
# print (self.updateparam)
minbound = updateparam['min']
maxbound = updateparam['max']
initialvalue = updateparam['val']
label = widgets.HTML(value=updateparam['full_name'], padding='5px')
slider = widgets.FloatSlider(value=initialvalue,
min=minbound,
max=maxbound,
step=0.001,
description='',
orientation='horizontal',
readout=False,
padding='5px')
slider.msg_throttle = 0
mintext = widgets.BoundedFloatText(value=minbound,
min=-1e20,
max=maxbound,
description=' ',
readout_format='.3f',
padding='5px')
mintext.observe(onminchange, names='value')
maxtext = widgets.BoundedFloatText(value=maxbound,
min=minbound,
max=+1e20,
description=' ',
readout_format='.3f',
padding='5px')
maxtext.observe(onmaxchange, names='value')
valtext = widgets.BoundedFloatText(value=slider.value,
min=slider.min,
max=slider.max,
description=' ',
readout_format='.3f',
padding='5px')
valtext.observe(onvalchange, names='value')
frozen = widgets.Checkbox(description=' ',
value=updateparam['frozen'],
visible=True,
padding='5px',
height=20,
width=20)
frozen.observe(onfrozenchange, names='value')
lmin = traitlets.dlink((mintext, 'value'), (slider, 'min'))
lmax = traitlets.dlink((maxtext, 'value'), (slider, 'max'))
vlmin = traitlets.dlink((mintext, 'value'), (valtext, 'min'))
vlmax = traitlets.dlink((maxtext, 'value'), (valtext, 'max'))
lval = traitlets.link((slider, 'value'), (valtext, 'value'))
return widgets.HBox(
children=[label, valtext, mintext, slider, maxtext, frozen])
def __init__(self):
style = {'description_width': 'initial'}
self.container = widgets.VBox(width="100%", background_color="#AAAAAA")
strat_lab = widgets.HTML(
value="<b>Spectroscopic Aperture Extraction</b>", margin='5px')
self.target_box = widgets.HBox(padding='10px', width="100%")
targ_lab = widgets.HTML(value="Extraction Target: ", margin='5px')
self.target_x = widgets.BoundedFloatText(description="X:",
min=-37.5,
max=37.5,
value=0,
width=30)
self.target_y = widgets.BoundedFloatText(description="Y:",
min=-37.5,
max=37.5,
value=0,
width=30)
self.target_box.children = [targ_lab, self.target_x, self.target_y]
self.reference_wavelength = widgets.BoundedFloatText(
description="Wavelength of Interest",
min=0.95,
max=1.8,
value=1.3,
width=30,
style=style)
self.advanced = widgets.VBox(width="100%", background_color="#AAAAAA")
self.aperture_box = widgets.HBox(padding='10px', width="100%")
ap_lab = widgets.HTML(value="Aperture half-height (arcsec): ",
margin='5px')
self.ap_size = widgets.BoundedFloatText(min=0.0,
max=999.0,
value=0.1,
width=30)
self.ap_size.on_trait_change(self.check_ann, 'value')
self.aperture_box.children = [ap_lab, self.ap_size]
self.background_box = widgets.VBox(width="100%",
background_color="#AAAAAA")
bg_lab = widgets.HTML(value="Sky Sample Region (arcsec): ",
margin='5px')
self.ann_inner = widgets.BoundedFloatText(description="inner",
min=0.0,
max=999.0,
value=0.2,
width=30)
self.ann_inner.on_trait_change(self.check_ann_inner, 'value')
self.ann_outer = widgets.BoundedFloatText(description="outer",
min=0.0,
max=999.0,
value=0.3,
width=30)
self.ann_outer.on_trait_change(self.check_ann_outer, 'value')
self.background_box.children = [bg_lab, self.ann_inner, self.ann_outer]
self.advanced.children = [self.aperture_box, self.background_box]
self.advanced_drop = widgets.Accordion(children=[self.advanced])
self.advanced_drop.set_title(0, "ADVANCED")
self.advanced_drop.selected_index = None
self.container.children = [
strat_lab, self.target_box, self.reference_wavelength,
self.advanced_drop
]
def __init__(self):
self.container = widgets.VBox(width="100%", background_color="#EEEEEE")
# Flux
self.flux_box = widgets.HBox(padding='10px', width="100%")
self.flux = widgets.BoundedFloatText(description="Source flux: ",
min=0.0,
max=1.0e30,
value=23.0)
self.funits = widgets.Dropdown(
value='abmag', options=['abmag', 'njy', 'ujy', 'mjy', 'jy'])
atwave = widgets.HTML(value=" at ", margin='5px')
self.wave = widgets.BoundedFloatText(min=0.1, max=99999.0, value=1.5)
waveunits = widgets.HTML(value="microns", margin='5px')
self.flux_box.children = [
self.flux, self.funits, atwave, self.wave, waveunits
]
# SED
self.sed_box = widgets.HBox(padding='10px', width="100%")
self.sed_select = widgets.Dropdown(description="SED type: ",
options=[
'flat', 'phoenix', 'blackbody',
'extragalactic', 'star',
'power-law'
],
value='flat')
self.bb_temp = widgets.BoundedFloatText(description="Temp (K): ",
min=0.0,
max=99999.0,
value=6500.0,
width=75)
phoenix_config_file = os.path.join(refdata, 'sed', 'phoenix',
'spectra.json')
self.phoenix_config = get_config(phoenix_config_file)
self.phoenix = widgets.Dropdown(options=sorted(self.phoenix_config))
gal_config_file = os.path.join(refdata, 'sed', 'brown', 'spectra.json')
self.gal_config = get_config(gal_config_file)
self.galaxies = widgets.Dropdown(options=sorted(self.gal_config))
star_config_file = os.path.join(refdata, 'sed', 'hst_calspec',
'spectra.json')
self.star_config = get_config(star_config_file)
self.star = widgets.Dropdown(options=sorted(self.star_config))
self.pl_index = widgets.FloatText(description="Index: ",
value=1.0,
width=50)
# We have to define anything we're going to use from the beginning, so we do that, and then
# run the helper function that displays the selected (default) item and hides the rest.
self.on_sed_change(dummy)
self.sed_box.children = [
self.sed_select, self.phoenix, self.pl_index, self.bb_temp,
self.star, self.galaxies
]
self.sed_select.observe(self.on_sed_change)
# Advanced
# Geometry
# The selector goes in one box, and all the geometry selections goes in another so that items can be activated/
# deactivated as needed.
self.geom_box = widgets.VBox(width="100%")
self.source_box = widgets.HBox(width="100%")
#profile_config_file = os.path.join(refdata, 'source', 'config.json')
#self.profile_config = get_config(profile_config_file)
self.src_select = widgets.Dropdown(description="Profile: ",
options=[
'Point Source', 'Flat',
'2D Gaussian',
'Sersic (Scale Radius)'
],
value='Point Source')
self.source_box.children = [self.src_select]
self.prof_box = widgets.VBox(width="100%")
style = {'description_width': 'initial'}
# We have to define anything we're going to use from the beginning, so we do that, and then
# run the helper function that displays the selected (default) item and its attendant pieces, and hides the rest.
self.major = widgets.FloatText(description="Semimajor (arcsec): ",
value=0.5,
style=style)
self.minor = widgets.FloatText(description="Semiminor (arcsec): ",
value=0.25,
style=style)
#self.r_core = widgets.FloatText(description="Core Radius (arcsec): ", value=0.005, style=style)
self.pos_a = widgets.BoundedFloatText(
description="Orientation (deg): ",
value=0,
min=0,
max=359.9,
style=style)
self.sersic = widgets.FloatSlider(description="Sersic Index: ",
value=0.5,
min=0.3,
max=4,
readout_format='.1f',
style=style)
#self.power = widgets.FloatSlider(description="Power Index: ", value=1, min=0.1, max=10, style=style)
self.norm = widgets.Dropdown(
description="Normalize at: ",
options=['infinity', 'scale radius', 'center'],
style=style)
self.norm_flat = widgets.Dropdown(description="Normalize at: ",
options=['infinity', 'center'],
style=style)
#self.prof_box.children = [self.major, self.minor, self.r_core, self.pos_a, self.norm, self.sersic, self.power]
self.prof_box.children = [
self.major, self.minor, self.pos_a, self.norm, self.sersic
]
self.geom_box.children = [self.source_box, self.prof_box]
# Position
self.pos_box = widgets.HBox(padding='10px', width="100%")
self.pos_x = widgets.BoundedFloatText(description="X Position: ",
min=-37.5,
max=37.5)
self.pos_y = widgets.BoundedFloatText(description="Y Position: ",
min=-37.5,
max=37.5)
self.pos_box.children = [self.pos_x, self.pos_y]
# Redshift and Extinction
self.red_box = widgets.HBox(padding='10px', width="100%")
self.redshift = widgets.BoundedFloatText(description="Redshift:",
min=0.0,
max=99999.0,
value=0.0,
width=70)
self.red_box.children = [self.redshift]
self.advanced_options = widgets.Accordion(
children=[self.pos_box, self.geom_box, self.red_box])
self.advanced_options.set_title(0, "Position")
self.advanced_options.set_title(1, "Geometry")
self.advanced_options.set_title(2, "Redshift")
self.advanced_options.selected_index = None
self.advanced_drop = widgets.Accordion(
children=[self.advanced_options])
self.advanced_drop.set_title(0, "ADVANCED")
self.advanced_drop.selected_index = None
self.container.children = [
self.flux_box, self.sed_box, self.advanced_drop
]
self.on_prof_change(dummy)
self.src_select.observe(self.on_prof_change)
def process_interactive(value, kind=None):
INVALID = f"invalid interactive combination between a value of type \
{type(value)} and a widget of kind {kind}"
if isinstance(value, (int, float)):
value = float(value)
if kind == "text":
return widgets.FloatText(value=value, )
elif kind == "slider":
return widgets.FloatSlider(value=value,
min=2 * value * (value < 0),
max=2 * value * (value > 0))
elif kind is not None:
raise ValueError(INVALID)
elif isinstance(value, tuple):
# infer tuple range values
if len(value) > 3:
raise ValueError(f"tuple values should be at most of length \
3, not {len(value)}")
elif len(value) == 1:
return EcoGraph.process_interactive(value[0], kind=kind)
elif len(value) >= 2:
lower, default, upper = value[0], np.mean(value[:2]), value[1]
step = value[2] if len(value) == 3 else 1
# create interactive from infered values
if kind == "text":
return widgets.BoundedFloatText(value=default,
min=lower,
max=upper,
step=step)
elif kind == "slider":
return widgets.FloatSlider(value=default,
min=lower,
max=upper,
step=step)
elif kind == "dropdown":
return widgets.Dropdown(options=range(int(lower), int(upper),
int(step)),
value=int(default))
elif kind is not None:
raise ValueError(INVALID)
elif isinstance(value, list):
if kind == "slider":
return widgets.SelectionSlider(options=value, value=value[0])
elif kind == "dropdown":
return widgets.Dropdown(options=value, value=value[0])
elif kind == "option":
return widgets.RadioButtons(options=value)
elif kind is not None:
raise ValueError(INVALID)
elif isinstance(value, bool):
return EcoGraph.process_interactive([value, not value])
return value
style_mini = {'description_width': '5px'}
style_short = {'description_width': '100px'}
style_med = {'description_width': '250px'}
style_long = {'description_width': '200px'}
layout_mini = Layout(width='18.75%')
layout_50 = Layout(width='50%')
layout_med = Layout(width='70%')
widget_layout = Layout(width='100%')
ξ_base = widgets.BoundedFloatText(
value=0.01,
min=0,
max=1,
step=0.001,
disabled=False,
description=r'Baseline quarantine rate ($\xi^u$)',
style=style_med,
layout=layout_med)
A_rel = widgets.BoundedFloatText(
value=0.5,
min=0,
max=1,
step=0.001,
disabled=False,
description=r'Relative productivity of quarantined ($A_{rel}$)',
style=style_med,
layout=layout_med)
d_vaccine = widgets.BoundedIntText(value=500,
min=20,
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])
