rtc-tools-interface 0.6.0b2__tar.gz → 0.7.0__tar.gz

{rtc-tools-interface-0.6.0b2 → rtc-tools-interface-0.7.0}/PKG-INFO

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

{rtc-tools-interface-0.6.0b2 → rtc-tools-interface-0.7.0}/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.6.0b2 → rtc-tools-interface-0.7.0}/rtc_tools_interface.egg-info/PKG-INFO

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

{rtc-tools-interface-0.6.0b2 → rtc-tools-interface-0.7.0}/rtc_tools_interface.egg-info/SOURCES.txt

@@ -16,23 +16,32 @@ rtctools_interface/optimization/base_optimization_problem.py
 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_and_goal_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/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
+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.6.0b2 → rtc-tools-interface-0.7.0}/rtctools_interface/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-11-13T16:01:56+0100",
+ "date": "2023-12-19T14:41:26+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "3f4ef7c3896bbc5f0b95b5e15be2a69e56f9c03a",
- "version": "0.6.0b2"
+ "full-revisionid": "4873e97ef18dfc53c55550cf1c3d12f32aa6d368",
+ "version": "0.7.0"
 }
 '''  # END VERSION_JSON
 

{rtc-tools-interface-0.6.0b2 → rtc-tools-interface-0.7.0}/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")
@@ -48,6 +48,7 @@ class BaseGoal(Goal):
     ):
         self.goal_id = goal_id
         self.state = state
+        self.target_data_type = target_data_type
         self._set_goal_type(goal_type)
         if goal_type in ["range", "range_rate_of_change"]:
             self._set_function_bounds(
@@ -59,7 +60,6 @@ class BaseGoal(Goal):
         if goal_type in ["range", "range_rate_of_change"]:
             self._set_target_bounds(
                 optimization_problem=optimization_problem,
-                target_data_type=target_data_type,
                 target_min=target_min,
                 target_max=target_max,
             )
@@ -155,7 +155,6 @@ class BaseGoal(Goal):
     def _set_target_bounds(
         self,
         optimization_problem: OptimizationProblem,
-        target_data_type="value",
         target_min=np.nan,
         target_max=np.nan,
     ):
@@ -193,19 +192,21 @@ class BaseGoal(Goal):
             elif np.isnan(target_min):
                 self.target_min = np.nan
 
-        if target_data_type not in TARGET_DATA_TYPES:
+        if self.target_data_type not in TARGET_DATA_TYPES:
             raise ValueError(f"target_data_type should be one of {TARGET_DATA_TYPES}.")
 
-        if self.goal_type == "range_rate_of_change" and target_data_type != "value":
+        if self.goal_type == "range_rate_of_change" and self.target_data_type != "value":
             raise ValueError("For range_rate_of_change goal only the `value` target type is supported.")
 
-        if target_data_type == "value":
+        if self.target_data_type == "value":
             set_value_target()
-        elif target_data_type == "parameter":
+        elif self.target_data_type == "parameter":
             set_parameter_target()
-        elif target_data_type == "timeseries":
+        elif self.target_data_type == "timeseries":
             set_timeseries_target()
 
+        self._target_dict = optimization_problem.collect_range_target_values_from_basegoal(self)
+
     def get_goal_config(self) -> GoalConfig:
         """
         Serialize the goal configuration into a dictionary.
@@ -217,6 +218,8 @@ class BaseGoal(Goal):
             "function_min": self.function_range[0] if np.isfinite(self.function_range[0]) else None,
             "function_max": self.function_range[1] if np.isfinite(self.function_range[1]) else None,
             "function_nominal": self.function_nominal if np.isfinite(self.function_nominal) else None,
+            "target_min_series": None,
+            "target_max_series": None,
             "target_min": self.target_min,
             "target_max": self.target_max,
             "priority": self.priority,
@@ -227,4 +230,8 @@ class BaseGoal(Goal):
             goal_config["target_min"] = self.target_min.values
         if isinstance(self.target_max, Timeseries):
             goal_config["target_max"] = self.target_max.values
+
+        if hasattr(self, "_target_dict"):
+            goal_config["target_min_series"] = self._target_dict["target_min"]
+            goal_config["target_max_series"] = self._target_dict["target_max"]
         return goal_config

{rtc-tools-interface-0.6.0b2 → rtc-tools-interface-0.7.0}/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 = {}
@@ -73,7 +63,8 @@ class GoalGeneratorMixin(StatisticsMixin):
         """Calculate and store performance metrics."""
         results = self.extract_results()
         goal_generator_goals = self._all_goal_generator_goals
-        targets = self.collect_range_target_values(goal_generator_goals)
+        all_base_goals = [goal for goal in self.goals() + self.path_goals() if isinstance(goal, BaseGoal)]
+        targets = self.collect_range_target_values(all_base_goals)
         for goal in goal_generator_goals:
             next_row = get_performance_metrics(results, goal, targets.get(str(goal.goal_id)))
             if next_row is not None:

{rtc-tools-interface-0.6.0b2 → rtc-tools-interface-0.7.0}/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")
@@ -63,33 +63,37 @@ def performance_metrics_minmaximization(results: Dict[str, np.ndarray], goal: Mi
 
 def get_range_percentual_exceedance(
     timeseries: np.ndarray, goal: RangeGoalModel, targets: TargetDict
-) -> Optional[dict[str, float]]:
+) -> Optional[dict[str, Optional[float]]]:
     """Calculate percentage of timesteps in which target is exceeded"""
     if goal.goal_type not in ["range", "range_rate_of_change"]:
         below_target = None
         above_target = None
     else:
-        below_target = sum(np.where(timeseries + ABS_TOL < targets["target_min"], 1, 0)) / len(timeseries)
-        above_target = sum(np.where(timeseries - ABS_TOL > targets["target_max"], 1, 0)) / len(timeseries)
+        below_target = float(sum(np.where(timeseries + ABS_TOL < targets["target_min"], 1, 0)) / len(timeseries))
+        above_target = float(sum(np.where(timeseries - ABS_TOL > targets["target_max"], 1, 0)) / len(timeseries))
     return {"perc_below_target": below_target, "perc_above_target": above_target}
 
 
 def get_range_total_exceedance(
     timeseries: np.ndarray, goal: RangeGoalModel, targets: TargetDict
-) -> Optional[dict[str, float]]:
+) -> Optional[dict[str, Optional[float]]]:
     """Calculate sum of absolute exceedances of the target"""
     if goal.goal_type not in ["range", "range_rate_of_change"]:
         below_target = None
         above_target = None
     else:
-        below_target = sum(np.abs(np.where(timeseries < targets["target_min"], timeseries - targets["target_min"], 0)))
-        above_target = sum(np.abs(np.where(timeseries > targets["target_max"], timeseries - targets["target_max"], 0)))
+        below_target = float(
+            sum(np.abs(np.where(timeseries < targets["target_min"], timeseries - targets["target_min"], 0)))
+        )
+        above_target = float(
+            sum(np.abs(np.where(timeseries > targets["target_max"], timeseries - targets["target_max"], 0)))
+        )
     return {"sum_below_target": below_target, "sum_above_target": above_target}
 
 
 def performance_metrics_range(results: Dict[str, np.ndarray], goal: RangeGoalModel, targets: TargetDict) -> pd.Series:
     """Get all relevant statistics for a range goal."""
-    metrics = {}
+    metrics: dict = {}
     state_timeseries = results[goal.state]
     metrics = metrics | get_basic_metrics(state_timeseries)
     metrics = metrics | get_range_percentual_exceedance(state_timeseries, goal, targets)
@@ -101,7 +105,7 @@ def performance_metrics_rangerateofchange(
     results: Dict[str, np.ndarray], goal: RangeGoalModel, _targets: TargetDict
 ) -> pd.Series:
     """Get all relevant statistics for a range-rate-of-change goal."""
-    metrics = {}
+    metrics: dict[str, Optional[float]] = {}
     state_timeseries = results[goal.state]
     metrics = metrics | get_basic_metrics(state_timeseries)
     return pd.Series(metrics)

{rtc-tools-interface-0.6.0b2 → rtc-tools-interface-0.7.0}/rtctools_interface/optimization/goal_table_schema.py

@@ -103,7 +103,7 @@ PATH_GOALS = {
     "range": RangeGoalModel,
     "range_rate_of_change": RangeRateOfChangeGoalModel,
 }
-NON_PATH_GOALS = {}
+NON_PATH_GOALS: dict = {}
 GOAL_TYPES = PATH_GOALS | NON_PATH_GOALS
 TARGET_DATA_TYPES = [
     "value",

rtc-tools-interface-0.7.0/rtctools_interface/optimization/helpers/statistics_mixin.py

@@ -0,0 +1,68 @@
+"""Base class/mixin for with some methods for retrieving particular data/stats for goals and plotting. """
+
+import logging
+from typing import Dict, List, Tuple
+
+import numpy as np
+from rtctools_interface.optimization.base_goal import BaseGoal
+from rtctools_interface.utils.type_definitions import TargetDict
+
+logger = logging.getLogger("rtctools")
+
+
+class StatisticsMixin:
+    # TODO: remove pylint disable below once we have more public functions.
+    # pylint: disable=too-few-public-methods
+    """A mixin class providing methods for collecting data and statistics from optimization results,
+    useful for solution performance analysis."""
+
+    def collect_range_target_values(
+        self,
+        base_goals: List[BaseGoal],
+    ) -> Dict[str, TargetDict]:
+        """For the goals with targets, collect the actual timeseries with these targets."""
+        target_series: Dict[str, TargetDict] = {}
+        for goal in base_goals:
+            if goal.goal_type in ["range", "range_rate_of_change"]:
+                target_dict = self.collect_range_target_values_from_basegoal(goal)
+                target_series[str(goal.goal_id)] = target_dict
+        return target_series
+
+    def collect_range_target_values_from_basegoal(self, goal: BaseGoal) -> TargetDict:
+        """Collect the target timeseries for a single basegoal."""
+        t = self.times()
+
+        def get_parameter_ranges(goal) -> Tuple[np.ndarray, np.ndarray]:
+            target_min = np.full_like(t, 1) * float(goal.target_min)
+            target_max = np.full_like(t, 1) * float(goal.target_max)
+            return target_min, target_max
+
+        def get_value_ranges(goal) -> Tuple[np.ndarray, np.ndarray]:
+            target_min = np.full_like(t, 1) * float(goal.target_min)
+            target_max = np.full_like(t, 1) * float(goal.target_max)
+            return target_min, target_max
+
+        def get_timeseries_ranges(goal) -> Tuple[np.ndarray, np.ndarray]:
+            try:
+                target_min = goal.target_min.values
+            except AttributeError:
+                target_min = goal.target_min
+            try:
+                target_max = goal.target_max.values
+            except AttributeError:
+                target_max = goal.target_max
+            return target_min, target_max
+
+        if goal.goal_type in ["range", "range_rate_of_change"]:
+            if goal.target_data_type == "parameter":
+                target_min, target_max = get_parameter_ranges(goal)
+            elif goal.target_data_type == "value":
+                target_min, target_max = get_value_ranges(goal)
+            elif goal.target_data_type == "timeseries":
+                target_min, target_max = get_timeseries_ranges(goal)
+            else:
+                message = "Target type {} not known for goal {}.".format(goal.target_data_type, goal.goal_id)
+                logger.error(message)
+                raise ValueError(message)
+            target_dict: TargetDict = {"target_min": target_min, "target_max": target_max}
+        return target_dict

rtc-tools-interface-0.7.0/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.0/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.6.0b2 → rtc-tools-interface-0.7.0}/rtctools_interface/optimization/read_goals.py

@@ -54,8 +54,8 @@ def read_goals_from_list(
     """Read goals from a list. Validates whether the goals are of correct type."""
     if not isinstance(goals_to_generate, list):
         raise TypeError(f"Pass a list of goal elements, not a {type(goals_to_generate)}")
-    for plot_config in goals_to_generate:
-        if not isinstance(plot_config, BaseGoalModel):
+    for base_goal in goals_to_generate:
+        if not isinstance(base_goal, BaseGoalModel):
             raise TypeError("Each element in the list of goals to generate should be a child of BaseGoalModel")
     active_goals = []
     for goal in goals_to_generate:

{rtc-tools-interface-0.6.0b2/rtctools_interface/optimization → rtc-tools-interface-0.7.0/rtctools_interface}/plotting/plot_tools.py

@@ -10,13 +10,12 @@ import matplotlib
 import matplotlib.pyplot as plt
 from plotly.subplots import make_subplots
 
-from rtctools_interface.optimization.base_goal import BaseGoal
-from rtctools_interface.optimization.plotting.subplot_classes import (
+from rtctools_interface.plotting.subplot_classes import (
     COMPARISON_RUN_SUFFIX,
     SubplotMatplotlib,
     SubplotPlotly,
 )
-from rtctools_interface.optimization.type_definitions import IntermediateResult, PlotDataAndConfig
+from rtctools_interface.utils.type_definitions import GoalConfig, IntermediateResult, PlotDataAndConfig
 
 logger = logging.getLogger("rtctools")
 
@@ -71,9 +70,9 @@ def save_fig_as_html(fig, output_folder, priority, final_result) -> dict:
     return fig
 
 
-def get_goal(subplot_config, all_goals) -> Union[BaseGoal, None]:
+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 all_goals:
+    for goal in base_goals:
         if goal.get("goal_id") == subplot_config.id:
             return goal
     return None
@@ -145,7 +144,7 @@ def check_empty_plot_table(plot_config):
 def get_main_title(final_result: bool, result_dict):
     """Generate main title."""
     if final_result:
-        main_title = "Result after optimizing for all priorities"
+        main_title = "Final results"
     else:
         main_title = "Results after optimizing until priority {}".format(result_dict["priority"])
     return main_title
@@ -156,8 +155,8 @@ def create_matplotlib_figure(
 ) -> 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 = []
-    results = result_dict["extract_result"]
+    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):
@@ -171,12 +170,12 @@ def create_matplotlib_figure(
     fig.suptitle(main_title, fontsize=14)
     i_plot = -1
 
-    all_goals = current_run["prio_independent_data"]["all_goals"]
+    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, all_goals)
+        goal = get_goal(subplot_config, base_goals)
         subplot = SubplotMatplotlib(
             axis,
             subplot_config,
@@ -232,18 +231,18 @@ def create_plotly_figure(
     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)
-    all_goals = current_run["prio_independent_data"]["all_goals"]
+    base_goals = current_run["prio_independent_data"]["base_goals"]
 
     # Add subplot for each row in the plot_table
-    used_colors = []
+    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, all_goals)
+        goal = get_goal(subplot_config, base_goals)
         subplot = SubplotPlotly(
             subplot_config,
             goal,
-            result_dict["extract_result"],
+            result_dict["timeseries_data"],
             results_prev,
             current_run["prio_independent_data"],
             used_colors,