rtc-tools-interface 0.0.1b1__tar.gz → 0.0.1b2__tar.gz

{rtc-tools-interface-0.0.1b1 → rtc-tools-interface-0.0.1b2}/PKG-INFO

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

{rtc-tools-interface-0.0.1b1 → rtc-tools-interface-0.0.1b2}/rtc_tools_interface.egg-info/PKG-INFO

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

rtc-tools-interface-0.0.1b2/rtc_tools_interface.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+COPYING.LESSER
+README.md
+setup.cfg
+setup.py
+versioneer.py
+rtc_tools_interface.egg-info/PKG-INFO
+rtc_tools_interface.egg-info/SOURCES.txt
+rtc_tools_interface.egg-info/dependency_links.txt
+rtc_tools_interface.egg-info/requires.txt
+rtc_tools_interface.egg-info/top_level.txt
+rtctools_interface/__init__.py
+rtctools_interface/_version.py
+rtctools_interface/optimization/__init__.py
+rtctools_interface/optimization/base_goal.py
+rtctools_interface/optimization/base_optimization_problem.py
+rtctools_interface/optimization/goal_generator_mixin.py
+rtctools_interface/optimization/plot_goals_mixin.py
+rtctools_interface/optimization/read_goals.py
+rtctools_interface/optimization/read_plot_table.py
+tests/__init__.py
+tests/optimization/__init__.py
+tests/optimization/get_test.py
+tests/optimization/test_base_optimization_problem.py
+tests/optimization/test_plot_goals_mixin.py
+tests/optimization/test_read_goals.py

rtc-tools-interface-0.0.1b2/rtc_tools_interface.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+rtctools_interface
+tests

rtc-tools-interface-0.0.1b2/rtctools_interface/__init__.py

@@ -0,0 +1,3 @@
+
+from . import _version
+__version__ = _version.get_versions()['version']

{rtc-tools-interface-0.0.1b1 → rtc-tools-interface-0.0.1b2}/rtctools_interface/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-06-27T14:56:52+0200",
+ "date": "2023-06-27T15:41:22+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "befc5a66f72406ec1c1867462bd4001279a4f0da",
- "version": "0.0.1b1"
+ "full-revisionid": "7ddd0961853c2359d2f270f2afa1e2291843689b",
+ "version": "0.0.1b2"
 }
 '''  # END VERSION_JSON
 

rtc-tools-interface-0.0.1b2/rtctools_interface/optimization/base_goal.py

@@ -0,0 +1,126 @@
+"""Module for a basic Goal."""
+import logging
+import numpy as np
+
+from rtctools.optimization.goal_programming_mixin import Goal
+from rtctools.optimization.optimization_problem import OptimizationProblem
+
+logger = logging.getLogger("rtctools")
+
+GOAL_TYPES = [
+    "range",
+    "minimization",
+]
+
+TARGET_DATA_TYPES = [
+    "value",
+    "parameter",
+    "timeseries",
+]
+
+
+class BaseGoal(Goal):
+    """
+    Basic optimization goal for a given state.
+
+    :cvar goal_type:
+        Type of goal ('range' or 'minimization').
+    :cvar target_data_type:
+        Type of target data ('value', 'parameter', 'timeseries').
+        If 'value', set the target bounds by value.
+        If 'parameter', set the bounds by a parameter. The target_min
+        and/or target_max are expected to be the name of the parameter.
+        If 'timeseries', set the bounds by a timeseries. The target_min
+        and/or target_max are expected to be the name of the timeseries.
+    """
+
+    def __init__(
+        self,
+        optimization_problem: OptimizationProblem,
+        state,
+        goal_type="minimization",
+        function_min=np.nan,
+        function_max=np.nan,
+        function_nominal=np.nan,
+        target_data_type="value",
+        target_min=np.nan,
+        target_max=np.nan,
+        priority=1,
+        weight=1.0,
+        order=2,
+    ):
+        self.state = state
+        self.goal_type = None
+        self._set_goal_type(goal_type)
+        if goal_type == "range":
+            self._set_function_bounds(
+                optimization_problem=optimization_problem,
+                function_min=function_min,
+                function_max=function_max)
+        self._set_function_nominal(function_nominal)
+        if goal_type == "range":
+            self._set_target_bounds(
+                optimization_problem=optimization_problem,
+                target_data_type=target_data_type,
+                target_min=target_min,
+                target_max=target_max)
+        self.priority = priority if np.isfinite(priority) else 1
+        self.weight = weight if np.isfinite(weight) else 1.0
+        self.order = order if np.isfinite(order) else 2
+
+    def function(self, optimization_problem, ensemble_member):
+        del ensemble_member
+        return optimization_problem.state(self.state)
+
+    def _set_goal_type(
+        self,
+        goal_type,
+    ):
+        """Set the goal type."""
+        if goal_type in GOAL_TYPES:
+            self.goal_type = goal_type
+        else:
+            raise ValueError(f"goal_type should be one of {GOAL_TYPES}.")
+
+    def _set_function_bounds(
+        self,
+        optimization_problem: OptimizationProblem,
+        function_min=np.nan,
+        function_max=np.nan,
+    ):
+        """Set function bounds and nominal."""
+        self.function_range = [function_min, function_max]
+        if not np.isfinite(function_min):
+            self.function_range[0] = optimization_problem.bounds()[self.state][0]
+        if not np.isfinite(function_max):
+            self.function_range[1] = optimization_problem.bounds()[self.state][1]
+
+    def _set_function_nominal(self, function_nominal):
+        """Set function nominal"""
+        self.function_nominal = function_nominal
+        if not np.isfinite(self.function_nominal):
+            if np.all(np.isfinite(self.function_range)):
+                self.function_nominal = np.sum(self.function_range) / 2
+            else:
+                self.function_nominal = 1.0
+                logger.warning("Function nominal not specified, nominal is set to 1.0")
+
+    def _set_target_bounds(
+        self,
+        optimization_problem: OptimizationProblem,
+        target_data_type="value",
+        target_min=np.nan,
+        target_max=np.nan,
+    ):
+        """Set the target bounds."""
+        if target_data_type not in TARGET_DATA_TYPES:
+            raise ValueError(f"target_data_type should be one of {TARGET_DATA_TYPES}.")
+        if target_data_type == "value":
+            self.target_min = float(target_min)
+            self.target_max = float(target_max)
+        elif target_data_type == "parameter":
+            self.target_min = optimization_problem.parameters(0)[target_min]
+            self.target_max = optimization_problem.parameters(0)[target_max]
+        elif target_data_type == "timeseries":
+            self.target_min = optimization_problem.get_timeseries(target_min)
+            self.target_max = optimization_problem.get_timeseries(target_max)

rtc-tools-interface-0.0.1b2/rtctools_interface/optimization/base_optimization_problem.py

@@ -0,0 +1,32 @@
+"""Module for a basic optimization problem."""
+from rtctools.optimization.collocated_integrated_optimization_problem import (
+    CollocatedIntegratedOptimizationProblem,
+)
+from rtctools.optimization.csv_mixin import CSVMixin
+from rtctools.optimization.goal_programming_mixin import GoalProgrammingMixin
+from rtctools.optimization.modelica_mixin import ModelicaMixin
+
+from rtctools_interface.optimization.goal_generator_mixin import GoalGeneratorMixin
+
+
+class BaseOptimizationProblem(
+    GoalGeneratorMixin,
+    GoalProgrammingMixin,
+    CSVMixin,
+    ModelicaMixin,
+    CollocatedIntegratedOptimizationProblem,
+):
+    """
+    Basic optimization problem for a given state.
+
+    :cvar goal_table_file:
+        path to csv file containing a list of goals.
+    """
+
+    def __init__(
+        self,
+        goal_table_file,
+        **kwargs,
+    ):
+        self.goal_table_file = goal_table_file
+        super().__init__(**kwargs)

rtc-tools-interface-0.0.1b2/rtctools_interface/optimization/goal_generator_mixin.py

@@ -0,0 +1,32 @@
+import logging
+import os
+
+import pandas as pd
+
+from rtctools_interface.optimization.read_goals import read_goals
+from rtctools_interface.optimization.base_goal import BaseGoal
+
+logger = logging.getLogger("rtctools")
+
+
+class GoalGeneratorMixin:
+    """Add path goals as specified in the goal_table.
+
+    By default, the mixin looks for the csv in the in the default input
+    folder. One can also set the path to the goal_table_file manually
+    with the `goal_table_file` class variable.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        if not hasattr(self, "goal_table_file"):
+            self.goal_table_file = os.path.join(self._input_folder, "goal_table.csv")
+
+    def _goal_data_to_goal(self, goal_data: pd.Series):
+        """Convert a series with goal data to a BaseGoal."""
+        return BaseGoal(optimization_problem=self, **goal_data.to_dict())
+
+    def path_goals(self):
+        goal_df = read_goals(self.goal_table_file)
+        goals = goal_df.apply(self._goal_data_to_goal, axis=1)
+        return goals

rtc-tools-interface-0.0.1b2/rtctools_interface/optimization/plot_goals_mixin.py

@@ -0,0 +1,156 @@
+import logging
+import math
+import os
+
+import matplotlib.dates as mdates
+import matplotlib.pyplot as plt
+
+import numpy as np
+
+from rtctools_interface.optimization.read_plot_table import read_plot_table
+
+logger = logging.getLogger("rtctools")
+
+
+class PlotGoalsMixin:
+    plot_max_rows = 4
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        try:
+            plot_table_file = self.plot_table_file
+        except AttributeError:
+            plot_table_file = os.path.join(self._input_folder, "plot_table.csv")
+        self.plot_table = read_plot_table(plot_table_file, self.goal_table_file)
+
+    def pre(self):
+        super().pre()
+        self.intermediate_results = []
+
+    def plot_goal_results_from_dict(self, result_dict, results_dict_prev=None):
+        self.plot_goals_results(result_dict, results_dict_prev)
+
+    def plot_goal_results_from_self(self, priority=None):
+        result_dict = {
+            "extract_result": self.extract_results(),
+            "priority": priority,
+        }
+        self.plot_goals_results(result_dict)
+
+    def plot_goals_results(self, result_dict, results_dict_prev=None):
+        timeseries_import_times = self.io.datetimes
+        extract_result = result_dict["extract_result"]
+        all_goals = self.plot_table.to_dict("records")
+        range_goals = [goal for goal in all_goals if goal["goal_type"] == "range"]
+        min_q_goals = [goal for goal in all_goals if goal["goal_type"] == "minimization"]
+        priority = result_dict["priority"]
+
+        t = self.times()
+        t_datetime = np.array(timeseries_import_times)
+        results = extract_result
+
+        # Prepare the plot
+        n_plots = len(range_goals + min_q_goals)
+        n_cols = math.ceil(n_plots / self.plot_max_rows)
+        n_rows = math.ceil(n_plots / n_cols)
+        fig, axs = plt.subplots(nrows=n_rows, ncols=n_cols, figsize=(n_cols * 9, n_rows * 3), dpi=80, squeeze=False)
+        fig.suptitle("Results after optimizing until priority {}".format(priority), fontsize=14)
+        i_plot = -1
+
+        # Function to apply the general settings used by all goal types
+        def apply_general_settings():
+            """Add line with the results for a particular goal. If previous results
+            are available, a line with the timeseries for those results is also plotted.
+
+            Note that this function does also determine the current row and column index
+            """
+            i_c = math.ceil((i_plot + 1) / n_rows) - 1
+            i_r = i_plot - i_c * n_rows
+
+            goal_variable = g["state"]
+            axs[i_r, i_c].plot(t_datetime, results[goal_variable], label=goal_variable)
+
+            if results_dict_prev:
+                results_prev = results_dict_prev["extract_result"]
+                axs[i_r, i_c].plot(
+                    t_datetime,
+                    results_prev[goal_variable],
+                    label=goal_variable + " at previous priority optimization",
+                    color="gray",
+                    linestyle="dotted",
+                )
+            return i_c, i_r
+
+        def apply_additional_settings(goal_settings):
+            """Sets some additional settings, like additional variables to plot.
+            The second list of variables has a specific style, the first not.
+            """
+
+            for var in goal_settings["variables_plot_1"]:
+                axs[i_row, i_col].plot(t_datetime, results[var], label=var)
+            for var in goal_settings["variables_plot_2"]:
+                axs[i_row, i_col].plot(t_datetime, results[var], linestyle="solid", linewidth="0.5", label=var)
+            axs[i_row, i_col].set_ylabel(goal_settings["y_axis_title"])
+            axs[i_row, i_col].legend()
+            axs[i_row, i_col].set_title(
+                "Goal for {} (active from priority {})".format(goal_settings["state"], goal_settings["priority"])
+            )
+            dateFormat = mdates.DateFormatter("%d%b%H")
+            axs[i_row, i_col].xaxis.set_major_formatter(dateFormat)
+            axs[i_row, i_col].grid(which="both", axis="x")
+
+        # Add plots needed for range goals
+        for g in sorted(range_goals, key=lambda goal: goal["priority"]):
+            i_plot += 1
+
+            i_col, i_row = apply_general_settings()
+
+            if g["target_data_type"] == "parameter":
+                target_min = np.full_like(t, 1) * self.parameters(0)[g["target_min"]]
+                target_max = np.full_like(t, 1) * self.parameters(0)[g["target_max"]]
+            elif g["target_data_type"] == "value":
+                target_min = np.full_like(t, 1) * g["target_min"]
+                target_max = np.full_like(t, 1) * g["target_max"]
+            elif g["target_data_type"] == "timeseries":
+                target_min = self.get_timeseries(g["target_min"]).values
+                target_max = self.get_timeseries(g["target_max"]).values
+            else:
+                message = "Target type {} not known.".format(g["target_data_type"])
+                logger.error(message)
+                raise ValueError(message)
+
+            if np.array_equal(target_min, target_max, equal_nan=True):
+                axs[i_row, i_col].plot(t_datetime, target_min, "r--", label="Target")
+            else:
+                axs[i_row, i_col].plot(t_datetime, target_min, "r--", label="Target min")
+                axs[i_row, i_col].plot(t_datetime, target_max, "r--", label="Target max")
+
+            apply_additional_settings(g)
+
+        # Add plots needed for minimization of discharge
+        for g in min_q_goals:
+            i_plot += 1
+            i_col, i_row = apply_general_settings()
+            apply_additional_settings(g)
+
+        # TODO: this should be expanded when there are more columns
+        for i in range(0, n_cols):
+            axs[n_rows - 1, i].set_xlabel("Time")
+        os.makedirs("goal_figures", exist_ok=True)
+        fig.tight_layout()
+        new_output_folder = os.path.join(self._output_folder, "goal_figures")
+        os.makedirs(new_output_folder, exist_ok=True)
+        fig.savefig(os.path.join(new_output_folder, "after_priority_{}.png".format(priority)))
+
+    def priority_completed(self, priority: int) -> None:
+        # Store results required for plotting
+        to_store = {"extract_result": self.extract_results(), "priority": priority}
+        self.intermediate_results.append(to_store)
+        super().priority_completed(priority)
+
+    def post(self):
+        super().post()
+        for intermediate_result_prev, intermediate_result in zip(
+            [None] + self.intermediate_results[:-1], self.intermediate_results
+        ):
+            self.plot_goal_results_from_dict(intermediate_result, intermediate_result_prev)

rtc-tools-interface-0.0.1b2/rtctools_interface/optimization/read_goals.py

@@ -0,0 +1,25 @@
+"""Module for reading goals from a csv file."""
+import pandas as pd
+
+
+GOAL_PARAMETERS = [
+    'state',
+    'goal_type',
+    'function_min',
+    'function_max',
+    'function_nominal',
+    'target_data_type',
+    'target_min',
+    'target_max',
+    'priority',
+    'weight',
+    'order',
+]
+
+
+def read_goals(file):
+    """Read goals from a cvs file.
+    """
+    goals = pd.read_csv(file, sep=",")
+    is_active = (goals['active'] == 1)
+    return goals.loc[is_active, GOAL_PARAMETERS]

rtc-tools-interface-0.0.1b2/rtctools_interface/optimization/read_plot_table.py

@@ -0,0 +1,29 @@
+"""Module for reading goals from a csv file."""
+import pandas as pd
+
+from rtctools_interface.optimization.read_goals import GOAL_PARAMETERS
+
+PLOT_PARAMETERS = ["id", "y_axis_title", "variables_plot_1", "variables_plot_2"]
+
+
+def string_to_list(string):
+    """
+    Convert a string to a list of strings
+    """
+    if string == "" or not isinstance(string, str):
+        return []
+    string_without_whitespace = string.replace(" ", "")
+    list_of_strings = string_without_whitespace.split(",")
+    return list_of_strings
+
+
+def read_plot_table(plot_table_file, goal_table_file):
+    """Read plot table for PlotGoals and merge with goals table"""
+    plot_table = pd.read_csv(plot_table_file, sep=",")
+    plot_table[["variables_plot_1", "variables_plot_2"]] = plot_table[
+        ["variables_plot_1", "variables_plot_2"]
+    ].applymap(string_to_list)
+    goals = pd.read_csv(goal_table_file, sep=",")
+    joined_table = plot_table.merge(goals, on="id")
+    is_active = goals["active"] == 1
+    return joined_table.loc[is_active, PLOT_PARAMETERS + GOAL_PARAMETERS]

{rtc-tools-interface-0.0.1b1 → rtc-tools-interface-0.0.1b2}/setup.py

@@ -1,4 +1,4 @@
-from setuptools import setup
+from setuptools import find_packages, setup
 
 import versioneer
 
@@ -7,6 +7,7 @@ setup(
     name='rtc-tools-interface',
     version=versioneer.get_version(),
     maintainer='Deltares',
+    packages=find_packages("."),
     author='Deltares',
     description="Toolbox for user interfaces for RTC-Tools",
     install_requires=["pandas",

rtc-tools-interface-0.0.1b2/tests/optimization/get_test.py

@@ -0,0 +1,21 @@
+"""Module for getting optimization test data."""
+import pathlib
+
+import pandas as pd
+
+
+DATA_DIR = pathlib.Path(__file__).parent.parent / "data"
+
+
+def get_test_data(test: str):
+    tests_df = pd.read_csv(DATA_DIR / "optimization" / "tests.csv", sep=",")
+    tests_df.set_index("test", inplace=True)
+    test_data = tests_df.loc[test]
+    return {
+        "model_folder": DATA_DIR / "models" / test_data["model_folder"],
+        "model_name": test_data["model_name"],
+        "model_input_folder": DATA_DIR / "model_input" / test_data["model_input_folder"],
+        "goals_file": DATA_DIR / "goals" / test_data["goals_file"],
+        "plot_table_file": DATA_DIR / "plot_table" / test_data["plot_table_file"],
+        "output_folder": DATA_DIR / "optimization" / "output" / test_data["output_folder"],
+    }

rtc-tools-interface-0.0.1b2/tests/optimization/test_base_optimization_problem.py

@@ -0,0 +1,23 @@
+import unittest
+
+from rtctools_interface.optimization.base_optimization_problem import BaseOptimizationProblem
+
+from .get_test import get_test_data
+
+
+class TestBaseOptimizationProblem(unittest.TestCase):
+    def run_test(self, test):
+        test_data = get_test_data(test)
+        problem = BaseOptimizationProblem(
+            goal_table_file=test_data["goals_file"],
+            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.optimize()
+
+    # TODO: use pytest instead to parametrise tests.
+    def test_base_optimization_problem(self):
+        for test in ["basic", "target_bounds_as_parameters", "target_bounds_as_timeseries"]:
+            self.run_test(test)

rtc-tools-interface-0.0.1b2/tests/optimization/test_plot_goals_mixin.py

@@ -0,0 +1,41 @@
+import unittest
+
+from rtctools_interface.optimization.base_optimization_problem import (
+    BaseOptimizationProblem,
+)
+from rtctools_interface.optimization.plot_goals_mixin import PlotGoalsMixin
+
+from .get_test import get_test_data
+
+
+class BaseOptimizationProblemPlotting(PlotGoalsMixin, BaseOptimizationProblem):
+    def __init__(
+        self,
+        plot_table_file,
+        goal_table_file,
+        **kwargs,
+    ):
+        self.plot_table_file = plot_table_file
+        super().__init__(goal_table_file=goal_table_file, **kwargs)
+
+
+class TestPlotGoalsMixin(unittest.TestCase):
+    def run_test(self, test):
+        test_data = get_test_data(test)
+        problem = BaseOptimizationProblemPlotting(
+            goal_table_file=test_data["goals_file"],
+            plot_table_file=test_data["plot_table_file"],
+            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.optimize()
+
+    def test_plot_goals_mixin(self):
+        for test in [
+            "basic",
+            "target_bounds_as_parameters",
+            "target_bounds_as_timeseries",
+        ]:
+            self.run_test(test)

rtc-tools-interface-0.0.1b2/tests/optimization/test_read_goals.py

@@ -0,0 +1,16 @@
+"""Test reading goals from a csv file."""
+import pathlib
+import unittest
+
+from rtctools_interface.optimization.read_goals import read_goals
+
+
+CSV_FILE = pathlib.Path(__file__).parent.parent / "data" / "goals" / "basic.csv"
+
+
+class TestGoalReader(unittest.TestCase):
+
+    def test_read_csv(self):
+        goals = read_goals(CSV_FILE)
+        self.assertEqual(len(goals), 2)
+        pass

rtc-tools-interface-0.0.1b1/rtc_tools_interface.egg-info/SOURCES.txt

@@ -1,11 +0,0 @@
-COPYING.LESSER
-README.md
-setup.cfg
-setup.py
-versioneer.py
-rtc_tools_interface.egg-info/PKG-INFO
-rtc_tools_interface.egg-info/SOURCES.txt
-rtc_tools_interface.egg-info/dependency_links.txt
-rtc_tools_interface.egg-info/requires.txt
-rtc_tools_interface.egg-info/top_level.txt
-rtctools_interface/_version.py

rtc-tools-interface-0.0.1b1/rtc_tools_interface.egg-info/top_level.txt

@@ -1 +0,0 @@
-