rtc-tools-interface 0.7.0b3__tar.gz → 0.7.1__tar.gz

{rtc-tools-interface-0.7.0b3 → rtc-tools-interface-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rtc-tools-interface
-Version: 0.7.0b3
+Version: 0.7.1
 Summary: Toolbox for user interfaces for RTC-Tools
 Home-page: UNKNOWN
 Author: Deltares

{rtc-tools-interface-0.7.0b3 → rtc-tools-interface-0.7.1}/rtc_tools_interface.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rtc-tools-interface
-Version: 0.7.0b3
+Version: 0.7.1
 Summary: Toolbox for user interfaces for RTC-Tools
 Home-page: UNKNOWN
 Author: Deltares

{rtc-tools-interface-0.7.0b3 → rtc-tools-interface-0.7.1}/rtc_tools_interface.egg-info/SOURCES.txt

@@ -21,6 +21,12 @@ rtctools_interface/optimization/plot_mixin.py
 rtctools_interface/optimization/read_goals.py
 rtctools_interface/optimization/helpers/__init__.py
 rtctools_interface/optimization/helpers/statistics_mixin.py
+rtctools_interface/plotting/__init__.py
+rtctools_interface/plotting/plot_tools.py
+rtctools_interface/plotting/subplot_classes.py
+rtctools_interface/simulation/__init__.py
+rtctools_interface/simulation/base_simulation_problem.py
+rtctools_interface/simulation/plot_mixin.py
 rtctools_interface/utils/__init__.py
 rtctools_interface/utils/plot_table_schema.py
 rtctools_interface/utils/read_goals_mixin.py

{rtc-tools-interface-0.7.0b3 → rtc-tools-interface-0.7.1}/rtctools_interface/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-11-28T16:07:57+0000",
+ "date": "2023-12-22T13:22:49+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "499d6e416027fec2a9b6dd1cc4d7249b30a41463",
- "version": "0.7.0b3"
+ "full-revisionid": "5d3d1b69fbc76a7bf4fd384003bfa601bb820486",
+ "version": "0.7.1"
 }
 '''  # END VERSION_JSON
 

rtc-tools-interface-0.7.1/rtctools_interface/plotting/plot_tools.py

@@ -0,0 +1,306 @@
+"""Functions to create plots."""
+from io import StringIO
+import logging
+import math
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+import matplotlib
+
+import matplotlib.pyplot as plt
+from plotly.subplots import make_subplots
+
+from rtctools_interface.plotting.subplot_classes import (
+    COMPARISON_RUN_SUFFIX,
+    SubplotMatplotlib,
+    SubplotPlotly,
+)
+from rtctools_interface.utils.type_definitions import GoalConfig, IntermediateResult, PlotDataAndConfig
+
+logger = logging.getLogger("rtctools")
+
+
+def get_row_col_number(i_plot, n_rows, n_cols, row_first=False):
+    """Get row and col number given a plot number."""
+    if row_first:
+        i_r = math.ceil((i_plot + 1) / n_cols) - 1
+        i_c = i_plot - i_r * n_cols
+    else:  # Count along column direction first.
+        i_c = math.ceil((i_plot + 1) / n_rows) - 1
+        i_r = i_plot - i_c * n_rows
+    return i_c, i_r
+
+
+def get_subplot_axis(i_plot, n_rows, n_cols, axs):
+    """Determine the row and column index and returns the corresponding subplot object."""
+    i_c, i_r = get_row_col_number(i_plot, n_rows, n_cols)
+    subplot = axs[i_r, i_c]
+    return subplot
+
+
+def get_file_write_path(output_folder: Union[str, Path], file_name="figure"):
+    """Get path to to file."""
+    new_output_folder = Path(output_folder) / "goal_figures"
+    os.makedirs(new_output_folder, exist_ok=True)
+    return os.path.join(new_output_folder, file_name)
+
+
+def get_file_name(priority: int, final_result: bool):
+    """Get the file name for the figure to be written."""
+    if final_result:
+        file_name = "final_results"
+    else:
+        file_name = "after_priority_{}".format(priority)
+    return file_name
+
+
+def save_fig_as_png(fig, output_folder, priority, final_result) -> matplotlib.figure.Figure:
+    """Save matplotlib figure to output folder."""
+    file_name = get_file_name(priority, final_result)
+    figure_path = get_file_write_path(output_folder, file_name)
+    fig.savefig(figure_path + ".png")
+    return fig
+
+
+def save_fig_as_html(fig, output_folder, priority, final_result) -> dict:
+    """Save plotly figure as html"""
+    file_name = get_file_name(priority, final_result)
+    figure_path = get_file_write_path(output_folder, file_name)
+    fig.write_html(figure_path + ".html")
+    return fig
+
+
+def get_goal(subplot_config, base_goals) -> Union[GoalConfig, None]:
+    """Find the goal belonging to a subplot. Only checks for goals as specified in the goal table."""
+    for goal in base_goals:
+        if goal.get("goal_id") == subplot_config.id:
+            return goal
+    return None
+
+
+def save_fig_as_stringio(fig):
+    """Save figure as stringio in self."""
+    svg_data = StringIO()
+    fig.savefig(svg_data, format="svg")
+    return svg_data
+
+
+def save_figure(fig, save_plot_to, output_folder, priority, final_result) -> Union[StringIO, matplotlib.figure.Figure]:
+    """Save figure."""
+    if save_plot_to == "image":
+        return save_fig_as_png(fig, output_folder, priority, final_result)
+    if save_plot_to == "stringio":
+        return save_fig_as_stringio(fig)
+    raise ValueError("Unsupported method of saving the plot results.")
+
+
+def add_buttons_to_plotly(plotly_figure):
+    """Add buttons to the plotly figure.
+
+    Currently only a button to select whether previous results should also be visible"""
+
+    def comparison_run(name):
+        """Returns bool indicating whether the trace corresponds to a comparison run."""
+        return COMPARISON_RUN_SUFFIX in name
+
+    all_names = [True for _ in plotly_figure.data]
+    hide_comparison = [not comparison_run(trace.name) for trace in plotly_figure.data]
+    buttons = [
+        {
+            "label": "Show results from previous run",
+            "method": "update",
+            "args": [{"visible": all_names}],
+        },
+        {
+            "label": "Hide results from previous run",
+            "method": "update",
+            "args": [{"visible": hide_comparison}],
+        },
+    ]
+
+    # Add the buttons to the layout
+    plotly_figure.update_layout(
+        updatemenus=[
+            {
+                "buttons": buttons,
+                "x": 1.0,
+                "y": 1.0,
+                "xanchor": "left",
+                "yanchor": "bottom",
+                "pad": {"r": 2, "t": 2, "l": 20, "b": 10},
+            }
+        ]
+    )
+
+
+def check_empty_plot_table(plot_config):
+    """Chech whether there are any elements in the plot table."""
+    if len(plot_config) == 0:
+        logger.info("Nothing to plot." + " Are there any goals that are active and described in the plot_table?")
+        return True
+    return False
+
+
+def get_main_title(final_result: bool, result_dict):
+    """Generate main title."""
+    if final_result:
+        main_title = "Final results"
+    else:
+        main_title = "Results after optimizing until priority {}".format(result_dict["priority"])
+    return main_title
+
+
+def create_matplotlib_figure(
+    result_dict, results_prev, current_run: PlotDataAndConfig, final_result=False
+) -> Union[StringIO, matplotlib.figure.Figure]:
+    # pylint: disable=too-many-locals
+    """Creates a figure with a subplot for each row in the plot_table."""
+    used_colors: list = []
+    results = result_dict["timeseries_data"]
+    plot_config = current_run["plot_options"]["plot_config"]
+    plot_max_rows = current_run["plot_options"]["plot_max_rows"]
+    if check_empty_plot_table(plot_config):
+        return None
+
+    # Initalize figure
+    n_cols = math.ceil(len(plot_config) / plot_max_rows)
+    n_rows = math.ceil(len(plot_config) / n_cols)
+    fig, axs = plt.subplots(nrows=n_rows, ncols=n_cols, figsize=(n_cols * 9, n_rows * 3), dpi=80, squeeze=False)
+    main_title = get_main_title(final_result, result_dict)
+    fig.suptitle(main_title, fontsize=14)
+    i_plot = -1
+
+    base_goals = current_run["prio_independent_data"]["base_goals"]
+    # Add subplot for each row in the plot_table
+    for subplot_config in plot_config:
+        i_plot += 1
+        axis = get_subplot_axis(i_plot, n_rows, n_cols, axs)
+        goal = get_goal(subplot_config, base_goals)
+        subplot = SubplotMatplotlib(
+            axis,
+            subplot_config,
+            goal,
+            results,
+            results_prev,
+            current_run["prio_independent_data"],
+            used_colors,
+        )
+        subplot.plot()
+
+    fig.tight_layout()
+    return save_figure(
+        fig,
+        current_run["plot_options"]["save_plot_to"],
+        current_run["plot_options"]["output_folder"],
+        result_dict["priority"],
+        final_result,
+    )
+
+
+def set_plotly_layout(plotly_figure, final_result, result_dict, results_compare):
+    """Set the layout for the plotly figure."""
+    main_title = get_main_title(final_result, result_dict)
+    plotly_figure.update_layout(title_text=main_title)
+    scale_factor = 0.8
+    plotly_figure.update_layout(
+        font={"size": scale_factor * 12},
+        title_font={"size": scale_factor * 16},
+    )
+    plotly_figure.update_traces(hovertemplate="%{y}")
+    plotly_figure.update_layout(hovermode="x")
+    plotly_figure.update_annotations(font_size=scale_factor * 14)
+    if results_compare:
+        add_buttons_to_plotly(plotly_figure)
+    plotly_figure.update_traces(marker={"size": 5})
+
+
+def create_plotly_figure(
+    result_dict: IntermediateResult,
+    results_prev: Optional[IntermediateResult],
+    current_run: PlotDataAndConfig,
+    final_result=False,
+    results_compare: Optional[IntermediateResult] = None,
+) -> Any:
+    # pylint: disable=too-many-locals
+    """Creates a figure with a subplot for each row in the plot_table."""
+    plot_config = current_run["plot_options"]["plot_config"]
+    if check_empty_plot_table(plot_config):
+        return None
+
+    n_cols = math.ceil(len(plot_config) / current_run["plot_options"]["plot_max_rows"])
+    n_rows = math.ceil(len(plot_config) / n_cols)
+    i_plot = -1
+    plotly_figure = make_subplots(rows=n_rows, cols=n_cols, subplot_titles=len(plot_config) * [" "], shared_xaxes=True)
+    base_goals = current_run["prio_independent_data"]["base_goals"]
+
+    # Add subplot for each row in the plot_table
+    used_colors: list = []
+    for subplot_config in plot_config:
+        i_plot += 1
+        i_c, i_r = get_row_col_number(i_plot, n_rows, n_cols, row_first=True)
+        goal = get_goal(subplot_config, base_goals)
+        subplot = SubplotPlotly(
+            subplot_config,
+            goal,
+            result_dict["timeseries_data"],
+            results_prev,
+            current_run["prio_independent_data"],
+            used_colors,
+            results_compare,
+            plotly_figure,
+            i_r + 1,
+            i_c + 1,
+            i_plot,
+        )
+        subplot.plot()
+
+    set_plotly_layout(plotly_figure, final_result, result_dict, results_compare)
+
+    return save_fig_as_html(
+        plotly_figure, current_run["plot_options"]["output_folder"], result_dict["priority"], final_result
+    )
+
+
+def create_plot_each_priority(current_run: PlotDataAndConfig, plotting_library: str = "plotly") -> Dict[int, Any]:
+    """Create all plots for one optimization run, for each priority one seperate plot."""
+    intermediate_results = current_run["intermediate_results"]
+    plot_results = {}
+    for intermediate_result_prev, intermediate_result in zip([None] + intermediate_results[:-1], intermediate_results):
+        priority = intermediate_result["priority"]
+        if plotting_library == "plotly":
+            plot_results[priority] = create_plotly_figure(intermediate_result, intermediate_result_prev, current_run)
+        elif plotting_library == "matplotlib":
+            plot_results[priority] = create_matplotlib_figure(
+                intermediate_result, intermediate_result_prev, current_run
+            )
+        else:
+            raise ValueError("Invalid plotting library.")
+    return plot_results
+
+
+def create_plot_final_results(
+    current_run: PlotDataAndConfig,
+    previous_run: Optional[PlotDataAndConfig] = None,
+    output_folder=None,
+    plotting_library: str = "plotly",
+) -> Dict[str, Union[StringIO, matplotlib.figure.Figure]]:
+    """Create a plot for the final results."""
+    current_final_result = sorted(current_run["intermediate_results"], key=lambda x: x["priority"])[-1]
+    if previous_run:
+        previous_final_result = sorted(previous_run["intermediate_results"], key=lambda x: x["priority"])[-1]
+    else:
+        previous_final_result = None
+
+    if output_folder:
+        current_run["plot_options"]["output_folder"] = output_folder
+
+    if plotting_library == "plotly":
+        final_results_plot = create_plotly_figure(
+            current_final_result, None, current_run, final_result=True, results_compare=previous_final_result
+        )
+    elif plotting_library == "matplotlib":
+        final_results_plot = create_matplotlib_figure(current_final_result, None, current_run, final_result=True)
+    else:
+        raise ValueError("Invalid plotting library.")
+    result_name = "final_results"
+    return {result_name: final_results_plot}

rtc-tools-interface-0.7.1/rtctools_interface/plotting/subplot_classes.py

@@ -0,0 +1,304 @@
+"""Classes for plotting, either using plotly or matplotlib. The classes generate one subplot in the full figure.."""
+from abc import abstractmethod, ABC
+import logging
+import random
+from typing import Any, Dict, Optional
+
+import matplotlib.dates as mdates
+import matplotlib.ticker as mtick
+import plotly.graph_objects as go
+
+import numpy as np
+from rtctools_interface.utils.plot_table_schema import PlotTableRow
+from rtctools_interface.utils.type_definitions import GoalConfig, IntermediateResult, PrioIndependentData
+
+logger = logging.getLogger("rtctools")
+
+COMPARISON_RUN_SUFFIX = " (previous run)"
+
+
+def get_timedeltas(times):
+    """Get delta_t for each timestep."""
+    return [np.nan] + [times[i] - times[i - 1] for i in range(1, len(times))]
+
+
+def generate_unique_color(used_colors):
+    """Get a color. Adds the new color to used_colors."""
+    color_palette = [
+        "#1f77b4",
+        "#ff7f0e",
+        "#2ca02c",
+        "#d62728",
+        "#9467bd",
+        "#8c564b",
+        "#e377c2",
+        "#7f7f7f",
+        "#bcbd22",
+        "#17becf",
+    ]
+
+    available_colors = [color for color in color_palette if color not in used_colors]
+
+    if available_colors:
+        new_color = available_colors[0]
+    else:  # Generate a new color, may be similar to the existing colors.
+        new_color = "#{:02x}{:02x}{:02x}".format(random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+    used_colors.append(new_color)
+    return new_color
+
+
+class SubplotBase(ABC):
+    """Base class for creating subplots."""
+
+    def __init__(
+        self,
+        subplot_config: PlotTableRow,
+        goal: Optional[GoalConfig],
+        results: Dict[str, Any],
+        results_prev: Optional[IntermediateResult],
+        prio_independent_data: PrioIndependentData,
+        used_colors,
+        results_compare: Optional[IntermediateResult] = None,
+    ):
+        self.config: PlotTableRow = subplot_config
+        self.goal = goal
+        self.function_nominal = self.goal["function_nominal"] if self.goal else 1
+        self.results = results
+        self.results_prev = results_prev
+        self.results_compare = results_compare
+        self.datetimes = prio_independent_data["io_datetimes"]
+        self.time_deltas = get_timedeltas(prio_independent_data["times"])
+        self.used_colors = used_colors
+
+        if self.goal:
+            self.rate_of_change = self.goal.get("goal_type") in ["range_rate_of_change"]
+            if self.goal.get("goal_type") in ["range", "range_rate_of_change"]:
+                self.target_min, self.target_max = self.goal["target_min_series"], self.goal["target_max_series"]
+            else:
+                self.target_min, self.target_max = None, None
+        else:
+            self.rate_of_change = False
+
+        if "custom_title" in self.config.__dict__ and isinstance(self.config.custom_title, str):
+            self.subplot_title = self.config.custom_title
+        elif self.config.specified_in == "goal_generator" and self.goal:
+            self.subplot_title = "Goal for {} (active from priority {})".format(
+                self.goal["state"], self.goal["priority"]
+            )
+        else:
+            self.subplot_title = ""
+
+    def get_differences(self, timeseries):
+        """Get rate of change timeseries for input timeseries, relative to the function nominal."""
+        timeseries = list(timeseries)
+        return [
+            (st - st_prev) / dt / self.function_nominal * 100
+            for st, st_prev, dt in zip(timeseries, [np.nan] + timeseries[:-1], self.time_deltas)
+        ]
+
+    def plot_with_comparison(self, label, state_name, linestyle=None, linewidth=None):
+        """Plot the state both for the recent run and the comparison run."""
+        timeseries_data = self.results[state_name]
+        color = generate_unique_color(self.used_colors)
+        self.plot_timeseries(label, timeseries_data, color=color, linestyle=linestyle, linewidth=linewidth)
+        if self.results_compare and state_name in self.results_compare["timeseries_data"]:
+            timeseries_data = self.results_compare["timeseries_data"][state_name]
+            label += COMPARISON_RUN_SUFFIX
+            self.plot_timeseries(label, timeseries_data, linestyle="dotted", color=color, linewidth=linewidth)
+
+    def plot_with_previous(self, label, state_name, linestyle=None, linewidth=None):
+        """Add line with the results for a particular state. If the results for the previous
+        priority are availab, also add a (gray) line with those."""
+        self.plot_with_comparison(label, state_name, linestyle=linestyle, linewidth=linewidth)
+
+        if self.results_prev:
+            timeseries_data = self.results_prev["timeseries_data"][state_name]
+            label += " (at previous priority optimization)"
+            self.plot_timeseries(
+                label,
+                timeseries_data,
+                color="gray",
+                linestyle="dotted",
+            )
+
+    def plot_additional_variables(self):
+        """Plot the additional variables defined in the plot_table"""
+        for var in self.config.variables_style_1:
+            self.plot_with_comparison(var, var)
+        for var in self.config.variables_style_2:
+            self.plot_with_comparison(var, var, linestyle="solid", linewidth="0.5")
+        for var in self.config.variables_with_previous_result:
+            self.plot_with_previous(var, var)
+
+    def plot(self):
+        """Plot the data in the subplot and format."""
+        if self.config.specified_in == "goal_generator" and self.goal:
+            self.plot_with_previous(self.goal["state"], self.goal["state"])
+        self.plot_additional_variables()
+        if (
+            self.config.specified_in == "goal_generator"
+            and self.goal
+            and self.goal["goal_type"]
+            in [
+                "range",
+                "range_rate_of_change",
+            ]
+        ):
+            self.add_ranges()
+        self.format_subplot()
+
+    def add_ranges(self):
+        """Add lines for the lower and upper target."""
+        if np.array_equal(self.target_min, self.target_max, equal_nan=True):
+            self.plot_dashed_line(self.datetimes, self.target_min, "Target", "r")
+        else:
+            if not (isinstance(self.target_max, float) or np.isnan(self.target_max).any()):
+                self.plot_dashed_line(self.datetimes, self.target_max, "Target max", "r")
+            if not (isinstance(self.target_min, float) or np.isnan(self.target_min).any()):
+                self.plot_dashed_line(self.datetimes, self.target_min, "Target min", "r")
+
+    def plot_timeseries(self, label, timeseries_data, color=None, linewidth=None, linestyle=None):
+        """Plot a timeseries with the given style.
+        If subplot is of rate_of_change type, the difference series will be plotted."""
+        if self.rate_of_change:
+            label = "Rate of Change of " + label
+            series_to_plot = self.get_differences(timeseries_data)
+        else:
+            series_to_plot = timeseries_data
+
+        self.plot_line(self.datetimes, series_to_plot, label, color, linewidth, linestyle)
+
+    @abstractmethod
+    def plot_line(self, xarray, yarray, label, color=None, linewidth=None, linestyle=None):
+        """Given the input and output array, add a line plot to the subplot."""
+
+    @abstractmethod
+    def plot_dashed_line(self, xarray, yarray, label, color):
+        """Given the input and output array, add dashed line plot to the subplot."""
+
+    @abstractmethod
+    def format_subplot(self):
+        """Format the current subplot."""
+
+
+class SubplotMatplotlib(SubplotBase):
+    """Class for creating subplots using matplotlib. Expects an axis object
+    which refers to that subplot."""
+
+    def __init__(
+        self,
+        axis,
+        subplot_config: PlotTableRow,
+        goal: Optional[GoalConfig],
+        results: Dict[str, Any],
+        results_prev: Optional[IntermediateResult],
+        prio_independent_data: PrioIndependentData,
+        used_colors,
+    ):
+        super().__init__(subplot_config, goal, results, results_prev, prio_independent_data, used_colors)
+        self.axis = axis
+
+    def plot_dashed_line(self, xarray, yarray, label, color="red"):
+        """Given the input and output array, add dashed line plot to the subplot."""
+        self.axis.plot(xarray, yarray, "--", label=label, color=color)
+
+    def plot_line(self, xarray, yarray, label, color=None, linewidth=None, linestyle=None):
+        self.axis.plot(xarray, yarray, label=label, color=color, linewidth=linewidth, linestyle=linestyle)
+
+    def format_subplot(self):
+        """Format the current axis and set legend and title."""
+        # Format y-axis
+        self.axis.set_ylabel(self.config.y_axis_title)
+        self.axis.legend()
+        # Set title
+        self.axis.set_title(self.subplot_title)
+        # Format x-axis
+        data_format_str = "%d%b%H"
+        date_format = mdates.DateFormatter(data_format_str)
+        self.axis.xaxis.set_major_formatter(date_format)
+        self.axis.set_xlabel("Time")
+        # Format y-axis for rate-of-change-goals
+        if self.rate_of_change:
+            self.axis.yaxis.set_major_formatter(mtick.PercentFormatter())
+        # Add grid lines
+        self.axis.grid(which="both", axis="x")
+
+
+class SubplotPlotly(SubplotBase):
+    # As this class is still work in progress...
+    """Class for creating subplots using plotly. Expects to be part of
+    a figure object with subplots."""
+
+    def __init__(
+        self,
+        subplot_config: PlotTableRow,
+        goal: Optional[GoalConfig],
+        results: Dict[str, Any],
+        results_prev: Optional[IntermediateResult],
+        prio_independent_data: PrioIndependentData,
+        used_colors,
+        results_compare: Optional[IntermediateResult] = None,
+        figure=None,
+        row_num=0,
+        col_num=0,
+        i_plot=None,
+    ):
+        super().__init__(
+            subplot_config, goal, results, results_prev, prio_independent_data, used_colors, results_compare
+        )
+        self.row_num = row_num
+        self.col_num = col_num
+        self.use_plotly = True
+        self.figure = figure
+        self.i_plot = i_plot
+
+    def map_color_code(self, color):
+        """Map a color code to a plotly supported color code."""
+        color_mapping = {"r": "red"}
+        return color_mapping.get(color, color)
+
+    def plot_dashed_line(self, xarray, yarray, label, color="red"):
+        """Given the input and output array, add dashed line plot to the subplot."""
+        self.figure.add_trace(
+            go.Scatter(
+                legendgroup=self.i_plot,
+                x=xarray,
+                y=yarray,
+                name=label,
+                line={"color": self.map_color_code(color), "dash": "dot"},
+            ),
+            row=self.row_num,
+            col=self.col_num,
+        )
+
+    def plot_line(self, xarray, yarray, label, color=None, linewidth=None, linestyle=None):
+        linewidth = float(linewidth) * 1.3 if linewidth else linewidth
+        linestyle = "dot" if linestyle == "dotted" else linestyle
+        self.figure.add_trace(
+            go.Scatter(
+                legendgroup=self.i_plot,
+                legendgrouptitle_text=self.subplot_title,
+                x=xarray,
+                y=yarray,
+                name=label,
+                line={"width": linewidth, "dash": linestyle, "color": color},
+            ),
+            row=self.row_num,
+            col=self.col_num,
+        )
+
+    def format_subplot(self):
+        """Format the current axis and set legend and title."""
+        # Format y-axis
+        self.figure.update_yaxes(title_text=self.config.y_axis_title, row=self.row_num, col=self.col_num)
+        # Set title
+        self.figure.layout.annotations[self.i_plot]["text"] = self.subplot_title
+        # Format x-axis
+        data_format_str = "%d%b%H"
+        self.figure.update_xaxes(tickformat=data_format_str, row=self.row_num, col=self.col_num)
+        # Format y-axis for rate-of-change-goals
+        if self.rate_of_change:
+            self.figure.update_yaxes(tickformat=".1", row=self.row_num, col=self.col_num)
+        # Add grid lines
+        self.figure.update_xaxes(showgrid=True, row=self.row_num, col=self.col_num, gridwidth=1, gridcolor="gray")
+        self.figure.update_xaxes(showticklabels=True, row=self.row_num, col=self.col_num)

rtc-tools-interface-0.7.1/rtctools_interface/simulation/base_simulation_problem.py

@@ -0,0 +1,31 @@
+"""Module for a basic simulation problem."""
+from rtctools.simulation.csv_mixin import CSVMixin
+from rtctools.simulation.simulation_problem import SimulationProblem
+
+
+class BaseSimulationProblem(
+    CSVMixin,
+    SimulationProblem,
+):
+    # Ignore too many ancestors, since the use of mixin classes is how rtc-tools is set up.
+    # pylint: disable=too-many-ancestors
+    """
+    Basic simulation problem for a given state.
+
+    :cvar goal_table_file:
+        path to csv file containing a list of goals.
+    """
+
+    def __init__(
+        self,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+    def update(self, dt):
+        self.set_var("u", 1)
+        super().update(dt)
+
+    def initialize(self):
+        self.set_var("u", 1)
+        super().initialize()

rtc-tools-interface-0.7.1/rtctools_interface/simulation/plot_mixin.py

@@ -0,0 +1,27 @@
+"""Mixin to store all required data for plotting. Can also call the plot function."""
+import logging
+
+from rtctools_interface.plotting.plot_tools import create_plot_final_results
+from rtctools_interface.utils.results_collection import PlottingBaseMixin
+
+logger = logging.getLogger("rtctools")
+
+
+class PlotMixin(PlottingBaseMixin):
+    """
+    Class for plotting results based on the plot_table.
+    """
+
+    optimization_problem = False
+
+    def post(self):
+        """Tasks after optimizing."""
+        super().post()
+
+        timeseries_data = self.collect_timeseries_data(self.custom_variables)
+        self.intermediate_results.append({"timeseries_data": timeseries_data, "priority": 0})
+        current_run = self.create_plot_data_and_config([])
+        self._store_current_results(self._cache_folder, current_run)
+
+        if self.plot_final_results:
+            create_plot_final_results(current_run, self._previous_run, plotting_library=self.plotting_library)