rtc-tools 2.6.0b2__py3-none-any.whl → 2.7.0__py3-none-any.whl

rtctools/optimization/control_tree_mixin.py

@@ -86,6 +86,11 @@ class ControlTreeMixin(OptimizationProblem):
         logger.debug("ControlTreeMixin: Branching times:")
         logger.debug(self.__branching_times)
 
+        # Avoid calling constant_inputs() many times
+        constant_inputs = [
+            self.constant_inputs(ensemble_member=i) for i in range(self.ensemble_size)
+        ]
+
         # Branches start at branching times, so that the tree looks like the following:
         #
         #         *-----
@@ -122,18 +127,16 @@ class ControlTreeMixin(OptimizationProblem):
             for forecast_variable in options["forecast_variables"]:
                 # We assume the time stamps of the forecasts in all ensemble
                 # members to be identical
-                timeseries = self.constant_inputs(ensemble_member=0)[forecast_variable]
+                timeseries = constant_inputs[0][forecast_variable]
                 els = np.logical_and(
                     timeseries.times >= branching_time_0, timeseries.times < branching_time_1
                 )
 
                 # Compute distance between ensemble members
                 for i, member_i in enumerate(branches[current_branch]):
-                    timeseries_i = self.constant_inputs(ensemble_member=member_i)[forecast_variable]
+                    timeseries_i = constant_inputs[member_i][forecast_variable]
                     for j, member_j in enumerate(branches[current_branch]):
-                        timeseries_j = self.constant_inputs(ensemble_member=member_j)[
-                            forecast_variable
-                        ]
+                        timeseries_j = constant_inputs[member_j][forecast_variable]
                         distances[i, j] += np.linalg.norm(
                             timeseries_i.values[els] - timeseries_j.values[els]
                         )

rtctools/optimization/csv_lookup_table_mixin.py

@@ -2,7 +2,6 @@ import configparser
 import glob
 import logging
 import os
-import pickle
 from typing import Iterable, List, Tuple, Union
 
 import casadi as ca
@@ -56,7 +55,7 @@ class LookupTable(LookupTableBase):
                 "This lookup table was not instantiated with tck metadata. \
                                   Domain/Range information is unavailable."
             )
-        if type(t) == tuple and len(t) == 2:
+        if isinstance(t, tuple) and len(t) == 2:
             raise NotImplementedError(
                 "Domain/Range information is not yet implemented for 2D LookupTables"
             )
@@ -299,8 +298,9 @@ class CSVLookupTableMixin(OptimizationProblem):
         def check_lookup_table(lookup_table):
             if lookup_table in self.__lookup_tables:
                 raise Exception(
-                    "Cannot add lookup table {},"
-                    "since there is already one with this name.".format(lookup_table)
+                    "Cannot add lookup table {},since there is already one with this name.".format(
+                        lookup_table
+                    )
                 )
 
         # Read CSV files
@@ -323,7 +323,7 @@ class CSVLookupTableMixin(OptimizationProblem):
 
             # If tck file is newer than the csv file, first try to load the cached values from
             # the tck file
-            tck_filename = filename.replace(".csv", ".tck")
+            tck_filename = filename.replace(".csv", ".npz")
             valid_cache = False
             if os.path.exists(tck_filename):
                 if no_curvefit_options:
@@ -338,11 +338,13 @@ class CSVLookupTableMixin(OptimizationProblem):
                             output
                         )
                     )
-                    with open(tck_filename, "rb") as f:
-                        try:
-                            tck, function = pickle.load(f)
-                        except Exception:
-                            valid_cache = False
+                    try:
+                        with np.load(filename.replace(".csv", ".npz")) as data:
+                            tck = (data["arr_0"], data["arr_1"], int(data["arr_2"]))
+                        function = ca.Function.load(filename.replace(".csv", ".ca"))
+                    except Exception:
+                        valid_cache = False
+
             if not valid_cache:
                 logger.info("CSVLookupTableMixin: Recalculating tck values for {}".format(output))
 
@@ -357,6 +359,7 @@ class CSVLookupTableMixin(OptimizationProblem):
                             k=k,
                             monotonicity=mono,
                             curvature=curv,
+                            ipopt_options={"nlp_scaling_method": "none"},
                         )
                     else:
                         raise Exception(
@@ -446,11 +449,8 @@ class CSVLookupTableMixin(OptimizationProblem):
                 )
 
             if not valid_cache:
-                pickle.dump(
-                    (tck, function),
-                    open(filename.replace(".csv", ".tck"), "wb"),
-                    protocol=pickle.HIGHEST_PROTOCOL,
-                )
+                np.savez(filename.replace(".csv", ".npz"), *tck)
+                function.save(filename.replace(".csv", ".ca"))
 
     def lookup_tables(self, ensemble_member):
         # Call parent class first for default values.

rtctools/optimization/csv_mixin.py

@@ -98,6 +98,9 @@ class CSVMixin(IOMixin):
                 names=True,
                 encoding=None,
             )
+            if len(self.__ensemble.shape) == 0:
+                # If there is only one ensemble member, the array is 0-dimensional.
+                self.__ensemble = np.expand_dims(self.__ensemble, 0)
 
             logger.debug("CSVMixin: Read ensemble description")
 

rtctools/optimization/goal_programming_mixin.py

@@ -351,8 +351,9 @@ class GoalProgrammingMixin(_GoalProgrammingMixinBase):
         if goal.has_target_bounds:
             # We use a violation variable formulation, with the violation
             # variables epsilon bounded between 0 and 1.
-            m, M = np.full_like(epsilon, -np.inf, dtype=np.float64), np.full_like(
-                epsilon, np.inf, dtype=np.float64
+            m, M = (
+                np.full_like(epsilon, -np.inf, dtype=np.float64),
+                np.full_like(epsilon, np.inf, dtype=np.float64),
             )
 
             # A function range does not have to be specified for critical
@@ -667,6 +668,7 @@ class GoalProgrammingMixin(_GoalProgrammingMixinBase):
         logger.info("Starting goal programming")
 
         success = False
+        self.skip_priority = False
 
         self.__constraint_store = [OrderedDict() for ensemble_member in range(self.ensemble_size)]
         self.__path_constraint_store = [
@@ -691,6 +693,13 @@ class GoalProgrammingMixin(_GoalProgrammingMixinBase):
             # Call the pre priority hook
             self.priority_started(priority)
 
+            if self.skip_priority:
+                logger.info(
+                    "priority {} was removed in priority_started. No optimization problem "
+                    "is solved at this priority.".format(priority)
+                )
+                continue
+
             (
                 self.__subproblem_epsilons,
                 self.__subproblem_objectives,

rtctools/optimization/goal_programming_mixin_base.py

@@ -437,7 +437,7 @@ class _GoalConstraint:
     ):
         assert isinstance(m, (float, np.ndarray, Timeseries))
         assert isinstance(M, (float, np.ndarray, Timeseries))
-        assert type(m) == type(M)
+        assert type(m) is type(M)
 
         # NumPy arrays only allowed for vector goals
         if isinstance(m, np.ndarray):
@@ -982,8 +982,9 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
         if goal.has_target_bounds:
             # We use a violation variable formulation, with the violation
             # variables epsilon bounded between 0 and 1.
-            m, M = np.full_like(epsilon, -np.inf, dtype=np.float64), np.full_like(
-                epsilon, np.inf, dtype=np.float64
+            m, M = (
+                np.full_like(epsilon, -np.inf, dtype=np.float64),
+                np.full_like(epsilon, np.inf, dtype=np.float64),
             )
 
             # A function range does not have to be specified for critical
@@ -1081,6 +1082,7 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
 
         :param priority: The priority level that was started.
         """
+        self.skip_priority = False
         pass
 
     def priority_completed(self, priority: int) -> None:

rtctools/optimization/modelica_mixin.py

@@ -1,10 +1,18 @@
+import importlib.resources
 import itertools
 import logging
+import sys
 from typing import Dict, Union
 
+# Python 3.9's importlib.metadata does not support the "group" parameter to
+# entry_points yet.
+if sys.version_info < (3, 10):
+    import importlib_metadata
+else:
+    from importlib import metadata as importlib_metadata
+
 import casadi as ca
 import numpy as np
-import pkg_resources
 import pymoca
 import pymoca.backends.casadi.api
 
@@ -48,9 +56,21 @@ class ModelicaMixin(OptimizationProblem):
             else:
                 model_name = self.__class__.__name__
 
-        self.__pymoca_model = pymoca.backends.casadi.api.transfer_model(
-            kwargs["model_folder"], model_name, self.compiler_options()
-        )
+        compiler_options = self.compiler_options()
+        logger.info(f"Loading/compiling model {model_name}.")
+        try:
+            self.__pymoca_model = pymoca.backends.casadi.api.transfer_model(
+                kwargs["model_folder"], model_name, compiler_options
+            )
+        except (RuntimeError, ModuleNotFoundError) as error:
+            if not compiler_options.get("cache", False):
+                raise error
+            compiler_options["cache"] = False
+            logger.warning(f"Loading model {model_name} using a cache file failed: {error}.")
+            logger.info(f"Compiling model {model_name}.")
+            self.__pymoca_model = pymoca.backends.casadi.api.transfer_model(
+                kwargs["model_folder"], model_name, compiler_options
+            )
 
         # Extract the CasADi MX variables used in the model
         self.__mx = {}
@@ -162,9 +182,9 @@ class ModelicaMixin(OptimizationProblem):
         # Where imported model libraries are located.
         library_folders = self.modelica_library_folders.copy()
 
-        for ep in pkg_resources.iter_entry_points(group="rtctools.libraries.modelica"):
+        for ep in importlib_metadata.entry_points(group="rtctools.libraries.modelica"):
             if ep.name == "library_folder":
-                library_folders.append(pkg_resources.resource_filename(ep.module_name, ep.attrs[0]))
+                library_folders.append(str(importlib.resources.files(ep.module).joinpath(ep.attr)))
 
         compiler_options["library_folders"] = library_folders
 
@@ -314,7 +334,7 @@ class ModelicaMixin(OptimizationProblem):
             try:
                 (m, M) = bounds[sym_name]
             except KeyError:
-                if self.__python_types.get(sym_name, float) == bool:
+                if self.__python_types.get(sym_name, float) is bool:
                     (m, M) = (0, 1)
                 else:
                     (m, M) = (-np.inf, np.inf)
@@ -388,7 +408,7 @@ class ModelicaMixin(OptimizationProblem):
         return seed
 
     def variable_is_discrete(self, variable):
-        return self.__python_types.get(variable, float) != float
+        return self.__python_types.get(variable, float) is not float
 
     @property
     @cached

rtctools/optimization/optimization_problem.py

@@ -314,6 +314,24 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         if log_level == logging.ERROR and not log_solver_failure_as_error:
             log_level = logging.INFO
 
+        if self.solver_options()["solver"].lower() == "knitro":
+            list_feas_flags = [
+                "KN_RC_OPTIMAL_OR_SATISFACTORY",
+                "KN_RC_ITER_LIMIT_FEAS",
+                "KN_RC_NEAR_OPT",
+                "KN_RC_FEAS_XTOL",
+                "KN_RC_FEAS_NO_IMPROVE",
+                "KN_RC_FEAS_FTOL",
+                "KN_RC_TIME_LIMIT_FEAS",
+                "KN_RC_FEVAL_LIMIT_FEAS",
+                "KN_RC_MIP_EXH_FEAS",
+                "KN_RC_MIP_TERM_FEAS",
+                "KN_RC_MIP_SOLVE_LIMIT_FEAS",
+                "KN_RC_MIP_NODE_LIMIT_FEAS",
+            ]
+            if solver_stats["return_status"] in list_feas_flags:
+                success = True
+
         return success, log_level
 
     @abstractproperty

rtctools/optimization/pi_mixin.py

@@ -277,3 +277,16 @@ class PIMixin(IOMixin):
         :class:`pi.Timeseries` object for holding the output data.
         """
         return self.__timeseries_export
+
+    def set_unit(self, variable: str, unit: str):
+        """
+        Set the unit of a time series.
+
+        :param variable:        Time series ID.
+        :param unit:            Unit.
+        """
+        assert hasattr(self, "_PIMixin__timeseries_import"), (
+            "set_unit can only be called after read() in pre() has finished."
+        )
+        self.__timeseries_import.set_unit(variable, unit, 0)
+        self.__timeseries_export.set_unit(variable, unit, 0)

rtctools/rtctoolsapp.py

@@ -1,9 +1,17 @@
+import importlib.resources
 import logging
 import os
 import shutil
 import sys
 from pathlib import Path
 
+# Python 3.9's importlib.metadata does not support the "group" parameter to
+# entry_points yet.
+if sys.version_info < (3, 10):
+    import importlib_metadata
+else:
+    from importlib import metadata as importlib_metadata
+
 import rtctools
 
 logging.basicConfig(format="%(asctime)s %(levelname)s %(message)s")
@@ -23,9 +31,6 @@ def copy_libraries(*args):
     if not os.path.exists(path):
         sys.exit("Folder '{}' does not exist".format(path))
 
-    # pkg_resources can be quite a slow import, so we do it here
-    import pkg_resources
-
     def _copytree(src, dst, symlinks=False, ignore=None):
         if not os.path.exists(dst):
             os.makedirs(dst)
@@ -56,11 +61,10 @@ def copy_libraries(*args):
     dst = Path(path)
 
     library_folders = []
-    for ep in pkg_resources.iter_entry_points(group="rtctools.libraries.modelica"):
+
+    for ep in importlib_metadata.entry_points(group="rtctools.libraries.modelica"):
         if ep.name == "library_folder":
-            library_folders.append(
-                Path(pkg_resources.resource_filename(ep.module_name, ep.attrs[0]))
-            )
+            library_folders.append(Path(importlib.resources.files(ep.module).joinpath(ep.attr)))
 
     tlds = {}
     for lf in library_folders:
@@ -100,25 +104,24 @@ def download_examples(*args):
     from zipfile import ZipFile
 
     version = rtctools.__version__
-    rtc_full_name = "rtc-tools-{}".format(version)
     try:
-        url = "https://gitlab.com/deltares/rtc-tools/-/archive/{}/{}.zip".format(
-            version, rtc_full_name
-        )
+        url = "https://github.com/deltares/rtc-tools/zipball/{}".format(version)
 
         opener = urllib.request.build_opener()
         urllib.request.install_opener(opener)
-        local_filename, _ = urllib.request.urlretrieve(url)
+        # The security warning can be dismissed as the url variable is hardcoded to a remote.
+        local_filename, _ = urllib.request.urlretrieve(url)  # nosec
     except HTTPError:
         sys.exit("Could not found examples for RTC-Tools version {}.".format(version))
 
     with ZipFile(local_filename, "r") as z:
         target = path / "rtc-tools-examples"
-        prefix = "{}/examples/".format(rtc_full_name)
+        zip_folder_name = next(x for x in z.namelist() if x.startswith("Deltares-rtc-tools-"))
+        prefix = "{}/examples/".format(zip_folder_name.rstrip("/"))
         members = [x for x in z.namelist() if x.startswith(prefix)]
         z.extractall(members=members)
         shutil.move(prefix, target)
-        shutil.rmtree(rtc_full_name)
+        shutil.rmtree(zip_folder_name)
 
         sys.exit("Succesfully downloaded the RTC-Tools examples to '{}'".format(target.resolve()))
 

rtctools/simulation/io_mixin.py

@@ -94,7 +94,7 @@ class IOMixin(SimulationProblem, metaclass=ABCMeta):
             self.__cache_loop_timeseries = {}
 
             timeseries_names = set(self.io.get_timeseries_names(0))
-            for v in self.get_variables():
+            for v in self.get_input_variables():
                 if v in timeseries_names:
                     _, values = self.io.get_timeseries_sec(v)
                     self.__cache_loop_timeseries[v] = values

rtctools/simulation/pi_mixin.py

@@ -240,3 +240,16 @@ class PIMixin(IOMixin):
     def get_timeseries(self, variable):
         _, values = self.io.get_timeseries(variable)
         return values
+
+    def set_unit(self, variable: str, unit: str):
+        """
+        Set the unit of a time series.
+
+        :param variable:        Time series ID.
+        :param unit:            Unit.
+        """
+        assert hasattr(self, "_PIMixin__timeseries_import"), (
+            "set_unit can only be called after read() in pre() has finished."
+        )
+        self.__timeseries_import.set_unit(variable, unit, 0)
+        self.__timeseries_export.set_unit(variable, unit, 0)