def set_callbacks(self, app): @app.callback(self.plugin_data_output, [self.plugin_data_requested]) def user_download_data(data_requested): if data_requested: return WebvizPluginABC.plugin_data_compress( [ { "filename": Path(self.csv_file).name, "content": get_data(self.csv_file).to_csv(), } ] ) return "" inputs = [Input(self.key_dropdown_id, "value")] data = get_data(self.csv_file) if "date" in data.columns: inputs.append(Input(self.date_dropdown_id, "value")) @app.callback( Output(self.graph_id, "figure"), inputs, ) def update_graph(key_list, *args): if key_list is None: return {} data = get_data(self.csv_file) traces = [] if "date" in data.columns: for key in key_list: for date in args[0]: selected_data = data[data["date"] == date].drop( columns=["date"] ) traces.append( go.Bar( y=selected_data[key], x=selected_data["realization"], name=f"{key}:{date}", showlegend=True, ), ) else: for key in key_list: traces.append( go.Bar( y=data[key], x=data["realization"], name=key, showlegend=True, ), ) return { "data": traces, "layout": dict( xaxis={"title": "Realization"}, yaxis={"title": "Value"}, ), }
def update_graph( xaxis_name, yaxis_name, realization_nr, xaxis_type, yaxis_type, interpolation_type, xaxis_opt, yaxis_opt, ): if None in [xaxis_name, yaxis_name]: return {} if isinstance(realization_nr, int): realization_nr = [realization_nr] df = get_data(self.data_path) traces = [] for realization in realization_nr: x_data = df.filter(like=xaxis_name).loc[realization] y_data = df.filter(like=yaxis_name).loc[realization] mode = "markers" if not interpolation_type else "markers+lines" traces.append( get_graph_line( x_data, y_data, xaxis_opt, yaxis_opt, mode=mode, line_shape=interpolation_type, name="Realization: {}".format(realization_nr), )) return crossplot_update_graph(traces, xaxis_name, yaxis_name, xaxis_type, yaxis_type)
def update_graph(control_list): # # The key_list arguments is the list of functions to plot. if control_list is None: return {} # # Get the data, setting its index. data = get_data(self.csv_file).set_index("control") traces = [] for control in control_list: control_data = data.xs(control) traces.append( go.Scatter( y=control_data["value"], x=control_data["batch"], mode="lines", name=control, showlegend=True, ), ) return { "data": traces, "layout": dict( xaxis={"title": "Batch"}, yaxis={"title": "Control Value"}, ), }
def layout(self): data = get_data(self.csv_file) fig = px.scatter( data, y="value", x="control", color="batch", template="plotly_white", labels={ "control": "Control", "value": "Control Value" }, ) return html.Div([ dcc.Graph( id=self.graph_id, config={ "displaylogo": False, "toImageButtonOptions": { "filename": "best_controls" }, }, figure=fig, ) ])
def user_download_data( data_requested, radio_value, realizations_check, realizations_input, ): if data_requested: content = get_data(self.csv_file) if realizations_check: realizations = parse_range(realizations_input) if realizations: content = content[content["realization"].isin( realizations)] if radio_value == "Statistics": filename = "objective_statistics.csv" content = calculate_statistics(content) else: filename = "objective_values.csv" return WebvizPluginABC.plugin_data_compress([{ "filename": filename, "content": content.to_csv(), }]) return ""
def update_graph(function_list, _): if function_list is None: return {} data = get_data(self.csv_file) accepted_data = data[data.accepted == 1] not_accepted_data = data[data.accepted == 0] colors = cycle(DEFAULT_PLOTLY_COLORS) traces = [] for name, color in zip(function_list, colors): if name != "objective": traces.append( go.Scatter( y=data[name], x=data.batch, mode="lines+markers", marker={ "color": color, "size": 10 }, name=name, ), ) else: traces.extend([ go.Scatter( y=accepted_data[name], x=accepted_data.batch, mode="lines+markers", marker={ "color": "blue", "size": 10 }, name="accepted", ), go.Scatter( y=not_accepted_data[name], x=not_accepted_data.batch, mode="markers", marker={ "color": "red", "size": 9 }, name="rejected", ), ]) return { "data": traces, "layout": dict( xaxis={ "title": "Batch", "tickformat": ",d" }, yaxis={"title": "Objective function value"}, ), }
def user_download_data(data_requested): if data_requested: return { "filename": Path(self.data_path).name, "content": base64encode(get_data(self.data_path).to_csv()), "mime_type": "text/csv", } return None
def user_download_data(data_requested, radio_value): if data_requested: if radio_value == "Statistics": data = get_data(self.statistics_file).set_index( ["summary_key", "batch", "date"]) file_path = self.statistics_file else: data = get_data(self.values_file).set_index( ["batch", "date"]) file_path = self.values_file return WebvizPluginABC.plugin_data_compress([{ "filename": Path(file_path).name, "content": data.to_csv(), }]) return ""
def user_download_data(data_requested): if data_requested: return WebvizPluginABC.plugin_data_compress([{ "filename": Path(self.csv_file).name, "content": get_data(self.csv_file).to_csv(), }]) return ""
def layout(self): data = get_data(self.statistics_file) functions = data["function"].unique() function_dropdown_options = [{"label": i, "value": i} for i in functions] func_elements = [ html.Label("Functions to plot:"), dcc.Dropdown( id=self.function_dropdown_id, options=function_dropdown_options, multi=True, value=[functions[0]], ), ] radio_options = ["Statistics", "Data"] radio_elements = [ dcc.RadioItems( id=self.radio_id, options=[{"label": i, "value": i} for i in radio_options], value=radio_options[1], labelStyle={"display": "inline-block"}, style={"margin-top": 20}, ) ] return html.Div( [ html.Div( [ html.Div( func_elements + radio_elements, style={ "width": "29%", "display": "inline-block", "vertical-align": "top", }, ), html.Div( [ dcc.Graph( id=self.graph_id, config={ "modeBarButtonsToRemove": ["toImage"], "displaylogo": False, }, ) ], style={"width": "69%", "display": "inline-block"}, ), ] ), ] )
def user_download_data(data_requested, radio_value): if data_requested: file_path = ( self.statistics_file if radio_value == "Statistics" else self.values_file ) return WebvizPluginABC.plugin_data_compress( [ { "filename": Path(file_path).name, "content": get_data(file_path).to_csv(), } ] ) return ""
def layout(self): data = get_data(self.csv_file) exclude = ["batch", "accepted"] functions = [name for name in data.columns if name not in exclude] function_dropdown_options = [{ "label": i, "value": i } for i in functions] func_elements = [ html.Label("Functions to plot:"), dcc.Dropdown( id=self.function_dropdown_id, options=function_dropdown_options, multi=True, value=[functions[0]], ), ] return html.Div([ html.Div( func_elements, style={ "width": "29%", "display": "inline-block", "vertical-align": "top", }, ), html.Div( [ dcc.Graph( id=self.graph_id, config={ "displaylogo": False, "toImageButtonOptions": { "filename": "single_objectives" }, }, ) ], id=self.div_id, style={ "width": "69%", "display": "inline-block" }, ), ])
def update_graph(key_list, *args): if key_list is None: return {} data = get_data(self.csv_file) traces = [] if "date" in data.columns: for key in key_list: for date in args[0]: selected_data = data[data["date"] == date].drop( columns=["date"]) traces.append( go.Bar( y=selected_data[key], x=selected_data["realization"], name=f"{key}:{date}", showlegend=True, ), ) else: for key in key_list: traces.append( go.Bar( y=data[key], x=data["realization"], name=key, showlegend=True, ), ) return { "data": traces, "layout": dict( xaxis={ "title": "Realization", "tickformat": ",d" }, yaxis={ "title": "(best realization) - (initial realization)" }, ), }
def layout(self): data = get_data(self.csv_file) controls = data["control"].unique() control_dropdown_options = [{"label": i, "value": i} for i in controls] control_elements = [ html.Label("Controls to plot:"), dcc.Dropdown( id=self.controls_dropdown_id, options=control_dropdown_options, multi=True, value=[controls[0]], ), ] return html.Div([ html.Div([ html.Div( control_elements, style={ "width": "29%", "display": "inline-block", "vertical-align": "top", }, ), html.Div( [ dcc.Graph( id=self.graph_id, config={ "modeBarButtonsToRemove": ["toImage"], "displaylogo": False, }, ) ], style={ "width": "69%", "display": "inline-block" }, ), ]), ])
def update_graph( xaxis_column_name, yaxis_column_name, xaxis_type, yaxis_type, axis_options_x_id, axis_options_y_id, ): if None in [xaxis_column_name, yaxis_column_name]: return {} df = get_data(self.data_path) x_data = df[xaxis_column_name] y_data = df[yaxis_column_name] data = [ get_graph_line(x_data, y_data, axis_options_x_id, axis_options_y_id) ] return crossplot_update_graph(data, xaxis_column_name, yaxis_column_name, xaxis_type, yaxis_type)
def update_graph(well_keys, batch_list, statistics, target_rate): if well_keys is None or batch_list is None: return {} if well_keys is not None and len(well_keys) == 0: return {} if batch_list is not None and len(batch_list) == 0: return {} df = get_data(self.csv_file) if statistics == "Statistics": df = calculate_statistics(df, well_keys).set_index( ["summary_key", "batch", "date"]) else: df = df.set_index(["batch", "date"]) callback = summary_callback.get_callback_func(statistics) traces = callback(df, well_keys, batch_list, "batch", "date") if target_rate == "On": target_keys = _get_target_keys(df, well_keys) traces.extend( callback(df, target_keys, batch_list, "batch", "date", mode="lines")) return { "data": traces, "layout": dict( xaxis={"title": "Date"}, yaxis={"title": "Well rates"}, hovermode="closest", ), }
def update_graph(_): data = get_data(self.csv_file) accepted_data = data[data.accepted == True] # pylint: disable=C0121 not_accepted_data = data[data.accepted == False] # pylint: disable=C0121 traces = [ go.Scatter( y=accepted_data.value, x=accepted_data.batch, mode="lines+markers", marker={ "color": "blue", "size": 10 }, name="accepted", ), go.Scatter( y=not_accepted_data.value, x=not_accepted_data.batch, mode="markers", marker={ "color": "red", "size": 9 }, name="not accepted", ), ] return { "data": traces, "layout": dict( xaxis={"title": "Batch"}, yaxis={"title": "Objective function value"}, ), }
def user_download_data( data_requested, radio_value, realizations_check, realizations_input, ): if data_requested: content = get_data(self.csv_file) if realizations_check: realizations = parse_range(realizations_input) if realizations: content = content[content["realization"].isin( realizations)] if radio_value == "Statistics": filename = "objective_statistics.csv" content = calculate_statistics(content) else: filename = "objective_values.csv" return { "filename": filename, "content": base64encode(content.to_csv()), "mime_type": "text/csv", } return None
def layout(self): axis_type = [(i, i) for i in ["Linear", "Log"]] axis_options = ["Normal", "Cumulative"] df = get_data(self.data_path) plot_keys = df.columns.unique() sidebar_configs = [ ( "radio", { "title": "X-axis", "item_id": self.axis_type_x_id, "options": axis_type, }, ), ( "radio", { "item_id": self.axis_opt_x_id, "options": axis_options }, ), ( "dropdown", { "item_id": self.keys_x_id, "options": plot_keys }, ), ( "radio", { "title": "Y-axis", "item_id": self.axis_type_y_id, "options": axis_type, }, ), ( "radio", { "item_id": self.axis_opt_y_id, "options": axis_options }, ), ( "dropdown", { "item_id": self.keys_y_id, "options": plot_keys }, ), ] return html.Div([ html.H1( children=self.title, style={"textAlign": "center"}, ), html.Div([ html.Div( [get_sidebar_layout(sidebar_configs)], style={ "width": "29%", "display": "inline-block", "vertical-align": "top", }, ), html.Div( [ dcc.Graph( id=self.graph_id, config={ "displaylogo": False, "toImageButtonOptions": { "filename": "crossplot" }, }, ) ], style={ "width": "69%", "display": "inline-block" }, ), ]), ])
def set_callbacks(self, app): @app.callback(self.plugin_data_output, [self.plugin_data_requested]) def user_download_data(data_requested): if data_requested: return { "filename": Path(self.csv_file).name, "content": base64encode(csv=get_data(self.csv_file).to_csv()), "mime_type": "text/csv", } return None inputs = [Input(self.key_dropdown_id, "value")] data = get_data(self.csv_file) if "date" in data.columns: inputs.append(Input(self.date_dropdown_id, "value")) @app.callback( Output(self.graph_id, "figure"), inputs, ) def update_graph(key_list, *args): if key_list is None: return {} data = get_data(self.csv_file) traces = [] if "date" in data.columns: for key in key_list: for date in args[0]: selected_data = data[data["date"] == date].drop( columns=["date"]) traces.append( go.Bar( y=selected_data[key], x=selected_data["realization"], name=f"{key}:{date}", showlegend=True, ), ) else: for key in key_list: traces.append( go.Bar( y=data[key], x=data["realization"], name=key, showlegend=True, ), ) return { "data": traces, "layout": dict( xaxis={ "title": "Realization", "tickformat": ",d" }, yaxis={ "title": "(best realization) - (initial realization)" }, ), }
def update_graph(func_list, radio_value): # # The key_list arguments is the list of functions to plot. if func_list is None: return {} # # Get the data, setting its index. if radio_value == "Statistics": data = get_data(self.statistics_file).set_index("function") else: data = get_data(self.values_file).set_index("function") # Make a cycle iterator over the plotly colors. colors = cycle(DEFAULT_PLOTLY_COLORS) traces = [] for color, key in zip(colors, func_list): # Select all data belonging to the current key. func_data = data.xs(key) # Make the traces, with mean, P10 and P90, shading in between. if radio_value == "Statistics": traces.extend( [ go.Scatter( y=func_data["P90"], x=func_data["batch"], mode="lines", marker={"size": 10}, line={"color": color}, name=key + "(P90)", showlegend=False, ), go.Scatter( y=func_data["P10"], x=func_data["batch"], mode="lines", line={"color": color}, marker={"size": 10}, fill="tonexty", name=key + "(P10)", showlegend=False, ), go.Scatter( y=func_data["Mean"], x=func_data["batch"], mode="lines", marker={"size": 10}, line={"color": color}, name=key, showlegend=True, ), ] ) else: traces.append( go.Scatter( y=func_data["value"], x=func_data["batch"], mode="markers", marker={"size": 10}, name=key, showlegend=True, ) ) return { "data": traces, "layout": dict( xaxis={"title": "Batch"}, yaxis={"title": "Function Key Value"}, ), }
def update_graph(func_list, radio_value, plot_mode, realizations_check, realizations_input): # The key_list arguments is the list of functions to plot. if func_list is None: return {} # Get the data, filter if requested. data = get_data(self.csv_file) if realizations_check: realizations = parse_range(realizations_input) if realizations: data = data[data["realization"].isin(realizations)] if len(data) == 0: return {} if radio_value == "Statistics": data = calculate_statistics(data) data = data.set_index("function") # Make a cycle iterator over the plotly colors. colors = cycle(DEFAULT_PLOTLY_COLORS) traces = [] for color, key in zip(colors, func_list): # Select all data belonging to the current key. func_data = data.xs(key) # Make the traces, with mean, P10 and P90, shading in between. if radio_value == "Statistics": traces.extend([ go.Scatter( y=func_data["P90"], x=func_data["batch"], mode=plot_mode, marker={"size": 10}, line={"color": color}, name=key + "(P90)", showlegend=False, ), go.Scatter( y=func_data["P10"], x=func_data["batch"], mode=plot_mode, line={"color": color}, marker={"size": 10}, fill="tonexty", name=key + "(P10)", showlegend=False, ), go.Scatter( y=func_data["Mean"], x=func_data["batch"], mode=plot_mode, marker={"size": 10}, line={"color": color}, name=key, showlegend=True, ), ]) else: y_values = func_data["value"] if radio_value == "Normalized": y_values = y_values * func_data["norm"] elif radio_value == "Weighted + Normalized": y_values = y_values * func_data["norm"] * func_data[ "weight"] traces.append( go.Scatter( y=y_values, x=func_data["batch"], mode=plot_mode, marker={"size": 10}, name=key, showlegend=True, )) return { "data": traces, "layout": dict( xaxis={"title": "Batch"}, yaxis={"title": "Function Key Value"}, ), }
def layout(self): data = get_data(self.csv_file) functions = data["function"].unique() function_dropdown_options = [{ "label": i, "value": i } for i in functions] func_elements = [ html.Label("Functions to plot:"), dcc.Dropdown( id=self.function_dropdown_id, options=function_dropdown_options, multi=True, value=[functions[0]], ), ] radio_options = [ "Statistics", "Values", "Normalized", "Weighted + Normalized" ] radio_elements = [ dcc.RadioItems( id=self.radio_id, options=[{ "label": i, "value": i } for i in radio_options], value=radio_options[1], labelStyle={"display": "inline-block"}, style={"margin-top": 20}, ), html.Label("Style:"), dcc.RadioItems( id=self.radio_id_mode, options=[ { "label": "line", "value": "lines" }, { "label": "scatter", "value": "markers" }, ], value="lines", labelStyle={"display": "inline-block"}, ), ] realization_elements = [ html.Div( [ dcc.Checklist( id=self.realization_filter_check_id, options=[{ "label": "Filter realizations:", "value": "filter" }], style={ "display": "inline-block", "margin-right": 8 }, ), dcc.Input( id=self.realization_filter_input_id, type="text", placeholder="example: 0, 3, 6-10", pattern= r"\s*|([0-9]+(\s*-\s*[0-9]+)?)(\s*,\s*[0-9]+(\s*-\s*[0-9]+)?)*", style={"display": "inline-block"}, ), ], style={"margin-top": 20}, ) ] return html.Div([ html.Div([ html.Div( func_elements + radio_elements + realization_elements, style={ "width": "29%", "display": "inline-block", "vertical-align": "top", }, ), html.Div( [ dcc.Graph( id=self.graph_id, config={ "modeBarButtonsToRemove": ["toImage"], "displaylogo": False, }, ) ], style={ "width": "69%", "display": "inline-block" }, ), ]), ])
def layout(self): data = get_data(self.csv_file) key_dropdown_options = [ {"label": i, "value": i} for i in data.columns if i not in ["realization", "date"] ] if self.pre_select == "first": key_dropdown_value = [key_dropdown_options[0]["label"]] elif self.pre_select == "all": key_dropdown_value = [option["label"] for option in key_dropdown_options] elif self.pre_select == "none": key_dropdown_value = [] else: raise RuntimeError(f"Invalid argument: 'pre_select={self.pre_select}") dropdown_elements = [ html.Label("Values to plot:"), dcc.Dropdown( id=self.key_dropdown_id, options=key_dropdown_options, multi=True, value=key_dropdown_value, ), ] if "date" in data.columns: date_dropdown_options = [ {"label": i, "value": i} for i in data["date"].unique() ] date_dropdown_value = ( [date_dropdown_options[-1]["label"]] if date_dropdown_options else None ) dropdown_elements.extend( [ html.Label("Dates to plot:"), dcc.Dropdown( id=self.date_dropdown_id, options=date_dropdown_options, multi=True, value=date_dropdown_value, ), ] ) return html.Div( [ html.Div( [ html.Div( dropdown_elements, style={ "width": "29%", "display": "inline-block", "vertical-align": "top", }, ), html.Div( [dcc.Graph(id=self.graph_id)], style={"width": "69%", "display": "inline-block"}, ), ] ), ] )
def update_graph(key_list, line_list, radio_value, realizations_check, realizations_input): # The key_list arguments is the list of keys to plot. The line_list # argument is a list of batches, or a list of dates to plot for # those keys. if key_list is None or line_list is None: return {} data = get_data(self.csv_file) if realizations_check: realizations = parse_range(realizations_input) if realizations: data = data[data["realization"].isin(realizations)] if radio_value == "Statistics": data = calculate_statistics(data).set_index( ["summary_key", "batch", "date"]) else: data = data.set_index(["batch", "date"]) # Make a cycle iterator over the plotly colors. colors = cycle(DEFAULT_PLOTLY_COLORS) # Choose between dates or batches for different lines. line_key = "batch" if self.xaxis == "date" else "date" traces = [] for color, key in zip(colors, key_list): # Select all data belonging to the current key. if radio_value == "Statistics": key_data = data.xs(key, level="summary_key", drop_level=True) else: key_data = data[key] for line in line_list: # Select all rows belonging the current batch or date. line_data = key_data.xs(line, level=line_key, drop_level=True).reset_index() # Set the name of the plotted line. name = key if len(line_list) > 1: name += f", {line_key}:{line}" # Make the traces, with mean, P10 and P90, shading in between. if radio_value == "Statistics": traces.extend([ go.Scatter( y=line_data["P90"], x=line_data[self.xaxis], mode="lines", marker={"size": 10}, line={"color": color}, name=name + "(P90)", showlegend=False, ), go.Scatter( y=line_data["P10"], x=line_data[self.xaxis], mode="lines", line={"color": color}, marker={"size": 10}, fill="tonexty", name=name + "(P10)", showlegend=False, ), go.Scatter( y=line_data["mean"], x=line_data[self.xaxis], mode="lines", marker={"size": 10}, line={"color": color}, name=name, showlegend=True, ), ]) else: traces.append( go.Scatter( y=line_data[key], x=line_data[self.xaxis], mode="markers", marker={"size": 10}, name=name, showlegend=True, )) return { "data": traces, "layout": dict( xaxis={"title": self.xaxis.capitalize()}, yaxis={"title": "Summary Key Value"}, ), }
def layout(self): radio_options = ["Statistics", "Data"] data = get_data(self.csv_file).set_index( ["batch", "date", "realization"]) key_dropdown_options = [{ "label": i, "value": i } for i in list(data.columns.unique())] data = data.reset_index() xaxis_dropdown_options = [{ "label": i, "value": i } for i in list(data["batch" if self.xaxis == "date" else "date"].unique())] xaxis_dropdown_title = ("Batches to plot" if self.xaxis == "date" else "Dates to plot") # Keywords dropdown. keyword_elements = [ html.Label("Keywords to plot:"), dcc.Dropdown( id=self.key_dropdown_id, options=key_dropdown_options, multi=True, ), ] # X-axis dropdown. xaxis_elements = [ html.Label(xaxis_dropdown_title, style={"margin-top": 24}), dcc.Dropdown( id=self.xaxis_dropdown_id, options=xaxis_dropdown_options, multi=True, value=[xaxis_dropdown_options[0]["value"]], ), ] # Radio for switching between data and statistics. radio_elements = [ dcc.RadioItems( id=self.radio_id, options=[{ "label": i, "value": i } for i in radio_options], value=radio_options[0], labelStyle={"display": "inline-block"}, style={"margin-top": 20}, ), ] realization_elements = [ html.Div( [ dcc.Checklist( id=self.realization_filter_check_id, options=[{ "label": "Filter realizations:", "value": "filter" }], style={ "display": "inline-block", "margin-right": 8 }, ), dcc.Input( id=self.realization_filter_input_id, type="text", placeholder="example: 0, 3, 6-10", pattern= r"\s*|([0-9]+(\s*-\s*[0-9]+)?)(\s*,\s*[0-9]+(\s*-\s*[0-9]+)?)*", style={"display": "inline-block"}, ), ], style={"margin-top": 20}, ) ] return html.Div([ html.Div([ html.Div( keyword_elements + xaxis_elements + radio_elements + realization_elements, style={ "width": "29%", "display": "inline-block", "vertical-align": "top", }, ), html.Div( [ dcc.Graph( id=self.graph_id, config={ "modeBarButtonsToRemove": ["toImage"], "displaylogo": False, }, ) ], style={ "width": "69%", "display": "inline-block" }, ), ]), ])
def layout(self): df = get_data(self.data_path) dropdown_options = list( identify_indexed_controls(df.columns.unique()).keys()) realizations = df.index.values axis_type = [(i, i) for i in ["Linear", "Log"]] axis_options = ["Normal", "Cumulative"] interp_types = [ ("None", None), ("Linear", "linear"), ("High value", "hv"), ("Low value", "vh"), ] side_bar_config = [ ( "radio", { "title": "X-axis", "item_id": self.axis_type_x_id, "options": axis_type, }, ), ( "radio", { "item_id": self.axis_options_x_id, "options": axis_options }, ), ( "dropdown", { "item_id": self.dropdown_x_id, "options": dropdown_options }, ), ( "radio", { "title": "Y-axis", "item_id": self.axis_type_y_id, "options": axis_type, }, ), ( "radio", { "item_id": self.axis_options_y_id, "options": axis_options }, ), ( "dropdown", { "item_id": self.dropdown_y_id, "options": dropdown_options }, ), ( "radio", { "title": "Interpolation type", "item_id": self.interpolation_id, "options": interp_types, }, ), ( "dropdown", { "item_id": self.dropdown_realization_id, "options": realizations, "multi": True, }, ), ] return html.Div([ html.H1(children=self.title, style={"textAlign": "center"}), html.Div([ html.Div( [get_sidebar_layout(side_bar_config)], style={ "width": "29%", "display": "inline-block", "vertical-align": "top", }, ), html.Div( [ dcc.Graph( id=self.graph_id, config={ "displaylogo": False, "toImageButtonOptions": { "filename": "indexed_crossplot" }, }, ) ], style={ "width": "69%", "display": "inline-block" }, ), ]), ])
def update_graph( func_list, radio_value, plot_mode, realizations_check, realizations_input, click_data, ): # The key_list arguments is the list of functions to plot. if func_list is None or len(func_list) == 0: return {} # Get the data, filter if requested. data = get_data(self.csv_file) if realizations_check: realizations = parse_range(realizations_input) if realizations: data = data[data["realization"].isin(realizations)] if len(data) == 0: return {} if radio_value == "Statistics": data = calculate_statistics(data) data = data.set_index("function") # Make a cycle iterator over the plotly colors. colors = cycle(DEFAULT_PLOTLY_COLORS) traces = [] for color, key in zip(colors, func_list): # Select all data belonging to the current key. func_data = data.xs(key) # Make the traces, with mean, P10 and P90, shading in between. if radio_value == "Statistics": traces.extend( statistics_traces(color, func_data, key, plot_mode)) else: traces.extend( function_traces( func_list, click_data, color, func_data, key, plot_mode, radio_value, )) return { "data": traces, "layout": dict( xaxis={ "title": "Batch", "tickformat": ",d" }, yaxis={"title": "Function Key Value"}, hovermode="closest", ), }
def update_dropwdown_y(selected_control): df = get_data(self.data_path) indexed_controls = identify_indexed_controls(df.columns.unique()) return dropdown_callback(selected_control, indexed_controls)
def layout(self): data = get_data(self.csv_file).set_index( ["batch", "date", "realization"]) well_summary_keys = [ i for i in list(data.columns.unique()) if i.split(":")[0] in _WELL_RATE_KEYS ] data = data.reset_index() realizations = data["realization"].unique() batches = list(data["batch"].unique()) statistics_toggle = ["Data", "Statistics"] target_rate_toggle = ["Off", "On"] side_bar_config = [ ( "dropdown", { "item_id": self.dropdown_key, "options": well_summary_keys, "multi": True, }, ), ( "dropdown", { "item_id": self.dropdown_batch, "options": batches, "multi": True }, ), ( "label", { "item_id": self.label_id, "text": f"Statistics are calculated based on {len(realizations)} realizations", "style": {}, }, ), ( "radio", { "item_id": self.radio_statistics, "options": statistics_toggle }, ), ( "radio", { "title": "Target rate", "item_id": self.radio_target, "options": target_rate_toggle, }, ), ] return html.Div([ html.H1(children=self.title, style={"textAlign": "center"}), html.Div([ html.Div( [get_sidebar_layout(side_bar_config)], style={ "width": "29%", "display": "inline-block", "vertical-align": "top", }, ), html.Div( [ dcc.Graph( id=self.graph_id, config={ "displaylogo": False, "toImageButtonOptions": { "filename": "wells" }, }, ) ], style={ "width": "69%", "display": "inline-block" }, ), ]), ])