rtc-tools-interface 0.7.0b1__tar.gz → 0.7.0b3__tar.gz

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

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

{rtc-tools-interface-0.7.0b1 → rtc-tools-interface-0.7.0b3}/README.md

@@ -110,28 +110,32 @@ The calculated metrics are:
 
 
 ## Automatic plotting of results
-With the `PlotGoalsMixin` one can easily make plots of the results of rtc-tools. To utilize this functionality, import the mixin as follows:
+With the `PlotMixin` one can easily make plots of the results of rtc-tools. This functionality can be used both for optimization and simulation problems. For optimization problems, use:
 ```python
-from rtctools_interface.optimization.plot_goals_mixin import PlotGoalsMixin
+from rtctools_interface.optimization.plot_mixin import PlotMixin
 ```
-Then, add the `PlotGoalsMixin` to your optimization problem class. The PlotGoalsMixin can create a plot after each priority and/or a plot with the final results only.
-By default, the `PlotGoalsMixin` will make both. This can be changed by setting the class variables `plot_results_each_priority` and `plot_final_results` to either `True` or `False` in your problem class.
+and for simulation problems use:
+```python
+from rtctools_interface.simulation.plot_mixin import PlotMixin
+```
+Then, add the `PlotMixin` to your optimization/simulation problem class. For optimization problems, the PlotMixin can create a plot after each priority and/or a plot with the final results only.
+By default, the `PlotMixin` will make both. This can be changed by setting the class variables `plot_results_each_priority` and `plot_final_results` to either `True` or `False` in your problem class.
 
-Furthermore, the PlotGoalsMixin can either create `Plotly` plots and `matplotlib` plots. The `matplotlib` plots will be exported as `png`, the Plotly figures as `html`. By default, `Plotly` is used. To change this, pass the keyword-argument `plotting_library="matplotlib"` to the `run_optimization_problem` function.
+Furthermore, the PlotMixin can either create `Plotly` plots and `matplotlib` plots. The `matplotlib` plots will be exported as `png`, the Plotly figures as `html`. By default, `Plotly` is used. To change this, pass the keyword-argument `plotting_library="matplotlib"` to the `run_optimization_problem` function.
 
 ### Comparing results from different runs
--  The plots for a particular priority will contain line segments with the results from the previous priority result. This makes it easy to see what changed from priority to priority.
-- The `final_results` plot will show the result from the **previous optimization run**. This allows for comparing results from different scenario's (like input timeseries or differently parametrized goals). Note that is not possible to change the number of goals between two comparison runs. This feature currently only works with Plotly plots, where a dropdown is available to hide the previous results.
+- In optimization mode, the plots for a particular priority will contain line segments with the results from the previous priority result. This makes it easy to see what changed from priority to priority.
+- The `final_results` plot will show the result from the **previous run**. This allows for comparing results from different scenario's (like input timeseries or changes to the model). Note that is not possible to change the number of goals between two comparison runs. This feature currently only works with Plotly plots, where a dropdown is available to hide the previous results.
 ### Configuration variables
-The following class variables can be set to change the behaviour of the PlotGoalsMixin:
+The following class variables can be set to change the behaviour of the PlotMixin:
 - `plot_max_rows`: an integer number for the maximum number of rows (default is 4). The number of columns will be derived from that.
-- `plot_results_each_priority`: boolean indicating whether the plots for each priority should be generated and saved. Default is True.
+- `plot_results_each_priority`: Only for optimization: boolean indicating whether the plots for each priority should be generated and saved. Default is True.
 - `plot_table_file`: path to plot table csv file. Default is `input\plot_table.csv`.
 
 ### Specifying the plot table
-There are two types of plots that can be made with the PlotGoalsMixin
-1. Plots based on goals in the goal_generator table
-2. Plots of arbitrary states, for example ones being optimized in a goal defined in Python.
+There are two types of plots that can be made with the PlotMixin
+1. Plots of arbitrary states, for example ones being optimized in a goal defined in Python.
+2. Plots based on goals in the goal_generator table (only applicable to optimization problems).
 
 To add a plot for a goal in the `goal_generator` table, one should add a row to the `plot_table` with an `id` equal to the id of the goal in the `goal_generator` to be plotted. The `specified_in` field should be set to `goal_generator`. Rows of the `plot_table` with `specified_in`=`goal_generator` but with an `id` that does not occcur in the `goal_table`, are ignored.  
 

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

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

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

@@ -17,21 +17,25 @@ rtctools_interface/optimization/goal_generator_mixin.py
 rtctools_interface/optimization/goal_performance_metrics.py
 rtctools_interface/optimization/goal_table_schema.py
 rtctools_interface/optimization/plot_goals_mixin.py
-rtctools_interface/optimization/plot_table_schema.py
+rtctools_interface/optimization/plot_mixin.py
 rtctools_interface/optimization/read_goals.py
-rtctools_interface/optimization/read_plot_table.py
-rtctools_interface/optimization/type_definitions.py
 rtctools_interface/optimization/helpers/__init__.py
-rtctools_interface/optimization/helpers/serialization.py
 rtctools_interface/optimization/helpers/statistics_mixin.py
-rtctools_interface/optimization/plotting/__init__.py
-rtctools_interface/optimization/plotting/plot_tools.py
-rtctools_interface/optimization/plotting/subplot_classes.py
 rtctools_interface/utils/__init__.py
+rtctools_interface/utils/plot_table_schema.py
+rtctools_interface/utils/read_goals_mixin.py
+rtctools_interface/utils/read_plot_table.py
+rtctools_interface/utils/results_collection.py
+rtctools_interface/utils/serialization.py
+rtctools_interface/utils/type_definitions.py
 tests/__init__.py
 tests/optimization/__init__.py
-tests/optimization/get_test.py
 tests/optimization/test_base_optimization_problem.py
 tests/optimization/test_passing_goals_directly.py
 tests/optimization/test_plot_goals_mixin.py
-tests/optimization/test_read_goals.py
+tests/optimization/test_read_goals.py
+tests/simulation/__init__.py
+tests/simulation/test_base_simulation_problem.py
+tests/simulation/test_plot_mixin.py
+tests/utils/__init__.py
+tests/utils/get_test.py

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

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-11-21T10:57:38+0000",
+ "date": "2023-11-28T16:07:57+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "b8f48b0eb7ffe88f3bf8c0fd75781d0f9661f6e1",
- "version": "0.7.0b1"
+ "full-revisionid": "499d6e416027fec2a9b6dd1cc4d7249b30a41463",
+ "version": "0.7.0b3"
 }
 '''  # END VERSION_JSON
 

{rtc-tools-interface-0.7.0b1 → rtc-tools-interface-0.7.0b3}/rtctools_interface/optimization/base_goal.py

@@ -8,7 +8,7 @@ from rtctools.optimization.optimization_problem import OptimizationProblem
 from rtctools.optimization.timeseries import Timeseries
 
 from rtctools_interface.optimization.goal_table_schema import GOAL_TYPES, TARGET_DATA_TYPES
-from rtctools_interface.optimization.type_definitions import GoalConfig
+from rtctools_interface.utils.type_definitions import GoalConfig
 
 
 logger = logging.getLogger("rtctools")

{rtc-tools-interface-0.7.0b1 → rtc-tools-interface-0.7.0b3}/rtctools_interface/optimization/goal_generator_mixin.py

@@ -2,13 +2,12 @@
 from pathlib import Path
 from typing import Dict, Union
 import logging
-import os
 import pandas as pd
 
 from rtctools_interface.optimization.base_goal import BaseGoal
 from rtctools_interface.optimization.goal_performance_metrics import get_performance_metrics
 from rtctools_interface.optimization.helpers.statistics_mixin import StatisticsMixin
-from rtctools_interface.optimization.read_goals import read_goals
+from rtctools_interface.utils.read_goals_mixin import ReadGoalsMixin
 
 logger = logging.getLogger("rtctools")
 
@@ -21,7 +20,7 @@ def write_performance_metrics(performance_metrics: Dict[str, pd.DataFrame], outp
         performance_metric_table.to_csv(output_path / f"{goal_id}.csv")
 
 
-class GoalGeneratorMixin(StatisticsMixin):
+class GoalGeneratorMixin(ReadGoalsMixin, StatisticsMixin):
     # TODO: remove pylint disable below once we have more public functions.
     # pylint: disable=too-few-public-methods
     """Add path goals as specified in the goal_table.
@@ -34,19 +33,10 @@ class GoalGeneratorMixin(StatisticsMixin):
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.goals_to_generate = kwargs.get("goals_to_generate", [])
-        self.read_from = kwargs.get("read_goals_from", "csv_table")
-        if not hasattr(self, "goal_table_file"):
-            self.goal_table_file = os.path.join(self._input_folder, "goal_table.csv")
-
-        self._goal_generator_path_goals = read_goals(
-            self.goal_table_file, path_goal=True, read_from=self.read_from, goals_to_generate=self.goals_to_generate
-        )
-        self._goal_generator_non_path_goals = read_goals(
-            self.goal_table_file, path_goal=False, read_from=self.read_from, goals_to_generate=self.goals_to_generate
-        )
-        self._all_goal_generator_goals = self._goal_generator_path_goals + self._goal_generator_non_path_goals
-
+        if not hasattr(self, "_all_goal_generator_goals"):
+            goals_to_generate = kwargs.get("goals_to_generate", [])
+            read_from = kwargs.get("read_goals_from", "csv_table")
+            self.load_goals(read_from, goals_to_generate)
         if self.calculate_performance_metrics:
             # A dataframe for each goal defined by the goal generator
             self._performance_metrics = {}

{rtc-tools-interface-0.7.0b1 → rtc-tools-interface-0.7.0b3}/rtctools_interface/optimization/goal_performance_metrics.py

@@ -12,7 +12,7 @@ from rtctools_interface.optimization.goal_table_schema import (
     RangeGoalModel,
     RangeRateOfChangeGoalModel,
 )
-from rtctools_interface.optimization.type_definitions import TargetDict
+from rtctools_interface.utils.type_definitions import TargetDict
 
 
 logger = logging.getLogger("rtctools")

{rtc-tools-interface-0.7.0b1 → rtc-tools-interface-0.7.0b3}/rtctools_interface/optimization/helpers/statistics_mixin.py

@@ -5,7 +5,7 @@ from typing import Dict, List, Tuple
 
 import numpy as np
 from rtctools_interface.optimization.base_goal import BaseGoal
-from rtctools_interface.optimization.type_definitions import TargetDict
+from rtctools_interface.utils.type_definitions import TargetDict
 
 logger = logging.getLogger("rtctools")
 

rtc-tools-interface-0.7.0b3/rtctools_interface/optimization/plot_goals_mixin.py

@@ -0,0 +1,14 @@
+"""Deprecated, use PlotMixin."""
+import warnings
+
+from rtctools_interface.optimization.plot_mixin import PlotMixin
+
+
+class PlotGoalsMixin(PlotMixin):
+    """
+    Deprecated class, use PlotMixin instead.
+    """
+
+    def __init__(self, *args, **kwargs):
+        warnings.warn("PlotGoalsMixin is deprecated, use PlotMixin instead", FutureWarning, stacklevel=1)
+        super().__init__(*args, **kwargs)

rtc-tools-interface-0.7.0b3/rtctools_interface/optimization/plot_mixin.py

@@ -0,0 +1,46 @@
+"""Mixin to store all required data for plotting. Can also call the plot function."""
+import logging
+
+from rtctools_interface.optimization.helpers.statistics_mixin import StatisticsMixin
+from rtctools_interface.plotting.plot_tools import create_plot_each_priority, create_plot_final_results
+from rtctools_interface.optimization.base_goal import BaseGoal
+from rtctools_interface.utils.results_collection import PlottingBaseMixin
+
+logger = logging.getLogger("rtctools")
+
+
+class PlotMixin(PlottingBaseMixin, StatisticsMixin):
+    """
+    Class for plotting results.
+    """
+
+    optimization_problem = True
+
+    def priority_completed(self, priority: int) -> None:
+        """Store priority-dependent results required for plotting."""
+        timeseries_data = self.collect_timeseries_data(list(set(self.custom_variables + self.state_variables)))
+        to_store = {"timeseries_data": timeseries_data, "priority": priority}
+        self.intermediate_results.append(to_store)
+        super().priority_completed(priority)
+
+    def post(self):
+        """Tasks after optimizing. Creates a plot for for each priority."""
+        super().post()
+
+        if self.solver_stats["success"]:
+            base_goals = [
+                goal.get_goal_config() for goal in self.goals() + self.path_goals() if isinstance(goal, BaseGoal)
+            ]
+            current_run = self.create_plot_data_and_config(base_goals)
+            # Cache results, such that in a next run they can be used for comparison
+            self._store_current_results(self._cache_folder, current_run)
+
+            # Create the plots
+            plot_data = {}
+            if self.plot_results_each_priority:
+                plot_data = plot_data | create_plot_each_priority(current_run, plotting_library=self.plotting_library)
+
+            if self.plot_final_results:
+                plot_data = plot_data | create_plot_final_results(
+                    current_run, self._previous_run, plotting_library=self.plotting_library
+                )

rtc-tools-interface-0.7.0b3/rtctools_interface/utils/read_goals_mixin.py

@@ -0,0 +1,31 @@
+"""Mixin to read the goal table and store as class variables."""
+import os
+from typing import Literal, Optional
+
+from rtctools_interface.optimization.read_goals import read_goals
+
+
+class ReadGoalsMixin:
+    """Read the goal table either from the default or specified path."""
+
+    def load_goals(
+        self, read_from: Literal["csv_table", "passed_list"] = "csv_table", goals_to_generate: Optional[list] = None
+    ):
+        """Read goal table and store as instance variable."""
+        goals_to_generate = goals_to_generate if goals_to_generate else []
+        if not hasattr(self, "goal_table_file"):
+            self.goal_table_file = os.path.join(self._input_folder, "goal_table.csv")
+
+        if read_from == "csv_table" and os.path.isfile(self.goal_table_file) or read_from == "passed_list":
+            self._goal_generator_path_goals = read_goals(
+                self.goal_table_file, path_goal=True, read_from=read_from, goals_to_generate=goals_to_generate
+            )
+            self._goal_generator_non_path_goals = read_goals(
+                self.goal_table_file,
+                path_goal=False,
+                read_from=read_from,
+                goals_to_generate=goals_to_generate,
+            )
+            self._all_goal_generator_goals = self._goal_generator_path_goals + self._goal_generator_non_path_goals
+        else:
+            self._all_goal_generator_goals = []

{rtc-tools-interface-0.7.0b1/rtctools_interface/optimization → rtc-tools-interface-0.7.0b3/rtctools_interface/utils}/read_plot_table.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from typing import List, Union
 import pandas as pd
 
-from rtctools_interface.optimization.plot_table_schema import PlotTableRow
+from rtctools_interface.utils.plot_table_schema import PlotTableRow
 
 logger = logging.getLogger("rtctools")
 
@@ -23,7 +23,7 @@ def read_plot_config_from_csv(plot_table_file: Union[Path, str]) -> List[PlotTab
         return parsed_rows
     message = (
         f"No plot table was found at the default location ({plot_table_file.resolve()})."
-        + " Please create one before using the PlotGoalsMixin."
+        + " Please create one before using the PlotMixin."
         + f" It should have the following columns: '{list(PlotTableRow.model_fields.keys())}'"
     )
     raise FileNotFoundError(message)
@@ -45,4 +45,4 @@ def get_plot_config(plot_table_file=None, plot_config_list=None, read_from="csv_
         return read_plot_config_from_csv(plot_table_file)
     if read_from == "passed_list":
         return read_plot_config_from_list(plot_config_list)
-    raise ValueError("PlotGoalsMixin should either read from 'csv_table' or 'passed_list'")
+    raise ValueError("PlotMixin should either read from 'csv_table' or 'passed_list'")

rtc-tools-interface-0.7.0b1/rtctools_interface/optimization/plot_goals_mixin.py → rtc-tools-interface-0.7.0b3/rtctools_interface/utils/results_collection.py

@@ -1,27 +1,28 @@
-"""Mixin to store all required data for plotting. Can also call the plot function."""
+"""Mixin to store all required data for plotting."""
 import logging
 import os
 import copy
 from pathlib import Path
 import time
-from typing import Optional
-
-from rtctools_interface.optimization.helpers.serialization import deserialize, serialize
-from rtctools_interface.optimization.helpers.statistics_mixin import StatisticsMixin
-from rtctools_interface.optimization.plotting.plot_tools import create_plot_each_priority, create_plot_final_results
-from rtctools_interface.optimization.read_plot_table import get_plot_config
-from rtctools_interface.optimization.base_goal import BaseGoal
-from rtctools_interface.optimization.type_definitions import (
+from typing import Dict, List, Optional
+
+import numpy as np
+from rtctools_interface.utils.plot_table_schema import PlotTableRow
+from rtctools_interface.utils.read_goals_mixin import ReadGoalsMixin
+
+from rtctools_interface.utils.serialization import deserialize, serialize
+from rtctools_interface.utils.read_plot_table import get_plot_config
+from rtctools_interface.utils.type_definitions import (
     PlotDataAndConfig,
     PlotOptions,
     PrioIndependentData,
 )
 
-logger = logging.getLogger("rtctools")
-
 MAX_NUM_CACHED_FILES = 5
 CONFIG_VERSION: float = 1.0
 
+logger = logging.getLogger("rtctools")
+
 
 def get_most_recent_cache(cache_folder):
     """Get the most recent pickle file, based on its name."""
@@ -73,10 +74,31 @@ def read_cache_file_from_folder(cache_folder: Path) -> Optional[PlotDataAndConfi
     return loaded_data
 
 
-class PlotGoalsMixin(StatisticsMixin):
-    """
-    Class for plotting results.
-    """
+def get_plot_variables(plot_config: list[PlotTableRow]) -> List[str]:
+    """Get list of variable-names that are in the plot table."""
+    variables_style_1 = [var for subplot_config in plot_config for var in subplot_config.variables_style_1]
+    variables_style_2 = [var for subplot_config in plot_config for var in subplot_config.variables_style_2]
+    variables_with_previous_result = [
+        var for subplot_config in plot_config for var in subplot_config.variables_with_previous_result
+    ]
+    return variables_style_1 + variables_style_2 + variables_with_previous_result
+
+
+def filter_plot_config(plot_config: list[PlotTableRow], all_goal_generator_goals) -> list[PlotTableRow]:
+    """ "Remove PlotTableRows corresponding to non-existing goals in the goal generator."""
+    goal_generator_goal_ids = [goal.goal_id for goal in all_goal_generator_goals]
+    new_plot_config = [
+        plot_table_row
+        for plot_table_row in plot_config
+        if plot_table_row.id in goal_generator_goal_ids or plot_table_row.specified_in == "python"
+    ]
+    return new_plot_config
+
+
+class PlottingBaseMixin(ReadGoalsMixin):
+    """Base class for creating plots.
+
+    Reads the plot table, if available the goal table, and contains functions to store all required data for plots."""
 
     plot_max_rows = 4
     plot_results_each_priority = True
@@ -94,29 +116,21 @@ class PlotGoalsMixin(StatisticsMixin):
         self.plotting_library = kwargs.get("plotting_library", "plotly")
         self.plot_config = get_plot_config(plot_table_file, plot_config_list, read_from)
 
-        # Store list of variable-names that may not be present in the results.
-        variables_style_1 = [var for subplot_config in self.plot_config for var in subplot_config.variables_style_1]
-        variables_style_2 = [var for subplot_config in self.plot_config for var in subplot_config.variables_style_2]
-        variables_with_previous_result = [
-            var for subplot_config in self.plot_config for var in subplot_config.variables_with_previous_result
-        ]
-        self.custom_variables = variables_style_1 + variables_style_2 + variables_with_previous_result
+        self.custom_variables = get_plot_variables(self.plot_config)
+
+        if not hasattr(self, "_all_goal_generator_goals") and self.optimization_problem:
+            goals_to_generate = kwargs.get("goals_to_generate", [])
+            read_from = kwargs.get("read_goals_from", "csv_table")
+            self.load_goals(read_from, goals_to_generate)
 
-        if hasattr(self, "_all_goal_generator_goals"):
+        if self.optimization_problem:
             all_goal_generator_goals = self._all_goal_generator_goals
             self.state_variables = list({base_goal.state for base_goal in all_goal_generator_goals})
         else:
             self.state_variables = []
             all_goal_generator_goals = []
 
-        # Remove PlotTableRows corresponding to a goal in the goal in the goal generator,
-        # but that goal is not specified in the goal table.
-        goal_generator_goal_ids = [goal.goal_id for goal in all_goal_generator_goals]
-        self.plot_config = [
-            plot_table_row
-            for plot_table_row in self.plot_config
-            if plot_table_row.id in goal_generator_goal_ids or plot_table_row.specified_in == "python"
-        ]
+        self.plot_config = filter_plot_config(self.plot_config, all_goal_generator_goals)
 
         self._cache_folder = Path(self._output_folder) / "cached_results"
         if "previous_run_plot_config" in kwargs:
@@ -129,64 +143,40 @@ class PlotGoalsMixin(StatisticsMixin):
         super().pre()
         self.intermediate_results = []
 
-    def priority_completed(self, priority: int) -> None:
-        """Store priority-dependent results required for plotting."""
+    def collect_timeseries_data(self, all_variables_to_store: List[str]) -> Dict[str, np.ndarray]:
+        """Collect the timeseries data for a list of variables."""
         extracted_results = copy.deepcopy(self.extract_results())
-        all_variables_to_store = set(self.custom_variables + self.state_variables)
-        timeseries_to_store = {}
+        timeseries_data = {}
         for timeseries_name in all_variables_to_store:
             try:
-                timeseries_to_store[timeseries_name] = extracted_results[timeseries_name]
+                timeseries_data[timeseries_name] = extracted_results[timeseries_name]
             except KeyError:
                 try:
-                    timeseries_to_store[timeseries_name] = self.get_timeseries(timeseries_name)
+                    timeseries_data[timeseries_name] = self.get_timeseries(timeseries_name)
                 except KeyError as exc:
                     raise KeyError("Cannot find timeseries for %s" % timeseries_name) from exc
-
-        to_store = {"timeseries_data": timeseries_to_store, "priority": priority}
-        self.intermediate_results.append(to_store)
-        super().priority_completed(priority)
-
-    def post(self):
-        """Tasks after optimizing. Creates a plot for for each priority."""
-        super().post()
-
-        if self.solver_stats["success"]:
-            prio_independent_data: PrioIndependentData = {
-                "io_datetimes": self.io.datetimes,
-                "times": self.times(),
-                "base_goals": [
-                    goal.get_goal_config() for goal in self.goals() + self.path_goals() if isinstance(goal, BaseGoal)
-                ],
-            }
-
-            plot_options: PlotOptions = {
-                "plot_config": self.plot_config,
-                "plot_max_rows": self.plot_max_rows,
-                "output_folder": self._output_folder,
-                "save_plot_to": self.save_plot_to,
-            }
-
-            current_run: PlotDataAndConfig = {
-                "intermediate_results": self.intermediate_results,
-                "plot_options": plot_options,
-                "prio_independent_data": prio_independent_data,
-                "config_version": CONFIG_VERSION,
-            }
-
-            self.plot_data = {}
-            if self.plot_results_each_priority:
-                self.plot_data = self.plot_data | create_plot_each_priority(
-                    current_run, plotting_library=self.plotting_library
-                )
-
-            if self.plot_final_results:
-                self.plot_data = self.plot_data | create_plot_final_results(
-                    current_run, self._previous_run, plotting_library=self.plotting_library
-                )
-
-            # Cache results, such that in a next run they can be used for comparison
-            self._store_current_results(self._cache_folder, current_run)
+        return timeseries_data
+
+    def create_plot_data_and_config(self, base_goals: list) -> PlotDataAndConfig:
+        """Create the PlotDataAndConfig dict."""
+        prio_independent_data: PrioIndependentData = {
+            "io_datetimes": self.io.datetimes,
+            "times": self.times(),
+            "base_goals": base_goals,
+        }
+        plot_options: PlotOptions = {
+            "plot_config": self.plot_config,
+            "plot_max_rows": self.plot_max_rows,
+            "output_folder": self._output_folder,
+            "save_plot_to": self.save_plot_to,
+        }
+        plot_data_and_config: PlotDataAndConfig = {
+            "intermediate_results": self.intermediate_results,
+            "plot_options": plot_options,
+            "prio_independent_data": prio_independent_data,
+            "config_version": CONFIG_VERSION,
+        }
+        return plot_data_and_config
 
     def _store_current_results(self, cache_folder, results_to_store):
         write_cache_file(cache_folder, results_to_store)

{rtc-tools-interface-0.7.0b1/rtctools_interface/optimization/helpers → rtc-tools-interface-0.7.0b3/rtctools_interface/utils}/serialization.py

@@ -6,7 +6,7 @@ from typing import Any
 
 import numpy as np
 import pandas as pd
-from rtctools_interface.optimization.plot_table_schema import PlotTableRow
+from rtctools_interface.utils.plot_table_schema import PlotTableRow
 
 
 def custom_encoder(obj):

{rtc-tools-interface-0.7.0b1/rtctools_interface/optimization → rtc-tools-interface-0.7.0b3/rtctools_interface/utils}/type_definitions.py

@@ -4,7 +4,7 @@ import pathlib
 from typing import Optional, Tuple, TypedDict, List, Dict, Literal
 
 import numpy as np
-from rtctools_interface.optimization.plot_table_schema import PlotTableRow
+from rtctools_interface.utils.plot_table_schema import PlotTableRow
 
 
 class TargetDict(TypedDict):

{rtc-tools-interface-0.7.0b1 → rtc-tools-interface-0.7.0b3}/tests/optimization/test_base_optimization_problem.py

@@ -2,15 +2,15 @@
 import unittest
 
 from rtctools_interface.optimization.base_optimization_problem import BaseOptimizationProblem
+from tests.utils.get_test import get_test_data
 
-from .get_test import get_test_data
 
 
 class TestBaseOptimizationProblem(unittest.TestCase):
     """Test for the base optimization problem class."""
     def run_test(self, test):
         """Solve an optimization problem."""
-        test_data = get_test_data(test)
+        test_data = get_test_data(test, optimization=True)
         problem = BaseOptimizationProblem(
             goal_table_file=test_data["goals_file"],
             model_folder=test_data["model_folder"],

{rtc-tools-interface-0.7.0b1 → rtc-tools-interface-0.7.0b3}/tests/optimization/test_passing_goals_directly.py

@@ -4,7 +4,7 @@ import unittest
 from rtctools_interface.optimization.base_optimization_problem import BaseOptimizationProblem
 from rtctools_interface.optimization.read_goals import read_goals_from_csv
 
-from .get_test import get_test_data
+from tests.utils.get_test import get_test_data
 
 
 class TestPassingGoalsDirectly(unittest.TestCase):
@@ -12,7 +12,7 @@ class TestPassingGoalsDirectly(unittest.TestCase):
 
     def run_test(self, test):
         """Solve an optimization problem."""
-        test_data = get_test_data(test)
+        test_data = get_test_data(test, optimization=True)
 
         goals_to_generate = read_goals_from_csv(test_data["goals_file"])
         problem = BaseOptimizationProblem(

{rtc-tools-interface-0.7.0b1 → rtc-tools-interface-0.7.0b3}/tests/optimization/test_plot_goals_mixin.py

@@ -4,12 +4,12 @@ import unittest
 from rtctools_interface.optimization.base_optimization_problem import (
     BaseOptimizationProblem,
 )
-from rtctools_interface.optimization.plot_goals_mixin import PlotGoalsMixin
+from rtctools_interface.optimization.plot_mixin import PlotMixin
 
-from .get_test import get_test_data
+from tests.utils.get_test import get_test_data
 
 
-class BaseOptimizationProblemPlotting(PlotGoalsMixin, BaseOptimizationProblem):
+class BaseOptimizationProblemPlotting(PlotMixin, BaseOptimizationProblem):
     # Ignore too many ancestors, since the use of mixin classes is how rtc-tools is set up.
     # pylint: disable=too-many-ancestors
     """Optimization problem with plotting functionalities."""
@@ -24,12 +24,12 @@ class BaseOptimizationProblemPlotting(PlotGoalsMixin, BaseOptimizationProblem):
         super().__init__(goal_table_file=goal_table_file, **kwargs)
 
 
-class TestPlotGoalsMixin(unittest.TestCase):
+class TestPlotMixin(unittest.TestCase):
     """Test for goal-plotting functionalities."""
 
     def run_test(self, test, plotting_library):
         """Solve an optimization problem."""
-        test_data = get_test_data(test)
+        test_data = get_test_data(test, optimization=True)
         problem = BaseOptimizationProblemPlotting(
             goal_table_file=test_data["goals_file"],
             plot_table_file=test_data["plot_table_file"],

rtc-tools-interface-0.7.0b3/tests/simulation/test_base_simulation_problem.py

@@ -0,0 +1,27 @@
+"""Tests for the base simulation problem class."""
+import unittest
+
+from rtctools_interface.simulation.base_simulation_problem import BaseSimulationProblem
+
+from tests.utils.get_test import get_test_data
+
+
+class TestBasSimulationProblem(unittest.TestCase):
+    """Test for the base simulation problem class."""
+
+    def run_test(self, test):
+        """Solve an simulation problem."""
+        test_data = get_test_data(test, optimization=False)
+        problem = BaseSimulationProblem(
+            model_folder=test_data["model_folder"],
+            model_name=test_data["model_name"],
+            input_folder=test_data["model_input_folder"],
+            output_folder=test_data["output_folder"],
+        )
+        problem.simulate()
+
+    # TODO: use pytest instead to parametrise tests.
+    def test_base_simulation_problem(self):
+        """Solve several simulation problems."""
+        for test in ["basic"]:
+            self.run_test(test)