コード例 #1
0
ファイル: example2.py プロジェクト: Cadair/ginga
def main(options, args):
    
    logger = log.get_logger("ginga", options=options)

    # create a new plot with default tools, using figure
    fig = figure(x_range=[0,600], y_range=[0,600], plot_width=600, plot_height=600,
                 toolbar_location=None)

    viewer = ib.CanvasView(logger)
    viewer.set_figure(fig)

    def load_file(path):
        image = AstroImage(logger)
        image.load_file(path)
        viewer.set_image(image)

    def load_file_cb(attr_name, old_val, new_val):
        #print(attr_name, old_val, new_val)
        load_file(new_val)

    # add a entry widget and configure with the call back
    dstdir = options.indir
    path_w = TextInput(value=dstdir, title="File:")
    path_w.on_change('value', load_file_cb)

    if len(args) > 0:
        load_file(args[0])

    # put the path widget and viewer in a layout and add to the document
    curdoc().add_root(vplot(fig, path_w))
コード例 #2
0
ファイル: risk_app.py プロジェクト: steve98654/bokeh-demos
    def make_inputs(self):

        self.ticker1_select = Select(
            name='ticker1',
            title='Portfolio:',
            value='MSFT',
            options = ['INTC', 'Tech Basket', 'IBB', 'IGOV']
        )
        self.ticker2_select = Select(
            name='ticker2',
            title='Risk/Performance Metric:',
            value='Price',
            options=['Daily Prices', 'Daily Returns', 'Daily Cum Returns', 'Max DD Percentage', 'Percentage Up Days', 'Rolling 95% VaR', 'Rolling Ann. Volatility', 'Rolling Worst Dly. Loss', 'Ann. Sharpe Ratio']
        )
        self.ticker3_select = TextInput(
            name='ticker3',
            title='Window Size:',
            value='63'
        )
        self.ticker4_select = TextInput(
            name='ticker4',
            title='Start Date:',
            value='2010-01-01'
        )
        self.ticker5_select = TextInput(
            name='ticker5',
            title='End Date:',
            value='2015-08-01'
        )
コード例 #3
0
ファイル: mc_bokeh.py プロジェクト: steve98654/bokeh-demos
    def make_inputs(self):

        self.ticker1_select = TextInput(
            name='ticker1',
            title='Drift Function:',
            value='1.2*(1.1-x)',
        )
        self.ticker1p_select = TextInput(
            name='ticker1p',
            title='Drift Derivative:',
            value='-1.2',
        )
        self.ticker2_select = TextInput(
            name='ticker2',
            title='Volatility Function:',
            value='4.0',
        )
        self.ticker2p_select = TextInput(
            name='ticker2p',
            title='Volatility Derivative:',
            value='0.0',
        )
        self.ticker3_select = TextInput(
            name='ticker3',
            title='Number of Paths:',
            value='500'
        )
        self.ticker3_1_select = TextInput(
            name='ticker3_1',
            title='Number of Points:',
            value='252'
        )
        self.ticker3_2_select = TextInput(
            name='ticker3_2',
            title='Time Step:',
            value='0.01'
        )
        self.ticker4_select = TextInput(
            name='ticker4',
            title='Histogram Line:',
            value='100'
        )
        self.ticker4_1_select = TextInput(
            name='ticker4_1',
            title='Initial Value:',
            value='1.01'
        )
        self.ticker4_2_select = Select(
            name='ticker4_2',
            title='MC Scheme:',
            value='Milstein',
            options=['Euler','Milstein', 'Pred/Corr']
        )
        self.button_select = TextInput(
            name='button',
            title='Type any word containing "run" to run Simulation ',
            value = ''
        )
コード例 #4
0
def plot():
    # Set up data
    N = 200
    x = np.linspace(0, 4*np.pi, N)
    y = np.sin(x)
    source = ColumnDataSource(data=dict(x=x, y=y))


    # Set up plots
    plot = Figure(plot_height=400, plot_width=400, title="my sine wave",
                  tools="crosshair,pan,reset,resize,save,wheel_zoom",
                  x_range=[0, 4*np.pi], y_range=[-2.5, 2.5])

    plot.line('x', 'y', source=source, line_width=3, line_alpha=0.6)


    # Set up widgets
    text = TextInput(title="title", value='my sine wave')
    offset = Slider(title="offset", value=0.0, start=-5.0, end=5.0, step=0.1)
    amplitude = Slider(title="amplitude", value=1.0, start=-5.0, end=5.0)
    phase = Slider(title="phase", value=0.0, start=0.0, end=2*np.pi)
    freq = Slider(title="frequency", value=1.0, start=0.1, end=5.1)


    # Set up callbacks
    def update_title(attrname, old, new):
        plot.title = text.value

    text.on_change('value', update_title)

    def update_data(attrname, old, new):

        # Get the current slider values
        a = amplitude.value
        b = offset.value
        w = phase.value
        k = freq.value

        # Generate the new curve
        x = np.linspace(0, 4*np.pi, N)
        y = a*np.sin(k*x + w) + b

        source.data = dict(x=x, y=y)

    for w in [offset, amplitude, phase, freq]:
        w.on_change('value', update_data)


    # Set up layouts and add to document
    inputs = VBoxForm(children=[text, offset, amplitude, phase, freq])
    fullformat = HBox(children=[inputs, plot], width=800)

    return fullformat, []
コード例 #5
0
ファイル: example1.py プロジェクト: Cadair/ginga
def main(options, args):
    
    logger = log.get_logger("ginga", options=options)

    TOOLS = "pan,wheel_zoom,box_select,tap"
    
    # create a new plot with default tools, using figure
    fig = figure(x_range=[0,600], y_range=[0,600], plot_width=600, plot_height=600,
                 tools=TOOLS)

    viewer = ib.CanvasView(logger)
    viewer.set_figure(fig)

    ## box_select_tool = fig.select(dict(type=BoxSelectTool))
    ## box_select_tool.select_every_mousemove = True
    #tap_tool = fig.select_one(TapTool).renderers = [cr]

    # open a session to keep our local document in sync with server
    session = push_session(curdoc())

    #curdoc().add_periodic_callback(update, 50)

    def load_file(path):
        image = AstroImage(logger)
        image.load_file(path)
        viewer.set_image(image)

    def load_file_cb(attr_name, old_val, new_val):
        #print(attr_name, old_val, new_val)
        load_file(new_val)

    # add a entry widget and configure with the call back
    dstdir = options.indir
    path_w = TextInput(value=dstdir, title="File:")
    path_w.on_change('value', load_file_cb)

    curdoc().add_root(vplot(fig, path_w))

    if len(args) > 0:
        load_file(args[0])

    # open the document in a browser
    session.show() 

    # run forever
    session.loop_until_closed() 
コード例 #6
0
def plot():

    # FIGURES AND X-AXIS
    fig1 = Figure(title = 'Energy',  plot_width = WIDTH, plot_height = HEIGHT, tools = TOOLS)

    timeticks = DatetimeTickFormatter(formats=dict(seconds =["%b%d %H:%M:%S"],
                                                   minutes =["%b%d %H:%M"],
                                                   hours =["%b%d %H:%M"],
                                                   days  =["%b%d %H:%M"],
                                                   months=["%b%d %H:%M"],
                                                   years =["%b%d %H:%M %Y"]))
    fig1.xaxis.formatter = timeticks

    # INPUT WIDGETS
    collection_list = CONN[DB].collection_names(include_system_collections=False)
    gliders = sorted([platformID for platformID in collection_list if len(platformID)>2])
    gliders = Select(title = 'PlatformID', value = gliders[0], options = gliders)
    prev_glider = Button(label = '<')
    next_glider = Button(label = '>')
    glider_controlbox = HBox(children = [gliders, prev_glider, next_glider])

    max_amphr = TextInput(title='Max AmpHrs', value='1040')
    deadby_date = TextInput(title='Deadby Date', value='')
    data_controlbox = HBox(max_amphr, deadby_date,  width = 300)

    control_box = HBox(glider_controlbox,
                       data_controlbox)

    # DATA VARS
    coulombs_raw = ColumnDataSource(dict(x=[],y=[]))
    coulombs_ext = ColumnDataSource(dict(x=[],y=[]))
    coulombs_per = ColumnDataSource(dict(x=[],y=[]))

    # AXIS setup
    fig1.yaxis.axis_label = 'Coulombs (AmpHr)'
    fig1.extra_y_ranges = {'usage': Range1d(start=0, end=1200)}


    # PLOT OBJECTS
    fig1.line(  'x', 'y', source = coulombs_raw, legend = 'm_coulombs_amphr_total', color = 'blue')
    fig1.circle('x', 'y', source = coulombs_raw, legend = 'm_coulombs_amphr_total', color = 'blue')
    fig1.line(  'x', 'y', source = coulombs_ext, legend = 'projected',              color = 'red')
    #fig1.cross('x', 'y', source = coulombs_ext, legend = 'projected',  size=10,     color = 'red')
    fig1.renderers.append(Span(name = 'maxamp_span',      location = int(max_amphr.value),  dimension = 'width',  line_color= 'green', line_dash='dashed', line_width=2))
    fig1.renderers.append(Span(name = 'maxamp_intersect', location = 1000*time.time(),      dimension = 'height', line_color= 'green', line_dash='dashed', line_width=2))

    fig1.legend[0].location = 'top_left'
    fig1.legend[0].legend_padding = 30

    # CALLBACK FUNCS
    def update_coulombs(attrib,old,new):
        g = gliders.value

        coulombs_raw.data   = load_sensor(g, 'm_coulomb_amphr_total')
        #coulombs_per.data  = moving_usage(coulombs_raw.data)
        update_projection(None,None,None)


    def update_projection(attrib,old,new):
        g = gliders.value
        try:
            fig1.select('maxamp_span')[0].location = int(max_amphr.value)
            coulombs_ext.data, deadby_date.value = calc_deadby_date(g, int(max_amphr.value))
            fig1.select('maxamp_intersect')[0].location = coulombs_ext.data['x'][-1]
        except Exception as e:
            print('update_projection error',type(e),e)

    #GLIDER SELECTS
    def glider_buttons(increment):
        ops = gliders.options
        new_index = ops.index(gliders.value) + increment
        if new_index >= len(ops):
            new_index = 0
        elif new_index < 0:
            new_index = len(ops)-1
        gliders.value = ops[new_index]
    def next_glider_func():
        glider_buttons(1)
    def prev_glider_func():
        glider_buttons(-1)

    gliders.on_change('value', update_coulombs)
    next_glider.on_click(next_glider_func)
    prev_glider.on_click(prev_glider_func)

    max_amphr.on_change('value', update_projection)

    update_coulombs(None,None,None)

    return vplot(control_box, fig1)
コード例 #7
0
ファイル: query.py プロジェクト: rainygoblin/DVH-Analytics
    def __init__(self, sources, categories, dvhs, rad_bio, roi_viewer, time_series,
                 correlation, regression, mlc_analyzer, custom_title, data_tables):
        self.sources = sources
        self.selector_categories = categories.selector
        self.range_categories = categories.range
        self.correlation_variables = categories.correlation_variables
        self.dvhs = dvhs
        self.rad_bio = rad_bio
        self.roi_viewer = roi_viewer
        self.time_series = time_series
        self.correlation = correlation
        self.regression = regression
        self.mlc_analyzer = mlc_analyzer

        self.uids = {n: [] for n in GROUP_LABELS}
        self.allow_source_update = True
        self.current_dvh = []
        self.anon_id_map = []
        self.colors = itertools.cycle(palette)

        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!
        # Selection Filter UI objects
        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!
        category_options = list(self.selector_categories)
        category_options.sort()

        # Add Current row to source
        self.add_selector_row_button = Button(label="Add Selection Filter", button_type="primary", width=200)
        self.add_selector_row_button.on_click(self.add_selector_row)

        # Row
        self.selector_row = Select(value='1', options=['1'], width=50, title="Row")
        self.selector_row.on_change('value', self.selector_row_ticker)

        # Category 1
        self.select_category1 = Select(value="ROI Institutional Category", options=category_options, width=300,
                                       title="Category 1")
        self.select_category1.on_change('value', self.select_category1_ticker)

        # Category 2
        cat_2_sql_table = self.selector_categories[self.select_category1.value]['table']
        cat_2_var_name = self.selector_categories[self.select_category1.value]['var_name']
        self.category2_values = DVH_SQL().get_unique_values(cat_2_sql_table, cat_2_var_name)
        self.select_category2 = Select(value=self.category2_values[0], options=self.category2_values, width=300,
                                       title="Category 2")
        self.select_category2.on_change('value', self.select_category2_ticker)

        # Misc
        self.delete_selector_row_button = Button(label="Delete", button_type="warning", width=100)
        self.delete_selector_row_button.on_click(self.delete_selector_row)
        self.group_selector = CheckboxButtonGroup(labels=["Group 1", "Group 2"], active=[0], width=180)
        self.group_selector.on_change('active', self.ensure_selector_group_is_assigned)
        self.selector_not_operator_checkbox = CheckboxGroup(labels=['Not'], active=[])
        self.selector_not_operator_checkbox.on_change('active', self.selector_not_operator_ticker)

        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!
        # Range Filter UI objects
        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!
        category_options = list(self.range_categories)
        category_options.sort()

        # Add Current row to source
        self.add_range_row_button = Button(label="Add Range Filter", button_type="primary", width=200)
        self.add_range_row_button.on_click(self.add_range_row)

        # Row
        self.range_row = Select(value='', options=[''], width=50, title="Row")
        self.range_row.on_change('value', self.range_row_ticker)

        # Category
        self.select_category = Select(value=options.SELECT_CATEGORY_DEFAULT, options=category_options, width=240, title="Category")
        self.select_category.on_change('value', self.select_category_ticker)

        # Min and max
        self.text_min = TextInput(value='', title='Min: ', width=150)
        self.text_min.on_change('value', self.min_text_ticker)
        self.text_max = TextInput(value='', title='Max: ', width=150)
        self.text_max.on_change('value', self.max_text_ticker)

        # Misc
        self.delete_range_row_button = Button(label="Delete", button_type="warning", width=100)
        self.delete_range_row_button.on_click(self.delete_range_row)
        self.group_range = CheckboxButtonGroup(labels=["Group 1", "Group 2"], active=[0], width=180)
        self.group_range.on_change('active', self.ensure_range_group_is_assigned)
        self.range_not_operator_checkbox = CheckboxGroup(labels=['Not'], active=[])
        self.range_not_operator_checkbox.on_change('active', self.range_not_operator_ticker)

        self.query_button = Button(label="Query", button_type="success", width=100)
        self.query_button.on_click(self.update_data)

        # define Download button and call download.js on click
        menu = [("All Data", "all"), ("Lite", "lite"), ("Only DVHs", "dvhs"), ("Anonymized DVHs", "anon_dvhs")]
        self.download_dropdown = Dropdown(label="Download", button_type="default", menu=menu, width=100)
        self.download_dropdown.callback = CustomJS(args=dict(source=sources.dvhs,
                                                             source_rxs=sources.rxs,
                                                             source_plans=sources.plans,
                                                             source_beams=sources.beams),
                                                   code=open(join(dirname(dirname(__file__)), "download.js")).read())

        self.layout = column(Div(text="<b>DVH Analytics v%s</b>" % options.VERSION),
                             row(custom_title['1']['query'], Spacer(width=50), custom_title['2']['query'],
                                 Spacer(width=50), self.query_button, Spacer(width=50), self.download_dropdown),
                             Div(text="<b>Query by Categorical Data</b>", width=1000),
                             self.add_selector_row_button,
                             row(self.selector_row, Spacer(width=10), self.select_category1, self.select_category2,
                                 self.group_selector, self.delete_selector_row_button, Spacer(width=10),
                                 self.selector_not_operator_checkbox),
                             data_tables.selection_filter,
                             Div(text="<hr>", width=1050),
                             Div(text="<b>Query by Numerical Data</b>", width=1000),
                             self.add_range_row_button,
                             row(self.range_row, Spacer(width=10), self.select_category, self.text_min,
                                 Spacer(width=30),
                                 self.text_max, Spacer(width=30), self.group_range,
                                 self.delete_range_row_button, Spacer(width=10), self.range_not_operator_checkbox),
                             data_tables.range_filter)
コード例 #8
0
exponent_slider = Slider(title="Weighted Sum Exponent",
                        value=0.1,
                        start=0,
                        end=1,
                        step=0.1,
                        width=200)

samples_slider = Slider(title="Number of Aspects",
                        value=15,
                        start=1,
                        end=30,
                        step=1,
                        width=200)

ratings_box = TextInput(value="1,2,3,4,5", title="Star Rating:", width=185)


def update_dataset(attrname, old, new):
    dataset = dataset_select.value
    n_expon = exponent_slider.value
    n_samples = int(samples_slider.value)
    n_stars = [int(val) for val in ratings_box.value.split(',')]

    newdata = get_dataset(dataset, n_expon, n_stars)
    source_all.data = dict(newdata.to_dict('list'))

    newdata = get_ends(n_samples)
    source_cut.data = dict(newdata.to_dict('list'))

    plot.x_range.factors = newdata['aspects'].tolist() # this was missing
コード例 #9
0
ファイル: taylor_server.py プロジェクト: 0-T-0/bokeh
    order = int(new)
    update_data()

def on_text_value_change(attr, old, new):
    try:
        global expr
        expr = sy.sympify(new, dict(x=xs))
    except (sy.SympifyError, TypeError, ValueError) as exception:
        dialog.content = str(exception)
        dialog.visible = True
    else:
        update_data()

dialog = Dialog(title="Invalid expression")

slider = Slider(start=1, end=20, value=order, step=1, title="Order:")
slider.on_change('value', on_slider_value_change)

text = TextInput(value=str(expr), title="Expression:")
text.on_change('value', on_text_value_change)

inputs = HBox(children=[slider, text])
layout = VBox(children=[inputs, plot, dialog])
update_data()
document.add_root(layout)
session.show(layout)

if __name__ == "__main__":
    print("\npress ctrl-C to exit")
    session.loop_until_closed()
コード例 #10
0
source_point_arc = ColumnDataSource(data=dict(x=[], y=[]))


# initialize controls
# choose between original and arc length parametrization
parametrization_input = CheckboxGroup(labels=['show original parametrization',
                                              'show arc length parametrization'],
                                      active=[0, 1])
parametrization_input.on_click(parametrization_change)
# slider controlling the current parameter t
t_value_input = Slider(title="parameter t", name='parameter t', value=arc_settings.t_value_init,
                       start=arc_settings.t_value_min, end=arc_settings.t_value_max,
                       step=arc_settings.t_value_step)
t_value_input.on_change('value', t_value_change)
# text input for the x component of the curve
x_component_input = TextInput(value=arc_settings.x_component_input_msg, title="curve x")
x_component_input.on_change('value', curve_change)
# text input for the y component of the curve
y_component_input = TextInput(value=arc_settings.y_component_input_msg, title="curve y")
y_component_input.on_change('value', curve_change)
# dropdown menu for selecting one of the sample curves
sample_curve_input = Dropdown(label="choose a sample function pair or enter one below",
                              menu=arc_settings.sample_curve_names)
sample_curve_input.on_click(sample_curve_change)


# initialize plot
toolset = "crosshair,pan,reset,resize,save,wheel_zoom"
# Generate a figure container
plot = Figure(plot_height=400, plot_width=400, tools=toolset,
              title="Arc length parametrization",
コード例 #11
0
P2_source = ColumnDataSource(data=dict(x=t, y=0*t ))
P0_experiment_source = ColumnDataSource(data=dict(x=t, y=0*t ))
P1_experiment_source = ColumnDataSource(data=dict(x=t, y=0*t ))
P2_experiment_source = ColumnDataSource(data=dict(x=t, y=0*t ))

#plot.multi_line('x', 'y', source=source, line_width=3, line_alpha=0.6)
plot.line('x', 'y', source=P0_source, line_width=3, line_alpha=0.6,color='red')
plot.line('x', 'y', source=P1_source, line_width=3, line_alpha=0.6,color='green')
plot.line('x', 'y', source=P2_source, line_width=3, line_alpha=0.6,color='blue')
plot.circle( 'x', 'y', source=P0_experiment_source,color='red', size=6 , legend='SS'  ) #,'green','blue'] 
plot.circle( 'x', 'y', source=P1_experiment_source,color='green', size=6, legend='SD+DS'   ) #,'green','blue'] 
plot.circle( 'x', 'y', source=P2_experiment_source,color='blue', size=6, legend='DD   '   ) #,'green','blue']     


# Set up widgets
path = TextInput(title="file path", value='my sine wave')
file_name = TextInput(title="file name", value='1203_24')
etta = Slider(title="etta", value=0.08637, start=0.0, end=0.15, step=0.01)
#delta = Slider(title="delta [KHz]", value=0.08637, start=0.0, end=0.15, step=0.01)
Pi_time = Slider(title="pi_time [us]", value=9.6, start=5, end=15, step=0.05)
n_bar = Slider(title="n_bar", value=0.0, start=0.0, end=10, step=0.1)
chi = TextInput(title="chi", value='7.0')



# Set up callbacks
def update_exp_data(attrname, old, new):
    # set up the data
    try:

        #csv_reader = csv.reader(open('00001 - MS Gate 2017Sep13_1203_24.csv'))
コード例 #12
0
	def plotting(self):



		#Tools = [hover, TapTool(), BoxZoomTool(), BoxSelectTool(), PreviewSaveTool(), ResetTool()]
		TOOLS="crosshair,pan,wheel_zoom,box_zoom,reset,hover,previewsave"


		tab_plots = []
		#output_file("test.html")
		self.all_elements = []
		self.elements_comparison = []

		for attr_id, i in zip(self.attribute_ids, range(len(self.attribute_ids))):
			
			"""
			create plots for each datafile and put them in a tab.
			"""
			list_of_datasets = getattr(self, attr_id)
			y_axis_units = [x["y_unit"] for x in list_of_datasets]
			x_axis_units = [x["x_unit"] for x in list_of_datasets]

			figure_obj = figure(plot_width = 1000, plot_height = 800, y_axis_type = "log",
			title = attr_id, tools = TOOLS)
			#figure_obj.axes.major_label_text_font_size("12pt")
			#figure_obj.major_label_text_font_size("12pt")
			
			setattr(self, attr_id+"_"+"figure_obj",figure_obj)

			figure_obj.yaxis.axis_label = y_axis_units[0]
			figure_obj.xaxis.axis_label = x_axis_units[0]

			if not all(x == y_axis_units[0] for x in y_axis_units):
				for unit, data in zip(y_axis_units, list_of_datasets): 
					if not unit == y_axis_units[0]:
						figure_obj.extra_y_ranges =  {"foo": Range1d(start = np.amin(data["data"]["y"]),
						end = np.amax(data["data"]["y"]))}
						figure_obj.add_layout(LogAxis(y_range_name = "foo", axis_label = unit), "right")
						break

			if not all(x == x_axis_units[0] for x in x_axis_units):
				for unit, data in zip(x_axis_units, list_of_datasets): 
					if not unit == x_axis_units[0]:
						figure_obj.extra_x_ranges =  {"bar": Range1d(start = np.amin(data["data"]["x"]),
						end = np.amax(data["data"]["x"]))}
						figure_obj.add_layout(LinearAxis(x_range_name = "bar", axis_label = unit), "above")
						break



			figure_obj.xaxis.axis_label = list_of_datasets[0]["x_unit"]
			colour_list = Spectral11 + RdPu9 + Oranges9
			colour_indices = [0, 2, 8, 10, 12, 14, 20, 22, 1, 3, 9, 11, 13, 15]

			list_of_elements = []

			for dataset, color_index in zip(list_of_datasets, colour_indices):

				self.all_elements.append(dataset["sample element"]) #strip isotope number 
				color = colour_list[color_index]

				source = ColumnDataSource(data = dataset["data"]) #Datastructure for source of plotting

				setattr(self, attr_id+"_"+dataset["sample element"]+"_source", source) #Source element generalized for all plotting				


				list_of_elements.append(dataset["sample element"])

				figure_obj.line("x", "y", source = getattr(self, attr_id+"_"+dataset["sample element"]
								+"_source"), line_width = 2, line_color = color, 
								legend = dataset["sample element"], name = dataset["sample element"],
								 )

			hover = figure_obj.select_one(HoverTool).tooltips = [("element", "@element"), ("(x,y)", "($x, $y)")]

			radio_group = RadioGroup(labels = list_of_elements, active=0)

			"""
			Need to fetch default variables from input file and replace DEFAULT

			Block of code produces the layout of buttons and callbacks
			"""

			
			#Calculations on the dataset
			text_input_rsf = TextInput(value = "default", title = "RSF (at/cm^3): ")
			do_integral_button = Button(label = "Calibration Integral")
			smoothing_button = Button(label = "Smoothing on selected curve")

			text_input_sputter = TextInput(value = "default", title = "Sputter speed: float unit")
			text_input_crater_depth = TextInput(value = "default", title = "Depth of crater in: float")
			

			radio_group.on_change("active", lambda attr, old, new: None)

			text_input_xval_integral = TextInput(value = "0", title = "x-value for calibration integral ")
			text_input_yval_integral = TextInput(value = "0", title = "y-value for calibration integral ")

			#Save files for later use
			save_flexDPE_button = Button(label = "Save element for FlexPDE")
			save_all_flexDPE_button = Button(label = "Save all elements for FlexPDE")


			#Pointers to methods on click / change handlers
			do_integral_button.on_click(lambda identity = self.attribute_ids[i], radio = radio_group, 
										x_box = text_input_xval_integral, y_box = text_input_yval_integral: 
										self.integrate(identity, radio, x_box, y_box))

			smoothing_button.on_click(lambda identity = self.attribute_ids[i], radio = radio_group: 
									self.smoothing(identity, radio) )

			save_flexDPE_button.on_click(lambda identity = self.attribute_ids[i], radio = radio_group: 
										self.write_to_flexPDE(identity, radio))

			save_all_flexDPE_button.on_click(lambda identity = self.attribute_ids[i], radio = radio_group:
											self.write_all_to_flexPDE(identity, radio))

			text_input_rsf.on_change("value", lambda attr, old, new, radio = radio_group, 
								identity = self.attribute_ids[i], text_input = text_input_rsf, which = "rsf":
								self.update_data(identity, radio, text_input, new, which))


			text_input_sputter.on_change("value", lambda attr, old, new, radio = radio_group, 
								identity = self.attribute_ids[i], text_input = text_input_sputter, which = "sputter":
								self.update_data(identity, radio, text_input, new, which))

			text_input_crater_depth.on_change("value", lambda attr, old, new, radio = radio_group, 
								identity = self.attribute_ids[i], text_input = text_input_crater_depth, which = "crater_depth":
								self.update_data(identity, radio, text_input, new, which))


			#Initialization of actual plotting. 
			tab_plots.append(Panel(child = hplot(figure_obj, 
										   vform(radio_group, save_flexDPE_button, save_all_flexDPE_button), 
										   vform(text_input_rsf, smoothing_button, text_input_sputter, text_input_crater_depth),
										   vform(text_input_xval_integral, text_input_yval_integral, do_integral_button)),
										   title = attr_id))


		"""
		Check to see if one or more element exists in the samples and creat a comparison plot for each 
		of those elements.
		"""
		
		for element in self.all_elements:
			checkers = list(self.all_elements)
			checkers.remove(element)
			if element in checkers and not element in self.elements_comparison:
				self.elements_comparison.append(element)

		"""create plots for each element that is to be compared """
	
		for comparison_element in self.elements_comparison: 

			colour_list = Spectral11 + RdPu9 + Oranges9
			colour_indices = [0, 2, 8, 10, 12, 14, 20, 22, 1, 3, 9, 11, 13, 15]
			figure_obj = figure(plot_width = 1000, plot_height = 800, y_axis_type = "log", title = comparison_element, tools = TOOLS)
			#figure_obj.xaxis.major_label_text_font_size("12pt")
			#figure_obj.yaxis.major_label_text_font_size("12pt")
			

			y_axis_units = []
			x_axis_units = []

			comparison_datasets = []


			for attr_id, color_index in zip(self.attribute_ids, colour_indices):

				list_of_datasets = getattr(self, attr_id)

				for dataset in list_of_datasets:

					if dataset["sample element"] == comparison_element:
						comparison_datasets.append(dataset)
						y_axis_units.append(dataset["y_unit"])
						x_axis_units.append(dataset["x_unit"])

			figure_obj.xaxis.axis_label = comparison_datasets[-1]["x_unit"]
			figure_obj.yaxis.axis_label = comparison_datasets[-1]["y_unit"]

			if not all(x == y_axis_units[-1] for x in y_axis_units):
				for unit, data in zip(y_axis_units, comparison_datasets): 
					if not unit == y_axis_units[-1]:
						figure_obj.extra_y_ranges =  {"foo": Range1d(start = np.amin(data["data"]["y"]),
						end = np.amax(data["data"]["y"]))}
						figure_obj.add_layout(LogAxis(y_range_name = "foo", axis_label = unit), "right")
						break

			if not all(x == x_axis_units[-1] for x in x_axis_units):
				for unit, data in zip(x_axis_units, comparison_datasets): 
					if not unit == x_axis_units[-1]:
						figure_obj.extra_x_ranges =  {"bar": Range1d(start = np.amin(data["data"]["x"]),
						end = np.amax(data["data"]["x"]))}
						figure_obj.add_layout(LinearAxis(x_range_name = "bar", axis_label = unit), "above")
						break


			for attr_id, color_index in zip(self.attribute_ids, colour_indices):

				list_of_datasets = getattr(self, attr_id)

				for dataset in list_of_datasets:

					if dataset["sample element"] == comparison_element:
						color = colour_list[color_index]

						"""
						Logic that ensures that plots get put with correspoinding axes. 
						"""
						if dataset["x_unit"] != x_axis_units[-1] or dataset["y_unit"] != y_axis_units[-1]:

							if dataset["x_unit"] != x_axis_units[-1] and dataset["y_unit"] != y_axis_units[-1]:

								figure_obj.line("x", "y", source = getattr(self, attr_id+"_"+dataset["sample element"]+"_source"), line_width = 2, 
								line_color = color, legend = attr_id, x_range_name = "bar", y_range_name = "foo")

							elif dataset["x_unit"] != x_axis_units[-1]:

								figure_obj.line("x", "y", source = getattr(self, attr_id+"_"+dataset["sample element"]+"_source"), line_width = 2, 
								line_color = color, legend = attr_id, x_range_name = "bar")

							else: 

								figure_obj.line("x", "y", source = getattr(self, attr_id+"_"+dataset["sample element"]+"_source"), line_width = 2, 
								line_color = color, legend = attr_id, y_range_name = "foo")

						else: 
							figure_obj.line("x", "y", source = getattr(self, attr_id+"_"+dataset["sample element"]+"_source"), line_width = 2, 
							line_color = color, legend = attr_id)
						


			tab_plots.append(Panel(child = figure_obj, title = comparison_element))	

		tabs = Tabs(tabs = tab_plots)

		session = push_session(curdoc())
		session.show()
		session.loop_until_closed()
コード例 #13
0
    return df


# Column order for displaying the details of a specific review
col_order = ["price", "points", "variety", "province", "description"]

all_provinces = [
    "All", "South Australia", "Victoria", "Western Australia",
    "Australia Other", "New South Wales", "Tasmania"
]

# Setup the display portions including widgets as well as text and HTML
desc = Div(text="All Provinces", width=800)
province = Select(title="Province", options=all_provinces, value="All")
price_max = Slider(start=0, end=900, step=5, value=200, title="Maximum Price")
title = TextInput(title="Title Contains")
details = Div(text="Selection Details:", width=800)

# Populate the data with the dataframe
source = ColumnDataSource(data=load_data())

# Build out the hover tools
hover = HoverTool(tooltips=[
    ("title", "@title"),
    ("variety", "@variety"),
])

# Define the tool list as a list of the objects so it is easier to customize
# each object
TOOLS = [
    hover,
コード例 #14
0
    input_file = 'input.txt'
    bert = sys.argv[1]
    layers = '0'
    for i in range(int(sys.argv[2]) - 1):
        layers += ',' + str(i + 1)
else:
    input_file = sys.argv[1]
    bert = sys.argv[2]
    layers = '0'
    for i in range(int(sys.argv[3]) - 1):
        layers += ',' + str(i + 1)

layer_idxs = [int(x) for x in layers.split(',')]
text_count = 1

text_input = TextInput()
button = Button(label='Обработать', button_type='success')
div = Div(text='')


def calculate():
    with open(input_file, 'w') as f:
        f.write(text_input.value)

    args = ['python', '../bert/extract_features.py']
    args.append('--input_file=' + input_file)
    args.append('--output_file=')
    args.append('--vocab_file=' + bert + 'vocab.txt')
    args.append('--bert_config_file=' + bert + 'bert_config.json')
    args.append('--init_checkpoint=' + bert + 'bert_model.ckpt')
    args.append('--layers=' + layers)
コード例 #15
0
ファイル: MLCSophieMagnetar.py プロジェクト: villrv/SRMP_LCs
          source=source,
          line_width=3,
          line_alpha=0.6,
          color="purple")
plot.line('x', 'yB', source=source, line_width=3, line_alpha=0.6, color="blue")
plot.circle('x', 'y', source=source2, size=5, color="black")
plot.circle('x', 'yG', source=source2, size=5, color="green")
plot.circle('x', 'yB', source=source2, size=5, color="blue")
plot.circle('x', 'yR', source=source2, size=5, color="red")
plot.circle('x', 'yi', source=source2, size=5, color="purple")
#plot.line('x', 'yV', source=source, line_width=3, line_alpha=0.6, color="turquoise")
#plot.line('x', 'yU', source=source, line_width=3, line_alpha=0.6, color="purple")

arrayoftimes = np.array(photometry_time)

text = TextInput(title="title", value='my parabola', callback=callback2)
lumdist_input = TextInput(title="title", value=str(lumdist))
redshift_input = TextInput(title="title", value=str(redshift))

M_slider = Slider(start=0.1,
                  end=10,
                  value=1,
                  step=.1,
                  title="Ejecta Mass",
                  callback=callback)
v_slider = Slider(start=5000,
                  end=20000,
                  value=10000,
                  step=1000,
                  title="Ejecta Velocity",
                  callback=callback)
コード例 #16
0
def callback_subtract_noise_from_signal_button():
    global signal_data_averaged_dict
    global noise_data_averaged_dict
    waveform_data_source.data = CCD_utils.subtract_dict_data(
        signal_data_averaged_dict, noise_data_averaged_dict)
    doc.add_next_tick_callback(callback_update_raman_spec)


### -------------- define callbacks --------------- ###

### -------------- make the document -------------- ###

# --- add widgets
# Select Serial Port Text Input
select_serial_port_text_input = TextInput(
    title=raman_languages.TEXT__SERIAL_PORT,
    value=raman_configs.DEFAULT_SERIAL_PORT)
select_serial_port_text_input.on_change(
    'value', callback_select_serial_port_text_input)

# Select Baud Rate
select_baud_rate_text_input = TextInput(title=raman_languages.TEXT__BAUD_RATE,
                                        value=str(
                                            raman_configs.DEFAULT_BAUD_RATE))
select_baud_rate_text_input.on_change('value',
                                      callback_select_baud_rate_text_input)

# Open Serial Port Button
open_serial_port_button = Button(label=raman_languages.TEXT__OPEN_SERIAL_PORT)
open_serial_port_button.on_click(callback_open_serial_port)
コード例 #17
0
ファイル: nigraph_view.py プロジェクト: naamaf/nigraph_view
# Slice direction dropdown
def sliceDropdown():
    pass

sliceDropdownMenu = Select(title="For fMRI Connectivity Only: Choose Direction:", value="X", options=["X", "Y", "Z"], width=int(total_width/6), height=50)

# Add ROI button
def addroiButton():
    pass

roiButton = Button(label="Add ROI", width=int(total_width/6), height=30)
roiButton.on_click(addroiButton)

# ROI name textbox
def roiNameTextbox():
    pass

roiName = TextInput(value="default", title="ROI Name", width=int(total_width/6), height=50)

# Choose ROI dropdown
def roiDropdown():
    pass

roiDropdownMenu = Select(title="Choose ROI:", value="X", options=["X", "Y", "Z"], width=int(total_width/6), height=50)

#orgenize figures
curdoc().add_root(layout([
    [fileButton, mapName, ConnectivityButton, AtlasButton, atlasName,MetadataButton],
    [connectivityMatrix, [sliceDropdownMenu, imageView]],
    [connectivityDropdown, connectivityMeasure, roiButton, roiName, roiDropdownMenu],
コード例 #18
0
                        dsTable.datasets_table,
                        dsTable.vars_table,
                        btn_plot_lonXlat,
                        plotLayout,
                        status_bar,
                        name='mainLayout')

    doc.remove_root(loadLayout)
    doc.add_root(mainLayout)


def log(msg, ex=None):
    status_bar.text = msg
    if ex is None:
        logger.debug(msg)
    else:
        logger.exception(msg, ex)


doc = curdoc()

log("Load an index file to get started.")
btnLoad = Button(label="Load")
btnLoad.on_click(lambda: load_file(txt_file.value))
txt_file = TextInput(value="index_201x.json",
                     title="Specify index file to load")
loadLayout = column(Div(height=50, style={"height": "50px"}), txt_file,
                    btnLoad, status_bar)

doc.add_root(loadLayout)  # [plot.init_layout()]
コード例 #19
0
                       style={
                           "font-family": "Arial",
                           "font-size": "15px"
                       },
                       width=300)
rectangular_pretext = Div(text='Rectangular Reflectors/Sources',
                          style={
                              "font-family": "Arial",
                              "font-size": "15px"
                          },
                          width=300)
#rotation_pretext =  PreText(text='Rotation (Degrees)', width=300)
#simulation_params_pretext =  PreText(text='Rotation (Degrees)', width=300)

# Text Input
mesh_width_input = TextInput(value='50', title='Mesh Width', width=100)
mesh_height_input = TextInput(value='50', title='Mesh Height', width=100)
quality_factor_input = TextInput(value='100', title='Plasmon Q', width=100)
plasmon_wavelength_input = TextInput(value='4',
                                     title='Plasmon ' + u"\u03BB",
                                     width=100)
mesh_density_input = TextInput(value='100', title='Mesh Density', width=200)
lambda_input = TextInput(value='100',
                         title='Excitation ' + u"\u03BB",
                         width=100)
phi_input = TextInput(value='90', title='Excitation ' + u"\u03B8", width=100)

# Sliders
slider_end_value = min(int(mesh_width_input.value),
                       int(mesh_height_input.value))
circular_radius = Slider(title='Radius',
コード例 #20
0
ファイル: main.py プロジェクト: amcdawes/coincidence
plot.vbar(x='x', top='y', width=0.5, source=source, color="red")

plot2 = figure(plot_height=400, plot_width=1000, title="Coincidence counts",
              tools="crosshair,pan,reset,save,wheel_zoom",
              x_range=coinc, y_range=[0, 4000])

plot2.background_fill_color = "black"
plot2.border_fill_color = "black"

plot2.vbar(x='x', top='y', width=0.5, source=source2, color="yellow")


# Set up widgets to control scale of plots
# TODO change these to actual range sliders
command = TextInput(title="Command Entry:", value='raw counts')
scalemin = Slider(title="Singles Scale minimum", value=0.0, start=0.0, end=1000.0, step=100)
scalemax = Slider(title="Singles Scale maximum", value=70000.0, start=1000.0, end=500000.0, step=100)
scalemin2 = Slider(title="Coinc. Scale minimum", value=0.0, start=0.0, end=5000.0, step=100)
scalemax2 = Slider(title="Coinc. Scale maximum", value=4000.0, start=1000.0, end=100000.0, step=100)

# other widgets (not all are used yet)
phase = Slider(title="phase", value=0.0, start=0.0, end=5.0, step=0.1)
points = Slider(title="data points", value=20, start=0, end=500, step=1)
statsA = Paragraph(text="100", width=400, height=40)
statsB = Paragraph(text="100", width=400, height=40)
g2 = Paragraph(text="100", width=400, height=80)
g2_2d = Paragraph(text="100", width=400, height=40)


# Set up callbacks
コード例 #21
0
ファイル: sliders_app.py プロジェクト: rbtr/bokeh
import logging

logging.basicConfig(level=logging.DEBUG)

import numpy as np

from bokeh.plotting import Figure
from bokeh.models import Plot, ColumnDataSource
from bokeh.models.widgets import HBox, Slider, TextInput, VBoxForm
from bokeh.io import curdoc

source = ColumnDataSource(data=dict(x=[], y=[]))

text = TextInput(
    title="title", name='title', value='my sine wave'
)

offset = Slider(
    title="offset", name='offset',
    value=0.0, start=-5.0, end=5.0, step=0.1
)
amplitude = Slider(
    title="amplitude", name='amplitude',
    value=1.0, start=-5.0, end=5.0
)
phase = Slider(
    title="phase", name='phase',
    value=0.0, start=0.0, end=2*np.pi
)
freq = Slider(
コード例 #22
0
ファイル: dashboard.py プロジェクト: cbouy/DashMD
class Dashboard:
    def __init__(self, default_dir, port):
        # path to source directory
        self.src_dir = os.path.dirname(os.path.abspath(__file__))
        # MD directory and files selection
        self.md_dir = TextInput(
            title="Path to MD directory containing mdin and mdout files",
            value="",
            width=750)
        self.anim_button = Toggle(label="▶ Load",
                                  button_type="warning",
                                  width=80,
                                  height=50,
                                  active=False)
        self.port = port
        # container for the buttons that are created while the user types in the textinput
        self.autocomp_results = column(children=[])
        # file used to display temperature, pressure...etc. plots
        self.mdout_sel = Select(
            title="MDout file",
            width=230,
            value=None,
            options=[],
        )
        # button to load content
        self.mdout_button = Button(width=80,
                                   height=50,
                                   label="Plot",
                                   button_type="primary")
        self.mdout_files = [None]
        self.md_mdout_files = []
        # mdinfo figures
        progressbar_tooltip = """
        <span style="color:#428df5">@completed{0,0}</span> out of <span style="color:#428df5">@total{0,0}</span> steps (<span style="color:#428df5">@remaining{0,0}</span> remaining)
        """
        self.progressbar = figure(title="Current progress",
                                  x_range=Range1d(0, 10),
                                  tooltips=progressbar_tooltip,
                                  height=70,
                                  width=350,
                                  tools="hover",
                                  toolbar_location=None)
        self.progressbar.xgrid.grid_line_color = None
        self.progressbar.ygrid.grid_line_color = None
        self.progressbar.axis.visible = False
        self.progressbar.outline_line_color = "#444444"
        self.steps_CDS = ColumnDataSource({
            "total": [np.nan],
            "completed": [np.nan],
            "remaining": [np.nan],
            "color": ['#428df5'],
        })
        self.progressbar.hbar(
            y=0,
            left=0,
            right="completed",
            source=self.steps_CDS,
            height=0.5,
            color="color",
        )
        self.progressbar.hover[0].mode = "hline"

        self.calc_speed = Div(width=150,
                              height=50,
                              text="Calculation speed:",
                              style={
                                  "font-weight": "bold",
                                  "color": "#444444",
                                  "margin-top": "5px"
                              })

        self.eta = Div(width=280,
                       height=50,
                       text="Estimated time remaining:",
                       style={
                           "font-weight": "bold",
                           "color": "#444444",
                           "margin-top": "5px"
                       })

        self.last_update = Div(width=280,
                               height=50,
                               text="Last update:",
                               style={
                                   "font-weight": "bold",
                                   "color": "#444444",
                                   "margin-top": "5px"
                               })

        # number of mdout files displayed on the dashboard at max
        self.slider = Slider(start=1,
                             end=12,
                             value=2,
                             step=1,
                             callback_policy="mouseup",
                             title="Number of simulations displayed")
        self.dashboard_CDS = ColumnDataSource({
            "y_coords": [0, 1],
            "mdout": ["heat.out", "prod.out"],
            "time": [42, 200],
            "angle": [1.09, 5.193],
            "color": [sim_palette[0], sim_palette[1]],
        })
        dashboard_tooltip = """
        <span style="color:@color">@mdout</span>: @time{0,0.00} ns
        """
        # pie plot
        self.pie = figure(plot_height=300,
                          width=500,
                          title="Simulations length",
                          toolbar_location=None,
                          tools="hover",
                          tooltips=dashboard_tooltip,
                          x_range=Range1d(-0.5, 1.0))

        self.rpie = self.pie.wedge(x=0,
                                   y=1,
                                   radius=0.4,
                                   source=self.dashboard_CDS,
                                   start_angle=cumsum('angle',
                                                      include_zero=True),
                                   end_angle=cumsum('angle'),
                                   line_color="white",
                                   fill_color='color',
                                   legend="mdout")
        self.pie.axis.axis_label = None
        self.pie.axis.visible = False
        self.pie.grid.grid_line_color = None
        self.pie.legend.label_text_font_size = '9pt'
        self.pie.legend.border_line_width = 0
        self.pie.legend.border_line_alpha = 0
        self.pie.legend.spacing = 0
        self.pie.legend.margin = 0
        # hbar plot
        self.bar = figure(width=850,
                          plot_height=300,
                          toolbar_location=None,
                          tools="hover",
                          tooltips=dashboard_tooltip)
        self.rbar = self.bar.hbar(y="y_coords",
                                  left=0,
                                  right="time",
                                  source=self.dashboard_CDS,
                                  height=0.8,
                                  color="color")
        self.bar.x_range.set_from_json("start", 0)
        self.bar.xaxis.axis_label = "Time (ns)"
        self.bar.yaxis.axis_label = None
        self.bar.yaxis.visible = False
        self.bar.hover[0].mode = "hline"

        ## Mdout figures
        self.mdinfo_CDS = ColumnDataSource(copy.deepcopy(empty_mddata_dic))
        self.moving_avg_trans = CustomJSTransform(v_func=moving_avg_func)
        ticker = PrintfTickFormatter(format="%4.0e")
        # Temperature
        self.temperature_fig = figure(
            plot_height=size[1],
            plot_width=size[0],
            active_scroll="wheel_zoom",
        )
        self.temperature_fig.toolbar.autohide = True
        self.temperature_fig.xaxis.axis_label = "Number of steps"
        self.temperature_fig.yaxis.axis_label = "Temperature (K)"
        self.temperature_fig.xaxis.formatter = ticker
        r = self.temperature_fig.line("Nsteps",
                                      "Temperature",
                                      color=palette[0],
                                      source=self.mdinfo_CDS,
                                      _width=1,
                                      alpha=0.15)
        self.temperature_fig.line(transform("Nsteps", self.moving_avg_trans),
                                  transform("Temperature",
                                            self.moving_avg_trans),
                                  color=colorscale(palette[0], 0.85),
                                  source=self.mdinfo_CDS,
                                  line_width=3)
        self.temperature_fig.add_tools(make_hover([r]))

        # Pressure
        self.pressure_fig = figure(
            plot_height=size[1],
            plot_width=size[0],
            active_scroll="wheel_zoom",
        )
        self.pressure_fig.toolbar.autohide = True
        self.pressure_fig.xaxis.axis_label = "Number of steps"
        self.pressure_fig.yaxis.axis_label = "Pressure"
        self.pressure_fig.xaxis.formatter = ticker
        r = self.pressure_fig.line("Nsteps",
                                   "Pressure",
                                   color=palette[1],
                                   source=self.mdinfo_CDS,
                                   line_width=1,
                                   alpha=0.15)
        self.pressure_fig.line(transform("Nsteps", self.moving_avg_trans),
                               transform("Pressure", self.moving_avg_trans),
                               color=colorscale(palette[1], 0.85),
                               source=self.mdinfo_CDS,
                               line_width=3)
        self.pressure_fig.add_tools(make_hover([r]))

        # Energy
        self.energy_fig = figure(
            plot_height=size[1],
            plot_width=size[0],
            active_scroll="wheel_zoom",
        )
        etot = self.energy_fig.line("Nsteps",
                                    "Etot",
                                    color=palette[2],
                                    source=self.mdinfo_CDS,
                                    line_width=1)
        ektot = self.energy_fig.line("Nsteps",
                                     "EKtot",
                                     color=palette[3],
                                     source=self.mdinfo_CDS,
                                     line_width=1)
        eptot = self.energy_fig.line("Nsteps",
                                     "EPtot",
                                     color=palette[4],
                                     source=self.mdinfo_CDS,
                                     line_width=1)
        legend = Legend(items=[
            ("Total", [etot]),
            ("Kinetic", [ektot]),
            ("Potential", [eptot]),
        ],
                        location="top_right")
        self.energy_fig.add_layout(legend, 'right')
        self.energy_fig.add_tools(make_hover([etot]))
        self.energy_fig.legend.location = "top_left"
        self.energy_fig.legend.click_policy = "hide"
        self.energy_fig.toolbar.autohide = True
        self.energy_fig.xaxis.axis_label = "Number of steps"
        self.energy_fig.yaxis.axis_label = "Energy"
        self.energy_fig.xaxis.formatter = ticker

        # Volume
        self.vol_fig = figure(
            plot_height=size[1],
            plot_width=size[0],
            active_scroll="wheel_zoom",
        )
        self.vol_fig.toolbar.autohide = True
        self.vol_fig.xaxis.axis_label = "Number of steps"
        self.vol_fig.yaxis.axis_label = "Volume"
        self.vol_fig.xaxis.formatter = ticker
        r = self.vol_fig.line("Nsteps",
                              "Volume",
                              color=palette[6],
                              source=self.mdinfo_CDS,
                              line_width=1,
                              alpha=0.15)
        self.vol_fig.line(transform("Nsteps", self.moving_avg_trans),
                          transform("Volume", self.moving_avg_trans),
                          color=colorscale(palette[6], 0.85),
                          source=self.mdinfo_CDS,
                          line_width=3)
        self.vol_fig.add_tools(make_hover([r]))

        # Density
        self.density_fig = figure(
            plot_height=size[1],
            plot_width=size[0],
            active_scroll="wheel_zoom",
        )
        self.density_fig.toolbar.autohide = True
        self.density_fig.xaxis.axis_label = "Number of steps"
        self.density_fig.yaxis.axis_label = "Density"
        self.density_fig.xaxis.formatter = ticker
        r = self.density_fig.line("Nsteps",
                                  "Density",
                                  color=palette[7],
                                  source=self.mdinfo_CDS,
                                  line_width=1,
                                  alpha=0.15)
        self.density_fig.line(transform("Nsteps", self.moving_avg_trans),
                              transform("Density", self.moving_avg_trans),
                              color=colorscale(palette[7], 0.85),
                              source=self.mdinfo_CDS,
                              line_width=3)
        self.density_fig.add_tools(make_hover([r]))

        ## RMSD figure
        self.empty_rmsd_dic = {k: [] for k in ["Time", "RMSD"]}
        self.rmsd_CDS = ColumnDataSource(self.empty_rmsd_dic)
        self.rmsd_fig = figure(
            plot_height=size[1],
            plot_width=size[0],
            active_scroll="wheel_zoom",
        )
        self.rmsd_fig.toolbar.autohide = True
        self.rmsd_fig.xaxis.axis_label = "Time (ps)"
        self.rmsd_fig.yaxis.axis_label = "RMSD (Å)"
        self.rmsd_fig.xaxis.formatter = ticker
        r = self.rmsd_fig.line("Time",
                               "RMSD",
                               color=palette[8],
                               source=self.rmsd_CDS,
                               line_width=2)
        self.rmsd_fig.add_tools(
            make_hover([r],
                       tooltips=[("Time (ps)", "@Time{0,0}"),
                                 ("RMSD (Å)", "@RMSD")]))
        self.rmsd_button = Button(width=100,
                                  label="Calculate RMSD",
                                  button_type="primary")
        self.trajectory = MultiSelect(
            title="Trajectory file(s)",
            width=400,
            value=None,
            options=[],
        )
        self.rst_traj = Select(
            title="Restart file",
            width=400,
            value=None,
            options=[],
        )
        self.topology = Select(
            title="Topology file",
            width=200,
            value=None,
            options=[],
        )
        self.mask = TextInput(title="Mask",
                              value="protein@CA,C,O,N",
                              width=200)
        # NGLview
        self.last_rst_update = 0
        self.view_button = Button(width=80,
                                  label="Visualize",
                                  button_type="primary")
        self.view_canvas = Div(width=size[0],
                               height=size[1] + 60,
                               css_classes=["ngldiv"],
                               text="")
        self.ngl_help_div = Div(width=0, height=0, text="")
        self.ngl_help_button = Toggle(width=80, label="Help", active=False)
        self.ngl_lig = TextInput(title="Ligand name", value="LIG", width=80)
        self.ngl_representations = CheckboxButtonGroup(
            labels=["Protein", "Ligand", "Water", "Lipids", "Ions"],
            active=[0, 1, 2, 3, 4],
        )
        # info about simulation files (min, dt, rst and mdcrd files)
        self.mdout_info = {}
        # add callbacks
        self.add_callbacks()
        self.md_dir.value = default_dir

    def ngl_help(self, new_value):
        """Show help on NGL controls"""
        if self.ngl_help_button.active:
            self.ngl_help_div.width = 300
            self.ngl_help_div.height = size[1]
            self.ngl_help_button.label = "Hide"
            self.ngl_help_div.text = NGL_HELP_TEXT
        else:
            self.ngl_help_div.width = 300
            self.ngl_help_div.height = size[1]
            self.ngl_help_button.label = "Help"
            self.ngl_help_div.text = ""

    def autocomp_callback(self, attr, old, new):
        """List all directories for the current typed path, output as buttons to click"""
        path = os.path.join(new + "*", "")
        opts = [] if new == "" else glob.glob(path)
        opts = sorted(opts, key=lambda x: x.split("/")[-2].lower())
        buttons = [Button(width=750, label=opt) for opt in opts]
        for b in buttons:
            cb = CustomJS(args=dict(md_dir=self.md_dir, button=b),
                          code="""
            md_dir.value_input = button.label;
            md_dir.value = button.label;
            """)
            b.js_on_click(cb)
        self.autocomp_results.children = buttons
        mdinfo_file = os.path.join(new, "mdinfo")
        if os.path.exists(mdinfo_file):
            self.anim_button.button_type = "success"
        else:
            self.anim_button.button_type = "warning"

    def traj_top_callback(self, attr, old, new):
        log.debug(f"Updating list of trajectory and topology files")
        try:
            # search netcdf files
            traj = [
                f for f in os.listdir(self.md_dir.value)
                if re.search(r'.+\.n(et)?c(df)?$', f)
            ]
            traj.sort(key=lambda f: os.path.getmtime(
                os.path.join(self.md_dir.value, f)),
                      reverse=True)
            self.trajectory.options = traj
            # search restart files
            restart = [
                f for f in os.listdir(self.md_dir.value)
                if re.search(r'.+\.rst7?$', f)
            ]
            restart.sort(key=lambda f: os.path.getmtime(
                os.path.join(self.md_dir.value, f)),
                         reverse=True)
            self.rst_traj.options = restart
            if self.rst_traj.options:
                self.rst_traj.value = self.rst_traj.options[0]
            # search for .top, .prmtop, .parm7 or .prm
            top = [
                f for f in os.listdir(self.md_dir.value)
                if re.search(r'.+\.(prm)?top$', f)
                or re.search(r'.+\.pa?rm7?$', f)
            ]
            self.topology.options = top
            if self.topology.options:
                self.topology.value = self.topology.options[0]

        except FileNotFoundError:
            pass

    def compute_rmsd(self):
        """Compute RMSD during a trajectory"""
        self.rmsd_button.button_type = "default"
        mask = self.mask.value.replace(
            "protein",
            ":ALA,ARG,ASH,ASN,ASP,CYM,CYS,CYX,GLH,GLN,GLU,GLY,HID,HIE,HIP,HYP,HIS,ILE,LEU,LYN,LYS,MET,PHE,PRO,SER,THR,TRP,TYR,VAL"
        )
        topology = os.path.join(self.md_dir.value, self.topology.value)
        trajectories = [
            os.path.join(self.md_dir.value, f) for f in self.trajectory.value
        ]
        trajectories.sort(key=lambda f: os.path.getmtime(f), reverse=False)
        traj = pt.iterload(trajectories, topology)
        stepsize = get_stepsize(traj)
        frames = list(
            traj.iterframe(step=stepsize,
                           autoimage=True,
                           rmsfit=False,
                           mask=mask))
        log.debug(
            f"Computing RMSD for top {topology} and traj {trajectories} with a step of {stepsize}, using mask {mask}"
        )
        ref = frames[0]
        results = {"Time": [], "RMSD": []}
        with ProcessPoolExecutor(max_workers=max_workers) as ex:
            for rmsd, frame in zip(
                    ex.map(partial(compute_rmsd, ref=ref), frames), frames):
                results["Time"].append(frame.time)
                results["RMSD"].append(rmsd)
        del traj
        self.rmsd_CDS.data = results
        self.rmsd_button.button_type = "primary"

    def autoview_structure(self):
        """Load structure automatically if it has been modified recently"""
        # check if rst7 file was rewritten recently
        update_time = os.path.getmtime(
            os.path.join(self.md_dir.value, self.rst_traj.value))
        # and viewing the latest rst7 file
        if (update_time > self.last_rst_update) and (
                self.rst_traj.value == self.rst_traj.options[0]):
            log.debug(
                f"Updating {self.rst_traj.value} with more recent version: {update_time}"
            )
            self.last_rst_update = update_time
            self.view_structure()
        else:
            log.debug(f"No recent update of restart {self.rst_traj.value}")

    def view_structure(self):
        """Visualize a restart file with NGL"""
        log.debug(
            f"Visualizing top {self.topology.value} and restart {self.rst_traj.value}"
        )
        # load rst7 with pytraj (NGL cannot read it directly)
        traj = pt.load(os.path.join(self.md_dir.value, self.rst_traj.value),
                       os.path.join(self.md_dir.value, self.topology.value))
        traj = pt.autoimage(traj)
        ## pass to parmed to write the pdb data in a StringIO
        # struct = pmd.load_file(os.path.join(self.md_dir.value, self.topology.value), xyz=traj.xyz)
        # f = StringIO()
        # struct.write_pdb(f)
        # pdb_data = f.getvalue().encode("ascii")
        # f.close()
        # write as pdb to temporary file (much faster than parmed + StringIO)
        with NamedTemporaryFile() as f:
            pt.write_traj(f.name, traj, format="pdb", overwrite=True)
            pdb_data = f.read()
        # create javascript code
        with open(os.path.join(self.src_dir, "static", "js",
                               "nglviewer.js")) as f:
            JS_TEMPLATE = f.read()
        self.js_view_structure.code = JS_TEMPLATE % (pdb_data)
        # trigger javascript callback by adding an invisible character to the button label
        self.view_button.label += " "

    def clear_canvas(self):
        """Clear the canvas"""
        log.debug("Clearing canvas")
        self.mdinfo_CDS.data = copy.deepcopy(empty_mddata_dic)

    def read_mdout_header(self, mdout):
        """Read the header of mdout file to search for info on minimization, dt, and output files"""
        log.debug(f"Reading header of {mdout} mdout file")
        mdout_path = os.path.join(self.md_dir.value, mdout)
        found_min, found_dt, found_rst, found_mdcrd = (False, False, False,
                                                       False)
        with open(mdout_path, 'r') as f:
            for i, line in enumerate(f):
                re1 = re.search(r"imin\s*=\s*([01])", line)
                if re1:
                    self.mdout_info[mdout]["min"] = bool(int(re1.group(1)))
                    found_min = True
                re2 = re.search(r"dt\s*=\s*([\.0-9]+)", line)
                if re2:
                    self.mdout_info[mdout]["dt"] = float(re2.group(1))
                    found_dt = True
                re3 = re.search(r"^\| RESTRT: ([^\s]+)\s*$", line)
                if re3:
                    self.mdout_info[mdout]["rst"] = re3.group(1)
                    found_rst = True
                re4 = re.search(r"^\|  MDCRD: ([^\s]+)\s*$", line)
                if re4:
                    self.mdout_info[mdout]["mdcrd"] = re4.group(1)
                    found_mdcrd = True
                if found_min and found_rst and found_mdcrd:
                    if self.mdout_info[mdout][
                            "min"]:  # if min, there's no dt to find
                        log.debug(
                            f"Finished reading header of {mdout}. Closing minimization file."
                        )
                        break
                    else:
                        if found_dt:
                            log.debug(
                                f"Finished reading header of {mdout}. Closing MD file."
                            )
                            break
                elif i > 150:
                    log.debug(
                        f"Could not find all the information within the first 150 lines of {mdout}. Closing file."
                    )
                    break

    def is_min(self, mdout):
        """Returns True if minimization, False if MD, None if the 'imin' keyword was not found"""
        try:
            t = self.mdout_info[mdout]["min"]
        except KeyError:
            log.debug(
                f"Parsing {mdout} mdout file to see if it's a minimization")
            self.read_mdout_header(mdout)
            t = self.mdout_info[mdout].get("min", None)
        log.debug(f"{mdout} is a minimization: {t}")
        return t

    def stream_mdout(self):
        """Parse and stream data from mdout files (minimization or MD simulation)"""
        self.mdout_button.button_type = "default"
        self.clear_canvas()
        mdout = self.mdout_sel.value
        mdout_path = os.path.join(self.md_dir.value, mdout)
        mdout_data = copy.deepcopy(empty_mddata_dic)
        # open file
        with open(mdout_path, 'r') as f:
            log.debug(f"Parsing data from {mdout} mdout file")
            lines = []
            # stop reading when reaching the following lines
            for line in f:
                if ("A V E R A G E S   O V E R" in line) or (
                        "Maximum number of minimization cycles reached"
                        in line):
                    break
                lines.append(line)
        # check if min or md:
        parse_func = parse_min_data if self.is_min(mdout) else parse_md_data
        # parse in parallel
        with ProcessPoolExecutor(max_workers=max_workers) as ex:
            for res in ex.map(parse_func, lines):
                for k, v in res.items():
                    mdout_data[k].extend(v)
        # convert to numpy
        for key, lst in mdout_data.items():
            mdout_data[key] = np.array(lst)
        # stream to CDS
        log.debug(f"Done. Streaming the data from {mdout}")
        self.mdinfo_CDS.stream(mdout_data)
        mdout_data = copy.deepcopy(empty_mddata_dic)
        self.mdout_button.button_type = "primary"

    def latest_mdout_files(self):
        """List all mdout files present in the MD directory, sorted by modification time"""
        mdout_files = [
            f for f in os.listdir(self.md_dir.value)
            if re.search(r'.+\.(md)?out$', f) and ("nohup.out" not in f)
        ]
        mdout_files.sort(
            key=lambda f: os.path.getmtime(os.path.join(self.md_dir.value, f)),
            reverse=True)
        return mdout_files

    def get_mdout_files(self):
        """Update the list of mdout files and automatically select the latest one"""
        log.debug("Updating the list of mdout files")
        self.mdout_files = [None]
        # set mdout file to read
        self.mdout_files = self.latest_mdout_files()
        for mdout in self.mdout_files:
            if not mdout in self.mdout_info:
                self.mdout_info[mdout] = {}
        mdout_options = self.mdout_sel.options
        self.mdout_sel.options = self.mdout_files
        # if new mdout is created
        if len(self.mdout_files) > len(mdout_options):
            self.mdout_sel.value = self.mdout_files[0]

    def parse_mdinfo(self):
        """Parse and stream data read from the mdinfo file"""
        log.debug("Parsing mdinfo file")
        mdinfo_path = os.path.join(self.md_dir.value, "mdinfo")

        try:
            with open(mdinfo_path, 'r') as f:
                lines = f.readlines()
        except FileNotFoundError:
            log.error("No mdinfo file in the current directory")
            return

        mdinfo_data = copy.deepcopy(empty_mddata_dic)
        # min or md
        latest_mdout_file = self.latest_mdout_files()[0]
        parse_func = parse_min_data if self.is_min(
            latest_mdout_file) else parse_md_data

        for i, line in enumerate(lines):
            # data
            res = parse_func(line)
            for k, v in res.items():
                mdinfo_data[k].extend(v)
            # number of steps
            re_steps = re.search(
                r"Total steps :\s*(\d+) \| Completed :\s*(\d+) \| Remaining :\s*(\d+)",
                line)
            if re_steps:
                total = int(re_steps.group(1))
                completed = int(re_steps.group(2))
                remaining = int(re_steps.group(3))
                steps_patch = {
                    "total": [(0, total)],
                    "completed": [(0, completed)],
                    "remaining": [(0, remaining)],
                }
                self.steps_CDS.patch(steps_patch)
                progress = 100 * completed / total
                self.progressbar.title.text = f"Progress: {progress:6.2f}%"
                self.progressbar.x_range.set_from_json("end", total)

            # calculation speed (ns/day)
            re_speed = re.search(r'Average timings for last', line)
            if re_speed:
                re_speed = re.search(r'ns/day =\s*([\.0-9]+)', lines[i + 2])
                speed = float(re_speed.group(1))
                self.calc_speed.text = f"Calculation speed:<br/>{speed} ns/day"

            # time remaining
            re_time = re.search(r'Estimated time remaining:\s*(.+).$', line)
            if re_time:
                time_left = re_time.group(1)
                time_left = pretty_time(time_left)
                self.eta.text = f"Estimated time remaining:<br/>{time_left}"
                break

        # last update
        self.last_update.text = f"Last update:<br/>{time_passed(os.path.getmtime(mdinfo_path))}"
        update_time = os.path.getmtime(mdinfo_path)
        if time.time() - update_time > 5 * 60:  # not updated recently
            self.last_update.style = {
                "font-weight": "bold",
                "color": "#d62727",
                "margin-top": "5px"
            }
        else:
            self.last_update.style = {
                "font-weight": "bold",
                "color": "#444444",
                "margin-top": "5px"
            }

    # only update plots if monitoring the latest mdout file
        if self.mdout_sel.value == latest_mdout_file:
            log.debug(
                f"Currently watching the latest mdout '{self.mdout_sel.value}'"
            )
            # fetch previous stream data as dict
            last_mdinfo_stream = self.mdinfo_CDS.to_df().tail(1).reset_index(
                drop=True).T.to_dict().get(0)
            if last_mdinfo_stream:
                # format the dict
                for key, value in last_mdinfo_stream.items():
                    last_mdinfo_stream[key] = [value]
                # update if mdinfo is different from the previous stream
                if mdinfo_data != last_mdinfo_stream:
                    log.debug("Streaming new data from mdinfo")
                    for key, value in mdinfo_data.items():
                        mdinfo_data[key] = np.array(value)
                    self.mdinfo_CDS.stream(mdinfo_data)
            else:
                log.debug(
                    f"No previous mdinfo data could be retrieved. Streaming new data"
                )
                for key, value in mdinfo_data.items():
                    mdinfo_data[key] = np.array(value)
                self.mdinfo_CDS.stream(mdinfo_data)
        else:
            log.debug(
                f"Currently watching mdout '{self.mdout_sel.value}' != '{latest_mdout_file}'"
            )

    def display_simulations_length(self):
        """Displays simulation length"""
        log.debug("Computing total time of simulation(s) displayed")
        current_time = OrderedDict()
        # discard min files and limit to XX most recent MD files
        self.md_mdout_files = [
            f for f in self.mdout_sel.options if not self.is_min(f)
        ][:self.slider.value]
        for mdout in self.md_mdout_files:
            mdout_path = os.path.join(self.md_dir.value, mdout)
            i = 0
            for line in readlines_reverse(mdout_path):
                i += 1
                re1 = re.search(r"NSTEP =\s*(\d+)", line)
                if re1:
                    current_time[mdout] = int(
                        re1.group(1)) * self.mdout_info[mdout].get(
                            "dt", 0.002) * 1e-3  # in ns
                    break
                if i > 150:
                    break
        data = pd.DataFrame.from_dict(
            current_time, orient="index",
            columns=["time"]).reset_index().rename(columns={"index": "mdout"})
        # compute properties for the pie plot
        data['angle'] = data['time'] / data['time'].sum() * 2 * pi
        # color palette
        data['color'] = sim_palette[:len(current_time)]
        # reverse index order for the barplot
        data = data.reindex(index=data.index[::-1]).reset_index(drop=True)
        data = data.reset_index().rename(columns={"index": "y_coords"})
        # update
        self.dashboard_CDS.data = {k: data[k].tolist() for k in data.columns}
        total_time = data["time"].sum()
        self.pie.title.text = f"Simulations length: {total_time:.2f} ns"

    def update_dashboard(self):
        log.debug("Starting update of the dashboard")
        self.get_mdout_files()
        self.parse_mdinfo()
        self.display_simulations_length()
        self.autoview_structure()
        log.debug("Finished updating the dashboard")

    def callback_slider(self, attr, old, new):
        log.debug(f"Slider update detected: from {old} to {new}")
        self.display_simulations_length()

    def add_callbacks(self):
        log.debug("Adding callbacks to the widgets")
        # User input
        self.md_dir.on_change("value_input", self.autocomp_callback)
        self.md_dir.on_change("value", self.traj_top_callback)
        # RMSD
        self.rmsd_button.on_click(self.compute_rmsd)
        # NGLView
        self.js_view_structure = CustomJS(code="",
                                          args={
                                              "ligand_mask": self.ngl_lig,
                                              "repr": self.ngl_representations
                                          })
        self.ngl_help_button.on_click(self.ngl_help)
        # hack to execute both python and JS code on button click
        self.view_button.js_on_change("label", self.js_view_structure)
        self.view_button.on_click(self.view_structure)
        # MDout parsing
        self.mdout_button.on_click(self.stream_mdout)
        self.slider.on_change("value_throttled", self.callback_slider)
コード例 #23
0
ファイル: dashboard.py プロジェクト: cbouy/DashMD
    def __init__(self, default_dir, port):
        # path to source directory
        self.src_dir = os.path.dirname(os.path.abspath(__file__))
        # MD directory and files selection
        self.md_dir = TextInput(
            title="Path to MD directory containing mdin and mdout files",
            value="",
            width=750)
        self.anim_button = Toggle(label="▶ Load",
                                  button_type="warning",
                                  width=80,
                                  height=50,
                                  active=False)
        self.port = port
        # container for the buttons that are created while the user types in the textinput
        self.autocomp_results = column(children=[])
        # file used to display temperature, pressure...etc. plots
        self.mdout_sel = Select(
            title="MDout file",
            width=230,
            value=None,
            options=[],
        )
        # button to load content
        self.mdout_button = Button(width=80,
                                   height=50,
                                   label="Plot",
                                   button_type="primary")
        self.mdout_files = [None]
        self.md_mdout_files = []
        # mdinfo figures
        progressbar_tooltip = """
        <span style="color:#428df5">@completed{0,0}</span> out of <span style="color:#428df5">@total{0,0}</span> steps (<span style="color:#428df5">@remaining{0,0}</span> remaining)
        """
        self.progressbar = figure(title="Current progress",
                                  x_range=Range1d(0, 10),
                                  tooltips=progressbar_tooltip,
                                  height=70,
                                  width=350,
                                  tools="hover",
                                  toolbar_location=None)
        self.progressbar.xgrid.grid_line_color = None
        self.progressbar.ygrid.grid_line_color = None
        self.progressbar.axis.visible = False
        self.progressbar.outline_line_color = "#444444"
        self.steps_CDS = ColumnDataSource({
            "total": [np.nan],
            "completed": [np.nan],
            "remaining": [np.nan],
            "color": ['#428df5'],
        })
        self.progressbar.hbar(
            y=0,
            left=0,
            right="completed",
            source=self.steps_CDS,
            height=0.5,
            color="color",
        )
        self.progressbar.hover[0].mode = "hline"

        self.calc_speed = Div(width=150,
                              height=50,
                              text="Calculation speed:",
                              style={
                                  "font-weight": "bold",
                                  "color": "#444444",
                                  "margin-top": "5px"
                              })

        self.eta = Div(width=280,
                       height=50,
                       text="Estimated time remaining:",
                       style={
                           "font-weight": "bold",
                           "color": "#444444",
                           "margin-top": "5px"
                       })

        self.last_update = Div(width=280,
                               height=50,
                               text="Last update:",
                               style={
                                   "font-weight": "bold",
                                   "color": "#444444",
                                   "margin-top": "5px"
                               })

        # number of mdout files displayed on the dashboard at max
        self.slider = Slider(start=1,
                             end=12,
                             value=2,
                             step=1,
                             callback_policy="mouseup",
                             title="Number of simulations displayed")
        self.dashboard_CDS = ColumnDataSource({
            "y_coords": [0, 1],
            "mdout": ["heat.out", "prod.out"],
            "time": [42, 200],
            "angle": [1.09, 5.193],
            "color": [sim_palette[0], sim_palette[1]],
        })
        dashboard_tooltip = """
        <span style="color:@color">@mdout</span>: @time{0,0.00} ns
        """
        # pie plot
        self.pie = figure(plot_height=300,
                          width=500,
                          title="Simulations length",
                          toolbar_location=None,
                          tools="hover",
                          tooltips=dashboard_tooltip,
                          x_range=Range1d(-0.5, 1.0))

        self.rpie = self.pie.wedge(x=0,
                                   y=1,
                                   radius=0.4,
                                   source=self.dashboard_CDS,
                                   start_angle=cumsum('angle',
                                                      include_zero=True),
                                   end_angle=cumsum('angle'),
                                   line_color="white",
                                   fill_color='color',
                                   legend="mdout")
        self.pie.axis.axis_label = None
        self.pie.axis.visible = False
        self.pie.grid.grid_line_color = None
        self.pie.legend.label_text_font_size = '9pt'
        self.pie.legend.border_line_width = 0
        self.pie.legend.border_line_alpha = 0
        self.pie.legend.spacing = 0
        self.pie.legend.margin = 0
        # hbar plot
        self.bar = figure(width=850,
                          plot_height=300,
                          toolbar_location=None,
                          tools="hover",
                          tooltips=dashboard_tooltip)
        self.rbar = self.bar.hbar(y="y_coords",
                                  left=0,
                                  right="time",
                                  source=self.dashboard_CDS,
                                  height=0.8,
                                  color="color")
        self.bar.x_range.set_from_json("start", 0)
        self.bar.xaxis.axis_label = "Time (ns)"
        self.bar.yaxis.axis_label = None
        self.bar.yaxis.visible = False
        self.bar.hover[0].mode = "hline"

        ## Mdout figures
        self.mdinfo_CDS = ColumnDataSource(copy.deepcopy(empty_mddata_dic))
        self.moving_avg_trans = CustomJSTransform(v_func=moving_avg_func)
        ticker = PrintfTickFormatter(format="%4.0e")
        # Temperature
        self.temperature_fig = figure(
            plot_height=size[1],
            plot_width=size[0],
            active_scroll="wheel_zoom",
        )
        self.temperature_fig.toolbar.autohide = True
        self.temperature_fig.xaxis.axis_label = "Number of steps"
        self.temperature_fig.yaxis.axis_label = "Temperature (K)"
        self.temperature_fig.xaxis.formatter = ticker
        r = self.temperature_fig.line("Nsteps",
                                      "Temperature",
                                      color=palette[0],
                                      source=self.mdinfo_CDS,
                                      _width=1,
                                      alpha=0.15)
        self.temperature_fig.line(transform("Nsteps", self.moving_avg_trans),
                                  transform("Temperature",
                                            self.moving_avg_trans),
                                  color=colorscale(palette[0], 0.85),
                                  source=self.mdinfo_CDS,
                                  line_width=3)
        self.temperature_fig.add_tools(make_hover([r]))

        # Pressure
        self.pressure_fig = figure(
            plot_height=size[1],
            plot_width=size[0],
            active_scroll="wheel_zoom",
        )
        self.pressure_fig.toolbar.autohide = True
        self.pressure_fig.xaxis.axis_label = "Number of steps"
        self.pressure_fig.yaxis.axis_label = "Pressure"
        self.pressure_fig.xaxis.formatter = ticker
        r = self.pressure_fig.line("Nsteps",
                                   "Pressure",
                                   color=palette[1],
                                   source=self.mdinfo_CDS,
                                   line_width=1,
                                   alpha=0.15)
        self.pressure_fig.line(transform("Nsteps", self.moving_avg_trans),
                               transform("Pressure", self.moving_avg_trans),
                               color=colorscale(palette[1], 0.85),
                               source=self.mdinfo_CDS,
                               line_width=3)
        self.pressure_fig.add_tools(make_hover([r]))

        # Energy
        self.energy_fig = figure(
            plot_height=size[1],
            plot_width=size[0],
            active_scroll="wheel_zoom",
        )
        etot = self.energy_fig.line("Nsteps",
                                    "Etot",
                                    color=palette[2],
                                    source=self.mdinfo_CDS,
                                    line_width=1)
        ektot = self.energy_fig.line("Nsteps",
                                     "EKtot",
                                     color=palette[3],
                                     source=self.mdinfo_CDS,
                                     line_width=1)
        eptot = self.energy_fig.line("Nsteps",
                                     "EPtot",
                                     color=palette[4],
                                     source=self.mdinfo_CDS,
                                     line_width=1)
        legend = Legend(items=[
            ("Total", [etot]),
            ("Kinetic", [ektot]),
            ("Potential", [eptot]),
        ],
                        location="top_right")
        self.energy_fig.add_layout(legend, 'right')
        self.energy_fig.add_tools(make_hover([etot]))
        self.energy_fig.legend.location = "top_left"
        self.energy_fig.legend.click_policy = "hide"
        self.energy_fig.toolbar.autohide = True
        self.energy_fig.xaxis.axis_label = "Number of steps"
        self.energy_fig.yaxis.axis_label = "Energy"
        self.energy_fig.xaxis.formatter = ticker

        # Volume
        self.vol_fig = figure(
            plot_height=size[1],
            plot_width=size[0],
            active_scroll="wheel_zoom",
        )
        self.vol_fig.toolbar.autohide = True
        self.vol_fig.xaxis.axis_label = "Number of steps"
        self.vol_fig.yaxis.axis_label = "Volume"
        self.vol_fig.xaxis.formatter = ticker
        r = self.vol_fig.line("Nsteps",
                              "Volume",
                              color=palette[6],
                              source=self.mdinfo_CDS,
                              line_width=1,
                              alpha=0.15)
        self.vol_fig.line(transform("Nsteps", self.moving_avg_trans),
                          transform("Volume", self.moving_avg_trans),
                          color=colorscale(palette[6], 0.85),
                          source=self.mdinfo_CDS,
                          line_width=3)
        self.vol_fig.add_tools(make_hover([r]))

        # Density
        self.density_fig = figure(
            plot_height=size[1],
            plot_width=size[0],
            active_scroll="wheel_zoom",
        )
        self.density_fig.toolbar.autohide = True
        self.density_fig.xaxis.axis_label = "Number of steps"
        self.density_fig.yaxis.axis_label = "Density"
        self.density_fig.xaxis.formatter = ticker
        r = self.density_fig.line("Nsteps",
                                  "Density",
                                  color=palette[7],
                                  source=self.mdinfo_CDS,
                                  line_width=1,
                                  alpha=0.15)
        self.density_fig.line(transform("Nsteps", self.moving_avg_trans),
                              transform("Density", self.moving_avg_trans),
                              color=colorscale(palette[7], 0.85),
                              source=self.mdinfo_CDS,
                              line_width=3)
        self.density_fig.add_tools(make_hover([r]))

        ## RMSD figure
        self.empty_rmsd_dic = {k: [] for k in ["Time", "RMSD"]}
        self.rmsd_CDS = ColumnDataSource(self.empty_rmsd_dic)
        self.rmsd_fig = figure(
            plot_height=size[1],
            plot_width=size[0],
            active_scroll="wheel_zoom",
        )
        self.rmsd_fig.toolbar.autohide = True
        self.rmsd_fig.xaxis.axis_label = "Time (ps)"
        self.rmsd_fig.yaxis.axis_label = "RMSD (Å)"
        self.rmsd_fig.xaxis.formatter = ticker
        r = self.rmsd_fig.line("Time",
                               "RMSD",
                               color=palette[8],
                               source=self.rmsd_CDS,
                               line_width=2)
        self.rmsd_fig.add_tools(
            make_hover([r],
                       tooltips=[("Time (ps)", "@Time{0,0}"),
                                 ("RMSD (Å)", "@RMSD")]))
        self.rmsd_button = Button(width=100,
                                  label="Calculate RMSD",
                                  button_type="primary")
        self.trajectory = MultiSelect(
            title="Trajectory file(s)",
            width=400,
            value=None,
            options=[],
        )
        self.rst_traj = Select(
            title="Restart file",
            width=400,
            value=None,
            options=[],
        )
        self.topology = Select(
            title="Topology file",
            width=200,
            value=None,
            options=[],
        )
        self.mask = TextInput(title="Mask",
                              value="protein@CA,C,O,N",
                              width=200)
        # NGLview
        self.last_rst_update = 0
        self.view_button = Button(width=80,
                                  label="Visualize",
                                  button_type="primary")
        self.view_canvas = Div(width=size[0],
                               height=size[1] + 60,
                               css_classes=["ngldiv"],
                               text="")
        self.ngl_help_div = Div(width=0, height=0, text="")
        self.ngl_help_button = Toggle(width=80, label="Help", active=False)
        self.ngl_lig = TextInput(title="Ligand name", value="LIG", width=80)
        self.ngl_representations = CheckboxButtonGroup(
            labels=["Protein", "Ligand", "Water", "Lipids", "Ions"],
            active=[0, 1, 2, 3, 4],
        )
        # info about simulation files (min, dt, rst and mdcrd files)
        self.mdout_info = {}
        # add callbacks
        self.add_callbacks()
        self.md_dir.value = default_dir
コード例 #24
0
ファイル: stack_player.py プロジェクト: mdheller/costar_plan
    curdoc().add_root(layout_child)


#iterator = iter(file_name_list)

button = Button(label=' Play', width=60)
button.on_click(animate)

button_next = Button(label='Next', width=60)
button_next.on_click(partial(next_image, files=file_name_list, action='next'))
button_prev = Button(label='Prev', width=60)
button_prev.on_click(partial(next_image, files=file_name_list, action='prev'))

# https://bokeh.pydata.org/en/latest/docs/reference/models/widgets.inputs.html
# TODO(ahundt) switch to AutocompleteInput with list of files
file_textbox = TextInput(value=file_name_list[index].split('\\')[-1],
                         width=width)

# TODO(ahundt) load another file when it changes
# def textbox_update(attrname, old, new):
#     plot.update(slider.value)

# file_textbox.on_change(textbox_update)

# Combine the bokeh plot on plot.state with the widgets
plot_list = [[plot.state], [gripper_plot.state], [action_plot.state]]

widget_list = [[slider, button, button_prev, button_next], [file_textbox]]

# "gripper_action" plot, labels based on the gripper opening and closing
plot_list.append([gripper_action_plot.state])
コード例 #25
0
ファイル: mc_bokeh.py プロジェクト: steve98654/bokeh-demos
class StockApp(VBox):
    extra_generated_classes = [["StockApp", "StockApp", "VBox"]]
    jsmodel = "VBox"

    Y = Instance(ColumnDataSource)

    # plots
    hist1 = Instance(Plot)
    hist2 = Instance(Plot)
    hist3 = Instance(Plot)

    # data source
    source = Instance(ColumnDataSource)
    risk_source = Instance(ColumnDataSource)

    # layout boxes
    mainrow = Instance(HBox)
    ticker1_box = Instance(HBox)
    ticker2_box = Instance(HBox)
    ticker3_box = Instance(HBox)
    ticker4_box = Instance(HBox)
    ticker5_box = Instance(HBox)
    second_row = Instance(HBox)
    histrow = Instance(HBox)

    # inputs
    ticker1  = String(default="1.2*(1.1-x)")
    ticker1p = String(default="-1.2")
    ticker2 = String(default="4.0")
    ticker2p = String(default="0.0")
    ticker3 = String(default="500")
    ticker3_1 = String(default="252")
    ticker3_2 = String(default="0.01")
    ticker4 = String(default="100")
    ticker4_1 = String(default="1.01")
    ticker4_2 = String(default="Milstein")
    button = String(default="")
    ticker1_select = Instance(TextInput)
    ticker1p_select = Instance(TextInput)
    ticker2_select = Instance(TextInput)
    ticker2p_select = Instance(TextInput)
    ticker3_select = Instance(TextInput)
    ticker3_1_select = Instance(TextInput)
    ticker3_2_select = Instance(TextInput)
    ticker4_select = Instance(TextInput)
    ticker4_1_select = Instance(TextInput)
    ticker4_2_select = Instance(Select)
    button_select = Instance(TextInput)
    input_box = Instance(VBoxForm)

    def __init__(self, *args, **kwargs):
        super(StockApp, self).__init__(*args, **kwargs)
        self._dfs = {}

    @classmethod
    def create(cls):
        """
        This function is called once, and is responsible for
        creating all objects (plots, datasources, etc)
        """
        # create layout widgets
        obj = cls()
        obj.mainrow = HBox()
        obj.ticker1_box = HBox(width=500)
        obj.ticker2_box = HBox(width=500)
        obj.ticker3_box = HBox(width=467)
        obj.ticker4_box = HBox(width=500)
        obj.ticker5_box = HBox(width=500)
        obj.second_row = HBox()
        obj.histrow = HBox()
        obj.input_box = VBoxForm(width=600)

        # create input widgets
        obj.make_inputs()

        # outputs
        #obj.make_source()
        obj.main_mc(252,500,0.01,'Milstein',1.01)
        obj.make_plots()

        # layout
        obj.set_children()
        return obj

    def make_inputs(self):

        self.ticker1_select = TextInput(
            name='ticker1',
            title='Drift Function:',
            value='1.2*(1.1-x)',
        )
        self.ticker1p_select = TextInput(
            name='ticker1p',
            title='Drift Derivative:',
            value='-1.2',
        )
        self.ticker2_select = TextInput(
            name='ticker2',
            title='Volatility Function:',
            value='4.0',
        )
        self.ticker2p_select = TextInput(
            name='ticker2p',
            title='Volatility Derivative:',
            value='0.0',
        )
        self.ticker3_select = TextInput(
            name='ticker3',
            title='Number of Paths:',
            value='500'
        )
        self.ticker3_1_select = TextInput(
            name='ticker3_1',
            title='Number of Points:',
            value='252'
        )
        self.ticker3_2_select = TextInput(
            name='ticker3_2',
            title='Time Step:',
            value='0.01'
        )
        self.ticker4_select = TextInput(
            name='ticker4',
            title='Histogram Line:',
            value='100'
        )
        self.ticker4_1_select = TextInput(
            name='ticker4_1',
            title='Initial Value:',
            value='1.01'
        )
        self.ticker4_2_select = Select(
            name='ticker4_2',
            title='MC Scheme:',
            value='Milstein',
            options=['Euler','Milstein', 'Pred/Corr']
        )
        self.button_select = TextInput(
            name='button',
            title='Type any word containing "run" to run Simulation ',
            value = ''
        )

    
    def make_source(self):
        self.source = ColumnDataSource(data=self.Y)

    def main_mc(self,num_pts,num_paths, delta_t, method, Y0):
        def a(x):
            return eval(self.ticker1)
        def ap(x):
            return eval(self.ticker1p)
        def b(x): 
            return eval(self.ticker2)
        def bp(x):
            return eval(self.ticker2p)

        rpaths = np.random.normal(0, delta_t, size=(num_pts,num_paths))
        Y = np.array([[Y0]*num_paths]) 
        dt_vec = np.array([delta_t]*num_paths)

        if method == 'Milstein':
            for i in xrange(0,num_pts):
                tY = Y[-1,:]
                dW = rpaths[i,:]
                Y = np.vstack([Y, tY + a(tY)*dt_vec + b(tY)*dW + 0.5*b(tY)*bp(tY)*(dW*dW-dt_vec)])

        elif method == 'Pred/Corr':
            # Predictor corrector method is taken from equation 2.6 in this paper:
            # http://www.qfrc.uts.edu.au/research/research_papers/rp222.pdf
            rpaths2 = np.random.normal(0, delta_t, size=(num_pts,num_paths))

            for i in xrange(0,num_pts):
                tY = Y[-1,:]
                Ybar = tY + a(tY)*dt_vec + b(tY)*rpaths[i,:]
                abar_before = a(tY) - 0.5*b(tY)*bp(tY)  
                abar_after = a(Ybar) - 0.5*b(Ybar)*bp(Ybar)  
                Y = np.vstack([Y, tY + 0.5*(abar_before + abar_after)*dt_vec + 0.5*(b(tY)+b(Ybar))*rpaths2[i,:]])

        else:  # default to Euler Scheme 
            for i in xrange(0,num_pts):
                tY = Y[-1,:]
                Y = np.vstack([Y, tY + a(tY)*dt_vec + b(tY)*rpaths[i,:]])
    
        return Y  # return simulated paths 
    
    def path_plot(self):
        num_paths_plot = min(50,int(self.ticker3))
        hist_point = int(self.ticker4)
        #print 'Hist Point ', hist_point
        Y = self.Y.as_matrix()
        pltdat = Y[:,0:num_paths_plot]
        mY, MY = min(Y[hist_point,:]), max(Y[hist_point,:])

        plt.plot(pltdat, alpha=0.1, linewidth=1.8)
        sns.tsplot(pltdat.T,err_style='ci_band', ci=[68,95,99], alpha=1, \
                linewidth = 2.5, color='indianred')
        #sns.tsplot(pltdat.T,err_style='ci_band', ci=[68,95,99,99.99999], alpha=1, \
        #        linewidth = 2.5, condition='Mean Path', color='indianred')
        plt.plot([hist_point, hist_point], [0.99*mY, 1.01*MY], 'k-',label='Time Series Histogram')
        plt.xlabel('Time Step')
        plt.ylabel('Price')
        #plt.legend()

        p = mpl.to_bokeh()
        p.title = 'Mean Path (Red), MC Paths (Background) and Density Line (Black)'
        p.title_text_font_size= str(TITLE_SIZE)+'pt'

        return p

    def hist_den_plot(self):
        Y = self.Y.as_matrix()
        hist_point = int(self.ticker4)
        delta_t = float(self.ticker3_2)

        data = Y[hist_point,:]
        sns.distplot(data, color='k', hist_kws={"color":"b"}, norm_hist=True)
        #sns.distplot(data, color='k', hist_kws={"color":"b"})
        plt.hist(data)
        plt.title('Distribution at T = ' + str(np.round(delta_t*hist_point,4)) + ' with Mean: ' +str(np.round(np.mean(data),4)) + ' and Std Dev: ' + str(np.round(np.std(data),4)))
        plt.xlabel('Price Bins')
        plt.ylabel('Bin Count')
       
        p = mpl.to_bokeh()
        p.title_text_font_size= str(TITLE_SIZE)+'pt'

        return p

    def mc_results(self):
        # Compute Monte Carlo results 
        Y = self.Y.as_matrix()
        Y0 = float(self.ticker4_1)
        hist_point = int(self.ticker4)
        num_paths = int(self.ticker3)

        center_point = np.mean(Y[hist_point,:])
        stkgrid = np.linspace(0.5*center_point,1.5*center_point,100)
        meanlst = np.array([])
        stdlst  = np.array([])
        paylst  = np.array([])

        for stk in stkgrid:
            meanlst = np.append(meanlst, np.mean(payoff(Y[hist_point,:],stk)))
            stdlst = np.append(stdlst,np.std(payoff(Y[hist_point,:],stk))/np.sqrt(num_paths))

        plt.plot(stkgrid,meanlst+2*stdlst, 'g-')
        plt.plot(stkgrid,meanlst-2*stdlst,'g-',label='2-Sig Error')
        plt.plot(stkgrid,meanlst+stdlst,'r-')
        plt.plot(stkgrid,meanlst-stdlst,'r-',label='1-Sig Error')
        plt.plot(stkgrid,meanlst,'b',label='Mean')
        plt.title('MC Option Price (Blue) with 1-Sig (Red) and 2-Sig (Green) Errors')
        plt.xlabel('Strike')
        plt.ylabel('Value')

        p = mpl.to_bokeh()
        p.title_text_font_size= str(TITLE_SIZE)+'pt'

        return p

    def hist_plot(self):
        histdf = pd.DataFrame(np.random.randn(100, 4), columns=list('ABCD'))
        #pltdf = self.source.to_df().set_index('date').dropna()
        #qlow, qhigh = mquantiles(pltdf[ticker],prob=[0.01,0.99]) 
        #tdf = pltdf[ticker]
        #histdf = tdf[((tdf > qlow) & (tdf < qhigh))]
        hist, bins = np.histogram(histdf, bins=50)
        width = 0.7 * (bins[1] - bins[0])
        center = (bins[:-1] + bins[1:]) / 2
        start = bins.min()
        end = bins.max()
        top = hist.max()

        p = figure(
            title=' Histogram',
            plot_width=600, plot_height=400,
            tools="",
            title_text_font_size="16pt",
            x_range=[start, end],
            y_range=[0, top],
            x_axis_label = ' Bins',
            y_axis_label = 'Bin Count' 
        )
        p.rect(center, hist / 2.0, width, hist)
        return p

    def make_plots(self):

        self.hist_plots()

    def hist_plots(self):
        self.hist1 = self.path_plot()
        self.hist2 = self.hist_den_plot()
        self.hist3 = self.mc_results()

    def set_children(self):
        self.children = [self.mainrow, self.second_row]
        self.mainrow.children = [self.input_box, self.hist1]
        self.second_row.children = [self.hist2, self.hist3]
        self.input_box.children = [self.ticker1_box, self.ticker2_box, self.ticker3_box,self.ticker4_box,self.ticker5_box]
        self.ticker1_box.children =[self.ticker1_select, self.ticker1p_select]
        self.ticker2_box.children =[self.ticker2_select, self.ticker2p_select]
        self.ticker3_box.children =[self.ticker3_select, self.ticker3_1_select, self.ticker3_2_select]
        self.ticker4_box.children =[self.ticker4_select, self.ticker4_1_select, self.ticker4_2_select]
        self.ticker5_box.children =[self.button_select]

    def input_change(self, obj, attrname, old, new):
        if obj == self.ticker4_2_select:
            self.ticker4_2 = new
        if obj == self.ticker4_1_select:
            self.ticker4_1 = new
        if obj == self.ticker4_select:
            self.ticker4 = new
        if obj == self.ticker3_2_select:
            self.ticker3_2 = new
        if obj == self.ticker3_1_select:
            self.ticker3_1 = new
        if obj == self.ticker3_select:
            self.ticker3 = new
        if obj == self.ticker2p_select:
            self.ticker2p = new
        if obj == self.ticker2_select:
            self.ticker2 = new
        if obj == self.ticker1p_select:
            self.ticker1p = new
        if obj == self.ticker1_select:
            self.ticker1 = new
        if obj == self.button_select:
            self.button = new 
            if 'run' in self.button:
                self.make_source()
                self.make_plots()
                self.set_children()
                curdoc().add(self)

        #self.make_source()
        #self.make_plots()
        #self.set_children()
        #curdoc().add(self)

    def setup_events(self):
        super(StockApp, self).setup_events()
        if self.ticker1_select:
            self.ticker1_select.on_change('value', self, 'input_change')
        if self.ticker1p_select:
            self.ticker1p_select.on_change('value', self, 'input_change')
        if self.ticker2_select:
            self.ticker2_select.on_change('value', self, 'input_change')
        if self.ticker2p_select:
            self.ticker2p_select.on_change('value', self, 'input_change')
        if self.ticker3_select:
            self.ticker3_select.on_change('value', self, 'input_change')
        if self.ticker3_1_select:
            self.ticker3_1_select.on_change('value', self, 'input_change')
        if self.ticker3_2_select:
            self.ticker3_2_select.on_change('value', self, 'input_change')
        if self.ticker4_select:
            self.ticker4_select.on_change('value', self, 'input_change')
        if self.ticker4_1_select:
            self.ticker4_1_select.on_change('value', self, 'input_change')
        if self.ticker4_2_select:
            self.ticker4_2_select.on_change('value', self, 'input_change')
        if self.button_select:
            self.button_select.on_change('value',self, 'input_change')

    @property
    def Y(self):
        tmpdf = pd.DataFrame(self.main_mc(int(self.ticker3_1),int(self.ticker3),float(self.ticker3_2),self.ticker4_2,float(self.ticker4_1)))
        tmpdf.columns = ['Col_' + str(i) for i in xrange(len(tmpdf.columns))]
        #print tmpdf
        return tmpdf
コード例 #26
0
#==================
#create plot
#==================

# Set up data

#global:
param_choice = data['resolution2']
#

#source = ColumnDataSource(data=dict(x=data['scene_lat'] , y=data['scene_lon'], c=param_choice ))
plot.circle('scene_lat', 'scene_lon', source=all_data, line_width=3, alpha=0.6)

# Set up widgets
text = TextInput(title="title", value='Daily Resolution')
print("You've made it this far, traveller!")

year_slider = Slider(title="Year", value=all_data['year'].min(), start=all_data['year'].min(), end=all_data['year'].max(), step=1)
month_slider = Slider(title="Month", value=all_data['year'].min(), start=all_data['year'].min(), end=all_data['year'].max(), step=1)
day_slider = DateSlider(title="Day", start=all_data['date'].min(), end=all_data['date'].max(), value=all_data['date'].min(), step=1)

#year_slider = Slider(title="Year", value=data['year'].min(), start=data['year'].min(), end=data['year'].max(), step=1)
#month_slider = Slider(title="Month", value=data['year'].min(), start=data['year'].min(), end=data['year'].max(), step=1)
#day_slider = DateSlider(title="Day", start=data['date'].min(), end=data['date'].max(), value=data['date'].min(), step=1)


#date = DateSlider(title="Day", start=data['date'].min(), end=data['date'].max(), value=data['date'].min(), step=1)
#param_button_group = RadioButtonGroup(labels=["Resolution", "Potential Water", "Cloud Coverage", "Gelbstoff"], active=0)
time_button_group = RadioButtonGroup(labels=["Yearly", "Monthly", "Daily"], active=0)
# Set up callbacks
コード例 #27
0
source = ColumnDataSource(data=dict(x=x, y=y))

# Set up plot
plot = figure(
    plot_height=400,
    plot_width=400,
    title="my sine wave",
    tools="crosshair,pan,reset,save,wheel_zoom",
    x_range=[0, 4 * np.pi],
    y_range=[-2.5, 2.5],
)

plot.line("x", "y", source=source, line_width=3, line_alpha=0.6)

# Set up widgets
text = TextInput(title="title", value="my sine wave")
offset = Slider(title="offset", value=0.0, start=-5.0, end=5.0, step=0.1)
amplitude = Slider(title="amplitude", value=1.0, start=-5.0, end=5.0, step=0.1)
phase = Slider(title="phase", value=0.0, start=0.0, end=2 * np.pi)
freq = Slider(title="frequency", value=1.0, start=0.1, end=5.1, step=0.1)


# Set up callbacks
def update_title(attrname, old, new):
    plot.title.text = text.value


text.on_change("value", update_title)


def update_data(attrname, old, new):
コード例 #28
0
    def __init__(self):

        self.options = load_options()
        self.option_types = ['AUTH_USER_REQ', 'DISABLE_BACKUP_TAB', 'OPTIONAL_TABS', 'LITE_VIEW', 'COLORS', 'SIZE',
                             'LINE_WIDTH', 'LINE_DASH', 'ALPHA', 'ENDPOINT_COUNT', 'RESAMPLED_DVH_BIN_COUNT']
        div = {key: Div(text=key) for key in self.option_types}

        self.input = {}

        self.input['AUTH_USER_REQ'] = RadioButtonGroup(labels=["True", "False"], active=1-int(self.options.AUTH_USER_REQ))
        self.input['AUTH_USER_REQ'].on_change('active', self.update_auth_user_req)

        self.input['DISABLE_BACKUP_TAB'] = RadioButtonGroup(labels=["True", "False"], active=1-int(self.options.DISABLE_BACKUP_TAB))
        self.input['DISABLE_BACKUP_TAB'].on_change('active', self.update_disable_backup_tab)

        labels = ['ROI Viewer', 'Planning Data', 'Time-Series', 'Correlation', 'Regression', 'MLC Analyzer']
        active = [l for l in range(0, len(labels)) if self.options.OPTIONAL_TABS[labels[l]]]
        self.input['OPTIONAL_TABS'] = CheckboxGroup(labels=labels, active=active)
        self.input['OPTIONAL_TABS'].on_change('active', self.update_options_tabs)

        self.input['LITE_VIEW'] = RadioButtonGroup(labels=["True", "False"], active=1 - int(self.options.LITE_VIEW))
        self.input['LITE_VIEW'].on_change('active', self.update_lite_view)

        color_variables = [c for c in self.options.__dict__ if c.find('COLOR') > -1]
        color_variables.sort()
        colors = plot_colors.cnames.keys()
        colors.sort()
        self.input['COLORS_var'] = Select(value=color_variables[0], options=color_variables)
        self.input['COLORS_var'].on_change('value', self.update_input_colors_var)
        self.input['COLORS_val'] = Select(value=getattr(self.options, color_variables[0]), options=colors)
        self.input['COLORS_val'].on_change('value', self.update_input_colors_val)

        size_variables = [s for s in self.options.__dict__ if s.find('SIZE') > -1]
        size_variables.sort()
        self.input['SIZE_var'] = Select(value=size_variables[0], options=size_variables)
        self.input['SIZE_var'].on_change('value', self.update_size_var)
        self.input['SIZE_val'] = TextInput(value=str(getattr(self.options, size_variables[0])).replace('pt', ''))
        self.input['SIZE_val'].on_change('value', self.update_size_val)

        width_variables = [l for l in self.options.__dict__ if l.find('LINE_WIDTH') > -1]
        width_variables.sort()
        self.input['LINE_WIDTH_var'] = Select(value=width_variables[0], options=width_variables)
        self.input['LINE_WIDTH_var'].on_change('value', self.update_line_width_var)
        self.input['LINE_WIDTH_val'] = TextInput(value=str(getattr(self.options, width_variables[0])))
        self.input['LINE_WIDTH_val'].on_change('value', self.update_line_width_val)

        line_dash_variables = [d for d in self.options.__dict__ if d.find('LINE_DASH') > -1]
        line_dash_variables.sort()
        self.input['LINE_DASH_var'] = Select(value=line_dash_variables[0], options=line_dash_variables)
        self.input['LINE_DASH_var'].on_change('value', self.update_line_dash_var)
        line_dash_options = ['solid', 'dashed', 'dotted', 'dotdash', 'dashdot']
        self.input['LINE_DASH_val'] = Select(value=getattr(self.options, line_dash_variables[0]),
                                             options=line_dash_options)
        self.input['LINE_DASH_val'].on_change('value', self.update_line_dash_val)

        alpha_variables = [a for a in self.options.__dict__ if a.find('ALPHA') > -1]
        alpha_variables.sort()
        self.input['ALPHA_var'] = Select(value=alpha_variables[0], options=alpha_variables)
        self.input['ALPHA_var'].on_change('value', self.update_alpha_var)
        self.input['ALPHA_val'] = TextInput(value=str(getattr(self.options, alpha_variables[0])))
        self.input['ALPHA_val'].on_change('value', self.update_alpha_val)

        self.input['ENDPOINT_COUNT'] = TextInput(value=str(self.options.ENDPOINT_COUNT))
        self.input['ENDPOINT_COUNT'].on_change('value', self.update_endpoint_count)

        self.input['RESAMPLED_DVH_BIN_COUNT'] = TextInput(value=str(self.options.RESAMPLED_DVH_BIN_COUNT))
        self.input['RESAMPLED_DVH_BIN_COUNT'].on_change('value', self.update_resampled_dvh_bin_count)

        self.default_options_button = Button(label="Restore Default Options", button_type='warning')
        self.default_options_button.on_click(self.restore_default_options)

        self.layout = column(Div(text="<hr>", width=900),
                             Div(text="<b>Options</b>"),
                             row(div['AUTH_USER_REQ'], self.input['AUTH_USER_REQ']),
                             row(div['DISABLE_BACKUP_TAB'], self.input['DISABLE_BACKUP_TAB']),
                             row(div['OPTIONAL_TABS'], self.input['OPTIONAL_TABS']),
                             row(div['LITE_VIEW'], self.input['LITE_VIEW']),
                             row(div['COLORS'], self.input['COLORS_var'], self.input['COLORS_val']),
                             row(div['SIZE'], self.input['SIZE_var'], self.input['SIZE_val']),
                             row(div['LINE_WIDTH'], self.input['LINE_WIDTH_var'], self.input['LINE_WIDTH_val']),
                             row(div['LINE_DASH'], self.input['LINE_DASH_var'], self.input['LINE_DASH_val']),
                             row(div['ALPHA'], self.input['ALPHA_var'], self.input['ALPHA_val']),
                             row(div['ENDPOINT_COUNT'], self.input['ENDPOINT_COUNT']),
                             row(div['RESAMPLED_DVH_BIN_COUNT'], self.input['RESAMPLED_DVH_BIN_COUNT']),
                             row(self.default_options_button,
                                 Div(text="Must restart Settings server to take effect after click")))
コード例 #29
0
def plot():

    # FIGURES AND X-AXIS
    fig1 = Figure(title = 'Dive Profile',  plot_width = WIDTH, plot_height = HEIGHT, tools = TOOLS)
    fig2 = Figure(title = 'Dive Controls', plot_width = WIDTH, plot_height = HEIGHT, tools = TOOLS, x_range=fig1.x_range)
    fig3 = Figure(title = 'Attitude',      plot_width = WIDTH, plot_height = HEIGHT, tools = TOOLS, x_range=fig1.x_range)
    figs = gridplot([[fig1],[fig2],[fig3]])

    # Formatting x-axis
    timeticks = DatetimeTickFormatter(formats=dict(seconds =["%b%d %H:%M:%S"],
                                                   minutes =["%b%d %H:%M"],
                                                   hourmin =["%b%d %H:%M"],
                                                   hours =["%b%d %H:%M"],
                                                   days  =["%b%d %H:%M"],
                                                   months=["%b%d %H:%M"],
                                                   years =["%b%d %H:%M %Y"]))
    fig1.xaxis.formatter = timeticks
    fig2.xaxis.formatter = timeticks
    fig3.xaxis.formatter = timeticks

    # removing gridlines
    fig1.xgrid.grid_line_color = None
    fig1.ygrid.grid_line_color = None
    fig2.xgrid.grid_line_color = None
    fig2.ygrid.grid_line_color = None
    fig3.xgrid.grid_line_color = None
    fig3.ygrid.grid_line_color = None

    # INPUT WIDGETS
    collection_list = CONN[DB].collection_names(include_system_collections=False)
    gliders = sorted([platformID for platformID in collection_list if len(platformID)>2])
    gliders = Select(title = 'PlatformID', value = gliders[0], options = gliders)
    prev_glider = Button(label = '<')
    next_glider = Button(label = '>')
    glider_controlbox = HBox(children = [gliders, prev_glider, next_glider], height=80)

    chunkations = Select(title = 'Chunkation', value = 'segment', options = ['segment', '24hr', '30days', '-ALL-'])
    chunk_indicator = TextInput(title = 'index', value = '0')
    prev_chunk = Button(label = '<')
    next_chunk = Button(label = '>')
    chunk_ID   = PreText(height=80)
    chunk_controlbox = HBox(chunkations,
                            HBox(chunk_indicator, width=25),
                            prev_chunk, next_chunk,
                            chunk_ID,
                            height = 80)

    control_box = HBox(glider_controlbox,
                        chunk_controlbox)

    # DATA VARS
    deadby_date = ''
    depth    = ColumnDataSource(dict(x=[],y=[]))
    vert_vel = ColumnDataSource(dict(x=[],y=[]))

    mbpump   = ColumnDataSource(dict(x=[],y=[]))
    battpos  = ColumnDataSource(dict(x=[],y=[]))
    pitch    = ColumnDataSource(dict(x=[],y=[]))

    mfin      = ColumnDataSource(dict(x=[],y=[]))
    cfin      = ColumnDataSource(dict(x=[],y=[]))
    mroll     = ColumnDataSource(dict(x=[],y=[]))
    mheading = ColumnDataSource(dict(x=[],y=[]))
    cheading = ColumnDataSource(dict(x=[],y=[]))

    # AXIS setup
    colors = COLORS[:]

    fig1.y_range.flipped = True
    fig1.yaxis.axis_label = 'm_depth (m)'
    fig1.extra_y_ranges = {'vert_vel': Range1d(start=-50, end=50),
                           'dummy':    Range1d(start=0, end=100)}
    fig1.add_layout(place = 'right',
                    obj = LinearAxis(y_range_name = 'vert_vel',
                                     axis_label   = 'vertical velocity (cm/s)'))
    fig1.add_layout(place = 'left',
                    obj = LinearAxis(y_range_name = 'dummy',
                                     axis_label   = ' '))
    fig1.yaxis[1].visible = False
    fig1.yaxis[1].axis_line_alpha = 0
    fig1.yaxis[1].major_label_text_alpha = 0
    fig1.yaxis[1].major_tick_line_alpha = 0
    fig1.yaxis[1].minor_tick_line_alpha = 0


    fig2.yaxis.axis_label = 'pitch (deg)'
    fig2.y_range.start, fig2.y_range.end = -40,40
    fig2.extra_y_ranges = {'battpos': Range1d(start=-1, end = 1),
                           'bpump':   Range1d(start=-275, end=275)}
    fig2.add_layout(place = 'right',
                    obj = LinearAxis(y_range_name = 'battpos',
                                     axis_label = 'battpos (in)'))
    fig2.add_layout(place = 'left',
                    obj = LinearAxis(y_range_name = 'bpump',
                                     axis_label   = 'bpump (cc)'))
    fig2.yaxis[1].visible = False # necessary for spacing. later gets set to true


    fig3.yaxis.axis_label = 'fin/roll (deg)'
    fig3.y_range.start, fig3.y_range.end = -30, 30
    fig3.extra_y_ranges = {'heading': Range1d(start=0, end=360), #TODO dynamic avg centering
                           'dummy':   Range1d(start=0, end=100)}
    fig3.add_layout(place = 'right',
                    obj = LinearAxis(y_range_name = 'heading',
                                     axis_label   = 'headings (deg)'))
    fig3.add_layout(place = 'left',
                    obj = LinearAxis(y_range_name = 'dummy',
                                     axis_label   = ' '))
    fig3.yaxis[1].visible = False
    fig3.yaxis[1].axis_line_alpha = 0
    fig3.yaxis[1].major_label_text_alpha = 0
    fig3.yaxis[1].major_tick_line_alpha = 0
    fig3.yaxis[1].minor_tick_line_alpha = 0

    # PLOT OBJECTS
    fig1.line(  'x', 'y', source = depth,    legend = 'm_depth',     color = 'red')
    fig1.circle('x', 'y', source = depth,    legend = 'm_depth',     color = 'red')
    fig1.line(  'x', 'y', source = vert_vel, legend = 'vert_vel',    color = 'green',     y_range_name = 'vert_vel')
    fig1.circle('x', 'y', source = vert_vel, legend = 'vert_vel',    color = 'green',     y_range_name = 'vert_vel')
    fig1.renderers.append(Span(location = 0, dimension = 'width',    y_range_name = 'vert_vel',
                               line_color= 'green', line_dash='dashed', line_width=1))

    fig2.line(  'x', 'y', source = pitch,   legend = "m_pitch",    color = 'indigo')
    fig2.circle('x', 'y', source = pitch,   legend = "m_pitch",    color = 'indigo')
    fig2.line(  'x', 'y', source = battpos, legend = 'm_battpos',  color = 'magenta',   y_range_name = 'battpos')
    fig2.circle('x', 'y', source = battpos, legend = 'm_battpos',  color = 'magenta',   y_range_name = 'battpos')
    fig2.line(  'x', 'y', source = mbpump,  legend = "m_'bpump'",  color = 'blue',      y_range_name = 'bpump')
    fig2.circle('x', 'y', source = mbpump,  legend = "m_'bpump'",  color = 'blue',      y_range_name = 'bpump')
    fig2.renderers.append(Span(location = 0, dimension = 'width',
                               line_color= 'black', line_dash='dashed', line_width=1))
    fig3.line(  'x', 'y', source = mfin,       legend = 'm_fin',     color = 'cyan')
    fig3.circle('x', 'y', source = mfin,       legend = 'm_fin',     color = 'cyan')
    fig3.line(  'x', 'y', source = cfin,       legend = 'c_fin',     color = 'orange')
    fig3.circle('x', 'y', source = cfin,       legend = 'c_fin',     color = 'orange')
    fig3.line(  'x', 'y', source = mroll,      legend = 'm_roll',    color = 'magenta')
    fig3.circle('x', 'y', source = mroll,      legend = 'm_roll',    color = 'magenta')
    fig3.line(  'x', 'y', source = mheading,   legend = 'm_heading', color = 'blue',    y_range_name = 'heading')
    fig3.circle('x', 'y', source = mheading,   legend = 'm_heading', color = 'blue',    y_range_name = 'heading')
    fig3.line(  'x', 'y', source = cheading,   legend = 'c_heading', color = 'indigo',  y_range_name = 'heading')
    fig3.circle('x', 'y', source = cheading,   legend = 'c_heading', color = 'indigo',  y_range_name = 'heading')
    fig3.renderers.append(Span(location = 0, dimension = 'width',    y_range_name = 'default',
                               line_color= 'black', line_dash='dashed', line_width=1))

    # CALLBACK FUNCS
    def update_data(attrib,old,new):
        g = gliders.value
        chnk = chunkations.value
        chindex = abs(int(chunk_indicator.value))

        depth.data    = dict(x=[],y=[])
        vert_vel.data = dict(x=[],y=[])
        mbpump.data   = dict(x=[],y=[])
        battpos.data  = dict(x=[],y=[])
        pitch.data    = dict(x=[],y=[])

        mfin.data     = dict(x=[],y=[])
        cfin.data     = dict(x=[],y=[])
        mroll.data    = dict(x=[],y=[])
        mheading.data = dict(x=[],y=[])
        cheading.data = dict(x=[],y=[])


        depth.data,startend   = load_sensor(g, 'm_depth', chnk, chindex)

        if chnk == 'segment':
            xbd = startend[2]
            chunk_ID.text = '{} {} \n{} ({}) \nSTART: {} \nEND:   {}'.format(g, xbd['mission'],
                                                                             xbd['onboard_filename'], xbd['the8x3_filename'],
                                                                             e2ts(xbd['start']), e2ts(xbd['end']))
            if len(set(depth.data['x']))<=1 and attrib == 'chunk':
                if old > new:
                    next_chunk.clicks += 1
                else:
                    prev_chunk.clicks += 1
                return
            elif len(set(depth.data['x']))<=1 and chunk_indicator.value == 0:
                chunk_indicator.value = 1

        elif chnk in ['24hr', '30days']:
            chunk_ID.text = '{} \nSTART: {} \nEND:   {}'.format(g, e2ts(startend[0]), e2ts(startend[1]))
        elif chnk == '-ALL-':
            chunk_ID.text = '{} \nSTART: {} \nEND:   {}'.format(g,e2ts(depth.data['x'][0] /1000),
                                                                  e2ts(depth.data['x'][-1]/1000))


        vert_vel.data  = calc_vert_vel(depth.data)

        mbpump.data,_     = load_sensor(g, 'm_de_oil_vol', chnk, chindex)
        if len(mbpump.data['x']) > 1:
            #for yax in fig2.select('mbpump'):
            #    yax.legend = 'm_de_oil_vol'
            pass
        else:
            mbpump.data,_     = load_sensor(g, 'm_ballast_pumped', chnk, chindex)
            #for yax in fig2.select('mbpump'):
            #    yax.legend = 'm_ballast_pumped'
        battpos.data,_ = load_sensor(g, 'm_battpos',    chnk, chindex)
        pitch.data,_   = load_sensor(g, 'm_pitch',      chnk, chindex)
        pitch.data['y'] = [math.degrees(y) for y in pitch.data['y']]

        mfin.data,_     = load_sensor(g, 'm_fin',     chnk, chindex)
        cfin.data,_     = load_sensor(g, 'c_fin',     chnk, chindex)
        mroll.data,_    = load_sensor(g, 'm_roll',    chnk, chindex)
        mheading.data,_ = load_sensor(g, 'm_heading', chnk, chindex)
        cheading.data,_ = load_sensor(g, 'c_heading', chnk, chindex)
        mfin.data['y']     = [math.degrees(y) for y in mfin.data['y']]
        cfin.data['y']     = [math.degrees(y) for y in cfin.data['y']]
        mheading.data['y'] = [math.degrees(y) for y in mheading.data['y']]
        cheading.data['y'] = [math.degrees(y) for y in cheading.data['y']]
        mroll.data['y']    = [math.degrees(y) for y in mroll.data['y']]

        fig1.yaxis[1].visible = True
        fig2.yaxis[1].visible = True
        fig3.yaxis[1].visible = True


    #GLIDER SELECTS
    def glider_buttons(increment):
        ops = gliders.options
        new_index = ops.index(gliders.value) + increment
        if new_index >= len(ops):
            new_index = 0
        elif new_index < 0:
            new_index = len(ops)-1
        gliders.value = ops[new_index]
        chunkation_update(None, None, None) #reset chunk indicator and clicks
    def next_glider_func():
        glider_buttons(1)
    def prev_glider_func():
        glider_buttons(-1)
    def update_glider(attrib,old,new):
        chunk_indicator.value = '0'
        #update_data(None,None,None)


    gliders.on_change('value', update_glider)
    next_glider.on_click(next_glider_func)
    prev_glider.on_click(prev_glider_func)


        #CHUNK SELECTS
    def chunkation_update(attrib,old,new):
        chunk_indicator.value = '0'
        prev_chunk.clicks = 0
        next_chunk.clicks = 0
        update_data(None,None,None)
        if new == '-ALL-':
            chunk_indicator.value = '-'

    def chunk_func():
        chunkdiff = prev_chunk.clicks - next_chunk.clicks
        if chunkdiff < 0:
            prev_chunk.clicks = 0
            next_chunk.clicks = 0
            chunkdiff = 0
        print (chunkdiff)
        chunk_indicator.value = str(chunkdiff)

    def chunk_indicator_update(attrib,old,new):
        try:
            if abs(int(old)-int(new))>1: #manual update, triggers new non-manual indicator update, ie else clause below
                prev_chunk.clicks = int(new)
                next_chunk.clicks = 0
            else:
                update_data('chunk',int(old),int(new))
            print("UPDATE", old, new)
        except Exception as e:
            print(type(e),e, old, new)

    chunkations.on_change('value', chunkation_update)
    chunk_indicator.on_change('value', chunk_indicator_update)
    next_chunk.on_click(chunk_func)
    prev_chunk.on_click(chunk_func)

    update_data(None,None,None)

    return vplot(control_box, figs)
コード例 #30
0
ファイル: iex.py プロジェクト: trentonpulsipher/stock_prices
    data.stream(
        dict(time=new_price["delayedPriceTime"],
             display_time=new_price["processedTime"],
             price=new_price["delayedPrice"]), 10000)
    return


hover = HoverTool(tooltips=[("Time",
                             "@display_time"), ("IEX Real-Time Price",
                                                "@price")])

price_plot = figure(plot_width=800,
                    plot_height=400,
                    x_axis_type='datetime',
                    tools=[hover],
                    title="Real-Time Price Plot")

price_plot.line(source=data, x='time', y='price')
price_plot.xaxis.axis_label = "Time"
price_plot.yaxis.axis_label = "IEX Real-Time Price"
price_plot.title.text = "IEX Real Time Price: " + TICKER

ticker_textbox = TextInput(placeholder="Ticker")
update = Button(label="Update")
update.on_click(update_ticker)

inputs = widgetbox([ticker_textbox, update], width=200)

curdoc().add_root(row(inputs, price_plot, width=1600))
curdoc().title = "Real-Time Price Plot from IEX"
curdoc().add_periodic_callback(update_price, 1000)
コード例 #31
0
ファイル: query.py プロジェクト: rainygoblin/DVH-Analytics
class Query:
    def __init__(self, sources, categories, dvhs, rad_bio, roi_viewer, time_series,
                 correlation, regression, mlc_analyzer, custom_title, data_tables):
        self.sources = sources
        self.selector_categories = categories.selector
        self.range_categories = categories.range
        self.correlation_variables = categories.correlation_variables
        self.dvhs = dvhs
        self.rad_bio = rad_bio
        self.roi_viewer = roi_viewer
        self.time_series = time_series
        self.correlation = correlation
        self.regression = regression
        self.mlc_analyzer = mlc_analyzer

        self.uids = {n: [] for n in GROUP_LABELS}
        self.allow_source_update = True
        self.current_dvh = []
        self.anon_id_map = []
        self.colors = itertools.cycle(palette)

        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!
        # Selection Filter UI objects
        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!
        category_options = list(self.selector_categories)
        category_options.sort()

        # Add Current row to source
        self.add_selector_row_button = Button(label="Add Selection Filter", button_type="primary", width=200)
        self.add_selector_row_button.on_click(self.add_selector_row)

        # Row
        self.selector_row = Select(value='1', options=['1'], width=50, title="Row")
        self.selector_row.on_change('value', self.selector_row_ticker)

        # Category 1
        self.select_category1 = Select(value="ROI Institutional Category", options=category_options, width=300,
                                       title="Category 1")
        self.select_category1.on_change('value', self.select_category1_ticker)

        # Category 2
        cat_2_sql_table = self.selector_categories[self.select_category1.value]['table']
        cat_2_var_name = self.selector_categories[self.select_category1.value]['var_name']
        self.category2_values = DVH_SQL().get_unique_values(cat_2_sql_table, cat_2_var_name)
        self.select_category2 = Select(value=self.category2_values[0], options=self.category2_values, width=300,
                                       title="Category 2")
        self.select_category2.on_change('value', self.select_category2_ticker)

        # Misc
        self.delete_selector_row_button = Button(label="Delete", button_type="warning", width=100)
        self.delete_selector_row_button.on_click(self.delete_selector_row)
        self.group_selector = CheckboxButtonGroup(labels=["Group 1", "Group 2"], active=[0], width=180)
        self.group_selector.on_change('active', self.ensure_selector_group_is_assigned)
        self.selector_not_operator_checkbox = CheckboxGroup(labels=['Not'], active=[])
        self.selector_not_operator_checkbox.on_change('active', self.selector_not_operator_ticker)

        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!
        # Range Filter UI objects
        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!
        category_options = list(self.range_categories)
        category_options.sort()

        # Add Current row to source
        self.add_range_row_button = Button(label="Add Range Filter", button_type="primary", width=200)
        self.add_range_row_button.on_click(self.add_range_row)

        # Row
        self.range_row = Select(value='', options=[''], width=50, title="Row")
        self.range_row.on_change('value', self.range_row_ticker)

        # Category
        self.select_category = Select(value=options.SELECT_CATEGORY_DEFAULT, options=category_options, width=240, title="Category")
        self.select_category.on_change('value', self.select_category_ticker)

        # Min and max
        self.text_min = TextInput(value='', title='Min: ', width=150)
        self.text_min.on_change('value', self.min_text_ticker)
        self.text_max = TextInput(value='', title='Max: ', width=150)
        self.text_max.on_change('value', self.max_text_ticker)

        # Misc
        self.delete_range_row_button = Button(label="Delete", button_type="warning", width=100)
        self.delete_range_row_button.on_click(self.delete_range_row)
        self.group_range = CheckboxButtonGroup(labels=["Group 1", "Group 2"], active=[0], width=180)
        self.group_range.on_change('active', self.ensure_range_group_is_assigned)
        self.range_not_operator_checkbox = CheckboxGroup(labels=['Not'], active=[])
        self.range_not_operator_checkbox.on_change('active', self.range_not_operator_ticker)

        self.query_button = Button(label="Query", button_type="success", width=100)
        self.query_button.on_click(self.update_data)

        # define Download button and call download.js on click
        menu = [("All Data", "all"), ("Lite", "lite"), ("Only DVHs", "dvhs"), ("Anonymized DVHs", "anon_dvhs")]
        self.download_dropdown = Dropdown(label="Download", button_type="default", menu=menu, width=100)
        self.download_dropdown.callback = CustomJS(args=dict(source=sources.dvhs,
                                                             source_rxs=sources.rxs,
                                                             source_plans=sources.plans,
                                                             source_beams=sources.beams),
                                                   code=open(join(dirname(dirname(__file__)), "download.js")).read())

        self.layout = column(Div(text="<b>DVH Analytics v%s</b>" % options.VERSION),
                             row(custom_title['1']['query'], Spacer(width=50), custom_title['2']['query'],
                                 Spacer(width=50), self.query_button, Spacer(width=50), self.download_dropdown),
                             Div(text="<b>Query by Categorical Data</b>", width=1000),
                             self.add_selector_row_button,
                             row(self.selector_row, Spacer(width=10), self.select_category1, self.select_category2,
                                 self.group_selector, self.delete_selector_row_button, Spacer(width=10),
                                 self.selector_not_operator_checkbox),
                             data_tables.selection_filter,
                             Div(text="<hr>", width=1050),
                             Div(text="<b>Query by Numerical Data</b>", width=1000),
                             self.add_range_row_button,
                             row(self.range_row, Spacer(width=10), self.select_category, self.text_min,
                                 Spacer(width=30),
                                 self.text_max, Spacer(width=30), self.group_range,
                                 self.delete_range_row_button, Spacer(width=10), self.range_not_operator_checkbox),
                             data_tables.range_filter)

    def get_query(self, group=None):

        if group:
            if group == 1:
                active_groups = [1]
            elif group == 2:
                active_groups = [2]
        else:
            active_groups = [1, 2]

        # Used to accumulate lists of query strings for each table
        # Will assume each item in list is complete query for that SQL column
        queries = {'Plans': [], 'Rxs': [], 'Beams': [], 'DVHs': []}

        # Used to group queries by variable, will combine all queries of same variable with an OR operator
        # e.g., queries_by_sql_column['Plans'][key] = list of strings, where key is sql column
        queries_by_sql_column = {'Plans': {}, 'Rxs': {}, 'Beams': {}, 'DVHs': {}}

        for active_group in active_groups:

            # Accumulate categorical query strings
            data = self.sources.selectors.data
            for r in data['row']:
                r = int(r)
                if data['group'][r - 1] in {active_group, 3}:
                    var_name = self.selector_categories[data['category1'][r - 1]]['var_name']
                    table = self.selector_categories[data['category1'][r - 1]]['table']
                    value = data['category2'][r - 1]
                    if data['not_status'][r - 1]:
                        operator = "!="
                    else:
                        operator = "="

                    query_str = "%s %s '%s'" % (var_name, operator, value)

                    # Append query_str in query_by_sql_column
                    if var_name not in queries_by_sql_column[table].keys():
                        queries_by_sql_column[table][var_name] = []
                    queries_by_sql_column[table][var_name].append(query_str)

            # Accumulate numerical query strings
            data = self.sources.ranges.data
            for r in data['row']:
                r = int(r)
                if data['group'][r - 1] in {active_group, 3}:
                    var_name = self.range_categories[data['category'][r - 1]]['var_name']
                    table = self.range_categories[data['category'][r - 1]]['table']

                    value_low, value_high = data['min'][r - 1], data['max'][r - 1]
                    if data['category'][r - 1] != 'Simulation Date':
                        value_low, value_high = float(value_low), float(value_high)

                    # Modify value_low and value_high so SQL interprets values as dates, if applicable
                    if var_name in {'sim_study_date', 'birth_date'}:
                        value_low = "'%s'" % value_low
                        value_high = "'%s'" % value_high

                    if data['not_status'][r - 1]:
                        query_str = var_name + " NOT BETWEEN " + str(value_low) + " AND " + str(value_high)
                    else:
                        query_str = var_name + " BETWEEN " + str(value_low) + " AND " + str(value_high)

                    # Append query_str in query_by_sql_column
                    if var_name not in queries_by_sql_column[table]:
                        queries_by_sql_column[table][var_name] = []
                    queries_by_sql_column[table][var_name].append(query_str)

        for table in queries:
            temp_str = []
            for v in queries_by_sql_column[table].keys():
                # collect all constraints for a given sql column into one list
                q_by_sql_col = [q for q in queries_by_sql_column[table][v]]

                # combine all constraints for a given sql column with 'or' operators
                temp_str.append("(%s)" % ' OR '.join(q_by_sql_col))

            queries[table] = ' AND '.join(temp_str)
            print(str(datetime.now()), '%s = %s' % (table, queries[table]), sep=' ')

        # Get a list of UIDs that fit the plan, rx, and beam query criteria.  DVH query criteria will not alter the
        # list of UIDs, therefore dvh_query is not needed to get the UID list
        print(str(datetime.now()), 'getting uids', sep=' ')
        uids = get_study_instance_uids(plans=queries['Plans'], rxs=queries['Rxs'], beams=queries['Beams'])['union']

        # uids: a unique list of all uids that satisfy the criteria
        # queries['DVHs']: the dvh query string for SQL
        return uids, queries['DVHs']

    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    # Functions for Querying by categorical data
    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    def update_select_category2_values(self):
        new = self.select_category1.value
        table_new = self.selector_categories[new]['table']
        var_name_new = self.selector_categories[new]['var_name']
        new_options = DVH_SQL().get_unique_values(table_new, var_name_new)
        self.select_category2.options = new_options
        self.select_category2.value = new_options[0]

    def ensure_selector_group_is_assigned(self, attr, old, new):
        if not self.group_selector.active:
            self.group_selector.active = [-old[0] + 1]
        self.update_selector_source()

    def update_selector_source(self):
        if self.selector_row.value:
            r = int(self.selector_row.value) - 1
            group = sum([i + 1 for i in self.group_selector.active])
            group_labels = ['1', '2', '1 & 2']
            group_label = group_labels[group - 1]
            not_status = ['', 'Not'][len(self.selector_not_operator_checkbox.active)]

            patch = {'category1': [(r, self.select_category1.value)], 'category2': [(r, self.select_category2.value)],
                     'group': [(r, group)], 'group_label': [(r, group_label)], 'not_status': [(r, not_status)]}
            self.sources.selectors.patch(patch)

    def add_selector_row(self):
        if self.sources.selectors.data['row']:
            temp = self.sources.selectors.data

            for key in list(temp):
                temp[key].append('')
            temp['row'][-1] = len(temp['row'])

            self.sources.selectors.data = temp
            new_options = [str(x + 1) for x in range(len(temp['row']))]
            self.selector_row.options = new_options
            self.selector_row.value = new_options[-1]
            self.select_category1.value = options.SELECT_CATEGORY1_DEFAULT
            self.select_category2.value = self.select_category2.options[0]
            self.selector_not_operator_checkbox.active = []
        else:
            self.selector_row.options = ['1']
            self.selector_row.value = '1'
            self.sources.selectors.data = dict(row=[1], category1=[''], category2=[''],
                                               group=[], group_label=[''], not_status=[''])
        self.update_selector_source()

        clear_source_selection(self.sources, 'selectors')

    def select_category1_ticker(self, attr, old, new):
        self.update_select_category2_values()
        self.update_selector_source()

    def select_category2_ticker(self, attr, old, new):
        self.update_selector_source()

    def selector_not_operator_ticker(self, attr, old, new):
        self.update_selector_source()

    def selector_row_ticker(self, attr, old, new):
        if self.sources.selectors.data['category1'] and self.sources.selectors.data['category1'][-1]:
            r = int(self.selector_row.value) - 1
            category1 = self.sources.selectors.data['category1'][r]
            category2 = self.sources.selectors.data['category2'][r]
            group = self.sources.selectors.data['group'][r]
            not_status = self.sources.selectors.data['not_status'][r]

            self.select_category1.value = category1
            self.select_category2.value = category2
            self.group_selector.active = [[0], [1], [0, 1]][group - 1]
            if not_status:
                self.selector_not_operator_checkbox.active = [0]
            else:
                self.selector_not_operator_checkbox.active = []

    def update_selector_row_on_selection(self, attr, old, new):
        if new:
            self.selector_row.value = self.selector_row.options[min(new)]

    def delete_selector_row(self):
        if self.selector_row.value:
            new_selectors_source = self.sources.selectors.data
            index_to_delete = int(self.selector_row.value) - 1
            new_source_length = len(self.sources.selectors.data['category1']) - 1

            if new_source_length == 0:
                clear_source_data(self.sources, 'selector')
                self.selector_row.options = ['']
                self.selector_row.value = ''
                self.group_selector.active = [0]
                self.selector_not_operator_checkbox.active = []
                self.select_category1.value = options.SELECT_CATEGORY1_DEFAULT
                self.select_category2.value = self.select_category2.options[0]
            else:
                for key in list(new_selectors_source):
                    new_selectors_source[key].pop(index_to_delete)

                for i in range(index_to_delete, new_source_length):
                    new_selectors_source['row'][i] -= 1

                self.selector_row.options = [str(x + 1) for x in range(new_source_length)]
                if self.selector_row.value not in self.selector_row.options:
                    self.selector_row.value = self.selector_row.options[-1]
                self.sources.selectors.data = new_selectors_source

            clear_source_selection(self.sources, 'selectors')

    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    # Functions for Querying by numerical data
    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    def add_range_row(self):
        if self.sources.ranges.data['row']:
            temp = self.sources.ranges.data

            for key in list(temp):
                temp[key].append('')
            temp['row'][-1] = len(temp['row'])
            self.sources.ranges.data = temp
            new_options = [str(x + 1) for x in range(len(temp['row']))]
            self.range_row.options = new_options
            self.range_row.value = new_options[-1]
            self.select_category.value = options.SELECT_CATEGORY_DEFAULT
            self.group_range.active = [0]
            self.range_not_operator_checkbox.active = []
        else:
            self.range_row.options = ['1']
            self.range_row.value = '1'
            self.sources.ranges.data = dict(row=['1'], category=[''], min=[''], max=[''], min_display=[''],
                                            max_display=[''],  group=[''], group_label=[''], not_status=[''])

        self.update_range_titles(reset_values=True)
        self.update_range_source()

        clear_source_selection(self.sources, 'ranges')

    def update_range_source(self):
        if self.range_row.value:
            table = self.range_categories[self.select_category.value]['table']
            var_name = self.range_categories[self.select_category.value]['var_name']

            r = int(self.range_row.value) - 1
            group = sum([i + 1 for i in self.group_range.active])  # a result of 3 means group 1 & 2
            group_labels = ['1', '2', '1 & 2']
            group_label = group_labels[group - 1]
            not_status = ['', 'Not'][len(self.range_not_operator_checkbox.active)]

            if self.select_category.value == 'Simulation Date':
                min_value = str(parse(self.text_min.value).date())
                min_display = min_value

                max_value = str(parse(self.text_max.value).date())
                max_display = max_value
            else:

                try:
                    min_value = float(self.text_min.value)
                except ValueError:
                    try:
                        min_value = float(DVH_SQL().get_min_value(table, var_name))
                    except TypeError:
                        min_value = ''

                try:
                    max_value = float(self.text_max.value)
                except ValueError:
                    try:
                        max_value = float(DVH_SQL().get_max_value(table, var_name))
                    except TypeError:
                        max_value = ''

                if min_value or min_value == 0.:
                    min_display = "%s %s" % (str(min_value), self.range_categories[self.select_category.value]['units'])
                else:
                    min_display = 'None'

                if max_value or max_value == 0.:
                    max_display = "%s %s" % (str(max_value), self.range_categories[self.select_category.value]['units'])
                else:
                    max_display = 'None'

            patch = {'category': [(r, self.select_category.value)], 'min': [(r, min_value)], 'max': [(r, max_value)],
                     'min_display': [(r, min_display)], 'max_display': [(r, max_display)],
                     'group': [(r, group)], 'group_label': [(r, group_label)], 'not_status': [(r, not_status)]}
            self.sources.ranges.patch(patch)

            self.group_range.active = [[0], [1], [0, 1]][group - 1]
            self.text_min.value = str(min_value)
            self.text_max.value = str(max_value)

    def update_range_titles(self, reset_values=False):
        table = self.range_categories[self.select_category.value]['table']
        var_name = self.range_categories[self.select_category.value]['var_name']
        min_value = DVH_SQL().get_min_value(table, var_name)
        self.text_min.title = 'Min: ' + str(min_value) + ' ' + self.range_categories[self.select_category.value]['units']
        max_value = DVH_SQL().get_max_value(table, var_name)
        self.text_max.title = 'Max: ' + str(max_value) + ' ' + self.range_categories[self.select_category.value]['units']

        if reset_values:
            self.text_min.value = str(min_value)
            self.text_max.value = str(max_value)

    def range_row_ticker(self, attr, old, new):
        if self.sources.ranges.data['category'] and self.sources.ranges.data['category'][-1]:
            r = int(new) - 1
            category = self.sources.ranges.data['category'][r]
            min_new = self.sources.ranges.data['min'][r]
            max_new = self.sources.ranges.data['max'][r]
            group = self.sources.ranges.data['group'][r]
            not_status = self.sources.ranges.data['not_status'][r]

            self.allow_source_update = False
            self.select_category.value = category
            self.text_min.value = str(min_new)
            self.text_max.value = str(max_new)
            self.update_range_titles()
            self.group_range.active = [[0], [1], [0, 1]][group - 1]
            self.allow_source_update = True
            if not_status:
                self.range_not_operator_checkbox.active = [0]
            else:
                self.range_not_operator_checkbox.active = []

    def select_category_ticker(self, attr, old, new):
        if self.allow_source_update:
            self.update_range_titles(reset_values=True)
            self.update_range_source()

    def min_text_ticker(self, attr, old, new):
        if self.allow_source_update:
            self.update_range_source()

    def max_text_ticker(self, attr, old, new):
        if self.allow_source_update:
            self.update_range_source()

    def range_not_operator_ticker(self, attr, old, new):
        if self.allow_source_update:
            self.update_range_source()

    def delete_range_row(self):
        if self.range_row.value:
            new_range_source = self.sources.ranges.data
            index_to_delete = int(self.range_row.value) - 1
            new_source_length = len(self.sources.ranges.data['category']) - 1

            if new_source_length == 0:
                clear_source_data(self.sources, 'ranges')
                self.range_row.options = ['']
                self.range_row.value = ''
                self.group_range.active = [0]
                self.range_not_operator_checkbox.active = []
                self.select_category.value = options.SELECT_CATEGORY_DEFAULT
                self.text_min.value = ''
                self.text_max.value = ''
            else:
                for key in list(new_range_source):
                    new_range_source[key].pop(index_to_delete)

                for i in range(index_to_delete, new_source_length):
                    new_range_source['row'][i] -= 1

                self.range_row.options = [str(x + 1) for x in range(new_source_length)]
                if self.range_row.value not in self.range_row.options:
                    self.range_row.value = self.range_row.options[-1]
                self.sources.ranges.data = new_range_source

            clear_source_selection(self.sources, 'ranges')

    def ensure_range_group_is_assigned(self, attr, old, new):
        if not self.group_range.active:
            self.group_range.active = [-old[0] + 1]
        self.update_range_source()

    def update_range_row_on_selection(self, attr, old, new):
        if new:
            self.range_row.value = self.range_row.options[min(new)]

    # main update function
    def update_data(self):
        global BAD_UID
        BAD_UID = {n: [] for n in GROUP_LABELS}
        old_update_button_label = self.query_button.label
        old_update_button_type = self.query_button.button_type
        self.query_button.label = 'Updating...'
        self.query_button.button_type = 'warning'
        print(str(datetime.now()), 'Constructing query for complete dataset', sep=' ')
        uids, dvh_query_str = self.get_query()
        print(str(datetime.now()), 'getting dvh data', sep=' ')
        self.current_dvh = DVH(uid=uids, dvh_condition=dvh_query_str)
        if self.current_dvh.count:
            print(str(datetime.now()), 'initializing source data ', self.current_dvh.query, sep=' ')
            self.time_series.update_current_dvh_group(self.update_dvh_data(self.current_dvh))
            if not options.LITE_VIEW:
                print(str(datetime.now()), 'updating correlation data')
                self.correlation.update_data(self.correlation_variables)
                print(str(datetime.now()), 'correlation data updated')
            self.dvhs.update_source_endpoint_calcs()
            if not options.LITE_VIEW:
                self.dvhs.calculate_review_dvh()
                self.rad_bio.initialize()
                self.time_series.y_axis.value = ''
                self.roi_viewer.update_mrn()
                try:
                    self.mlc_analyzer.update_mrn()
                except:
                    pass
        else:
            print(str(datetime.now()), 'empty dataset returned', sep=' ')
            self.query_button.label = 'No Data'
            self.query_button.button_type = 'danger'
            time.sleep(2.5)

        self.query_button.label = old_update_button_label
        self.query_button.button_type = old_update_button_type

    # updates beam ColumnSourceData for a given list of uids
    def update_beam_data(self, uids):

        cond_str = "study_instance_uid in ('" + "', '".join(uids) + "')"
        beam_data = QuerySQL('Beams', cond_str)

        groups = self.get_group_list(beam_data.study_instance_uid)

        anon_id = [self.anon_id_map[beam_data.mrn[i]] for i in range(len(beam_data.mrn))]

        attributes = ['mrn', 'beam_dose', 'beam_energy_min', 'beam_energy_max', 'beam_mu', 'beam_mu_per_deg',
                      'beam_mu_per_cp', 'beam_name', 'beam_number', 'beam_type', 'scan_mode', 'scan_spot_count',
                      'control_point_count', 'fx_count', 'fx_grp_beam_count', 'fx_grp_number', 'gantry_start',
                      'gantry_end', 'gantry_rot_dir', 'gantry_range', 'gantry_min', 'gantry_max', 'collimator_start',
                      'collimator_end', 'collimator_rot_dir', 'collimator_range', 'collimator_min', 'collimator_max',
                      'couch_start', 'couch_end', 'couch_rot_dir', 'couch_range', 'couch_min', 'couch_max',
                      'radiation_type', 'ssd', 'treatment_machine']
        for i in ['min', 'mean', 'median', 'max']:
            for j in ['area', 'complexity', 'cp_mu', 'x_perim', 'y_perim']:
                attributes.append('%s_%s' % (j, i))
        data = {attr: getattr(beam_data, attr) for attr in attributes}
        data['anon_id'] = anon_id
        data['group'] = groups
        data['uid'] = beam_data.study_instance_uid

        self.sources.beams.data = data

    # updates plan ColumnSourceData for a given list of uids
    def update_plan_data(self, uids):

        cond_str = "study_instance_uid in ('" + "', '".join(uids) + "')"
        plan_data = QuerySQL('Plans', cond_str)

        # Determine Groups
        groups = self.get_group_list(plan_data.study_instance_uid)

        anon_id = [self.anon_id_map[plan_data.mrn[i]] for i in range(len(plan_data.mrn))]

        attributes = ['mrn', 'age', 'birth_date', 'dose_grid_res', 'fxs', 'patient_orientation', 'patient_sex',
                      'physician', 'rx_dose', 'sim_study_date', 'total_mu', 'tx_modality', 'tx_site',
                      'heterogeneity_correction', 'complexity']
        data = {attr: getattr(plan_data, attr) for attr in attributes}
        data['anon_id'] = anon_id
        data['group'] = groups
        data['uid'] = plan_data.study_instance_uid

        self.sources.plans.data = data

    # updates rx ColumnSourceData for a given list of uids
    def update_rx_data(self, uids):

        cond_str = "study_instance_uid in ('" + "', '".join(uids) + "')"
        rx_data = QuerySQL('Rxs', cond_str)

        groups = self.get_group_list(rx_data.study_instance_uid)

        anon_id = [self.anon_id_map[rx_data.mrn[i]] for i in range(len(rx_data.mrn))]

        attributes = ['mrn', 'plan_name', 'fx_dose', 'rx_percent', 'fxs', 'rx_dose', 'fx_grp_count', 'fx_grp_name',
                      'fx_grp_number', 'normalization_method', 'normalization_object']
        data = {attr: getattr(rx_data, attr) for attr in attributes}
        data['anon_id'] = anon_id
        data['group'] = groups
        data['uid'] = rx_data.study_instance_uid

        self.sources.rxs.data = data

    def get_group_list(self, uids):

        groups = []
        for r in range(len(uids)):
            if uids[r] in self.uids['1']:
                if uids[r] in self.uids['2']:
                    groups.append('Group 1 & 2')
                else:
                    groups.append('Group 1')
            else:
                groups.append('Group 2')

        return groups

    def update_dvh_data(self, dvh):

        dvh_group_1, dvh_group_2 = [], []
        group_1_constraint_count, group_2_constraint_count = group_constraint_count(self.sources)

        if group_1_constraint_count and group_2_constraint_count:
            extra_rows = 12
        elif group_1_constraint_count or group_2_constraint_count:
            extra_rows = 6
        else:
            extra_rows = 0

        print(str(datetime.now()), 'updating dvh data', sep=' ')
        line_colors = [color for j, color in itertools.izip(range(dvh.count + extra_rows), self.colors)]

        x_axis = np.round(np.add(np.linspace(0, dvh.bin_count, dvh.bin_count) / 100., 0.005), 3)

        print(str(datetime.now()), 'beginning stat calcs', sep=' ')

        if self.dvhs.radio_group_dose.active == 1:
            stat_dose_scale = 'relative'
            x_axis_stat = dvh.get_resampled_x_axis()
        else:
            stat_dose_scale = 'absolute'
            x_axis_stat = x_axis
        if self.dvhs.radio_group_volume.active == 0:
            stat_volume_scale = 'absolute'
        else:
            stat_volume_scale = 'relative'

        print(str(datetime.now()), 'calculating patches', sep=' ')

        if group_1_constraint_count == 0:
            self.uids['1'] = []
            clear_source_data(self.sources, 'patch_1')
            clear_source_data(self.sources, 'stats_1')
        else:
            print(str(datetime.now()), 'Constructing Group 1 query', sep=' ')
            self.uids['1'], dvh_query_str = self.get_query(group=1)
            dvh_group_1 = DVH(uid=self.uids['1'], dvh_condition=dvh_query_str)
            self.uids['1'] = dvh_group_1.study_instance_uid
            stat_dvhs_1 = dvh_group_1.get_standard_stat_dvh(dose_scale=stat_dose_scale,
                                                            volume_scale=stat_volume_scale)

            if self.dvhs.radio_group_dose.active == 1:
                x_axis_1 = dvh_group_1.get_resampled_x_axis()
            else:
                x_axis_1 = np.add(np.linspace(0, dvh_group_1.bin_count, dvh_group_1.bin_count) / 100., 0.005)

            self.sources.patch_1.data = {'x_patch': np.append(x_axis_1, x_axis_1[::-1]).tolist(),
                                         'y_patch': np.append(stat_dvhs_1['q3'], stat_dvhs_1['q1'][::-1]).tolist()}
            self.sources.stats_1.data = {'x': x_axis_1.tolist(),
                                         'min': stat_dvhs_1['min'].tolist(),
                                         'q1': stat_dvhs_1['q1'].tolist(),
                                         'mean': stat_dvhs_1['mean'].tolist(),
                                         'median': stat_dvhs_1['median'].tolist(),
                                         'q3': stat_dvhs_1['q3'].tolist(),
                                         'max': stat_dvhs_1['max'].tolist()}
        if group_2_constraint_count == 0:
            self.uids['2'] = []
            clear_source_data(self.sources, 'patch_2')
            clear_source_data(self.sources, 'stats_2')

        else:
            print(str(datetime.now()), 'Constructing Group 2 query', sep=' ')
            self.uids['2'], dvh_query_str = self.get_query(group=2)
            dvh_group_2 = DVH(uid=self.uids['2'], dvh_condition=dvh_query_str)
            self.uids['2'] = dvh_group_2.study_instance_uid
            stat_dvhs_2 = dvh_group_2.get_standard_stat_dvh(dose_scale=stat_dose_scale,
                                                            volume_scale=stat_volume_scale)

            if self.dvhs.radio_group_dose.active == 1:
                x_axis_2 = dvh_group_2.get_resampled_x_axis()
            else:
                x_axis_2 = np.add(np.linspace(0, dvh_group_2.bin_count, dvh_group_2.bin_count) / 100., 0.005)

            self.sources.patch_2.data = {'x_patch': np.append(x_axis_2, x_axis_2[::-1]).tolist(),
                                         'y_patch': np.append(stat_dvhs_2['q3'], stat_dvhs_2['q1'][::-1]).tolist()}
            self.sources.stats_2.data = {'x': x_axis_2.tolist(),
                                         'min': stat_dvhs_2['min'].tolist(),
                                         'q1': stat_dvhs_2['q1'].tolist(),
                                         'mean': stat_dvhs_2['mean'].tolist(),
                                         'median': stat_dvhs_2['median'].tolist(),
                                         'q3': stat_dvhs_2['q3'].tolist(),
                                         'max': stat_dvhs_2['max'].tolist()}

        print(str(datetime.now()), 'patches calculated', sep=' ')

        if self.dvhs.radio_group_dose.active == 0:
            x_scale = ['Gy'] * (dvh.count + extra_rows + 1)
            self.dvhs.plot.xaxis.axis_label = "Dose (Gy)"
        else:
            x_scale = ['%RxDose'] * (dvh.count + extra_rows + 1)
            self.dvhs.plot.xaxis.axis_label = "Relative Dose (to Rx)"
        if self.dvhs.radio_group_volume.active == 0:
            y_scale = ['cm^3'] * (dvh.count + extra_rows + 1)
            self.dvhs.plot.yaxis.axis_label = "Absolute Volume (cc)"
        else:
            y_scale = ['%Vol'] * (dvh.count + extra_rows + 1)
            self.dvhs.plot.yaxis.axis_label = "Relative Volume"

        # new_endpoint_columns = [''] * (dvh.count + extra_rows + 1)

        x_data, y_data = [], []
        for n in range(dvh.count):
            if self.dvhs.radio_group_dose.active == 0:
                x_data.append(x_axis.tolist())
            else:
                x_data.append(np.divide(x_axis, dvh.rx_dose[n]).tolist())
            if self.dvhs.radio_group_volume.active == 0:
                y_data.append(np.multiply(dvh.dvh[:, n], dvh.volume[n]).tolist())
            else:
                y_data.append(dvh.dvh[:, n].tolist())

        y_names = ['Max', 'Q3', 'Median', 'Mean', 'Q1', 'Min']

        # Determine Population group (blue (1) or red (2))
        dvh_groups = []
        for r in range(len(dvh.study_instance_uid)):

            current_uid = dvh.study_instance_uid[r]
            current_roi = dvh.roi_name[r]

            if dvh_group_1:
                for r1 in range(len(dvh_group_1.study_instance_uid)):
                    if dvh_group_1.study_instance_uid[r1] == current_uid and dvh_group_1.roi_name[r1] == current_roi:
                        dvh_groups.append('Group 1')

            if dvh_group_2:
                for r2 in range(len(dvh_group_2.study_instance_uid)):
                    if dvh_group_2.study_instance_uid[r2] == current_uid and dvh_group_2.roi_name[r2] == current_roi:
                        if len(dvh_groups) == r + 1:
                            dvh_groups[r] = 'Group 1 & 2'
                        else:
                            dvh_groups.append('Group 2')

            if len(dvh_groups) < r + 1:
                dvh_groups.append('error')

        dvh_groups.insert(0, 'Review')

        for n in range(6):
            if group_1_constraint_count > 0:
                dvh.mrn.append(y_names[n])
                dvh.roi_name.append('N/A')
                x_data.append(x_axis_stat.tolist())
                current = stat_dvhs_1[y_names[n].lower()].tolist()
                y_data.append(current)
                dvh_groups.append('Group 1')
            if group_2_constraint_count > 0:
                dvh.mrn.append(y_names[n])
                dvh.roi_name.append('N/A')
                x_data.append(x_axis_stat.tolist())
                current = stat_dvhs_2[y_names[n].lower()].tolist()
                y_data.append(current)
                dvh_groups.append('Group 2')

        # Adjust dvh object to include stats data
        attributes = ['rx_dose', 'volume', 'surface_area', 'min_dose', 'mean_dose', 'max_dose', 'dist_to_ptv_min',
                      'dist_to_ptv_median', 'dist_to_ptv_mean', 'dist_to_ptv_max', 'dist_to_ptv_centroids',
                      'ptv_overlap', 'cross_section_max', 'cross_section_median', 'spread_x', 'spread_y',
                      'spread_z', 'toxicity_grade']
        if extra_rows > 0:
            dvh.study_instance_uid.extend(['N/A'] * extra_rows)
            dvh.institutional_roi.extend(['N/A'] * extra_rows)
            dvh.physician_roi.extend(['N/A'] * extra_rows)
            dvh.roi_type.extend(['Stat'] * extra_rows)
        if group_1_constraint_count > 0:
            for attr in attributes:
                getattr(dvh, attr).extend(calc_stats(getattr(dvh_group_1, attr)))

        if group_2_constraint_count > 0:
            for attr in attributes:
                getattr(dvh, attr).extend(calc_stats(getattr(dvh_group_2, attr)))

        # Adjust dvh object for review dvh
        dvh.dvh = np.insert(dvh.dvh, 0, 0, 1)
        dvh.count += 1
        dvh.mrn.insert(0, self.dvhs.select_reviewed_mrn.value)
        dvh.study_instance_uid.insert(0, '')
        dvh.institutional_roi.insert(0, '')
        dvh.physician_roi.insert(0, '')
        dvh.roi_name.insert(0, self.dvhs.select_reviewed_dvh.value)
        dvh.roi_type.insert(0, 'Review')
        dvh.rx_dose.insert(0, 0)
        dvh.volume.insert(0, 0)
        dvh.surface_area.insert(0, '')
        dvh.min_dose.insert(0, '')
        dvh.mean_dose.insert(0, '')
        dvh.max_dose.insert(0, '')
        dvh.dist_to_ptv_min.insert(0, 'N/A')
        dvh.dist_to_ptv_mean.insert(0, 'N/A')
        dvh.dist_to_ptv_median.insert(0, 'N/A')
        dvh.dist_to_ptv_max.insert(0, 'N/A')
        dvh.dist_to_ptv_centroids.insert(0, 'N/A')
        dvh.ptv_overlap.insert(0, 'N/A')
        dvh.cross_section_max.insert(0, 'N/A')
        dvh.cross_section_median.insert(0, 'N/A')
        dvh.spread_x.insert(0, 'N/A')
        dvh.spread_y.insert(0, 'N/A')
        dvh.spread_z.insert(0, 'N/A')
        dvh.toxicity_grade.insert(0, -1)
        line_colors.insert(0, options.REVIEW_DVH_COLOR)
        x_data.insert(0, [0])
        y_data.insert(0, [0])

        # anonymize ids
        self.anon_id_map = {mrn: i for i, mrn in enumerate(list(set(dvh.mrn)))}
        anon_id = [self.anon_id_map[dvh.mrn[i]] for i in range(len(dvh.mrn))]

        print(str(datetime.now()), "writing sources.dvhs.data", sep=' ')
        self.sources.dvhs.data = {'mrn': dvh.mrn,
                                  'anon_id': anon_id,
                                  'group': dvh_groups,
                                  'uid': dvh.study_instance_uid,
                                  'roi_institutional': dvh.institutional_roi,
                                  'roi_physician': dvh.physician_roi,
                                  'roi_name': dvh.roi_name,
                                  'roi_type': dvh.roi_type,
                                  'rx_dose': dvh.rx_dose,
                                  'volume': dvh.volume,
                                  'surface_area': dvh.surface_area,
                                  'min_dose': dvh.min_dose,
                                  'mean_dose': dvh.mean_dose,
                                  'max_dose': dvh.max_dose,
                                  'dist_to_ptv_min': dvh.dist_to_ptv_min,
                                  'dist_to_ptv_mean': dvh.dist_to_ptv_mean,
                                  'dist_to_ptv_median': dvh.dist_to_ptv_median,
                                  'dist_to_ptv_max': dvh.dist_to_ptv_max,
                                  'dist_to_ptv_centroids': dvh.dist_to_ptv_centroids,
                                  'ptv_overlap': dvh.ptv_overlap,
                                  'cross_section_max': dvh.cross_section_max,
                                  'cross_section_median': dvh.cross_section_median,
                                  'spread_x': dvh.spread_x,
                                  'spread_y': dvh.spread_y,
                                  'spread_z': dvh.spread_z,
                                  'x': x_data,
                                  'y': y_data,
                                  'color': line_colors,
                                  'x_scale': x_scale,
                                  'y_scale': y_scale,
                                  'toxicity_grade': dvh.toxicity_grade}

        print(str(datetime.now()), 'begin updating beam, plan, rx data sources', sep=' ')
        self.update_beam_data(dvh.study_instance_uid)
        self.update_plan_data(dvh.study_instance_uid)
        self.update_rx_data(dvh.study_instance_uid)
        print(str(datetime.now()), 'all sources set', sep=' ')

        return {'1': dvh_group_1, '2': dvh_group_2}
コード例 #32
0
ファイル: plot.py プロジェクト: broadinstitute/genepy
def volcano(data,
            folder='',
            tohighlight=None,
            tooltips=[('gene', '@gene_id')],
            title="volcano plot",
            xlabel='log-fold change',
            ylabel='-log(Q)',
            maxvalue=100,
            searchbox=False,
            logfoldtohighlight=0.15,
            pvaltohighlight=0.1,
            showlabels=False):
    """
    Make an interactive volcano plot from Differential Expression analysis tools outputs

    Args:
    -----
        data: a df with rows genes and cols [log2FoldChange, pvalue, gene_id]
        folder: str of location where to save the plot, won't save if empty
        tohighlight: list[str] of genes to highlight in the plot
        tooltips: list[tuples(str,str)] if user wants tot specify another bokeh tooltip
        title: str plot title
        xlabel: str if user wants to specify the title of the x axis
        ylabel: str if user wants tot specify the title of the y axis
        maxvalue: float the max -log2(pvalue authorized usefull when managing inf vals)
        searchbox: bool whether or not to add a searchBox to interactively highlight genes
        logfoldtohighlight: float min logfoldchange when to diplay points
        pvaltohighlight: float min pvalue when to diplay points
        showlabels: bool whether or not to show a text above each datapoint with its label information

    Returns:
    --------
        The bokeh object
    """
    # pdb.set_trace()
    to_plot_not, to_plot_yes = selector(
        data, tohighlight if tohighlight is not None else [],
        logfoldtohighlight, pvaltohighlight)
    hover = bokeh.models.HoverTool(tooltips=tooltips, names=['circles'])

    # Create figure
    p = bokeh.plotting.figure(title=title, plot_width=650, plot_height=450)

    p.xgrid.grid_line_color = 'white'
    p.ygrid.grid_line_color = 'white'
    p.xaxis.axis_label = xlabel
    p.yaxis.axis_label = ylabel

    # Add the hover tool
    p.add_tools(hover)
    p, source1 = add_points(p,
                            to_plot_not,
                            'log2FoldChange',
                            'pvalue',
                            color='#1a9641',
                            maxvalue=maxvalue)
    p, source2 = add_points(p,
                            to_plot_yes,
                            'log2FoldChange',
                            'pvalue',
                            color='#fc8d59',
                            alpha=0.6,
                            outline=True,
                            maxvalue=maxvalue)
    if showlabels:
        labels = LabelSet(x='log2FoldChange',
                          y='transformed_q',
                          text_font_size='7pt',
                          text="gene_id",
                          level="glyph",
                          x_offset=5,
                          y_offset=5,
                          source=source2,
                          render_mode='canvas')
        p.add_layout(labels)
    if searchbox:
        text = TextInput(title="text", value="gene")
        text.js_on_change(
            'value',
            CustomJS(args=dict(source=source1),
                     code="""
                var data = source.data
                var value = cb_obj.value
                var gene_id = data.gene_id
                var a = -1
                for (let i=0; i < gene_id.length; i++) {
                    if ( gene_id[i]===value ) { a=i; console.log(i); data.size[i]=7; data.alpha[i]=1; data.color[i]='#fc8d59' }
                }
                source.data = data
                console.log(source)
                console.log(cb_obj)
                source.change.emit()
                console.log(source)
                """))
        p = column(text, p)
    p.output_backend = "svg"
    if folder:
        save(p, folder + title.replace(' ', "_") + "_volcano.html")
        export_svg(p,
                   filename=folder + title.replace(' ', "_") + "_volcano.svg")
    try:
        show(p)
    except:
        show(p)
    return p
コード例 #33
0
ファイル: stock-test.py プロジェクト: sersei/Log-Plot
PLOT_WIDTH=500
sourceQuad = ColumnDataSource(dict(left=[min(source_small.data['x'])],top=[Max_Y],right=[max(source_small.data['x'])],bottom=[Min_Y]))

toolset = "box_zoom,resize,pan,reset,save,xwheel_zoom"
plot_zoomed = Figure(plot_width=1000, plot_height=500, x_axis_type="datetime",tools=toolset, lod_factor=100,lod_interval=1000)
plot_zoomed.line('x', 'y',source=source_zoomed, color='navy', alpha=0.5)
plot = Figure(plot_width=PLOT_WIDTH, plot_height=250, x_axis_type="datetime",toolbar_location=None,lod_factor=100,lod_interval=1000)
plot.line('x', 'y',source=source_small, color='navy', alpha=0.5)
plot.y_range.start=Min_Y
plot.y_range.end=Max_Y
glyph = Quad(left="left", right="right", top="top", bottom="bottom", fill_color="#b3de69", fill_alpha=0.1)
plot.add_glyph(sourceQuad, glyph)

RangeStartX=0
RangeEndX=1
text_start_x = TextInput(title="X range start", name='x_range_start', value="0")
text_end_x = TextInput(title="X range end", name='x_range_end', value="1")
text_start_x.on_change('value', update_data)
text_end_x.on_change('value', update_data)

toolset = "box_zoom,resize,pan,reset,save,x_wheel_zoom"

plot_zoomed.x_range.callback = CustomJS(args=dict(xrange=plot_zoomed.x_range,start_x=text_start_x,end_x=text_end_x),code="""
var start = xrange.get("start");
var end = xrange.get("end");
start_x.set("value",start.toString());
end_x.set("value",end.toString());
start_x.trigger('change');
end_x.trigger('change');
""")
コード例 #34
0
# Authorize access to discogs database
d = discogs_client.Client(user_agent, user_token=user_token)
df = pd.read_csv(join(dirname(__file__), 'decks_genre_filtered.csv'))
# df.release_date.apply(lambda x: datetime.strptime(x, "%Y-%m-%d"))
source = ColumnDataSource(data=dict())

# Input Buttons
genre_filter = [
    'All', 'Acid', 'Ambient', 'Breaks', 'Chicago', 'Deep House', 'Detroit',
    'Dub Techno', 'House', 'Minimal', 'Techhouse', 'Techno'
]
genre = Select(title="genre", value="All", options=genre_filter)
slider_min = Slider(title="Minimum Price", start=0, end=25, value=0, step=1)
slider_max = Slider(title="Maximum Price", start=0, end=150, value=20, step=1)
search_text = TextInput(title="Search")

columns = [
    TableColumn(field="release_date", title="Release Date"),
    TableColumn(field="release", title="Release Name"),
    TableColumn(field="artist", title="Artist"),
    TableColumn(field="label", title="Label"),
    TableColumn(field="genre", title="Genre"),
    TableColumn(field="catalog_num", title="Catalog Number"),
    TableColumn(field="price",
                title="Price (in USD)",
                formatter=NumberFormatter(format="$0.00")),
    TableColumn(field="in_stock",
                title="Percent Available",
                formatter=NumberFormatter(format="‘0.00%"))
]
コード例 #35
0
ファイル: main.py プロジェクト: priya-vijay/NicheLife
tools = [PanTool(), BoxZoomTool(), WheelZoomTool(), ResetTool(), hover, PreviewSaveTool()]

p = Figure(title="NicheLife Map", plot_width=800, plot_height=700, tools=tools)
# tools="pan,wheel_zoom,reset,box_zoom,save")  # toolbar_location="top", #box_select,
p.grid.grid_line_alpha = 0

p.patches("ct_x", "ct_y", source=source, fill_color="QI_colmap", fill_alpha=0.7, line_color="white", line_width=0.5)

# image1 = ImageURL(url=source.data["image"], x=-74.04, y=40.85)
# p.add_glyph(source, image1)
p.image_url(url=imageurl, x="-74.04", y="40.85")


# Set up widgets
text = TextInput(title="Map Name", value="NicheLife Map")
feature1 = Slider(title="Subway Accessibility", value=0.5, start=0, end=1, step=0.1)
feature2 = Slider(title="Safety", value=0.5, start=0, end=1, step=0.1)
feature3 = Slider(title="Public Satisfaction", value=0.5, start=0, end=1, step=0.1)
feature4 = Slider(title="Restaurants", value=0.5, start=0, end=1, step=0.1)
feature5 = Slider(title="Grocery Stores", value=0.5, start=0, end=1, step=0.1)
feature6 = Slider(title="Nightlife", value=0.5, start=0, end=1, step=0.1)
price = Select(title="Show Affordability", options=["Yes", "No"])


# Set up callbacks
def update_title(attrname, old, new):
    p.title = text.value


text.on_change("value", update_title)
コード例 #36
0
                 metric.value,
                 size=10,
                 color=color_set[i % len(color_set)],
                 source=main_source[i])
        i += 1

    return p


def update(attr, old, new):
    layout.children[1] = create_figure()


#Creates the widgets and updates values when they are changed
cat = Select(title="Category:", value="ReagentLot", options=cat_list)
cat.on_change('value', update)

metric = Select(title="Metric:", value="Q30", options=metric_list)
metric.on_change('value', update)

text = TextInput(title='N', value='300')
text.on_change('value', update)

cat_wig = widgetbox(cat)
metric_wig = widgetbox(metric)
text_wig = widgetbox(text)

layout = column(row(metric_wig, cat_wig, text_wig), create_figure())

curdoc().add_root(layout)
コード例 #37
0
# p_logo = figure(toolbar_location=None, tools = "lasso_select", x_range=(0,1), y_range=(0,1), plot_width=520, plot_height=200)
# img = mpimg.imread("cylance_logo.png")
# p_logo.image_url(url=["cylance_logo.png"], x=0, y=0)
# p_logo.background_fill_color = "black"
# p_logo.border_fill_color = "black"
# p_logo.grid.grid_line_color = "black"
# p_logo.outline_line_color = "black"


# radio button group for uploading file
radio_group = RadioButtonGroup(labels=["NO-SPLIT", "SPLIT", "START"], button_type="success")
radio_group.width = 500
radio_group.on_click(_fit_util)

# text for console output
text_input = TextInput(value="", title="CONSOLE")
text_input.width = 500

cluster_stats = Div(
    render_as_text=False,
    text=generate_display_string("", name="Cluster Statistics", height=100)
)
cluster_stats.width = 500
cluster_stats.height = 100

cluster_commonality = Div(
    render_as_text=False,
    text=generate_display_string("")
)
cluster_commonality.width = 500
cluster_commonality.height = 300
def initialize(curr_doc: CurrentDoc, max_indep_elements=20, catch_radius=0.15):
    """
    Creates and configures all bokeh objects and starts the web app.
    :param max_indep_elements: maximum number of node independent elements accepted in the input plot (int)
    :param catch_radius: radius in which to select an element in input plot (double)
    :return: none
    """

    curr_doc.catch_radius = catch_radius
    '''
    ###############################
    # TEXT BOXES
    ###############################
    '''
    # Div object showing x and y position of the cursor in the input plot
    div_xy = Div(width=75, height=25)

    # Div object showing hints for the graphical input into the input plot through the element buttons
    div_input_width = curr_doc.plot_input.plot_width - div_xy.width - 10
    curr_doc.div_input = Div(width=div_input_width, height=div_xy.height)

    # Div object showing general text messages to the user
    curr_doc.div_msg = Div(css_classes=["MSG_BOX"],
                           text=" ",
                           width=curr_doc.plot_input.plot_width,
                           height=100)
    # doc.div_msg = Div(css_classes=["MSG_BOX"], text=" ", width=doc.plot_input.plot_width, height=100)
    '''
    ###############################
    # INPUT PLOT
    ###############################
    '''
    # style and configuration of the input plot
    # this plot is used to allow the user to connect mechanical elements
    tooltips = [("name", "@name_user"), ("(x, y)", "(@x{0.0}, @y{0.0})")]
    curr_doc.plot_input = figure(
        # plot_width=600, plot_height=300,
        tools="pan,wheel_zoom,reset,lasso_select,hover,save",
        toolbar_location="above",
        # x_axis_label='x', y_axis_label='y',
        x_minor_ticks=10,
        y_minor_ticks=10,
        x_range=Range1d(start=0, end=5),
        y_range=Range1d(start=0, end=5),
        match_aspect=True,
        aspect_scale=1.0,
        tooltips=tooltips,
    )
    curr_doc.plot_input.toolbar.logo = None
    configure_input_plot(curr_doc, curr_doc.plot_input, div_xy,
                         max_indep_elements)
    '''
    ###############################
    # OUTPUT PLOTS
    ###############################
    '''
    # initialize plots for the output after calculations
    plot_output_width = 800
    plot_output_height = 250
    curr_doc.plot_normal_f = figure(plot_width=plot_output_width,
                                    plot_height=plot_output_height,
                                    active_scroll="wheel_zoom")
    curr_doc.plot_normal_f.toolbar.logo = None
    curr_doc.plot_normal_f.title.text = 'Normal force'

    curr_doc.plot_normal_disp = figure(plot_width=plot_output_width,
                                       plot_height=plot_output_height,
                                       active_scroll="wheel_zoom")
    curr_doc.plot_normal_disp.toolbar.logo = None
    curr_doc.plot_normal_disp.title.text = 'Normal displacement'

    curr_doc.plot_shear_f = figure(plot_width=plot_output_width,
                                   plot_height=plot_output_height,
                                   active_scroll="wheel_zoom")
    curr_doc.plot_shear_f.toolbar.logo = None
    curr_doc.plot_shear_f.title.text = 'Shear force'

    curr_doc.plot_moment = figure(plot_width=plot_output_width,
                                  plot_height=plot_output_height,
                                  active_scroll="wheel_zoom")
    curr_doc.plot_moment.toolbar.logo = None
    curr_doc.plot_moment.title.text = 'Bending moment'

    curr_doc.plot_shear_disp = figure(plot_width=plot_output_width,
                                      plot_height=plot_output_height,
                                      active_scroll="wheel_zoom")
    curr_doc.plot_shear_disp.toolbar.logo = None
    curr_doc.plot_shear_disp.title.text = 'Shear displacement'

    curr_doc.plot_shear_angle = figure(plot_width=plot_output_width,
                                       plot_height=plot_output_height,
                                       active_scroll="wheel_zoom")
    curr_doc.plot_shear_angle.toolbar.logo = None
    curr_doc.plot_shear_angle.title.text = 'Rotation angle'

    curr_doc.plot_list = [
        curr_doc.plot_normal_f, curr_doc.plot_normal_disp,
        curr_doc.plot_shear_f, curr_doc.plot_moment, curr_doc.plot_shear_angle,
        curr_doc.plot_shear_disp
    ]

    # add plot renderer
    ds = ColumnDataSource(data=dict(x=[], y=[]))
    curr_doc.plot_normal_f.circle('x', 'y', source=ds)
    curr_doc.plot_normal_disp.circle('x', 'y', source=ds)
    curr_doc.plot_shear_f.circle('x', 'y', source=ds)
    curr_doc.plot_moment.circle('x', 'y', source=ds)
    curr_doc.plot_shear_disp.circle('x', 'y', source=ds)
    curr_doc.plot_normal_f.circle('x', 'y', source=ds)
    curr_doc.plot_shear_angle.circle('x', 'y', source=ds)
    '''
    ###############################
    # TEST CASES
    ###############################
    '''
    menu_tc = [("Single beam load", "single_beam_load"),
               ("Two beam lineload", "two_beam_lineload"),
               ("Angled structure", "fin_struc_soft_lab")]
    dropdown_tc = Dropdown(label="Show test case", menu=menu_tc, width=150)
    dropdown_tc.on_change('value',
                          partial(vis_cbs.cb_plot_testcase, curr_doc=curr_doc))
    # partial(vis_cbs.cb_get_textinput, key=key_elinfo_n)
    '''
    ###############################
    # CALCULATE AND DELETE BUTTONS
    ###############################
    '''
    # add and configure a button to start calculations
    button_calc = Button(label="Calculate", width=240)
    button_calc.on_click(
        partial(vis_cbs.cb_button_calculation, curr_doc, button_calc))

    # add and configure a button to delete selected elements of the input graph
    b_del_w = int((button_calc.width - 10) / 2)
    button_del_selected = Button(label="Delete selected", width=b_del_w)
    button_del_selected.on_click(
        partial(vis_cbs.cb_button_delete,
                curr_doc=curr_doc,
                all_selected=False))

    # add and configure a button to delete selected elements of the input graph
    button_del_all = Button(label="Delete all", width=b_del_w)
    button_del_all.on_click(
        partial(vis_cbs.cb_button_delete, curr_doc=curr_doc,
                all_selected=True))
    '''
    ############################################
    # BOX OF ELEMENTS TO SELECT FOR INPUT PLOT
    ############################################
    '''
    # titles for groups of mechanical elements
    text_supports = Div(text="Supports:", width=100, height=20)
    text_springs = Div(text="Springs:", width=100, height=20)
    text_node = Div(text="Node:", width=100, height=20)
    text_joints = Div(text="Joints:", width=100, height=20)
    text_elements = Div(text="Line elements:", width=100, height=20)
    text_loads = Div(text="Loads:", width=100, height=20)

    b_height = 50
    b_line_width = 72

    # configure buttons for mechanical supports
    button_support_clamped = Button(
        label="",
        css_classes=[eLnum.ElSupEnum.SUPPORT_CLAMPED.name],
        width=b_height,
        height=b_height)
    curr_doc.buttons[
        eLnum.ElSupEnum.SUPPORT_CLAMPED.value] = button_support_clamped
    button_support_clamped.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.SUPPORT_CLAMPED))

    button_support_normal = Button(
        label="",
        css_classes=[eLnum.ElSupEnum.SUPPORT_NORMAL_FORCE.name],
        width=b_height,
        height=b_height)
    curr_doc.buttons[
        eLnum.ElSupEnum.SUPPORT_NORMAL_FORCE.value] = button_support_normal
    button_support_normal.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.SUPPORT_NORMAL_FORCE))

    button_support_transverse = Button(
        label="",
        css_classes=[eLnum.ElSupEnum.SUPPORT_TRANSVERSE_FORCE.name],
        width=b_height,
        height=b_height)
    curr_doc.buttons[eLnum.ElSupEnum.SUPPORT_TRANSVERSE_FORCE.
                     value] = button_support_transverse
    button_support_transverse.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.SUPPORT_TRANSVERSE_FORCE))

    button_support_fixed_conti = Button(
        label="",
        css_classes=[eLnum.ElSupEnum.SUPPORT_FIXED_CONTINUOUS.name],
        width=b_height,
        height=b_height)
    curr_doc.buttons[eLnum.ElSupEnum.SUPPORT_FIXED_CONTINUOUS.
                     value] = button_support_fixed_conti
    button_support_fixed_conti.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.SUPPORT_FIXED_CONTINUOUS))

    button_support_fixed_joint = Button(
        label="",
        css_classes=[eLnum.ElSupEnum.SUPPORT_FIXED_JOINT.name],
        width=b_height,
        height=b_height)
    curr_doc.buttons[
        eLnum.ElSupEnum.SUPPORT_FIXED_JOINT.value] = button_support_fixed_joint
    button_support_fixed_joint.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.SUPPORT_FIXED_JOINT))

    button_support_roller_conti = Button(
        label="",
        css_classes=[eLnum.ElSupEnum.SUPPORT_ROLLER_CONTINUOUS.name],
        width=b_height,
        height=b_height)
    curr_doc.buttons[eLnum.ElSupEnum.SUPPORT_ROLLER_CONTINUOUS.
                     value] = button_support_roller_conti
    button_support_roller_conti.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.SUPPORT_ROLLER_CONTINUOUS))

    button_support_roller_joint = Button(
        label="",
        css_classes=[eLnum.ElSupEnum.SUPPORT_ROLLER_JOINT.name],
        width=b_height,
        height=b_height)
    curr_doc.buttons[eLnum.ElSupEnum.SUPPORT_ROLLER_JOINT.
                     value] = button_support_roller_joint
    button_support_roller_joint.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.SUPPORT_ROLLER_JOINT))

    button_spring_support = Button(
        label="",
        css_classes=[eLnum.ElSupEnum.SPRING_SUPPORT.name],
        width=b_height,
        height=b_height)
    curr_doc.buttons[
        eLnum.ElSupEnum.SPRING_SUPPORT.value] = button_spring_support
    button_spring_support.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.SPRING_SUPPORT))

    button_spring_moment_support = Button(
        label="",
        css_classes=[eLnum.ElSupEnum.SPRING_MOMENT_SUPPORT.name],
        width=b_height,
        height=b_height)
    curr_doc.buttons[eLnum.ElSupEnum.SPRING_MOMENT_SUPPORT.
                     value] = button_spring_moment_support
    button_spring_moment_support.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.SPRING_MOMENT_SUPPORT))

    # configure curr_doc.buttons for connectors
    button_node = Button(label="",
                         css_classes=[eLnum.ElSupEnum.NODE.name],
                         width=b_height,
                         height=b_height)
    curr_doc.buttons[eLnum.ElSupEnum.NODE.value] = button_node
    button_node.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.NODE))

    button_joint = Button(label="",
                          css_classes=[eLnum.ElSupEnum.JOINT.name],
                          width=b_height,
                          height=b_height)
    curr_doc.buttons[eLnum.ElSupEnum.JOINT.value] = button_joint
    button_joint.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.JOINT))

    button_joint_normal = Button(
        label="",
        css_classes=[eLnum.ElSupEnum.JOINT_NORMAL_FORCE.name],
        width=b_height,
        height=b_height)
    curr_doc.buttons[
        eLnum.ElSupEnum.JOINT_NORMAL_FORCE.value] = button_joint_normal
    button_joint_normal.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.JOINT_NORMAL_FORCE))

    button_joint_transverse = Button(
        label="",
        css_classes=[eLnum.ElSupEnum.JOINT_TRANSVERSE_FORCE.name],
        width=b_height,
        height=b_height)
    curr_doc.buttons[
        eLnum.ElSupEnum.JOINT_TRANSVERSE_FORCE.value] = button_joint_transverse
    button_joint_transverse.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.JOINT_TRANSVERSE_FORCE))

    button_spring = Button(label="",
                           css_classes=[eLnum.ElSupEnum.SPRING.name],
                           width=b_line_width,
                           height=b_height)
    curr_doc.buttons[eLnum.ElSupEnum.SPRING.value] = button_spring
    button_spring.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.SPRING))

    # configure buttons for mechanical 1D or 2D elements
    # button_rod = Button(label="", css_classes=[eLnum.ElSupEnum.ROD.name], width=b_line_width, height=b_height)
    # curr_doc.buttons[eLnum.ElSupEnum.ROD.value] = button_rod
    # button_rod.on_click(partial(vis_cbs.cb_button_element_click, button_enum=eLnum.ElSupEnum.ROD))

    button_beam = Button(label="",
                         css_classes=[eLnum.ElSupEnum.BEAM.name],
                         width=b_line_width,
                         height=b_height)
    curr_doc.buttons[eLnum.ElSupEnum.BEAM.value] = button_beam
    button_beam.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.BEAM))

    # configure buttons for mechanical loads
    button_load_point = Button(label="",
                               css_classes=[eLnum.ElSupEnum.LOAD_POINT.name],
                               width=b_height,
                               height=b_height)
    curr_doc.buttons[eLnum.ElSupEnum.LOAD_POINT.value] = button_load_point
    button_load_point.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.LOAD_POINT))

    button_load_moment = Button(label="",
                                css_classes=[eLnum.ElSupEnum.LOAD_MOMENT.name],
                                width=b_height,
                                height=b_height)
    curr_doc.buttons[eLnum.ElSupEnum.LOAD_MOMENT.value] = button_load_moment
    button_load_moment.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.LOAD_MOMENT))

    button_load_random = Button(label="",
                                css_classes=[eLnum.ElSupEnum.LOAD_LINE.name],
                                width=b_line_width,
                                height=b_height)
    curr_doc.buttons[eLnum.ElSupEnum.LOAD_LINE.value] = button_load_random
    button_load_random.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.LOAD_LINE))

    button_load_temp = Button(label="",
                              css_classes=[eLnum.ElSupEnum.LOAD_TEMP.name],
                              width=b_height,
                              height=b_height)
    curr_doc.buttons[eLnum.ElSupEnum.LOAD_TEMP.value] = button_load_temp
    button_load_temp.on_click(
        partial(vis_cbs.cb_button_element_click,
                curr_doc=curr_doc,
                button_enum=eLnum.ElSupEnum.LOAD_TEMP))
    '''
    ###############################
    # ELEMENT INFO BOX
    ###############################
    '''
    elinfo_object_height = 26
    elinfo_label_width1 = 60
    elinfo_label_width2 = 40
    elinfo_input_width = 60

    # labels for values of an element of the input plot
    text_elinfo_name = Div(text="name:",
                           width=elinfo_label_width1,
                           height=elinfo_object_height)
    text_elinfo_x = Div(text="x:",
                        width=elinfo_label_width1,
                        height=elinfo_object_height)
    curr_doc.div_element_info["x"] = text_elinfo_x
    text_elinfo_y = Div(text="y:",
                        width=elinfo_label_width1,
                        height=elinfo_object_height)
    curr_doc.div_element_info["y"] = text_elinfo_y
    text_elinfo_angle1 = Div(text="angle:",
                             width=elinfo_label_width1,
                             height=elinfo_object_height)
    text_elinfo_angle2 = Div(text="°",
                             width=elinfo_label_width2 - 20,
                             height=elinfo_object_height)
    spacer_y_a = Div(text="",
                     width=text_elinfo_angle2.width,
                     height=elinfo_object_height)
    text_elinfo_k1 = Div(text="spring:",
                         width=elinfo_label_width1,
                         height=elinfo_object_height)
    text_elinfo_k2 = Div(text="* k",
                         width=elinfo_label_width2,
                         height=elinfo_object_height)
    text_elinfo_length1 = Div(text="length:",
                              width=elinfo_label_width1,
                              height=elinfo_object_height)
    text_elinfo_length2 = Div(text="* l",
                              width=elinfo_label_width2,
                              height=elinfo_object_height)
    text_elinfo_force1 = Div(text="force:",
                             width=elinfo_label_width1,
                             height=elinfo_object_height)
    text_elinfo_force2 = Div(text="* F",
                             width=elinfo_label_width2,
                             height=elinfo_object_height)
    text_elinfo_moment1 = Div(text="moment:",
                              width=elinfo_label_width1,
                              height=elinfo_object_height)
    text_elinfo_moment2 = Div(text="* M",
                              width=elinfo_label_width2,
                              height=elinfo_object_height)
    text_elinfo_beam = Div(text="BEAM",
                           width=elinfo_object_height,
                           height=elinfo_label_width1,
                           css_classes=["ELINFO_VERTICAL_TEXT"])
    text_elinfo_h = Div(text="* h",
                        width=elinfo_label_width2,
                        height=elinfo_object_height)
    text_elinfo_ei = Div(text="* EI",
                         width=elinfo_label_width2,
                         height=elinfo_object_height)
    text_elinfo_ea = Div(text="* EA",
                         width=elinfo_label_width2,
                         height=elinfo_object_height)
    text_elinfo_lineload = Div(text="LINE LOAD",
                               width=elinfo_object_height,
                               height=elinfo_label_width1,
                               css_classes=["ELINFO_VERTICAL_TEXT"])
    text_elinfo_xn = Div(text="* n",
                         width=elinfo_label_width2 - 10,
                         height=elinfo_object_height)
    curr_doc.div_element_info["xn"] = text_elinfo_xn
    text_elinfo_yq = Div(text="* q",
                         width=elinfo_label_width2 - 10,
                         height=elinfo_object_height)
    curr_doc.div_element_info["yq"] = text_elinfo_yq
    text_elinfo_temp = Div(text="TEMP.",
                           width=elinfo_object_height,
                           height=elinfo_label_width1,
                           css_classes=["ELINFO_VERTICAL_TEXT"])
    text_elinfo_dt = Div(text="* dT",
                         width=elinfo_label_width2,
                         height=elinfo_object_height)
    text_elinfo_tt = Div(text="* T",
                         width=elinfo_label_width2,
                         height=elinfo_object_height)
    text_elinfo_at = Div(text="* &alpha;T",
                         width=elinfo_label_width2,
                         height=elinfo_object_height)

    # text inputs showing the current value of an input plot element and taking input for a value change
    # name
    input_elinfo_name = TextInput(value="-",
                                  width=elinfo_input_width,
                                  height=elinfo_object_height,
                                  disabled=True)
    key_elinfo_n = "name"
    curr_doc.input_element_info[key_elinfo_n] = input_elinfo_name
    input_elinfo_name.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput, curr_doc=curr_doc, key=key_elinfo_n))

    # xy
    input_elinfo_x = TextInput(value="-",
                               width=elinfo_input_width,
                               height=elinfo_object_height,
                               disabled=True)
    key_elinfo_x = "x"
    curr_doc.input_element_info[key_elinfo_x] = input_elinfo_x
    input_elinfo_x.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput, curr_doc=curr_doc, key=key_elinfo_x))

    input_elinfo_y = TextInput(value="-",
                               width=elinfo_input_width,
                               height=elinfo_object_height,
                               disabled=True)
    key_elinfo_y = "y"
    curr_doc.input_element_info[key_elinfo_y] = input_elinfo_y
    input_elinfo_y.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput, curr_doc=curr_doc, key=key_elinfo_y))

    # angle
    input_elinfo_angle = TextInput(value="-",
                                   width=elinfo_input_width,
                                   height=elinfo_object_height,
                                   disabled=True)
    key_elinfo_angle = "angle"
    curr_doc.input_element_info[key_elinfo_angle] = input_elinfo_angle
    input_elinfo_angle.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput,
                curr_doc=curr_doc,
                key=key_elinfo_angle))

    # spring constant
    input_elinfo_k = TextInput(value="-",
                               width=elinfo_input_width,
                               height=elinfo_object_height,
                               disabled=True)
    key_elinfo_k = "k"
    curr_doc.input_element_info[key_elinfo_k] = input_elinfo_k
    input_elinfo_k.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput, curr_doc=curr_doc, key=key_elinfo_k))

    # length
    input_elinfo_length = TextInput(value="-",
                                    width=elinfo_input_width,
                                    height=elinfo_object_height,
                                    disabled=True)
    key_elinfo_length = "length"
    curr_doc.input_element_info[key_elinfo_length] = input_elinfo_length
    input_elinfo_k.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput,
                curr_doc=curr_doc,
                key=key_elinfo_length))

    # point load
    input_elinfo_force = TextInput(value="-",
                                   width=elinfo_input_width,
                                   height=elinfo_object_height,
                                   disabled=True)
    key_elinfo_f = "force"
    curr_doc.input_element_info[key_elinfo_f] = input_elinfo_force
    input_elinfo_force.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput, curr_doc=curr_doc, key=key_elinfo_f))

    # moment
    input_elinfo_moment = TextInput(value="-",
                                    width=elinfo_input_width,
                                    height=elinfo_object_height,
                                    disabled=True)
    key_elinfo_m = "moment"
    curr_doc.input_element_info[key_elinfo_m] = input_elinfo_moment
    input_elinfo_moment.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput, curr_doc=curr_doc, key=key_elinfo_m))

    # beam
    input_elinfo_h = TextInput(value="-",
                               width=elinfo_input_width,
                               height=elinfo_object_height,
                               disabled=True)
    key_elinfo_h = "h"
    curr_doc.input_element_info[key_elinfo_h] = input_elinfo_h
    input_elinfo_h.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput, curr_doc=curr_doc, key=key_elinfo_h))

    check_elinfo_beam = CheckboxGroup(labels=["EA -> inf.", "EI -> inf."],
                                      active=[],
                                      disabled=True,
                                      width=elinfo_input_width +
                                      elinfo_label_width1)
    curr_doc.group_element_info["beam"] = check_elinfo_beam
    check_elinfo_beam.on_change(
        'active', partial(vis_cbs.cb_elinfo_beam, curr_doc=curr_doc))

    input_elinfo_ea = TextInput(value="-",
                                width=elinfo_input_width,
                                height=elinfo_object_height,
                                disabled=True)
    key_elinfo_ea = "ea"
    curr_doc.input_element_info[key_elinfo_ea] = input_elinfo_ea
    input_elinfo_ea.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput, curr_doc=curr_doc,
                key=key_elinfo_ea))

    input_elinfo_ei = TextInput(value="-",
                                width=elinfo_input_width,
                                height=elinfo_object_height,
                                disabled=True)
    key_elinfo_ei = "ei"
    curr_doc.input_element_info[key_elinfo_ei] = input_elinfo_ei
    input_elinfo_ei.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput, curr_doc=curr_doc,
                key=key_elinfo_ei))

    # line load
    radio_elinfo_ll = RadioGroup(
        labels=["local", "global"],
        active=0,
        disabled=True,  # "angle"
        width=elinfo_input_width + elinfo_label_width1)
    curr_doc.group_element_info["ll"] = radio_elinfo_ll
    radio_elinfo_ll.on_change(
        'active', partial(vis_cbs.cb_elinfo_lineload, curr_doc=curr_doc))

    input_elinfo_xns = TextInput(value="-",
                                 width=elinfo_input_width,
                                 height=elinfo_object_height + 20,
                                 disabled=True,
                                 title="start")
    key_elinfo_xns = "xn_start"
    curr_doc.input_element_info[key_elinfo_xns] = input_elinfo_xns
    input_elinfo_xns.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput,
                curr_doc=curr_doc,
                key=key_elinfo_xns))

    input_elinfo_xne = TextInput(value="-",
                                 width=elinfo_input_width,
                                 height=elinfo_object_height + 20,
                                 disabled=True,
                                 title="end")
    key_elinfo_xne = "xn_end"
    curr_doc.input_element_info[key_elinfo_xne] = input_elinfo_xne
    input_elinfo_xne.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput,
                curr_doc=curr_doc,
                key=key_elinfo_xne))

    input_elinfo_yqs = TextInput(value="-",
                                 width=elinfo_input_width,
                                 height=elinfo_object_height,
                                 disabled=True)
    key_elinfo_yqs = "yq_start"
    curr_doc.input_element_info[key_elinfo_yqs] = input_elinfo_yqs
    input_elinfo_yqs.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput,
                curr_doc=curr_doc,
                key=key_elinfo_yqs))

    input_elinfo_yqe = TextInput(value="-",
                                 width=elinfo_input_width,
                                 height=elinfo_object_height,
                                 disabled=True)
    key_elinfo_yqe = "yq_end"
    curr_doc.input_element_info[key_elinfo_yqe] = input_elinfo_yqe
    input_elinfo_yqe.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput,
                curr_doc=curr_doc,
                key=key_elinfo_yqe))

    # temperature load
    input_elinfo_dt = TextInput(value="-",
                                width=elinfo_input_width,
                                height=elinfo_object_height,
                                disabled=True)
    key_elinfo_dt = "dT"
    curr_doc.input_element_info[key_elinfo_dt] = input_elinfo_dt
    input_elinfo_dt.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput, curr_doc=curr_doc,
                key=key_elinfo_dt))

    input_elinfo_tt = TextInput(value="-",
                                width=elinfo_input_width,
                                height=elinfo_object_height,
                                disabled=True)
    key_elinfo_tt = "T"
    curr_doc.input_element_info[key_elinfo_tt] = input_elinfo_tt
    input_elinfo_tt.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput, curr_doc=curr_doc,
                key=key_elinfo_tt))

    input_elinfo_at = TextInput(value="-",
                                width=elinfo_input_width,
                                height=elinfo_object_height,
                                disabled=True)
    key_elinfo_at = "aT"
    curr_doc.input_element_info[key_elinfo_at] = input_elinfo_at
    input_elinfo_at.on_change(
        'value',
        partial(vis_cbs.cb_get_textinput, curr_doc=curr_doc,
                key=key_elinfo_at))

    # button for deleting an input plot element
    button_elinfo_del = Button(label="Delete element",
                               width=elinfo_label_width1 + elinfo_input_width +
                               elinfo_label_width2,
                               height=elinfo_object_height + 10,
                               disabled=False)
    button_elinfo_del.on_click(
        partial(vis_cbs.cb_button_delete, curr_doc=curr_doc, single=True))
    '''
    ###############################
    # CHECKBOXES FOR OUTPUT PLOTS
    ###############################
    '''
    check_labels = ["Min/ max values", "Start/ end values", "Zero points"]
    check_init_active = [1]

    check_plot_nf = CheckboxGroup(labels=check_labels,
                                  active=check_init_active)  # inline=False
    text_plot_nf = Div(text="", width=100, height=10)
    check_plot_nf.on_change(
        'active',
        partial(vis_cbs.cb_toggle_characteristic_values,
                curr_doc=curr_doc,
                output_plot=curr_doc.plot_normal_f,
                div=text_plot_nf))

    check_plot_nd = CheckboxGroup(labels=check_labels,
                                  active=check_init_active)
    text_plot_nd = Div(text="", width=100, height=10)
    check_plot_nd.on_change(
        'active',
        partial(vis_cbs.cb_toggle_characteristic_values,
                curr_doc=curr_doc,
                output_plot=curr_doc.plot_normal_disp,
                div=text_plot_nd))

    check_plot_sf = CheckboxGroup(labels=check_labels,
                                  active=check_init_active)
    text_plot_sf = Div(text="", width=100, height=10)
    check_plot_sf.on_change(
        'active',
        partial(vis_cbs.cb_toggle_characteristic_values,
                curr_doc=curr_doc,
                output_plot=curr_doc.plot_shear_f,
                div=text_plot_sf))

    check_plot_mo = CheckboxGroup(labels=check_labels,
                                  active=check_init_active)
    text_plot_mo = Div(text="", width=100, height=10)
    check_plot_mo.on_change(
        'active',
        partial(vis_cbs.cb_toggle_characteristic_values,
                curr_doc=curr_doc,
                output_plot=curr_doc.plot_moment,
                div=text_plot_mo))

    check_plot_sa = CheckboxGroup(labels=check_labels,
                                  active=check_init_active)
    text_plot_sa = Div(text="", width=100, height=10)
    check_plot_sa.on_change(
        'active',
        partial(vis_cbs.cb_toggle_characteristic_values,
                curr_doc=curr_doc,
                output_plot=curr_doc.plot_shear_angle,
                div=text_plot_sa))

    check_plot_sd = CheckboxGroup(labels=check_labels,
                                  active=check_init_active)
    text_plot_sd = Div(text="", width=100, height=10)
    check_plot_sd.on_change(
        'active',
        partial(vis_cbs.cb_toggle_characteristic_values,
                curr_doc=curr_doc,
                output_plot=curr_doc.plot_shear_disp,
                div=text_plot_sd))
    '''
    ###############################
    # IMAGES: SIGN CONVENTION
    ###############################
    '''
    sign_convention_N = Div(
        text=
        "<img src='/System_of_Beams/static/images/sign_convention_N_u.png' width=100 height=60>",
        width=100,
        height=60)
    sign_convention_u = Div(
        text=
        "<img src='/System_of_Beams/static/images/sign_convention_N_u.png' width=100 height=60>",
        width=100,
        height=60)
    sign_convention_SF = Div(
        text=
        "<img src='/System_of_Beams/static/images/sign_convention_SF_w.png' width=100 height=60>",
        width=100,
        height=60)
    sign_convention_M = Div(
        text=
        "<img src='/System_of_Beams/static/images/sign_convention_M.png' width=100 height=60>",
        width=100,
        height=60)
    sign_convention_phi = Div(
        text=
        "<img src='/System_of_Beams/static/images/sign_convention_phi.png' width=100 height=60>",
        width=100,
        height=60)
    sign_convention_w = Div(
        text=
        "<img src='/System_of_Beams/static/images/sign_convention_SF_w.png' width=100 height=60>",
        width=100,
        height=60)
    '''
    ###############################
    # HTML  LATEX DESCRIPTION
    ###############################
    '''
    # latex packages not working with updated bokeh!
    # description_filename = join(dirname(__file__), "description.html")
    # description = LatexDiv(text=open(description_filename).read(), render_as_text=False, width=910)
    '''
    ####################################
    # CREATE LAYOUT AND START DOCUMENT
    ####################################
    '''
    spacer = Div(text="", width=20, height=20)
    minispacer = Div(text="", width=0, height=0)

    # element buttons
    layout_supports_1 = row(button_support_clamped, button_support_normal,
                            button_support_transverse)
    layout_supports_2 = row(button_support_fixed_joint,
                            button_support_fixed_conti,
                            button_support_roller_joint,
                            button_support_roller_conti)
    layout_springs = row(button_spring_support, button_spring_moment_support)
    layout_node = row(button_node)
    layout_joints = row(button_joint, button_joint_normal,
                        button_joint_transverse, button_spring)
    layout_elements = row(button_beam)  # button_rod,
    layout_loads = row(button_load_point, button_load_moment,
                       button_load_random, button_load_temp)
    layout_input_elements = column(
        spacer, text_supports, layout_supports_1, layout_supports_2,
        row(column(text_springs, layout_springs), spacer, minispacer,
            column(text_node, layout_node)), text_joints, layout_joints,
        text_elements, layout_elements, text_loads, layout_loads)

    # element info box
    elinfo_name = row(text_elinfo_name, input_elinfo_name)
    curr_doc.children_element_info[key_elinfo_n] = elinfo_name
    elinfo_xy = row(text_elinfo_x, input_elinfo_x, spacer_y_a, text_elinfo_y,
                    input_elinfo_y)
    curr_doc.children_element_info[key_elinfo_x] = elinfo_xy
    elinfo_angle_length = row(text_elinfo_angle1, input_elinfo_angle,
                              text_elinfo_angle2, text_elinfo_length1,
                              input_elinfo_length, text_elinfo_length2)
    curr_doc.children_element_info[key_elinfo_angle] = elinfo_angle_length
    elinfo_k = row(text_elinfo_k1, input_elinfo_k, text_elinfo_k2)
    curr_doc.children_element_info[key_elinfo_k] = elinfo_k
    elinfo_force = row(text_elinfo_force1, input_elinfo_force,
                       text_elinfo_force2)
    curr_doc.children_element_info[key_elinfo_f] = elinfo_force
    elinfo_moment = row(text_elinfo_moment1, input_elinfo_moment,
                        text_elinfo_moment2)
    curr_doc.children_element_info[key_elinfo_m] = elinfo_moment
    elinfo_beam = row(
        minispacer, column(minispacer, text_elinfo_beam),
        column(check_elinfo_beam, row(input_elinfo_h, text_elinfo_h)),
        column(row(input_elinfo_ea, text_elinfo_ea),
               row(input_elinfo_ei, text_elinfo_ei)))
    curr_doc.children_element_info[key_elinfo_h] = elinfo_beam
    elinfo_lineload = row(
        minispacer, column(spacer, text_elinfo_lineload),
        column(spacer, radio_elinfo_ll),
        column(row(input_elinfo_xns, input_elinfo_xne),
               row(input_elinfo_yqs, input_elinfo_yqe)),
        column(spacer, text_elinfo_xn, text_elinfo_yq))
    curr_doc.children_element_info[key_elinfo_ei] = elinfo_lineload
    elinfo_dt = row(
        minispacer, column(minispacer, text_elinfo_temp),
        column(
            row(input_elinfo_dt, text_elinfo_dt, minispacer, input_elinfo_at,
                text_elinfo_at), row(input_elinfo_tt, text_elinfo_tt)))
    curr_doc.children_element_info[key_elinfo_dt] = elinfo_dt
    curr_doc.layout_element_info = row(
        minispacer,
        column(minispacer, elinfo_name, elinfo_xy, elinfo_angle_length, spacer,
               elinfo_k, elinfo_force, elinfo_moment, spacer, elinfo_beam,
               spacer, elinfo_lineload, spacer, elinfo_dt, spacer,
               button_elinfo_del, minispacer),
        minispacer,
        css_classes=["ELEMENT_INFO_BOX"],
        margin=(20, 0, 0, 20),
        visible=True)

    # input plot with element buttons, delete and calculation buttons and divs
    user_input = row(curr_doc.plot_input, spacer, layout_input_elements)
    user_input_info = row(curr_doc.div_input, div_xy, spacer,
                          button_del_selected, button_del_all)
    user_msg = row(curr_doc.div_msg, spacer, button_calc)

    # output plots and check boxes for characteristic values
    user_output = column(
        row(curr_doc.plot_normal_f, spacer,
            column(spacer, check_plot_nf, sign_convention_N)),
        row(curr_doc.plot_normal_disp, spacer,
            column(spacer, check_plot_nd, sign_convention_u)),
        row(curr_doc.plot_shear_f, spacer,
            column(spacer, check_plot_sf, sign_convention_SF)),
        row(curr_doc.plot_moment, spacer,
            column(spacer, check_plot_mo, sign_convention_M)),
        row(curr_doc.plot_shear_angle, spacer,
            column(spacer, check_plot_sa, sign_convention_phi)),
        row(curr_doc.plot_shear_disp, spacer,
            column(spacer, check_plot_sd, sign_convention_w)))

    # assemble complete layout
    doc_layout = column(
        spacer, row(spacer, spacer, dropdown_tc),
        row(column(user_input, user_input_info, user_msg), minispacer,
            curr_doc.layout_element_info), spacer, user_output)

    # add layout
    curr_doc.curr_doc.add_root(doc_layout)
    # set title of browser tab
    curr_doc.curr_doc.title = split(dirname(__file__))[-1].replace(
        '_', ' ').replace('-', ' ')
    doc_title = split(dirname(__file__))[-1].replace('_',
                                                     ' ').replace('-', ' ')
コード例 #39
0
# initialize data source
source_fourier = ColumnDataSource(data=dict(t=[], x_fourier=[]))
source_orig = ColumnDataSource(data=dict(t=[], x_orig=[]))
source_interval_patch = ColumnDataSource(data=dict(x_patch=[], y_patch=[]))
source_interval_bound = ColumnDataSource(data=dict(x_min=[], x_max=[], y_minmax=[]))
source_coeff = ColumnDataSource(data=dict(a=[], b=[]))
source_f = ColumnDataSource(data=dict(f=[None]))
source_periodicity = ColumnDataSource(data=dict(t_start=[None], t_end=[None]))
source_view = ColumnDataSource(data=dict(x_start=[None], x_end=[None], y_start=[None], y_end=[None]))

# initialize controls
# buttons for choosing a sample function
sample_function_type = RadioButtonGroup(labels=fs.function_names, active=fs.function_init)

# here one can choose arbitrary input function
default_function_input = TextInput(value=fs.function_input_init)
default_function_period_start = TextInput(title='period start', value=fs.timeinterval_start_init)
default_function_period_end = TextInput(title='period end', value=fs.timeinterval_end_init)

# slider controlling degree of the fourier series
degree = Slider(title="degree", name='degree', value=fs.degree_init, start=fs.degree_min,
                end=fs.degree_max, step=fs.degree_step)

# initialize callback behaviour
degree.on_change('value', degree_change)
default_function_input.on_change('value',
                                 type_input_change)  # todo write default functions for any callback, like above
default_function_period_start.on_change('value', type_input_change)
default_function_period_end.on_change('value', type_input_change)
sample_function_type.on_change('active', type_input_change)
コード例 #40
0
ファイル: main.py プロジェクト: anas9244/vis_twitter
    Stream.twitterStream.disconnect()
    global straming
    straming = False
    rdf['flash'] = 0


# def update_count():
    # start_button_click


p.x_range.on_change('end', update_lod)
start_button = Button(label="Start", button_type="primary", width=80)
start_button.on_click(start_button_click)
stop_button = Button(label="Stop", button_type="danger", width=80)
stop_button.on_click(stop_button_click)
text_input = TextInput(placeholder="Enter query here", width=400)

spacer_row = Spacer(width=450)
spacer_pad_col = Spacer(height=20)
spacer_pad_row = Spacer(width=100)
spacer_col = Spacer(height=20)
layout = column(row(
    spacer_row, text_input, start_button, stop_button, spacer_row), spacer_col, p)

main_layout = row(spacer_pad_row, column(
    spacer_pad_col, layout, spacer_pad_col), spacer_pad_row)


def update_counts():

    if straming:
コード例 #41
0
def plotting():
    forcs = ptsgdf.drop('geometry', axis=1).copy()
    ptscs = ColumnDataSource(forcs)

    #    uscs = usmap.drop('geometry', axis=1).copy()
    #    usmcs = ColumnDataSource(uscs)

    plotp = figure(title="Airport Rankings", plot_width=1200, plot_height=1000)

    text_input1 = TextInput(value="", title="Enter Departing City")
    text_input2 = TextInput(value="", title="Enter Destination City")
    text_input3 = TextInput(
        value="", title="Number of Flights from Departing City to Destination")

    def update1(attr, old, new):
        global liness
        if liness is not None:
            liness.visible = False

        xlist = list()
        ylist = list()
        loccom = text_input1.value
        if loccom:
            for i in range(nc):
                ind = list(dadfra.index).index(loccom)
                if dadfra.loc[loccom, :][i] > 0:
                    xlist.append([ptsgdf.loc[i, "x"], ptsgdf.loc[ind, "x"]])
                    ylist.append([ptsgdf.loc[i, "y"], ptsgdf.loc[ind, "y"]])


#        hover2 = HoverTool(names = ["airl"])
#        hover2.tooltips = [("Number of Flights")]
#        plotp.add_tools(hover1)
        liness = plotp.multi_line(xlist,
                                  ylist,
                                  line_width=1,
                                  line_color="green")
        liness.visible = True

        if loccom:
            if text_input2.value:
                text_input3.value = str(
                    int(dadfra.loc[text_input1.value, text_input2.value]))
        #inst = inst +1

    text_input1.on_change("value", update1)

    def update2(attr, old, new):
        if text_input1.value:
            if text_input2.value:
                text_input3.value = str(
                    int(dadfra.loc[text_input1.value, text_input2.value]))

    text_input2.on_change("value", update2)

    hover1 = HoverTool(names=["airp"])
    plotp.patches(xarr,
                  yarr,
                  color="cyan",
                  alpha=1.0,
                  line_color="black",
                  line_width=2)
    plotp.circle('x', 'y', source=ptscs, name="airp", color='red', size=5)

    hover1.tooltips = [("Airport Name", "@City"), ("Airport Rank", "@Rank")]
    plotp.add_tools(hover1)
    curdoc().add_root(row(plotp, column(text_input1, text_input2,
                                        text_input3)))
コード例 #42
0
ファイル: polar.py プロジェクト: uber-research/parallax
# CONTROLS
dataset = Select(title="Dataset",
                 options=data_manager.dataset_ids,
                 value=selected_dataset)
measure = Select(title="Measure",
                 options=[
                     ('cosine_similarity', 'Cosine Similarity'),
                     ('cosine', 'Cosine Distance'),
                     ('euclidean', 'Euclidean'),
                     ('dot_product', 'Dot product'),
                     ('correlation', 'Correlation'),
                 ],
                 value='cosine_similarity')
axes_preset = '; '.join(['usa', 'europe', 'china', 'japan', 'brazil'])
axes = TextInput(title='Axes Formulae (separated by ";")',
                 placeholder=axes_preset)

items_preset = '; '.join(['food', 'movie'])
items = TextInput(title='Items Formulae (separated by ";")',
                  placeholder=items_preset)

visualization_title = Div(text="<strong>Visualization</strong>")
opacity = Slider(title="Opacity", value=0.2, start=0, end=1, step=0.1)

# BIND CONTROL EVENTS
dataset.on_change('value', update)
axes.on_change('value', update)
items.on_change('value', update)
measure.on_change('value', update)
opacity.on_change('value', update)
コード例 #43
0
ファイル: browse.py プロジェクト: JasperYH/MatchAnnot
        self.fasta = fasta
        self.title = title
        self.notes = notes
        self.highsupport = highsupport
        self.full = full
        self.partial = partial
        self.annotations = annotations


GTF = TextInput(title="Enter the name of annotation file", value="gencode.vM8.annotation.gtf")
Format = TextInput(title="Enter the format of annotation file, standard is gtf", value="standard")
Matches = TextInput(
    title="Enter the name of pickle files from MatchAnnot, e.g. of multiple files: match1.pickle,match2.pickle",
    value="matches.pickle",
)
Gene = TextInput(title="Select gene to visualize")
Alpha = Slider(title="Alpha value of exons", value=1.0, start=0, end=1.0, step=0.1)
Full = Slider(title="Full support threshold", value=0, start=0, end=30, step=1.0)
Partial = Slider(title="Partial support threshold", value=0, start=0, end=50, step=1.0)
Group = Select(title="Group isoform or not", value="on", options=["on", "off"])
Cluster = Slider(title="The number of groups", value=3, start=1, end=5, step=1.0)
Width = Slider(title="The width of transcripts", value=20, start=5, end=30, step=1)
Save = TextInput(title="Enter the folder name to data in Fasta", value=None)

blockSource = ColumnDataSource(
    data=dict(top=[], bottom=[], left=[], right=[], exon=[], start=[], end=[], chromosome=[], xs=[], ys=[])
)
source = ColumnDataSource(data=dict(x=[], y=[], color=[], line_alpha=[], width=[], QScore=[], start=[], end=[]))
geneSource = ColumnDataSource(data=dict(Gene=[], Cluster=[]))

df = pd.DataFrame()
コード例 #44
0
ファイル: main.py プロジェクト: guillochon/catexplorer
            'lws':[2]
        }
    ))

circobs = p.circle(x='xs', y='ys', color='colors',
    source=ColumnDataSource(data=
        {
            'xs':[[]],
            'ys':[[]],
            'colors':['white'],
        }
    ))

# add a button widget and configure with the call back
button = Button(label="Fetch Data")
namefield = TextInput(value="", title="Name(s):")
bandfield = TextInput(value="", title="Band(s):")

# add a text renderer to out plot (no data yet)

with open('/root/astrocats/astrocats/supernovae/output/names.min.json') as f:
    names = json.loads(f.read())
names = list(names.keys())
unames = [x.upper() for x in names]

bands = plotting.bandcodes
ubands = [x.upper() for x in bands]

nds = []

def callback():
コード例 #45
0
                          value="10")
top_n_clusters_dropdown = Dropdown(label="Show Top 100 Clusters",
                                   button_type="warning",
                                   menu=n_clusters_menu,
                                   value="100")
tfidf_slider = Slider(start=0,
                      end=1,
                      value=0,
                      step=.05,
                      title="Informativeness")
cval_slider = Slider(start=0, end=1, value=0, step=.05, title="Completeness")
freq_slider = Slider(start=0, end=1, value=0, step=.05, title="Linguistical")
filter_topics_tab = Panel(child=filter_topics_table, title="Filter Topics")
filter_custom_tab = Panel(child=filter_custom_table, title="Custom Trends")
filter_tabs = Tabs(tabs=[filter_topics_tab, filter_custom_tab])
search_input_box = TextInput(title="Search:", value="", width=300)
search_button = Button(label="Go",
                       button_type="success",
                       width=50,
                       css_classes=['search_button'])
clear_button = Button(label="Clear",
                      button_type="success",
                      width=50,
                      css_classes=['clear_button'])
buttons_layout = column(Div(height=0), Row(search_button, clear_button))
analyse_button = Button(label="re-analyze", button_type="success")
filter_label = Div(text="",
                   style={
                       'color': 'red',
                       'padding-bottom': '0px',
                       'font-size': '15px'
コード例 #46
0
# Plot constraint function contour g(x,y)=0
contour_g = my_bokeh_utils.Contour(plot, line_color='red', line_width=2, legend='g(x,y) = 0')
# Plot corresponding tangent vector
quiver_isolevel = my_bokeh_utils.Quiver(plot, fix_at_middle=False, line_width=2, color='black')
# Plot corresponding tangent vector
quiver_constraint = my_bokeh_utils.Quiver(plot, fix_at_middle=False, line_width=2, color='red')
# Plot mark at position on constraint function
plot.cross(x='x', y='y', color='red', size=10, line_width=2, source=source_mark)

# object that detects, if a position in the plot is clicked on
interactor = my_bokeh_utils.Interactor(plot)
# adds callback function to interactor, if position in plot is clicked, call on_selection_change
interactor.on_click(on_selection_change)

# text input window for objective function f(x,y) to be optimized
f_input = TextInput(value=lagrange_settings.f_init, title="f(x,y):")
f_input.on_change('value', f_changed)

# dropdown menu for selecting one of the sample functions
sample_fun_input_f = Dropdown(label="choose a sample function f(x,y) or enter one below",
                              menu=lagrange_settings.sample_f_names)
sample_fun_input_f.on_click(sample_fun_input_f_changed)

# text input window for side condition g(x,y)=0
g_input = TextInput(value=lagrange_settings.g_init, title="g(x,y):")
g_input.on_change('value', g_changed)

# dropdown menu for selecting one of the sample functions
sample_fun_input_g = Dropdown(label="choose a sample function g(x,y) or enter one below",
                              menu=lagrange_settings.sample_g_names)
sample_fun_input_g.on_click(sample_fun_input_g_changed)
コード例 #47
0
ファイル: taylor_server.py プロジェクト: jbcrail/bokeh

def on_text_value_change(attr, old, new):
    try:
        global expr
        expr = sy.sympify(new, dict(x=xs))
    except (sy.SympifyError, TypeError, ValueError) as exception:
        dialog.content = str(exception)
        dialog.visible = True
    else:
        update_data()


dialog = Dialog(title="Invalid expression")

slider = Slider(start=1, end=20, value=order, step=1, title="Order", callback_policy="mouseup")
slider.on_change("value", on_slider_value_change)

text = TextInput(value=str(expr), title="Expression:")
text.on_change("value", on_text_value_change)

inputs = WidgetBox(children=[slider, text], width=400)
layout = Column(children=[inputs, plot, dialog])
update_data()
document.add_root(layout)
session.show(layout)

if __name__ == "__main__":
    print("\npress ctrl-C to exit")
    session.loop_until_closed()
コード例 #48
0
ファイル: routes.py プロジェクト: sggaffney/pathscore
def compare():
    # if proj among arguments, show this tree first.
    try:
        proj_a = int(request.args.get('proj_a', None))
        proj_b = int(request.args.get('proj_b', None))
    except (TypeError, ValueError):
        proj_a = proj_b = None
    include = request.args.get('include', None)

    # list of projects (and proj_names) used to create dropdown project selector
    upload_list = UserFile.query.filter_by(user_id=current_user.id).\
        filter_by(run_complete=True).order_by(UserFile.file_id).all()

    if len(upload_list) > 1:
        # Use specified project from args or highest file_id as CURRENT PROJECT
        current_proj = upload_list[-1]  # override if valid proj specified
        if proj_a and proj_b:
            current_temp_a = [u for u in upload_list if u.file_id == proj_a]
            current_temp_b = [u for u in upload_list if u.file_id == proj_b]
            # if not among user's finished projects, use highest file_id
            if len(current_temp_a) == 1 and len(current_temp_b) == 1:
                current_proj_a = current_temp_a[0]
                current_proj_b = current_temp_b[0]
            else:
                current_proj_a = upload_list[-2]
                current_proj_b = upload_list[-1]
        else:
            current_proj_a = upload_list[-2]
            current_proj_b = upload_list[-1]
        detail_path1 = naming_rules.get_detailed_path(current_proj_a)
        detail_path2 = naming_rules.get_detailed_path(current_proj_b)
        js_name1 = naming_rules.get_js_name(current_proj_a)
        js_name2 = naming_rules.get_js_name(current_proj_b)
        xlabel = u"Effect size ({})".format(current_proj_a.get_fancy_filename())
        ylabel = u"Effect size ({})".format(current_proj_b.get_fancy_filename())

        # load pathways with 1+ mutation in 1+ patients,
        # ignoring ones with 'cancer' etc in name
        all_paths1 = load_pathway_list_from_file(detail_path1)
        all_paths2 = load_pathway_list_from_file(detail_path2)

        # IDs with p<0.05 and +ve effect
        sig_p = OrderedDict(
            [(i.path_id, i.nice_name) for i in all_paths1 if i.gene_set])
        sig_pids1 = [i for i in sig_p]
        sig_p2 = OrderedDict(
            [(i.path_id, i.nice_name) for i in all_paths2 if i.gene_set])
        sig_pids2 = [i for i in sig_p2]
        sig_p.update(sig_p2)  # ORDERED by proj1 effect size

        # BUILD DATAFRAME WITH ALL sig PATHWAYS, proj1 object order.
        pway_names = sig_p.values()  # order important
        columns = ['path_id', 'pname', 'ind1', 'ind2', 'e1', 'e2', 'e1_only',
                   'e2_only', 'q1', 'q2']
        df = pd.DataFrame(index=sig_p.keys(), data={'pname': pway_names},
                          columns=columns)
        for path_group, evar, qvar, ind, sigs in \
                [(all_paths1, 'e1', 'q1', 'ind1', sig_pids1),
                 (all_paths2, 'e2', 'q2', 'ind2', sig_pids2)]:
            for path in path_group:
                path_id = path.path_id
                if path_id not in sig_p:
                    continue
                df.loc[path_id, evar] = get_effect(path)
                df.loc[path_id, qvar] = get_q(path)
                temp_ind = sigs.index(path_id) if path_id in sigs else -1
                df.loc[path_id, ind] = temp_ind
        df.ind1.fillna(-1, inplace=True)
        df.ind2.fillna(-1, inplace=True)
        df.e1_only = df.where(df.e2.isnull())['e1']
        df.e2_only = df.where(df.e1.isnull())['e2']

        inds1 = list(df.ind1)
        inds2 = list(df.ind2)

        source = ColumnDataSource(data=df)
        source_full = ColumnDataSource(data=df)
        source.name, source_full.name = 'data_visible', 'data_full'
        # SET UP FIGURE
        minx = df.e1.min()
        minx *= 1 - minx / abs(minx) * 0.2
        miny = df.e2.min()
        miny *= 1 - miny/abs(miny) * 0.2
        maxx = df.e1.max() * 1.2
        maxy = df.e2.max() * 1.2
        TOOLS = "lasso_select,box_select,hover,crosshair,pan,wheel_zoom,"\
                "box_zoom,reset,tap,help" # poly_select,lasso_select, previewsave

        # SUPLOTS
        p = figure(plot_width=DIM_COMP_W, plot_height=DIM_COMP_H, tools=TOOLS,
                   title=None, logo=None, toolbar_location="above",
                   x_range=Range1d(minx, maxx), y_range=Range1d(miny, maxy),
                   x_axis_type="log", y_axis_type="log"
                   )
        pb = figure(plot_width=DIM_COMP_SM, plot_height=DIM_COMP_H, tools=TOOLS,
                    y_range=p.y_range, x_axis_type="log", y_axis_type="log")
        pa = figure(plot_width=DIM_COMP_W, plot_height=DIM_COMP_SM, tools=TOOLS,
                    x_range=p.x_range, x_axis_type="log", y_axis_type="log")
        pp = figure(plot_width=DIM_COMP_SM, plot_height=DIM_COMP_SM,
                    tools=TOOLS, outline_line_color=None)

        # SPANS
        p.add_layout(plot_fns.get_span(1, 'height'))
        p.add_layout(plot_fns.get_span(1, 'width'))
        pa.add_layout(plot_fns.get_span(1, 'height'))
        pb.add_layout(plot_fns.get_span(1, 'width'))

        # STYLE
        for ax in [p, pa, pb]:
            ax.grid.visible = False
            ax.outline_line_width = 2
            ax.background_fill_color = 'whitesmoke'
        for ax in [pa, pb]:
            ax.xaxis.visible = False
            ax.yaxis.visible = False

        pa.title.text = xlabel
        pb.title.text = ylabel
        pa.title_location, pa.title.align = 'below', 'center'
        pb.title_location, pb.title.align = 'left', 'center'

        # WIDGETS
        q_input = TextInput(value='', title="P* cutoff",
                            placeholder='e.g. 0.05')
        gene_input = TextInput(value='', title="Gene list",
                               placeholder='e.g. TP53,BRAF')
        radio_include = RadioGroup(labels=["Include", "Exclude"], active=0)
        widgets = widgetbox(q_input, gene_input, radio_include, width=200,
                            css_classes=['widgets_sg'])

        grid = gridplot([[pb, p, widgets],
                         [Spacer(width=DIM_COMP_SM), pa, Spacer()]],
                        sizing_mode='fixed')

        cb_inclusion = CustomJS(args=dict(genes=gene_input), code="""
            var gene_str = genes.value
            if (!gene_str)
                return;
            var include = cb_obj.active == 0 ? true : false
            selectPathwaysByGenes(gene_str, include);
            """)
        cb_genes = CustomJS(args=dict(radio=radio_include), code="""
            var gene_str = cb_obj.value
            if (!gene_str)
                return;
            var include = radio.active == 0 ? true : false
            selectPathwaysByGenes(gene_str, include);
            """)
        radio_include.js_on_change('active', cb_inclusion)
        gene_input.js_on_change('value', cb_genes)

        # SCATTER
        p.circle("e1", "e2", source=source, **SCATTER_KW)
        pa.circle('e1_only', 1, source=source, **SCATTER_KW)
        pb.circle(1, 'e2_only', source=source, **SCATTER_KW)

        # HOVER
        for hover in grid.select(dict(type=HoverTool)):
            hover.tooltips = OrderedDict([
                ("name", "@pname"),
                ("effects", "(@e1, @e2)"),
                ("P*", ("(@q1, @q2)"))
            ])

        # ADD Q FILTERING CALLBACK
        callback = CustomJS(args=dict(source=source, full=source_full), code="""
            // get old selection indices, if any
            var prv_selected = source.selected['1d'].indices;
            var prv_select_full = []
            for(var i=0; i<prv_selected.length; i++){
                prv_select_full.push(scatter_array[prv_selected[i]])
            }
            var new_selected = []
            var q_val = cb_obj.value;
            if(q_val == '')
                q_val = 1
            var fullset = full.data;
            var n_total = fullset['e1'].length;
            // Convert float64arrays to array
            var col_names = %s ;
            col_names.forEach(function(col_name){
                source.data[col_name] = [].slice.call(source.data[col_name])
                source.data[col_name].length = 0
            })
            scatter_array.length = 0;
            var j = -1;  // new glyph indices
            for (i = 0; i < n_total; i++) {
                this_q1 = fullset['q1'][i];
                this_q2 = fullset['q2'][i];
                if(this_q1 <= q_val || this_q2 <= q_val){
                    j++; // preserve previous selection if still visible
                    col_names.forEach(function(col){
                        source.data[col].push(fullset[col][i]);
                    })
                    scatter_array.push(i)
                    if($.inArray(i, prv_select_full) > -1){
                        new_selected.push(j);
                    }
                }
            }
            source.selected['1d'].indices = new_selected;
            source.trigger('change');
            updateIfSelectionChange_afterWait();
            """ % columns)

        q_input.js_on_change('value', callback)
        script, div = plot_fns.get_bokeh_components(grid)

        proj_dir_a = naming_rules.get_project_folder(current_proj_a)
        proj_dir_b = naming_rules.get_project_folder(current_proj_b)
        if os.path.exists(os.path.join(proj_dir_a, 'matrix_svg_cnv')) and \
                os.path.exists(os.path.join(proj_dir_b, 'matrix_svg_cnv')):
            has_cnv = True
        else:
            has_cnv = False

    else:  # not enough projects yet!
        flash("Two completed projects are required for a comparison.",
              "warning")
        return redirect(url_for('.index'))

    return render_template('pway/compare.html',
                           current_projs=[current_proj_a, current_proj_b],
                           inds_use=[inds1, inds2],
                           has_cnv=has_cnv,
                           js_name_a=js_name1,
                           js_name_b=js_name2,
                           projects=upload_list,
                           bokeh_script=script,
                           bokeh_div=div, include_genes=include,
                           resources=plot_fns.resources)
コード例 #49
0
ファイル: vis.py プロジェクト: lisa-1010/mighty-bitcoin
x = np.arange(0, max_days_to_compute, 1) # times
y = get_util_vs_time_data(days=x)
source = ColumnDataSource(data=dict(x=x, y=y))


# Set up plot
plot = figure(plot_height=plot_height, plot_width=plot_width, title=plot_title,
              tools="crosshair,pan,reset,save,wheel_zoom",
              x_range=[0, max_days_to_display],
              x_axis_label="Days Since Attack",
              y_axis_label="Relative Profit of Attacking (Millions of USD)")

plot.line('x', 'y', source=source, line_width=3, line_alpha=0.6)

# Set up widgets
text = TextInput(title="Title", value='mighty bitcoin')
mining_power = Slider(title="Mining Power", start=min_mining_power, end=max_mining_power, value=default_mining_power, step=mining_power_step)
discount_rate = Slider(title="Discount Rate", start=min_discount, end=max_discount, value=default_discount, step=discount_step)
btc_stolen = Slider(title="Amount of BTC Stolen", start=min_btc_stolen, end=max_btc_stolen, value=default_btc_stolen, step=btc_stolen_step)
btc_owned_0 = Slider(title="BTC Owned At Time 0", start=min_btc_owned_0, end=max_btc_owned_0, value=default_btc_owned_0, step=btc_owned_0_step)
exchange_rate = Slider(title="BTC-USD Exchange Rate", start=min_rate, end=max_rate, value=default_rate, step=rate_step)

btc_f_stolen = Slider(title="Fraction Amount of BTC Stolen", start=min_btc_f_stolen, end=max_btc_f_stolen, value=default_btc_f_stolen, step=btc_f_stolen_step)
btc_f_owned_0 = Slider(title="Fraction BTC Owned At Time 0", start=min_btc_f_owned_0, end=max_btc_f_owned_0, value=default_btc_f_owned_0, step=btc_f_owned_0_step)

hline = Span(location=0, dimension='width', line_color='green', line_width=1.5)
plot.renderers.extend([hline])


# Set up callbacks
def update_title(attrname, old, new):
コード例 #50
0
ファイル: explore.py プロジェクト: rchvist/dashboard
def explore_tab(df):
    def get_dataset(src, name, words, start, end):
        df = src[src.user == name].copy()
        mask = (df['timestamp'] > start) & (df['timestamp'] <= end)
        df = df[mask]
        words = [str(i) for i in words.split()]
        safe_words = []
        for word in words:
            word = re.escape(word)
            word = "(?=.*{})".format(word)
            safe_words.append(word)

        df = df[df['texts'].str.contains(''.join(safe_words))]

        source = ColumnDataSource(data=dict())

        cols = ['texts', 'displaySource', 'source']
        df[cols] = df[cols].replace({',': '', ',,': '', ';': ''}, regex=True)

        source.data = {
            # 'index': df.index,
            'impressionTime': df.impressionTime,
            'impressionOrder': df.impressionOrder,
            'source': df.source,
            'fblinktype': df.fblinktype,
            'texts': df.texts,
            'textsize': df.textsize,
            'publicationTime': df.publicationTime,
            'permaLink': df.permaLink,
            'nature': df.nature,
            'ANGRY': df.ANGRY,
            'HAHA': df.HAHA,
            'LIKE': df.LIKE,
            'LOVE': df.LOVE,
            'SAD': df.SAD,
            'WOW': df.WOW,
            'displaySource': df.displaySource,
            'id': df.id,
            'timestamp': df.timestamp,
            # 'images': df.images,
            # 'opengraph': df.opengraph,
            'postId': df.postId,
            # 'semanticCount': df.semanticCount,
            # 'semanticId': df.semanticId,
            'sourceLink': df.sourceLink,
            'timeline': df.timeline,
            'user': df.user,
            # 'videoautoplay': df.videoautoplay
        }
        return source

    def make_table(source):
        # Columns of tablem
        table_columns = [
            TableColumn(field='impressionTime', title='Time'),
            TableColumn(field='impressionOrder', title='Order'),
            TableColumn(field='source', title='Source'),
            TableColumn(field='fblinktype', title='Type'),
            TableColumn(field='texts', title='Text'),
            TableColumn(field='textsize', title='Text Size'),
            TableColumn(field='publicationTime', title='Publication Time'),
            TableColumn(field='permaLink', title='Link'),
            TableColumn(field='nature', title='Nature'),
            TableColumn(field='ANGRY', title='Angry'),
            TableColumn(field='HAHA', title='Haha'),
            TableColumn(field='LIKE', title='Like'),
            TableColumn(field='LOVE', title='Love'),
            TableColumn(field='SAD', title='Sad'),
            TableColumn(field='WOW', title='Wow')
        ]
        user_table = DataTable(source=source,
                               columns=table_columns,
                               width=1400)
        return user_table

    def update(attrname, old, new):
        name = name_select.value
        text_filter = text_input.value
        start = date_slider.value[0]
        end = date_slider.value[1]
        src = get_dataset(df, name, text_filter, start, end)
        source.data.update(src.data)

    name = df.user.iloc[0]
    words = ''
    names = df.user.unique()
    start = df.timestamp.min()
    end = df.timestamp.max()

    name_select = Select(value=name, title='User', options=sorted(names))
    text_input = TextInput(value="", title="Filter text:")
    date_slider = DateRangeSlider(title="Date Range: ",
                                  start=df.timestamp.min(),
                                  end=date.today(),
                                  value=(df.timestamp.min(), date.today()),
                                  step=1,
                                  callback_policy='mouseup')

    button = Button(label="Download", button_type="success")

    source = get_dataset(df, name, words, start, end)

    table = make_table(source)

    name_select.on_change('value', update)
    text_input.on_change('value', update)
    date_slider.on_change('value', update)

    button.js_on_click(
        CustomJS(args=dict(source=source),
                 code=open(join(dirname(__file__), "download.js")).read()))

    controls = column(name_select, date_slider, text_input, button)
    tab = Panel(child=row(table, controls), title='Explore')
    return tab
コード例 #51
0
	def plotting(self):

		if self.debug:
			self.debug_file = open("debug_output.txt", "w")
			self.debug_file.write("Initialized plotting subroutine \n")
			 

		TOOLS="pan,wheel_zoom,box_zoom,reset,hover,previewsave"

		tab_plots = []
		self.all_elements = []
		self.elements_comparison = []

		for filename in self.filenames:
			if "ITO" in filename:
				tab_plots.append(self.mass_plotting(filename))
				continue
	
			data_dict = self.data_generation(filename)
			self.data_test(data_dict)

			name_check = data_dict["gen_info"]["DATA FILES"]
			attr_id = name_check[1][4][:-3] + "_" + name_check[2][2]
			self.attribute_ids.append(attr_id)

			attr_extra_y_ranges = False
			attr_extra_x_ranges = False

			local_source_line = []

			"""
			create plots for each datafile and put them in a tab.
			"""

			y_axis_units = [x["y_unit"] for x in data_dict["data"]]
			x_axis_units = [x["x_unit"] for x in data_dict["data"]]

			figure_obj = figure(plot_width = 1000, plot_height = 800, y_axis_type = "log",
			title = attr_id, tools = TOOLS)
			#figure_obj.axes.major_label_text_font_size("12pt")
			#figure_obj.major_label_text_font_size("12pt")

			hover = figure_obj.select(dict(type = HoverTool))
			hover.tooltips = [
							("Element:", "@element"),
							("(x, y):", "($x, $y)")]

			self.figure_data.append((figure_obj, data_dict))
		
			figure_obj.yaxis.axis_label = y_axis_units[0]
			figure_obj.xaxis.axis_label = x_axis_units[0]

			if not all(x == y_axis_units[0] for x in y_axis_units):
				for unit, dataset in zip(y_axis_units, data_dict["data"]): 
					if not unit == y_axis_units[0]:
						
						extra_y_ranges_exists = attr_extra_y_ranges
						extra_y_ranges_exists = True

						if self.debug:
							  
							self.debug_file.write("Added extra y-axis for file_id: %s, element: %s | New length %g \n" 
								%(attr_id, dataset["sample_element"], len(figure_obj.yaxis)))
							 

						figure_obj.extra_y_ranges =  {"foo": Range1d(start = np.amin(dataset["y"]),
						end = np.amax(dataset["y"]))}
						figure_obj.add_layout(LogAxis(y_range_name = "foo", axis_label = unit), "right")
						break

			if not all(x == x_axis_units[0] for x in x_axis_units):
				for unit, dataset in zip(x_axis_units, data_dict["data"]): 
					if not unit == x_axis_units[0]:
						
						extra_x_ranges_exists = attr_extra_x_ranges
						extra_x_ranges_exists = True
						
						if self.debug:
							  
							self.debug_file.write("Added extra x-axis for file_id: %s, element: %s. | New length %g \n" 
								%(attr_id, dataset["sample_element"], len(figure_obj.yaxis)))
							 
			
						figure_obj.extra_x_ranges =  {"bar": Range1d(start = np.amin(dataset["x"]),
						end = np.amax(dataset["x"]))}
						figure_obj.add_layout(LinearAxis(x_range_name = "bar", axis_label = unit), "above")
						break

			figure_obj.xaxis.axis_label = x_axis_units[0]
			colour_list = Spectral11 + RdPu9 + Oranges9
			colour_indices = [0, 2, 8, 10, 12, 14, 20, 22, 1, 3, 9, 11, 13, 15]


			list_of_elements = []
			source_list = []
			line_list = []

			for dataset, color_index in zip(data_dict["data"], colour_indices):

				self.all_elements.append(dataset["sample_element"]) #strip isotope number 
				color = colour_list[color_index]

				source = ColumnDataSource(data = dataset) #Datastructure for source of plotting

				self.source_test(source)

				list_of_elements.append(dataset["sample_element"])
				line_glyph = figure_obj.line("x", "y", source = source, 
							line_width = 2,
							line_color = color, 
							legend = dataset["sample_element"])

				if self.debug:
					self.debug_file.write("Create line object on figure %s  at %s \n" %(id(figure_obj), id(line_glyph)))
					 

				line_list.append(line_glyph)
				source_list.append(source)

			local_source_line.append([[source, line] for source, line in zip(source_list, line_list)])
			self.source_line.append(local_source_line)

			#Calculations on the dataset
			text_input_rsf = TextInput(value = "default", title = "RSF or SF (at/cm^3): ")
			do_integral_button = Button(label = "Calibration integral")
			smoothing_button = Button(label = "smth selct elem")
			matplot_button = Button(label = "Create matplotlib fig")

			text_input_sputter = TextInput(value = "default", title = "Sputter speed: number unit")
			text_input_crater_depth = TextInput(value = "default", title = "Depth of crater in: number unit")
			


			radio_group = RadioGroup(labels = list_of_elements, active=0)


			text_input_xval_integral = TextInput(value = "0", title = "x-delimiter ")
			text_input_dose = TextInput(value = "0", title = "Dose[cm^-2] ")

			#Save files for later use
			save_flexDPE_button = Button(label = "Save element for FlexPDE")
			save_all_flexDPE_button = Button(label = "Save all elements for FlexPDE")
			save_textfile_button = Button(label = "Sava Data in textfile")

			#Pointers to methods on click / change handlers
			radio_group.on_change("active", lambda attr, old, new: None)

			matplot_button.on_click(lambda source_list = source_list:
										self.matplotlib_export(source_list))
			
			do_integral_button.on_click(lambda 
											source_list = source_list, 
											line_list = line_list, 
											source_line = self.source_line,
											figure_data = self.figure_data,
											data_dict = data_dict,
											radio = radio_group,
											x_box = text_input_xval_integral, 
											dose = text_input_dose,
											extra_y_ranges = attr_extra_y_ranges: 
										self.integrate(data_dict, source_list, line_list, source_line, figure_data, radio, x_box, dose, extra_y_ranges))

			smoothing_button.on_click(lambda 
										source_list = source_list,
										radio = radio_group, 
										data_dict = data_dict,
										x_box = text_input_xval_integral: 
									self.smoothing(source_list, data_dict, radio, x_box) )

			save_flexDPE_button.on_click(lambda 
											source_list = source_list,
											attrname = attr_id,
											radio = radio_group: 
										self.write_to_flexPDE(source_list, attrname, radio))

			save_all_flexDPE_button.on_click(lambda 
												source_list = source_list, 
												attrname = attr_id:
												self.write_all_to_flexPDE(source_list, attrname))

			save_textfile_button.on_click(lambda 
											data_dict = data_dict, 
											source_list = source_list,
											attrname = attr_id,
											radio = radio_group:
											self.write_new_datafile(data_dict, source_list, attrname,radio))


			text_input_rsf.on_change("value", lambda attr, old, new, 
												radio = radio_group, 
												data_dict = data_dict,
												figure = figure_obj,
												source_list = source_list,
												text_input = text_input_rsf,
												line_list = line_list,
												which = "rsf":
												self.update_data(line_list, data_dict, source_list, figure, radio, text_input, new, which))


			text_input_sputter.on_change("value", lambda attr, old, new, 
													radio = radio_group, 
													data_dict = data_dict,
													figure = figure_obj,
													source_list = source_list, 
													text_input = text_input_sputter,
													which = "sputter":
													self.update_data(data_dict, source_list, figure, radio, text_input, new, which))

			text_input_crater_depth.on_change("value", lambda attr, old, new, 
														radio = radio_group, 
														data_dict = data_dict,
														source_list = source_list,
														figure = figure_obj,
														text_input = text_input_crater_depth, 
														which = "crater_depth":
														self.update_data(data_dict, source_list, figure, radio, text_input, new, which))


			#Initialization of actual plotting. 
			tab_plots.append(Panel(child = hplot(figure_obj, 
										   vform(
										   vform(radio_group, save_flexDPE_button, save_all_flexDPE_button, save_textfile_button, matplot_button), 
										   vform(text_input_rsf, smoothing_button, text_input_sputter, text_input_crater_depth)
										   ),
										   vform(text_input_xval_integral, text_input_dose, do_integral_button)),
										   title = attr_id))



		"""
		Check to see if one or more element exists in the samples and creat a comparison plot for each 
		of those elements.
		"""
		
		for element in self.all_elements:
			checkers = list(self.all_elements)
			checkers.remove(element)
			if element in checkers and not element in self.elements_comparison:
				self.elements_comparison.append(element)

		"""create plots for each element that is to be compared """
	
		for comparison_element in self.elements_comparison: 

			figure_obj = figure(plot_width = 1000, plot_height = 800, y_axis_type = "log", title = comparison_element, tools = TOOLS)
			#figure_obj.xaxis.major_label_text_font_size("12pt")
			#figure_obj.yaxis.major_label_text_font_size("12pt")
			
			y_axis_units = []
			x_axis_units = []

			comparison_datasets = []

			for data_dict_iter in self.column(self.figure_data, 1):

				for dataset in data_dict_iter["data"]:

					if dataset["sample_element"] == comparison_element:
						comparison_datasets.append(dataset)
						y_axis_units.append(dataset["y_unit"])
						x_axis_units.append(dataset["x_unit"])

			figure_obj.xaxis.axis_label = comparison_datasets[-1]["x_unit"]
			figure_obj.yaxis.axis_label = comparison_datasets[-1]["y_unit"]

			if not all(x == y_axis_units[-1] for x in y_axis_units):
				for unit, data in zip(y_axis_units, comparison_datasets): 
					if not unit == y_axis_units[-1]:
						figure_obj.extra_y_ranges =  {"foo": Range1d(start = np.amin(data["y"]),
						end = np.amax(data["y"]))}
						figure_obj.add_layout(LogAxis(y_range_name = "foo", axis_label = unit), "right")
						break

			if not all(x == x_axis_units[-1] for x in x_axis_units):
				for unit, data in zip(x_axis_units, comparison_datasets): 
					if not unit == x_axis_units[-1]:
						figure_obj.extra_x_ranges =  {"bar": Range1d(start = np.amin(data["x"]),
						end = np.amax(data["x"]))}
						figure_obj.add_layout(LinearAxis(x_range_name = "bar", axis_label = unit), "above")
						break

			active_sources = []
			for data_dict, source_line_nested, attr_id, color_index  in zip(self.column(self.figure_data, 1), self.source_line,  self.attribute_ids,  colour_indices):

				for dataset, source_lis_coup, in zip(data_dict["data"], source_line_nested[0]):
					
					source_local = source_lis_coup[0]
					active_sources.append(source_local)

					self.source_test(source_local)
					self.source_dataset_test(source_local, dataset)

					if dataset["sample_element"] == comparison_element:
						color = colour_list[color_index]

						"""
						Logic that ensures that plots get put with correspoinding axes. 
						"""
						if dataset["x_unit"] != x_axis_units[-1] or dataset["y_unit"] != y_axis_units[-1]:

							if dataset["x_unit"] != x_axis_units[-1] and dataset["y_unit"] != y_axis_units[-1]:
								name_check = data_dict["gen_info"]["DATA FILES"]
								attr_id = name_check[1][4][:-3] + "_" + name_check[2][2]

								figure_obj.line("x", "y", source = source_local,
								line_width = 2, 
								line_color = color, 
								legend = attr_id,
								x_range_name = "bar", 
								y_range_name = "foo")

							elif dataset["x_unit"] != x_axis_units[-1]:

								figure_obj.line("x", "y", source = source_local,
								line_width = 2, 
								line_color = color, 
								legend = attr_id, 
								x_range_name = "bar")

							else: 

								figure_obj.line("x", "y", source = source_local,
								line_width = 2, 
								line_color = color, 
								legend = attr_id, 
								y_range_name = "foo")

						else: 
							figure_obj.line("x", "y", source = source_local,
							line_width = 2, 
							line_color = color, 
							legend = attr_id)


			matplot_button = Button(label = "Create matplotlib fig")
			save_all_flexDPE_button = Button(label = "Save all elements for FlexPDE")

			matplot_button.on_click(lambda source_list = active_sources:
							self.matplotlib_export(source_list))	

			save_all_flexDPE_button.on_click(lambda 
									source_list = active_sources, 
									attrname = comparison_element:
									self.write_all_to_flexPDE(source_list, attrname))


			tab_plots.append(Panel(child = hplot(figure_obj, vform(save_all_flexDPE_button, matplot_button)), 
				title = comparison_element))	


		tabs = Tabs(tabs = tab_plots)
		#curdoc().add_root(tabs)
		session = push_session(curdoc())
		session.show()
		session.loop_until_closed()
コード例 #52
0
acq_period_select = Select(title="Acquisition Period (s):", value="100",
                        options=[".5","1","10","100","300","1000"])
num_avgs_select = Select(title="Number of Points to Average:", value="100", 
                        options=["100","1000","10000","100000","1000000"])
channel_name_select1 = Select(title='Channel Select:', value="Channel 1",
                        options =["Channel 1", "Channel 2", "Channel 3", "Channel 4"])
channel_name_select2 = Select(title='Channel Names:', value="Channel 1",
                        options =["Channel 1", "Channel 2", "Channel 3", "Channel 4"])
number_points_select = Select(title="Number of Points", value="100",
                        options =["100", "200", "500", "1000", "5000", "10000", "100000", "1000000"])
load_plot_type_select = Select(title="Plot Type:", value="Multi-plot",
            options =["Multi-plot", "Pulse Capture Plot"])


# Text inputs
channel_name_input = TextInput(title="Name:")
trigger_level_input = TextInput(value="1", title="Trigger Level (V)")
time_range_input = TextInput(value="1000", title="Time Range (us)")
load_file_input = TextInput(value=home_dir, title="Load file:")
save_filepath_input = TextInput(value=home_dir, title="Save to directory:")
force_save_filename_input = TextInput(value=str(dt.now(PT).year)+"_"+str(dt.now(PT).month)+"_"+str(dt.now(PT).day)+".h5", 
                                title="Save as filename:")
save_filepath_PC_input = TextInput(value=home_dir, title="Save to directory:")
save_filename_PC_input = TextInput(value="PC_"+str(dt.now(PT).year)+"_"+str(dt.now(PT).month)+"_"+str(dt.now(PT).day)+".h5",
                                title="Save as filename:")


#setup event handlers
all_off_button.on_click(lambda x: allOff_ButtonClick())
all_on_button.on_click(lambda x: allOn_ButtonClick())
reset_button.on_click(lambda x: reset_ButtonClick())
コード例 #53
0
ファイル: main.py プロジェクト: Punchwes/linkedin-for-SCU
height_map={
    "Current Location":y_local_height,
    "Current Industry":y_indus_height,
    "Current Company":y_company_height
}

new_axis_map={
    "Current Location":'location',
    "Current Industry":'industry',
    "Current Company":'company'
}

source = ColumnDataSource(data=dict(x=[],y=[],height=[]))


cities=TextInput(title='location name')
companies=TextInput(title='company name')
industries=TextInput(title='industry name')
x_axis=Select(title='X axis',options=sorted(axis_map.keys()),value='Current Industry')

plot = figure(plot_height=600, plot_width=800, title="", toolbar_location=None, tools=[hover],x_range=industry[:10],y_range=[0,2000])
plot.rect(x='x',y='y',width=.8,height='height',source=source)
plot.xaxis.major_label_orientation = np.pi/3

controls=[x_axis,cities,companies,industries]
inputs=HBox(VBoxForm(*controls))


def select_types():
    city_val=cities.value.strip()
    company_val=companies.value.strip()
コード例 #54
0
from bokeh.io import curdoc
from bokeh.layouts import column
from bokeh.models.widgets import TextInput, Button, Paragraph

# create some widgets
button = Button(label="Say HI")
input = TextInput(value="Bokeh")
output = Paragraph()


# add a callback to a widget
def update():
    output.text = "Hello, " + input.value


button.on_click(update)

# create a layout for everything
layout = column(button, input, output)

# add the layout to curdoc
curdoc().add_root(layout)
コード例 #55
0
    # create a grid of samples
    xx, hx = np.linspace(source_view.data['x_start'][0], source_view.data['x_end'][0], curveintegral_settings.n_sample,
                         retstep=True)
    yy, hy = np.linspace(source_view.data['y_start'][0], source_view.data['y_end'][0], curveintegral_settings.n_sample,
                         retstep=True)
    x_val, y_val = np.meshgrid(xx, yy)
    # evaluate function at sample points
    u_val = u_fun(x_val, y_val)
    v_val = v_fun(x_val, y_val)

    return x_val, y_val, u_val, v_val, hx


# initialize controls
# text input for input of the vector function [fx(x,y),fy(x,y)]
u_input = TextInput(value=curveintegral_settings.sample_functions[curveintegral_settings.init_fun_key][0],
                    title="fx(x,y):")
v_input = TextInput(value=curveintegral_settings.sample_functions[curveintegral_settings.init_fun_key][1],
                    title="fy(x,y):")

u_input.on_change('value', function_change)
v_input.on_change('value', function_change)

# text input for input of the parametrized curve [cx(t),cy(t)]
cx_input = TextInput(value=curveintegral_settings.sample_curves[curveintegral_settings.init_curve_key][0],
                     title="cx(t):")
cy_input = TextInput(value=curveintegral_settings.sample_curves[curveintegral_settings.init_curve_key][1],
                     title="cy(t):")
# slider controlling the parameter t
parameter_input = Slider(title="t",
                         value=curveintegral_settings.parameter_input_init,
                         start=curveintegral_settings.parameter_min,
コード例 #56
0
x = np.linspace(0, 4 * np.pi, N)
y = np.sin(x)
source = ColumnDataSource(data=dict(x=x, y=y))

# Set up plot
plot = figure(plot_height=800,
              plot_width=800,
              title="my sine wave",
              tools="crosshair,pan,reset,save,wheel_zoom",
              x_range=[0, 4 * np.pi],
              y_range=[-2.5, 2.5])

plot.line('x', 'y', source=source, line_width=3, line_alpha=0.6)

# Set up widgets
text = TextInput(title="title", value='my sine wave')
offset = Slider(title="offset", value=0.0, start=-5.0, end=5.0, step=0.1)
amplitude = Slider(title="amplitude", value=1.0, start=-5.0, end=5.0, step=0.1)
phase = Slider(title="phase", value=0.0, start=0.0, end=2 * np.pi)
freq = Slider(title="frequency", value=1.0, start=0.1, end=5.1, step=0.1)


# Set up callbacks
def update_title(attrname, old, new):
    plot.title.text = text.value


text.on_change('value', update_title)


def update_data(attrname, old, new):
コード例 #57
0
ファイル: sliders.py プロジェクト: Chetver/bokeh
N = 200
x = np.linspace(0, 4*np.pi, N)
y = np.sin(x)
source = ColumnDataSource(data=dict(x=x, y=y))


# Set up plot
plot = Figure(plot_height=400, plot_width=400, title="my sine wave",
              tools="crosshair,pan,reset,resize,save,wheel_zoom",
              x_range=[0, 4*np.pi], y_range=[-2.5, 2.5])

plot.line('x', 'y', source=source, line_width=3, line_alpha=0.6)


# Set up widgets
text = TextInput(title="title", value='my sine wave')
offset = Slider(title="offset", value=0.0, start=-5.0, end=5.0, step=0.1)
amplitude = Slider(title="amplitude", value=1.0, start=-5.0, end=5.0)
phase = Slider(title="phase", value=0.0, start=0.0, end=2*np.pi)
freq = Slider(title="frequency", value=1.0, start=0.1, end=5.1)


# Set up callbacks
def update_title(attrname, old, new):
    plot.title.text = text.value

text.on_change('value', update_title)

def update_data(attrname, old, new):

    # Get the current slider values
コード例 #58
0
ファイル: main.py プロジェクト: alxsoares/zjsxzy_in_js
                         width=200,
                         options=bond_type_selections)
scale_select = Select(value=scale_selections[0],
                      title=u'基金资产净值',
                      width=200,
                      options=scale_selections)
time_select = Select(value=u'1年',
                     title=u'业绩时间窗口',
                     width=200,
                     options=time_selections)
time_select.on_change('value', lambda attr, old, new: update_data())
fund_button = Button(label=u"筛选基金", button_type="success", width=200)
fund_button.on_click(select_fund)
update_button = Button(label=u'更新数据', button_type='success', width=200)
update_button.on_click(update_new_data)
fund_text = TextInput(value='000088.OF', title=u'基金Wind代码', width=200)
fund_text.on_change('value', lambda attr, old, new: update_data())

columns = [
    TableColumn(field='sec_name', title=u'基金简称'),
    TableColumn(field='wind_code', title=u'万得代码'),
    TableColumn(field='fundmanager', title=u'基金经理'),
    TableColumn(field='netasset',
                title=u'基金资产净值',
                formatter=NumberFormatter(format='$0,0.00')),
    TableColumn(field='current return',
                title=u'当前业绩',
                formatter=NumberFormatter(format='0.00%')),
    TableColumn(field='volatility',
                title=u'波动率',
                formatter=NumberFormatter(format='0.00%')),
コード例 #59
0
from bokeh.models.widgets import Button, TextInput

label_saccade_button = Button(label='saccade')
label_saccade_button.on_click(label_saccade_cb)

label_pursuit_button = Button(label='pursuit')
label_pursuit_button.on_click(label_pursuit_cb)

label_fixation_button = Button(label='fixation')
label_fixation_button.on_click(label_fixation_cb)

remove_button = Button(label='remove')
remove_button.on_click(remove_cb)

trial_text = TextInput(value=str(trialNum))
trial_text.on_change('value', trial_text_cb)

nextTrial_button = Button(label='+trial')
nextTrial_button .on_click(next_trial_cb)

prevTrial_button= Button(label='-trial')
prevTrial_button.on_click(prev_trial_cb)

from bokeh.layouts import row
buttonBox = row(label_saccade_button, label_pursuit_button, label_fixation_button, remove_button)
trialSelectBox = row(prevTrial_button, trial_text, nextTrial_button)
#, sizing_mode='scale_width'

###########################################################################
# Get the HTML description header
コード例 #60
0
    update_volume_table()
    update_eyby()
    update_industry_corr()
    # update_min_liquidity()
    # update_wei_index_table()
    # update_wei_index()
    update_record_high_table()


asset_select = Select(value=u"万得全A指数",
                      title="资产",
                      width=300,
                      options=asset_selections)
asset_select.on_change('value', lambda attr, old, new: update_data())
time_text = TextInput(value="2005-01-01",
                      title="开始时间(例如:20050101或2005-01-01)",
                      width=300)
time_text.on_change('value', lambda attr, old, new: update_all())
today = (datetime.datetime.today() - datetime.timedelta(1))
time_end_text = TextInput(value=today.strftime("%Y-%m-%d"),
                          title="终止时间",
                          width=300)
time_end_text.on_change('value', lambda attr, old, new: update_all())
asset_text_1 = TextInput(value="881001.WI", title=u"资产一(万得代码)", width=300)
asset_text_2 = TextInput(value="HSI.HI", title=u"资产二(万得代码)", width=300)
department_select = Select(value=u"万得全A",
                           title=u"选择板块",
                           width=300,
                           options=index_selections)
department_select.on_change('value', lambda attr, old, new: update_cost())
industry_select = Select(value=u"石油石化",