def modify_doc(doc):
source = ColumnDataSource(dict(x=[1, 2], y=[1, 1]))
plot = Plot(plot_height=400,
plot_width=400,
x_range=Range1d(0, 1),
y_range=Range1d(0, 1),
min_border=0)
plot.add_glyph(source, Circle(x='x', y='y', size=20))
plot.add_tools(
CustomAction(callback=CustomJS(args=dict(s=source),
code=RECORD("data", "s.data"))))
button = Dropdown(label="Dropdown button",
menu=items,
css_classes=["foo"])
def cb(attr, old, new):
if new == "item_1_value":
source.data = dict(x=[10, 20], y=[10, 10])
elif new == "item_2_value":
source.data = dict(x=[100, 200], y=[100, 100])
elif new == "item_3_value":
source.data = dict(x=[1000, 2000], y=[1000, 1000])
button.on_change('value', cb)
doc.add_root(column(button, plot))
# create min / max TextInput widgets for updating the value range
update_figs(None, None, None)
# create the results figure object
fig = figure(toolbar_location='above', tools='pan,reset,save', logo='grey', width=700, height=250)
# create the x-var dropdown menu
xmenu = []
for param in r0.keys():
for item in r0[param]:
xmenu.append((item, item))
xmenu.append(None)
xdrop = Dropdown(menu=xmenu[:-1], button_type='primary')
xdrop.on_change('value', update_xdrop)
# create the Panel and Tabs objects for setting up the investment parameters
panels = []
for param in r0.keys():
panels.append(create_panel(param, r0[param]))
tabs = Tabs(tabs=panels, width=1000)
# create the app layout
top = row(fig, widgetbox(xdrop, width=300))
layout = column(top, tabs)
# update the document and initialize the app by setting the Dropdown value
curdoc().add_root(layout)
param0 = list(r0.keys())[0]
xdrop.value = list(r0[param0].keys())[0]
def create(palm):
energy_min = palm.energy_range.min()
energy_max = palm.energy_range.max()
energy_npoints = palm.energy_range.size
current_results = (0, 0, 0, 0)
doc = curdoc()
# Streaked and reference waveforms plot
waveform_plot = Plot(
title=Title(text="eTOF waveforms"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=PLOT_CANVAS_HEIGHT,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location="right",
)
# ---- tools
waveform_plot.toolbar.logo = None
waveform_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(),
ResetTool())
# ---- axes
waveform_plot.add_layout(LinearAxis(axis_label="Photon energy, eV"),
place="below")
waveform_plot.add_layout(LinearAxis(axis_label="Intensity",
major_label_orientation="vertical"),
place="left")
# ---- grid lines
waveform_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
waveform_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- line glyphs
waveform_source = ColumnDataSource(
dict(x_str=[], y_str=[], x_ref=[], y_ref=[]))
waveform_ref_line = waveform_plot.add_glyph(
waveform_source, Line(x="x_ref", y="y_ref", line_color="blue"))
waveform_str_line = waveform_plot.add_glyph(
waveform_source, Line(x="x_str", y="y_str", line_color="red"))
# ---- legend
waveform_plot.add_layout(
Legend(items=[("reference",
[waveform_ref_line]), ("streaked",
[waveform_str_line])]))
waveform_plot.legend.click_policy = "hide"
# Cross-correlation plot
xcorr_plot = Plot(
title=Title(text="Waveforms cross-correlation"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=PLOT_CANVAS_HEIGHT,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location="right",
)
# ---- tools
xcorr_plot.toolbar.logo = None
xcorr_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(),
ResetTool())
# ---- axes
xcorr_plot.add_layout(LinearAxis(axis_label="Energy shift, eV"),
place="below")
xcorr_plot.add_layout(LinearAxis(axis_label="Cross-correlation",
major_label_orientation="vertical"),
place="left")
# ---- grid lines
xcorr_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
xcorr_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- line glyphs
xcorr_source = ColumnDataSource(dict(lags=[], xcorr1=[], xcorr2=[]))
xcorr_plot.add_glyph(
xcorr_source,
Line(x="lags", y="xcorr1", line_color="purple", line_dash="dashed"))
xcorr_plot.add_glyph(xcorr_source,
Line(x="lags", y="xcorr2", line_color="purple"))
# ---- vertical span
xcorr_center_span = Span(location=0, dimension="height")
xcorr_plot.add_layout(xcorr_center_span)
# Delays plot
pulse_delay_plot = Plot(
title=Title(text="Pulse delays"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=PLOT_CANVAS_HEIGHT,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location="right",
)
# ---- tools
pulse_delay_plot.toolbar.logo = None
pulse_delay_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(),
ResetTool())
# ---- axes
pulse_delay_plot.add_layout(LinearAxis(axis_label="Pulse number"),
place="below")
pulse_delay_plot.add_layout(
LinearAxis(axis_label="Pulse delay (uncalib), eV",
major_label_orientation="vertical"),
place="left",
)
# ---- grid lines
pulse_delay_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
pulse_delay_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- line glyphs
pulse_delay_source = ColumnDataSource(dict(pulse=[], delay=[]))
pulse_delay_plot.add_glyph(
pulse_delay_source, Line(x="pulse", y="delay", line_color="steelblue"))
# ---- vertical span
pulse_delay_plot_span = Span(location=0, dimension="height")
pulse_delay_plot.add_layout(pulse_delay_plot_span)
# Pulse lengths plot
pulse_length_plot = Plot(
title=Title(text="Pulse lengths"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=PLOT_CANVAS_HEIGHT,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location="right",
)
# ---- tools
pulse_length_plot.toolbar.logo = None
pulse_length_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(),
ResetTool())
# ---- axes
pulse_length_plot.add_layout(LinearAxis(axis_label="Pulse number"),
place="below")
pulse_length_plot.add_layout(
LinearAxis(axis_label="Pulse length (uncalib), eV",
major_label_orientation="vertical"),
place="left",
)
# ---- grid lines
pulse_length_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
pulse_length_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- line glyphs
pulse_length_source = ColumnDataSource(dict(x=[], y=[]))
pulse_length_plot.add_glyph(pulse_length_source,
Line(x="x", y="y", line_color="steelblue"))
# ---- vertical span
pulse_length_plot_span = Span(location=0, dimension="height")
pulse_length_plot.add_layout(pulse_length_plot_span)
# Folder path text input
def path_textinput_callback(_attr, _old_value, new_value):
save_textinput.value = new_value
path_periodic_update()
path_textinput = TextInput(title="Folder Path:",
value=os.path.join(os.path.expanduser("~")),
width=510)
path_textinput.on_change("value", path_textinput_callback)
# Saved runs dropdown menu
def h5_update(pulse, delays, debug_data):
prep_data, lags, corr_res_uncut, corr_results = debug_data
waveform_source.data.update(
x_str=palm.energy_range,
y_str=prep_data["1"][pulse, :],
x_ref=palm.energy_range,
y_ref=prep_data["0"][pulse, :],
)
xcorr_source.data.update(lags=lags,
xcorr1=corr_res_uncut[pulse, :],
xcorr2=corr_results[pulse, :])
xcorr_center_span.location = delays[pulse]
pulse_delay_plot_span.location = pulse
pulse_length_plot_span.location = pulse
# this placeholder function should be reassigned in 'saved_runs_dropdown_callback'
h5_update_fun = lambda pulse: None
def saved_runs_dropdown_callback(_attr, _old_value, new_value):
if new_value != "Saved Runs":
nonlocal h5_update_fun, current_results
saved_runs_dropdown.label = new_value
filepath = os.path.join(path_textinput.value, new_value)
tags, delays, lengths, debug_data = palm.process_hdf5_file(
filepath, debug=True)
current_results = (new_value, tags, delays, lengths)
if autosave_checkbox.active:
save_button_callback()
pulse_delay_source.data.update(pulse=np.arange(len(delays)),
delay=delays)
pulse_length_source.data.update(x=np.arange(len(lengths)),
y=lengths)
h5_update_fun = partial(h5_update,
delays=delays,
debug_data=debug_data)
pulse_slider.end = len(delays) - 1
pulse_slider.value = 0
h5_update_fun(0)
saved_runs_dropdown = Dropdown(label="Saved Runs",
button_type="primary",
menu=[])
saved_runs_dropdown.on_change("value", saved_runs_dropdown_callback)
# ---- saved run periodic update
def path_periodic_update():
new_menu = []
if os.path.isdir(path_textinput.value):
for entry in os.scandir(path_textinput.value):
if entry.is_file() and entry.name.endswith((".hdf5", ".h5")):
new_menu.append((entry.name, entry.name))
saved_runs_dropdown.menu = sorted(new_menu, reverse=True)
doc.add_periodic_callback(path_periodic_update, 5000)
# Pulse number slider
def pulse_slider_callback(_attr, _old_value, new_value):
h5_update_fun(pulse=new_value)
pulse_slider = Slider(
start=0,
end=99999,
value=0,
step=1,
title="Pulse ID",
callback_policy="throttle",
callback_throttle=500,
)
pulse_slider.on_change("value", pulse_slider_callback)
# Energy maximal range value text input
def energy_max_spinner_callback(_attr, old_value, new_value):
nonlocal energy_max
if new_value > energy_min:
energy_max = new_value
palm.energy_range = np.linspace(energy_min, energy_max,
energy_npoints)
saved_runs_dropdown_callback("", "", saved_runs_dropdown.label)
else:
energy_max_spinner.value = old_value
energy_max_spinner = Spinner(title="Maximal Energy, eV:",
value=energy_max,
step=0.1)
energy_max_spinner.on_change("value", energy_max_spinner_callback)
# Energy minimal range value text input
def energy_min_spinner_callback(_attr, old_value, new_value):
nonlocal energy_min
if new_value < energy_max:
energy_min = new_value
palm.energy_range = np.linspace(energy_min, energy_max,
energy_npoints)
saved_runs_dropdown_callback("", "", saved_runs_dropdown.label)
else:
energy_min_spinner.value = old_value
energy_min_spinner = Spinner(title="Minimal Energy, eV:",
value=energy_min,
step=0.1)
energy_min_spinner.on_change("value", energy_min_spinner_callback)
# Energy number of interpolation points text input
def energy_npoints_spinner_callback(_attr, old_value, new_value):
nonlocal energy_npoints
if new_value > 1:
energy_npoints = new_value
palm.energy_range = np.linspace(energy_min, energy_max,
energy_npoints)
saved_runs_dropdown_callback("", "", saved_runs_dropdown.label)
else:
energy_npoints_spinner.value = old_value
energy_npoints_spinner = Spinner(title="Number of interpolation points:",
value=energy_npoints)
energy_npoints_spinner.on_change("value", energy_npoints_spinner_callback)
# Save location
save_textinput = TextInput(title="Save Folder Path:",
value=os.path.join(os.path.expanduser("~")))
# Autosave checkbox
autosave_checkbox = CheckboxButtonGroup(labels=["Auto Save"],
active=[],
width=250)
# Save button
def save_button_callback():
if current_results[0]:
filename, tags, delays, lengths = current_results
save_filename = os.path.splitext(filename)[0] + ".csv"
df = pd.DataFrame({
"pulse_id": tags,
"pulse_delay": delays,
"pulse_length": lengths
})
df.to_csv(os.path.join(save_textinput.value, save_filename),
index=False)
save_button = Button(label="Save Results",
button_type="default",
width=250)
save_button.on_click(save_button_callback)
# assemble
tab_layout = column(
row(
column(waveform_plot, xcorr_plot),
Spacer(width=30),
column(
path_textinput,
saved_runs_dropdown,
pulse_slider,
Spacer(height=30),
energy_min_spinner,
energy_max_spinner,
energy_npoints_spinner,
Spacer(height=30),
save_textinput,
autosave_checkbox,
save_button,
),
),
row(pulse_delay_plot, Spacer(width=10), pulse_length_plot),
)
return Panel(child=tab_layout, title="HDF5 File")
source_function1 = ColumnDataSource(data=dict(x=[], y=[]))
source_function2 = ColumnDataSource(data=dict(x=[], y=[]))
source_result = ColumnDataSource(data=dict(x=[], y=[]))
source_convolution = ColumnDataSource(data=dict(x=[], y=[]))
source_xmarker = ColumnDataSource(data=dict(x=[], y=[]))
source_overlay = ColumnDataSource(data=dict(x=[], y=[], y_neg=[], y_pos=[]))
# initialize properties
update_is_enabled = True
# initialize controls
# dropdown menu for sample functions
function_type = Dropdown(
label="choose a sample function pair or enter one below",
menu=convolution_settings.sample_function_names)
function_type.on_change('value', function_pair_input_change)
# slider controlling the evaluated x value of the convolved function
x_value_input = Slider(title="x value",
name='x value',
value=convolution_settings.x_value_init,
start=convolution_settings.x_value_min,
end=convolution_settings.x_value_max,
step=convolution_settings.x_value_step)
x_value_input.on_change('value', input_change)
# text input for the first function to be convolved
function1_input = TextInput(value=convolution_settings.function1_input_init,
title="my first function:")
function1_input.on_change('value', input_change)
# text input for the second function to be convolved
function2_input = TextInput(value=convolution_settings.function1_input_init,
)
sh_ess = TextAreaInput(
title='Essay %s: 338 words' % inp_id.value,
rows=30,
cols=50,
value=
"""Dear local newspaper, I think effects computers have on people are great learning skills/affects because they give us time to chat with friends/new people, helps us learn about the globe(astronomy) and keeps us out of troble! Thing about! Dont you think so? How would you feel if your teenager is always on the phone with friends! Do you ever time to chat with your friends or buisness partner about things. Well now - there's a new way to chat the computer, theirs plenty of sites on the internet to do so: @ORGANIZATION1, @ORGANIZATION2, @CAPS1, facebook, myspace ect. Just think now while your setting up meeting with your boss on the computer, your teenager is having fun on the phone not rushing to get off cause you want to use it. How did you learn about other countrys/states outside of yours? Well I have by computer/internet, it's a new way to learn about what going on in our time! You might think your child spends a lot of time on the computer, but ask them so question about the economy, sea floor spreading or even about the @DATE1's you'll be surprise at how much he/she knows. Believe it or not the computer is much interesting then in class all day reading out of books. If your child is home on your computer or at a local library, it's better than being out with friends being fresh, or being perpressured to doing something they know isnt right. You might not know where your child is, @CAPS2 forbidde in a hospital bed because of a drive-by. Rather than your child on the computer learning, chatting or just playing games, safe and sound in your home or community place. Now I hope you have reached a point to understand and agree with me, because computers can have great effects on you or child because it gives us time to chat with friends/new people, helps us learn about the globe and believe or not keeps us out of troble. Thank you for listening."""
)
# ------------------------------------------------------------------------------
# Define functionality of controls
num_tokens.on_change('value', update)
sel_yaxis.on_change('value', update)
sel_xaxis.on_change('value', update)
sel_plot.on_change('value', update)
add_row.on_change('value', change_file)
inp_id.on_change('value', update_pie)
# ------------------------------------------------------------------------------
# Define variable which holds the different columns of our dataframe
columns = [
TableColumn(field='ID', title='ID'),
TableColumn(field='nrOfMatches_AmplifierWordu46Amplifier',
title='Amplifier word'),
TableColumn(field='nrOfMatches_BeWordu46BeAsMainVerb',
title='Be as main verb'),
TableColumn(
field=
'nrOfMatches_CausativeAdverbialSubordinatorWordu46CausativeAdverbialSubordinator',
title='Causative adverbial subordinator'),
div_total_invested_capital = Div()
div_monthly_cash_flow = Div()
div_sale_profit = Div()
div_investment_metrics = Div()
divs = column(
widgetbox(div_total_invested_capital, width=400),
widgetbox(div_monthly_cash_flow, width=400),
widgetbox(div_sale_profit, width=400),
widgetbox(div_investment_metrics, width=400))
# create the app layout, update curdoc
drops = column(
widgetbox(ytext, width=300),
widgetbox(ydrop, width=300),
widgetbox(xtext, width=300),
widgetbox(xdrop, width=300))
top_left = row(drops, fig)
bottom_left = row(panels)
left = column(top_left, bottom_left)
layout = row(left, divs)
curdoc().add_root(layout)
# initialize the app thru setting the initial Dropdown value and callbacks
param0 = list(r0.keys())[0]
xdrop.label = list(r0[param0].keys())[0]
xdrop.value = xdrop.label
ydrop.label = ymenu[0]
xdrop.on_change('value', partial(update_drop, drop_type='x'))
ydrop.on_change('value', partial(update_drop, drop_type='y'))
ydrop.value = ydrop.label
def create(palm):
doc = curdoc()
# Calibration averaged waveforms per photon energy
waveform_plot = Plot(
title=Title(text="eTOF calibration waveforms"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=760,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location="right",
)
# ---- tools
waveform_plot.toolbar.logo = None
waveform_plot_hovertool = HoverTool(
tooltips=[("energy, eV", "@en"), ("eTOF bin", "$x{0.}")])
waveform_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(),
ResetTool(), waveform_plot_hovertool)
# ---- axes
waveform_plot.add_layout(LinearAxis(axis_label="eTOF time bin"),
place="below")
waveform_plot.add_layout(LinearAxis(axis_label="Intensity",
major_label_orientation="vertical"),
place="left")
# ---- grid lines
waveform_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
waveform_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- multiline glyphs
waveform_ref_source = ColumnDataSource(dict(xs=[], ys=[], en=[]))
waveform_ref_multiline = waveform_plot.add_glyph(
waveform_ref_source, MultiLine(xs="xs", ys="ys", line_color="blue"))
waveform_str_source = ColumnDataSource(dict(xs=[], ys=[], en=[]))
waveform_str_multiline = waveform_plot.add_glyph(
waveform_str_source, MultiLine(xs="xs", ys="ys", line_color="red"))
# ---- legend
waveform_plot.add_layout(
Legend(items=[(
"reference",
[waveform_ref_multiline]), ("streaked",
[waveform_str_multiline])]))
waveform_plot.legend.click_policy = "hide"
# ---- vertical spans
photon_peak_ref_span = Span(location=0,
dimension="height",
line_dash="dashed",
line_color="blue")
photon_peak_str_span = Span(location=0,
dimension="height",
line_dash="dashed",
line_color="red")
waveform_plot.add_layout(photon_peak_ref_span)
waveform_plot.add_layout(photon_peak_str_span)
# Calibration fit plot
fit_plot = Plot(
title=Title(text="eTOF calibration fit"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=PLOT_CANVAS_HEIGHT,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location="right",
)
# ---- tools
fit_plot.toolbar.logo = None
fit_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(), ResetTool())
# ---- axes
fit_plot.add_layout(LinearAxis(axis_label="Photoelectron peak shift"),
place="below")
fit_plot.add_layout(LinearAxis(axis_label="Photon energy, eV",
major_label_orientation="vertical"),
place="left")
# ---- grid lines
fit_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
fit_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- circle glyphs
fit_ref_circle_source = ColumnDataSource(dict(x=[], y=[]))
fit_ref_circle = fit_plot.add_glyph(
fit_ref_circle_source, Circle(x="x", y="y", line_color="blue"))
fit_str_circle_source = ColumnDataSource(dict(x=[], y=[]))
fit_str_circle = fit_plot.add_glyph(fit_str_circle_source,
Circle(x="x", y="y", line_color="red"))
# ---- line glyphs
fit_ref_line_source = ColumnDataSource(dict(x=[], y=[]))
fit_ref_line = fit_plot.add_glyph(fit_ref_line_source,
Line(x="x", y="y", line_color="blue"))
fit_str_line_source = ColumnDataSource(dict(x=[], y=[]))
fit_str_line = fit_plot.add_glyph(fit_str_line_source,
Line(x="x", y="y", line_color="red"))
# ---- legend
fit_plot.add_layout(
Legend(items=[
("reference", [fit_ref_circle, fit_ref_line]),
("streaked", [fit_str_circle, fit_str_line]),
]))
fit_plot.legend.click_policy = "hide"
# Calibration results datatables
def datatable_ref_source_callback(_attr, _old_value, new_value):
for en, ps, use in zip(new_value["energy"], new_value["peak_pos_ref"],
new_value["use_in_fit"]):
palm.etofs["0"].calib_data.loc[
en, "calib_tpeak"] = ps if ps != "NaN" else np.nan
palm.etofs["0"].calib_data.loc[en, "use_in_fit"] = use
calib_res = {}
for etof_key in palm.etofs:
calib_res[etof_key] = palm.etofs[etof_key].fit_calibration_curve()
update_calibration_plot(calib_res)
datatable_ref_source = ColumnDataSource(
dict(energy=["", "", ""],
peak_pos_ref=["", "", ""],
use_in_fit=[True, True, True]))
datatable_ref_source.on_change("data", datatable_ref_source_callback)
datatable_ref = DataTable(
source=datatable_ref_source,
columns=[
TableColumn(field="energy",
title="Photon Energy, eV",
editor=IntEditor()),
TableColumn(field="peak_pos_ref",
title="Reference Peak",
editor=IntEditor()),
TableColumn(field="use_in_fit",
title=" ",
editor=CheckboxEditor(),
width=80),
],
index_position=None,
editable=True,
height=300,
width=250,
)
def datatable_str_source_callback(_attr, _old_value, new_value):
for en, ps, use in zip(new_value["energy"], new_value["peak_pos_str"],
new_value["use_in_fit"]):
palm.etofs["1"].calib_data.loc[
en, "calib_tpeak"] = ps if ps != "NaN" else np.nan
palm.etofs["1"].calib_data.loc[en, "use_in_fit"] = use
calib_res = {}
for etof_key in palm.etofs:
calib_res[etof_key] = palm.etofs[etof_key].fit_calibration_curve()
update_calibration_plot(calib_res)
datatable_str_source = ColumnDataSource(
dict(energy=["", "", ""],
peak_pos_str=["", "", ""],
use_in_fit=[True, True, True]))
datatable_str_source.on_change("data", datatable_str_source_callback)
datatable_str = DataTable(
source=datatable_str_source,
columns=[
TableColumn(field="energy",
title="Photon Energy, eV",
editor=IntEditor()),
TableColumn(field="peak_pos_str",
title="Streaked Peak",
editor=IntEditor()),
TableColumn(field="use_in_fit",
title=" ",
editor=CheckboxEditor(),
width=80),
],
index_position=None,
editable=True,
height=350,
width=250,
)
# eTOF calibration folder path text input
def path_textinput_callback(_attr, _old_value, _new_value):
path_periodic_update()
update_load_dropdown_menu()
path_textinput = TextInput(title="eTOF calibration path:",
value=os.path.join(os.path.expanduser("~")),
width=510)
path_textinput.on_change("value", path_textinput_callback)
# eTOF calibration eco scans dropdown
def scans_dropdown_callback(_attr, _old_value, new_value):
scans_dropdown.label = new_value
scans_dropdown = Dropdown(label="ECO scans",
button_type="default",
menu=[])
scans_dropdown.on_change("value", scans_dropdown_callback)
# ---- etof scans periodic update
def path_periodic_update():
new_menu = []
if os.path.isdir(path_textinput.value):
for entry in os.scandir(path_textinput.value):
if entry.is_file() and entry.name.endswith(".json"):
new_menu.append((entry.name, entry.name))
scans_dropdown.menu = sorted(new_menu, reverse=True)
doc.add_periodic_callback(path_periodic_update, 5000)
# Calibrate button
def calibrate_button_callback():
try:
palm.calibrate_etof_eco(eco_scan_filename=os.path.join(
path_textinput.value, scans_dropdown.value))
except Exception:
palm.calibrate_etof(folder_name=path_textinput.value)
datatable_ref_source.data.update(
energy=palm.etofs["0"].calib_data.index.tolist(),
peak_pos_ref=palm.etofs["0"].calib_data["calib_tpeak"].tolist(),
use_in_fit=palm.etofs["0"].calib_data["use_in_fit"].tolist(),
)
datatable_str_source.data.update(
energy=palm.etofs["0"].calib_data.index.tolist(),
peak_pos_str=palm.etofs["1"].calib_data["calib_tpeak"].tolist(),
use_in_fit=palm.etofs["1"].calib_data["use_in_fit"].tolist(),
)
def update_calibration_plot(calib_res):
etof_ref = palm.etofs["0"]
etof_str = palm.etofs["1"]
shift_val = 0
etof_ref_wf_shifted = []
etof_str_wf_shifted = []
for wf_ref, wf_str in zip(etof_ref.calib_data["waveform"],
etof_str.calib_data["waveform"]):
shift_val -= max(wf_ref.max(), wf_str.max())
etof_ref_wf_shifted.append(wf_ref + shift_val)
etof_str_wf_shifted.append(wf_str + shift_val)
waveform_ref_source.data.update(
xs=len(etof_ref.calib_data) *
[list(range(etof_ref.internal_time_bins))],
ys=etof_ref_wf_shifted,
en=etof_ref.calib_data.index.tolist(),
)
waveform_str_source.data.update(
xs=len(etof_str.calib_data) *
[list(range(etof_str.internal_time_bins))],
ys=etof_str_wf_shifted,
en=etof_str.calib_data.index.tolist(),
)
photon_peak_ref_span.location = etof_ref.calib_t0
photon_peak_str_span.location = etof_str.calib_t0
def plot_fit(time, calib_a, calib_b):
time_fit = np.linspace(np.nanmin(time), np.nanmax(time), 100)
en_fit = (calib_a / time_fit)**2 + calib_b
return time_fit, en_fit
def update_plot(calib_results, circle, line):
(a, c), x, y = calib_results
x_fit, y_fit = plot_fit(x, a, c)
circle.data.update(x=x, y=y)
line.data.update(x=x_fit, y=y_fit)
update_plot(calib_res["0"], fit_ref_circle_source, fit_ref_line_source)
update_plot(calib_res["1"], fit_str_circle_source, fit_str_line_source)
calib_const_div.text = f"""
a_str = {etof_str.calib_a:.2f}<br>
b_str = {etof_str.calib_b:.2f}<br>
<br>
a_ref = {etof_ref.calib_a:.2f}<br>
b_ref = {etof_ref.calib_b:.2f}
"""
calibrate_button = Button(label="Calibrate eTOF",
button_type="default",
width=250)
calibrate_button.on_click(calibrate_button_callback)
# Photon peak noise threshold value text input
def phot_peak_noise_thr_spinner_callback(_attr, old_value, new_value):
if new_value > 0:
for etof in palm.etofs.values():
etof.photon_peak_noise_thr = new_value
else:
phot_peak_noise_thr_spinner.value = old_value
phot_peak_noise_thr_spinner = Spinner(title="Photon peak noise threshold:",
value=1,
step=0.1)
phot_peak_noise_thr_spinner.on_change(
"value", phot_peak_noise_thr_spinner_callback)
# Electron peak noise threshold value text input
def el_peak_noise_thr_spinner_callback(_attr, old_value, new_value):
if new_value > 0:
for etof in palm.etofs.values():
etof.electron_peak_noise_thr = new_value
else:
el_peak_noise_thr_spinner.value = old_value
el_peak_noise_thr_spinner = Spinner(title="Electron peak noise threshold:",
value=10,
step=0.1)
el_peak_noise_thr_spinner.on_change("value",
el_peak_noise_thr_spinner_callback)
# Save calibration button
def save_button_callback():
palm.save_etof_calib(path=path_textinput.value)
update_load_dropdown_menu()
save_button = Button(label="Save", button_type="default", width=250)
save_button.on_click(save_button_callback)
# Load calibration button
def load_dropdown_callback(_attr, _old_value, new_value):
if new_value:
palm.load_etof_calib(os.path.join(path_textinput.value, new_value))
datatable_ref_source.data.update(
energy=palm.etofs["0"].calib_data.index.tolist(),
peak_pos_ref=palm.etofs["0"].calib_data["calib_tpeak"].tolist(
),
use_in_fit=palm.etofs["0"].calib_data["use_in_fit"].tolist(),
)
datatable_str_source.data.update(
energy=palm.etofs["0"].calib_data.index.tolist(),
peak_pos_str=palm.etofs["1"].calib_data["calib_tpeak"].tolist(
),
use_in_fit=palm.etofs["1"].calib_data["use_in_fit"].tolist(),
)
# Drop selection, so that this callback can be triggered again on the same dropdown menu
# item from the user perspective
load_dropdown.value = ""
def update_load_dropdown_menu():
new_menu = []
calib_file_ext = ".palm_etof"
if os.path.isdir(path_textinput.value):
for entry in os.scandir(path_textinput.value):
if entry.is_file() and entry.name.endswith((calib_file_ext)):
new_menu.append(
(entry.name[:-len(calib_file_ext)], entry.name))
load_dropdown.button_type = "default"
load_dropdown.menu = sorted(new_menu, reverse=True)
else:
load_dropdown.button_type = "danger"
load_dropdown.menu = new_menu
doc.add_next_tick_callback(update_load_dropdown_menu)
doc.add_periodic_callback(update_load_dropdown_menu, 5000)
load_dropdown = Dropdown(label="Load", menu=[], width=250)
load_dropdown.on_change("value", load_dropdown_callback)
# eTOF fitting equation
fit_eq_div = Div(
text="""Fitting equation:<br><br><img src="/palm/static/5euwuy.gif">"""
)
# Calibration constants
calib_const_div = Div(text=f"""
a_str = {0}<br>
b_str = {0}<br>
<br>
a_ref = {0}<br>
b_ref = {0}
""")
# assemble
tab_layout = column(
row(
column(waveform_plot, fit_plot),
Spacer(width=30),
column(
path_textinput,
scans_dropdown,
calibrate_button,
phot_peak_noise_thr_spinner,
el_peak_noise_thr_spinner,
row(save_button, load_dropdown),
row(datatable_ref, datatable_str),
calib_const_div,
fit_eq_div,
),
))
return Panel(child=tab_layout, title="eTOF Calibration")
source = ColumnDataSource(data=dict(x=x, y=y, color=c))
plot_figure = figure(title='Dropdown',
plot_height=450,
plot_width=600,
tools="save,reset",
toolbar_location="below")
plot_figure.scatter('x', 'y', color='color', source=source, size=10)
menu = [("Red", "red"), ("Green", "green")]
dropdown = Dropdown(label="Choose color for plot", menu=menu)
def dropdown_click(attr, old, new):
active_dropdown = dropdown.value ##Getting dropdown value
if active_dropdown == 'red':
c = ['red', 'red', 'red', 'red', 'red', 'red']
elif active_dropdown == 'green':
c = ['green', 'green', 'green', 'green', 'green', 'green']
source.data = dict(x=x, y=y, color=c)
dropdown.on_change('value', dropdown_click)
layout = row(dropdown, plot_figure)
curdoc().add_root(layout)
curdoc().title = "Checkbox Bokeh Server"
def create(palm):
fit_max = 1
fit_min = 0
doc = curdoc()
# THz calibration plot
scan_plot = Plot(
title=Title(text="THz calibration"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=PLOT_CANVAS_HEIGHT,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location="right",
)
# ---- tools
scan_plot.toolbar.logo = None
scan_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(), ResetTool())
# ---- axes
scan_plot.add_layout(LinearAxis(axis_label="Stage delay motor"),
place="below")
scan_plot.add_layout(LinearAxis(axis_label="Energy shift, eV",
major_label_orientation="vertical"),
place="left")
# ---- grid lines
scan_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
scan_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- circle cluster glyphs
scan_circle_source = ColumnDataSource(dict(x=[], y=[]))
scan_plot.add_glyph(scan_circle_source,
Circle(x="x", y="y", line_alpha=0, fill_alpha=0.5))
# ---- circle glyphs
scan_avg_circle_source = ColumnDataSource(dict(x=[], y=[]))
scan_plot.add_glyph(
scan_avg_circle_source,
Circle(x="x", y="y", line_color="purple", fill_color="purple"))
# ---- line glyphs
fit_line_source = ColumnDataSource(dict(x=[], y=[]))
scan_plot.add_glyph(fit_line_source, Line(x="x",
y="y",
line_color="purple"))
# THz calibration folder path text input
def path_textinput_callback(_attr, _old_value, _new_value):
update_load_dropdown_menu()
path_periodic_update()
path_textinput = TextInput(title="THz calibration path:",
value=os.path.join(os.path.expanduser("~")),
width=510)
path_textinput.on_change("value", path_textinput_callback)
# THz calibration eco scans dropdown
def scans_dropdown_callback(_attr, _old_value, new_value):
scans_dropdown.label = new_value
scans_dropdown = Dropdown(label="ECO scans",
button_type="default",
menu=[])
scans_dropdown.on_change("value", scans_dropdown_callback)
# ---- eco scans periodic update
def path_periodic_update():
new_menu = []
if os.path.isdir(path_textinput.value):
for entry in os.scandir(path_textinput.value):
if entry.is_file() and entry.name.endswith(".json"):
new_menu.append((entry.name, entry.name))
scans_dropdown.menu = sorted(new_menu, reverse=True)
doc.add_periodic_callback(path_periodic_update, 5000)
# Calibrate button
def calibrate_button_callback():
palm.calibrate_thz(
path=os.path.join(path_textinput.value, scans_dropdown.value))
fit_max_spinner.value = np.ceil(palm.thz_calib_data.index.values.max())
fit_min_spinner.value = np.floor(
palm.thz_calib_data.index.values.min())
update_calibration_plot()
def update_calibration_plot():
scan_plot.xaxis.axis_label = f"{palm.thz_motor_name}, {palm.thz_motor_unit}"
scan_circle_source.data.update(
x=np.repeat(palm.thz_calib_data.index,
palm.thz_calib_data["peak_shift"].apply(len)).tolist(),
y=np.concatenate(
palm.thz_calib_data["peak_shift"].values).tolist(),
)
scan_avg_circle_source.data.update(
x=palm.thz_calib_data.index.tolist(),
y=palm.thz_calib_data["peak_shift_mean"].tolist())
x = np.linspace(fit_min, fit_max, 100)
y = palm.thz_slope * x + palm.thz_intersect
fit_line_source.data.update(x=np.round(x, decimals=5),
y=np.round(y, decimals=5))
calib_const_div.text = f"""
thz_slope = {palm.thz_slope}
"""
calibrate_button = Button(label="Calibrate THz",
button_type="default",
width=250)
calibrate_button.on_click(calibrate_button_callback)
# THz fit maximal value text input
def fit_max_spinner_callback(_attr, old_value, new_value):
nonlocal fit_max
if new_value > fit_min:
fit_max = new_value
palm.calibrate_thz(
path=os.path.join(path_textinput.value, scans_dropdown.value),
fit_range=(fit_min, fit_max),
)
update_calibration_plot()
else:
fit_max_spinner.value = old_value
fit_max_spinner = Spinner(title="Maximal fit value:",
value=fit_max,
step=0.1)
fit_max_spinner.on_change("value", fit_max_spinner_callback)
# THz fit maximal value text input
def fit_min_spinner_callback(_attr, old_value, new_value):
nonlocal fit_min
if new_value < fit_max:
fit_min = new_value
palm.calibrate_thz(
path=os.path.join(path_textinput.value, scans_dropdown.value),
fit_range=(fit_min, fit_max),
)
update_calibration_plot()
else:
fit_min_spinner.value = old_value
fit_min_spinner = Spinner(title="Minimal fit value:",
value=fit_min,
step=0.1)
fit_min_spinner.on_change("value", fit_min_spinner_callback)
# Save calibration button
def save_button_callback():
palm.save_thz_calib(path=path_textinput.value)
update_load_dropdown_menu()
save_button = Button(label="Save", button_type="default", width=250)
save_button.on_click(save_button_callback)
# Load calibration button
def load_dropdown_callback(_attr, _old_value, new_value):
palm.load_thz_calib(os.path.join(path_textinput.value, new_value))
update_calibration_plot()
def update_load_dropdown_menu():
new_menu = []
calib_file_ext = ".palm_thz"
if os.path.isdir(path_textinput.value):
for entry in os.scandir(path_textinput.value):
if entry.is_file() and entry.name.endswith((calib_file_ext)):
new_menu.append(
(entry.name[:-len(calib_file_ext)], entry.name))
load_dropdown.button_type = "default"
load_dropdown.menu = sorted(new_menu, reverse=True)
else:
load_dropdown.button_type = "danger"
load_dropdown.menu = new_menu
doc.add_next_tick_callback(update_load_dropdown_menu)
doc.add_periodic_callback(update_load_dropdown_menu, 5000)
load_dropdown = Dropdown(label="Load", menu=[], width=250)
load_dropdown.on_change("value", load_dropdown_callback)
# Calibration constants
calib_const_div = Div(text=f"""
thz_slope = {0}
""")
# assemble
tab_layout = column(
row(
scan_plot,
Spacer(width=30),
column(
path_textinput,
scans_dropdown,
calibrate_button,
fit_max_spinner,
fit_min_spinner,
row(save_button, load_dropdown),
calib_const_div,
),
))
return Panel(child=tab_layout, title="THz Calibration")
fill_color=factor_cmap('x',
palette=palette,
factors=result['genders'],
start=1,
end=2))
# create a plot and style its properties
p.y_range.start = 0
p.x_range.range_padding = 0.025
p.xaxis.major_label_orientation = 1
p.xgrid.grid_line_color = None
# create a callback
def dropdown_callback(attr, old, new):
result = getMedals(new)
counts = sum(zip(result['data']['men'], result['data']['women']), ())
p.x_range = FactorRange(*result['range'])
r.data_source.data = dict(x=result['range'], counts=counts)
# button details, range restrictions for display, with the callback
menu = [("1900", "1900"), ("1920", "1920"), ("1950", "1950"), ("1960", "1960"),
("1970", "1970"), ("1980", "1980"), ("1990", "1990"), ("2000", "2000"),
("2010", "2010"), ("2016", "2016")]
dropdown = Dropdown(label="Start Year", button_type="warning", menu=menu)
dropdown.on_change("value", dropdown_callback)
# add button to the graph page
curdoc().add_root(column(dropdown, p))
odesystem_settings.init_fun_key][0],
title="u(x,y):")
v_input = TextInput(value=odesystem_settings.sample_system_functions[
odesystem_settings.init_fun_key][1],
title="v(x,y):")
# dropdown menu for selecting one of the sample functions
sample_fun_input = Dropdown(
label="choose a sample function pair or enter one below",
menu=odesystem_settings.sample_system_names)
# Interactor for entering starting point of initial condition
interactor = my_bokeh_utils.Interactor(plot)
# initialize callback behaviour
sample_fun_input.on_change('value', sample_fun_change)
u_input.on_change('value', ode_change)
v_input.on_change('value', ode_change)
interactor.on_click(initial_value_change)
# calculate data
init_data()
# lists all the controls in our app associated with the default_funs panel
function_controls = widgetbox(sample_fun_input, u_input, v_input, width=400)
# refresh quiver field and streamline all 100ms
curdoc().add_periodic_callback(refresh_user_view, 100)
# make layout
curdoc().add_root(row(function_controls, plot))
curdoc().title = split(dirname(__file__))[-1].replace('_', ' ').replace(
to_remove = curdoc().get_model_by_name('view_space')
listOfSubLayouts.remove(to_remove)
plot = globals()[category_names[str(dropdown.value)]](
db) #programming(db)
listOfSubLayouts.append(column(plot, name='view_space'))
print("HOLI")
dropdown = Dropdown(
label='Categories',
menu=[(x, y)
for x, y in zip(category_names.keys(), category_names.keys())],
value='Basic needs')
dropdown_widget = widgetbox(dropdown, name='dropdown')
dropdown.on_change('value', lambda attr, old, new: update_dropdown(
db, category_names)) #, lambda attr, old, new: update_view())
plot = column(basic_needs(db), name='view_space')
curdoc().add_root(row(dropdown_widget, plot, name='main_layout'))
curdoc().title = "Dashboard"
#show(barplot_prerelease_preparation)
#curdoc().title = "Dashboard"
#curdoc().add_root(column(barplot_prerelease_preparation,table_prerelease_programming))
#p.xgrid.grid_line_color = None
#p.y_range.start = 0
#p.y_range.end = 9
#p.legend.orientation = "horizontal"
#p.legend.location = "top_center"
class ToolDesc:
def __init__(self):
self.rubric = pd.read_excel(
os.path.join(file_path, "data/Rubric.xlsx"), "Rubric v3")
self.tool_list = self.rubric.drop(
["Category", "Criteria", "Grading Scale", "Definition"],
axis=1).columns
self.tool_dir = os.listdir(os.path.join(file_path, "static/images"))
self.select_tool = Dropdown(menu=list(
zip(self.tool_list, self.tool_list)),
label="Choose Tool",
button_type="primary")
self.select_tool.on_change("value", self.select_callback)
self.app_layout = layout(self.select_tool)
def select_callback(self, attr, old, new):
self.get_images(new)
def get_images(self, tool):
tool_images = []
for t in self.tool_dir:
if t == tool:
img_dir = os.path.join("app/static/images", t)
txt_dir = os.path.join("app/static/text", t)
images = os.listdir(img_dir)
texts = os.listdir(txt_dir)
y = [
int(re.search(r"_(\d+)\.(png|txt)$", i).group(1))
for i in images
]
y += [
int(re.search(r"_(\d+)\.(png|txt)$", i).group(1))
for i in texts if i != ".gitignore"
]
img_path = [os.path.join(img_dir, i) for i in images]
txt_path = [os.path.join(txt_dir, i) for i in texts]
all_files = img_path + txt_path
tool_images.extend(list(zip(y, all_files)))
div_layout = []
count = 0
for i in sorted(tool_images):
file_type = re.search(r"\.(png|txt)$", i[1]).group(1)
if file_type == "txt":
try:
head = re.search(r"_(h\d)_", i[1]).group(1)
except AttributeError:
head = None
if head == "h1":
font_size = 26
elif head == "h2":
font_size = 20
elif head == "h3":
font_size = 14
else:
font_size = 11
with open(i[1], "r") as rf:
txt = rf.read()
div_layout.append(
Div(text=txt,
style={"font-size": "{}pt".format(font_size)},
width=1000))
else:
div_layout.append(Div(text="<img src = '{}'>".format(i[1])))
if len(self.app_layout.children) > 1:
self.app_layout.children.pop(1)
# except IndexError:
# pass
self.app_layout.children.append(layout(div_layout))
