rtc-tools 2.6.1__py3-none-any.whl → 2.7.0__py3-none-any.whl

{rtc_tools-2.6.1.dist-info → rtc_tools-2.7.0.dist-info}/METADATA

@@ -1,12 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: rtc-tools
-Version: 2.6.1
+Version: 2.7.0
 Summary: Toolbox for control and optimization of water systems.
 Home-page: https://oss.deltares.nl/web/rtc-tools/home
+Download-URL: http://github.com/deltares/rtc-tools/
 Author: Deltares
 Maintainer: Deltares
-License: UNKNOWN
-Download-URL: http://gitlab.com/deltares/rtc-tools/
 Platform: Windows
 Platform: Linux
 Platform: Mac OS-X
@@ -24,20 +23,31 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 License-File: COPYING.LESSER
-Requires-Dist: casadi ==3.6.*,>=3.6.3
-Requires-Dist: numpy <1.26,>=1.16.0
-Requires-Dist: scipy <1.11,>=1.0.0
-Requires-Dist: pymoca ==0.9.*,>=0.9.1
-Requires-Dist: rtc-tools-channel-flow >=1.1.0
-Requires-Dist: defusedxml >=0.7.0
-Provides-Extra: all
-Requires-Dist: netCDF4 ; extra == 'all'
+Requires-Dist: casadi!=3.6.6,<=3.7,>=3.6.3
+Requires-Dist: numpy>=1.16.0
+Requires-Dist: scipy>=1.0.0
+Requires-Dist: pymoca==0.9.*,>=0.9.1
+Requires-Dist: rtc-tools-channel-flow>=1.2.0
+Requires-Dist: defusedxml>=0.7.0
+Requires-Dist: importlib_metadata>=5.0.0; python_version < "3.10"
 Provides-Extra: netcdf
-Requires-Dist: netCDF4 ; extra == 'netcdf'
+Requires-Dist: netCDF4; extra == "netcdf"
+Provides-Extra: all
+Requires-Dist: netCDF4; extra == "all"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: platform
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 RTC-Tools is the Deltares toolbox for control and optimization of water systems.
 
-
-

rtc_tools-2.7.0.dist-info/RECORD

@@ -0,0 +1,50 @@
+rtc_tools-2.7.0.dist-info/licenses/COPYING.LESSER,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+rtctools/__init__.py,sha256=91hvS2-ryd2Pvw0COpsUzTwJwSnTZ035REiej-1hNI4,107
+rtctools/_version.py,sha256=GRY0UZKaQFpBKoUgttmG_1W-QGsYu3oGtZePebKhXj4,497
+rtctools/rtctoolsapp.py,sha256=2RVZI4QQUg0yC6ii4lr50yx1blEfHBFsAgUjLR5pBkA,4336
+rtctools/util.py,sha256=8IGva7xWcAH-9Xcr1LaxUpYoZjF6vbo1eqdNJ9pKgGA,9098
+rtctools/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rtctools/_internal/alias_tools.py,sha256=XuQSAhhFuVtwn0yrAObZWIKPsSF4j2axXRtEmitIFPs,5310
+rtctools/_internal/caching.py,sha256=p4gqSL7kCI7Hff-KjMEP7mhJCQSiU_lYm2MR7E18gBM,905
+rtctools/_internal/casadi_helpers.py,sha256=q8j5h9XXXkZMUgjg6wbkcFj1mcHi5_SdEi8SrkM---M,1457
+rtctools/_internal/debug_check_helpers.py,sha256=UgQTEPw4PyR7MbYLewSSWQqTwQj7xr5yUBk820O9Kk4,1084
+rtctools/data/__init__.py,sha256=EllgSmCdrlvQZSd1VilvjPaeYJGhY9ErPiQtedmuFoA,157
+rtctools/data/csv.py,sha256=hEpoTH3nhZaAvRN4r-9-nYeAjaFiNDRoiZWg8GxM3yo,5539
+rtctools/data/netcdf.py,sha256=tMs-zcSlOR0HhajUKJVbXGNoi3GeKCM3X4DjuW8FDo8,19130
+rtctools/data/pi.py,sha256=D2r9gaYu6qMpgWRqiWpWPSPJXWgqCVV0bz6ewgM78mc,46701
+rtctools/data/rtc.py,sha256=tYPOzZSFE02bAXX3lgcGR1saoQNIv6oWVWH8CS0dl5Q,9079
+rtctools/data/storage.py,sha256=67J4BRTl0AMEzlKNZ8Xdpy_4cGtwx8Lo_tL2n0G4S9w,13206
+rtctools/data/interpolation/__init__.py,sha256=GBubCIT5mFoSTV-lOk7cpwvZekNMEe5bvqSQJ9HE34M,73
+rtctools/data/interpolation/bspline.py,sha256=qevB842XWCH3fWlWMBqKMy1mw37ust-0YtSnb9PKCEc,948
+rtctools/data/interpolation/bspline1d.py,sha256=HAh7m5xLBuiFKzMzuYEqZX_GmCPChKjV7ynTS6iRZOc,6166
+rtctools/data/interpolation/bspline2d.py,sha256=ScmX0fPDxbUVtj3pbUE0L7UJocqroD_6fUT-4cvdRMc,1693
+rtctools/optimization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rtctools/optimization/collocated_integrated_optimization_problem.py,sha256=gB1RgEsOSgb745NxSosDqjBEJZI_ULtjlHZcuCcRjO4,131267
+rtctools/optimization/control_tree_mixin.py,sha256=ZMMH7Xy_qIVXeLDNtPdXQ8o_0ELRYVdM5QK2R8YulKU,9036
+rtctools/optimization/csv_lookup_table_mixin.py,sha256=TUYAT-u-mzH6HLP0iJHnLBVqV5tWnhYAqDC4Aj17MJg,17399
+rtctools/optimization/csv_mixin.py,sha256=_6iPVK_EJ8PxnukepzkhFtidceucsozRML_DDEycYik,12453
+rtctools/optimization/goal_programming_mixin.py,sha256=vdnKnz1Ov3OFN-J9KQiiAwHbrLjWH6o_PeZz2YfLz6k,33320
+rtctools/optimization/goal_programming_mixin_base.py,sha256=qJQQcJlJdio4GTcrKfuBi6Nho9u16pDuuprzK0LUyhA,43835
+rtctools/optimization/homotopy_mixin.py,sha256=Kh0kMfxB-Fo1FBGW5tPOQk24Xx_Mmw_p0YuSQotdkMU,6905
+rtctools/optimization/initial_state_estimation_mixin.py,sha256=74QYfG-VYYTNVg-kAnCG6QoY3_sUmaID0ideF7bPkkY,3116
+rtctools/optimization/io_mixin.py,sha256=AsZQ7YOUcUbWoczmjTXaSje5MUEsPNbQyZBJ6qzSjzU,11821
+rtctools/optimization/linearization_mixin.py,sha256=mG5S7uwvwDydw-eBPyQKnLyKoy08EBjQh25vu97afhY,1049
+rtctools/optimization/linearized_order_goal_programming_mixin.py,sha256=LQ2qpYt0YGLpEoerif4FJ5wwzq16q--27bsRjcqIU5A,9087
+rtctools/optimization/min_abs_goal_programming_mixin.py,sha256=WMOv9EF8cfDJgTunzXfI_cUmBSQK26u1HJB_9EAarfM,14031
+rtctools/optimization/modelica_mixin.py,sha256=b_VsEcg_VsAnODnTQybrY0GbuZUNQ3uugQmML6FlklE,18037
+rtctools/optimization/netcdf_mixin.py,sha256=-zkXh3sMYE50c3kHsrmUVGWMSFm-0cXQpGrCm0yn-Tc,7563
+rtctools/optimization/optimization_problem.py,sha256=lTk4tUBEb1xy9eyNy7-w0D6L6HxSCJ0MyvxjzrYLsR4,44824
+rtctools/optimization/pi_mixin.py,sha256=G_6RPlXO-IOjqYxNsMZGY4fmnfxVpwN-_T5Ka3rDwK4,11788
+rtctools/optimization/planning_mixin.py,sha256=O_Y74X8xZmaNZR4iYOe7BR06s9hnmcapbuHYHQTBPPQ,724
+rtctools/optimization/single_pass_goal_programming_mixin.py,sha256=Zb9szg3PGT2o6gkGsXluSfEaAswkw3TKfPQDzUrj_Y4,25784
+rtctools/optimization/timeseries.py,sha256=nCrsGCJThBMh9lvngEpbBDa834_QvklVvkxJqwX4a1M,1734
+rtctools/simulation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rtctools/simulation/csv_mixin.py,sha256=rGDUFPsqGHmF0_dWdXeWzWzMpkPmwCNweTBVrwSh31g,6704
+rtctools/simulation/io_mixin.py,sha256=WIKOQxr3fS-aNbgjet9iWoUayuD22zLIYmqlWEqxXHo,6215
+rtctools/simulation/pi_mixin.py,sha256=_TU2DrK2MQqVsyrHBD9W4SDEuot9dYmgTDNiXkDAJfk,9833
+rtctools/simulation/simulation_problem.py,sha256=v5Lk2x-yuVb5s7ne5fFgxONxGniLHTyTR0XRzYRl1fw,50005
+rtc_tools-2.7.0.dist-info/METADATA,sha256=ULtELHwTloQVwwzBsmnqDlvFMj-SMQmNO2r3ATeJRC8,1772
+rtc_tools-2.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rtc_tools-2.7.0.dist-info/entry_points.txt,sha256=DVS8sWf3b9ph9h8srEr6zmQ7ZKGwblwgZgGPZg-jRNQ,150
+rtc_tools-2.7.0.dist-info/top_level.txt,sha256=pnBrb58PFPd1kp1dqa-JHU7R55h3alDNJIJnF3Jf9Dw,9
+rtc_tools-2.7.0.dist-info/RECORD,,

{rtc_tools-2.6.1.dist-info → rtc_tools-2.7.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{rtc_tools-2.6.1.dist-info → rtc_tools-2.7.0.dist-info}/entry_points.txt

@@ -1,4 +1,3 @@
 [console_scripts]
 rtc-tools-copy-libraries = rtctools.rtctoolsapp:copy_libraries
 rtc-tools-download-examples = rtctools.rtctoolsapp:download_examples
-

rtctools/_internal/casadi_helpers.py

@@ -5,12 +5,12 @@ import casadi as ca
 logger = logging.getLogger("rtctools")
 
 
-def is_affine(e, v):
+def is_affine(expr, symbols):
     try:
-        Af = ca.Function("f", [v], [ca.jacobian(e, v)]).expand()
-    except RuntimeError as e:
-        if "'eval_sx' not defined for" in str(e):
-            Af = ca.Function("f", [v], [ca.jacobian(e, v)])
+        Af = ca.Function("f", [symbols], [ca.jacobian(expr, symbols)]).expand()
+    except RuntimeError as error:
+        if "'eval_sx' not defined for" in str(error):
+            Af = ca.Function("f", [symbols], [ca.jacobian(expr, symbols)])
         else:
             raise
     return Af.sparsity_jac(0, 0).nnz() == 0

rtctools/_version.py

@@ -1,5 +1,5 @@
 
-# This file was generated by 'versioneer.py' (0.18) from
+# This file was generated by 'versioneer.py' (0.29) from
 # revision-control system data, or from the parent directory name of an
 # unpacked source archive. Distribution tarballs contain a pre-generated copy
 # of this file.
@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-03-05T12:46:34+0100",
+ "date": "2025-05-23T14:56:50+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "0a079ff7858bac8dcf56c5c6fd0b6f3ee2cdbddb",
- "version": "2.6.1"
+ "full-revisionid": "16ab781cd81009655c779d5cc5b7c4aa3e73fa85",
+ "version": "2.7.0"
 }
 '''  # END VERSION_JSON
 

rtctools/data/csv.py

@@ -1,6 +1,7 @@
 import logging
 import sys
 from datetime import datetime
+from typing import Union
 
 import numpy as np
 
@@ -41,6 +42,21 @@ def _boolean_to_nan(data, fname):
     return data
 
 
+def _string_to_datetime(string: Union[str, bytes]) -> datetime:
+    """Convert a string to a datetime object."""
+    if isinstance(string, bytes):
+        string = string.decode("utf-8")
+    return datetime.strptime(string, "%Y-%m-%d %H:%M:%S")
+
+
+def _string_to_float(string: Union[str, bytes]) -> float:
+    """Convert a string to a float."""
+    if isinstance(string, bytes):
+        string = string.decode("utf-8")
+    string = string.replace(",", ".")
+    return float(string)
+
+
 def load(fname, delimiter=",", with_time=False):
     """
     Check delimiter of csv and read contents to an array. Assumes no date-time conversion needed.
@@ -53,7 +69,7 @@ def load(fname, delimiter=",", with_time=False):
     """
     c = {}
     if with_time:
-        c.update({0: lambda str: datetime.strptime(str.decode("utf-8"), "%Y-%m-%d %H:%M:%S")})
+        c.update({0: _string_to_datetime})
 
     # Check delimiter of csv file. If semicolon, check if decimal separator is
     # a comma.
@@ -73,12 +89,7 @@ def load(fname, delimiter=",", with_time=False):
             # If commas are used as decimal separator, we need additional
             # converters.
             if n_comma_decimal:
-                c.update(
-                    {
-                        i + len(c): lambda str: float(str.decode("utf-8").replace(",", "."))
-                        for i in range(1 + n_semicolon - len(c))
-                    }
-                )
+                c.update({i + len(c): _string_to_float for i in range(1 + n_semicolon - len(c))})
 
     # Read the csv file and convert to array
     try:

rtctools/data/interpolation/bspline1d.py

@@ -55,6 +55,7 @@ class BSpline1D(BSpline):
         epsilon=1e-7,
         delta=1e-4,
         interior_pts=None,
+        ipopt_options=None,
     ):
         """
         fit() returns a tck tuple like scipy.interpolate.splrep, but adjusts
@@ -153,7 +154,10 @@ class BSpline1D(BSpline):
         nlp = {"x": c, "f": f, "g": g}
         my_solver = "ipopt"
         solver = nlpsol(
-            "solver", my_solver, nlp, {"print_time": 0, "expand": True, "ipopt": {"print_level": 0}}
+            "solver",
+            my_solver,
+            nlp,
+            {"print_time": 0, "expand": True, "ipopt": ipopt_options},
         )
         sol = solver(lbg=lbg, ubg=ubg)
         stats = solver.stats()

rtctools/data/netcdf.py

@@ -401,20 +401,21 @@ class ExportDataset:
         """
         assert len(set(variable_names)) == len(variable_names)
 
-        assert (
-            self.__time_dim is not None
-        ), "First call write_times to ensure the time dimension has been created."
-        assert (
-            self.__station_dim is not None
-        ), "First call write_station_data to ensure the station dimension has been created"
+        assert self.__time_dim is not None, (
+            "First call write_times to ensure the time dimension has been created."
+        )
+        assert self.__station_dim is not None, (
+            "First call write_station_data to ensure the station dimension has been created"
+        )
         assert (
             self.__station_id_to_index_mapping is not None
         )  # should also be created in write_station_data
 
         if ensemble_size > 1:
-            assert (
-                self.__ensemble_member_dim is not None
-            ), "First call write_ensemble_data to ensure the realization dimension has been created"
+            assert self.__ensemble_member_dim is not None, (
+                "First call write_ensemble_data to ensure "
+                "the realization dimension has been created"
+            )
 
             for variable_name in variable_names:
                 self.__dataset.createVariable(
@@ -446,15 +447,15 @@ class ExportDataset:
         :param values:        The values that are to be written to the file
         :param ensemble_size: the number of members in the ensemble
         """
-        assert (
-            self.__station_id_to_index_mapping is not None
-        ), "First call write_station_data and create_variables."
+        assert self.__station_id_to_index_mapping is not None, (
+            "First call write_station_data and create_variables."
+        )
 
         station_index = self.__station_id_to_index_mapping[station_id]
         if ensemble_size > 1:
-            self.__dataset.variables[variable_name][
-                :, station_index, ensemble_member_index
-            ] = values
+            self.__dataset.variables[variable_name][:, station_index, ensemble_member_index] = (
+                values
+            )
         else:
             self.__dataset.variables[variable_name][:, station_index] = values
 

rtctools/data/pi.py

@@ -333,8 +333,11 @@ class ParameterConfig:
 
             parameters = group.findall("pi:parameter", ns)
             for parameter in parameters:
-                yield location_id, model_id, parameter.attrib["id"], self.__parse_parameter(
-                    parameter
+                yield (
+                    location_id,
+                    model_id,
+                    parameter.attrib["id"],
+                    self.__parse_parameter(parameter),
                 )
 
 
@@ -369,8 +372,6 @@ class Timeseries:
         self.__folder = folder
         self.__basename = basename
 
-        self.__path_xml = os.path.join(self.__folder, basename + ".xml")
-
         self.__internal_dtype = np.float64
         self.__pi_dtype = np.float32
 
@@ -378,7 +379,7 @@ class Timeseries:
         if self.make_new_file:
             self.__reset_xml_tree()
         else:
-            self.__tree = DefusedElementTree.parse(self.__path_xml)
+            self.__tree = DefusedElementTree.parse(self.path)
             self.__xml_root = self.__tree.getroot()
 
         self.__values = [{}]
@@ -801,13 +802,20 @@ class Timeseries:
         # Add series to xml
         self.__xml_root.append(series)
 
-    def write(self):
+    def write(self, output_folder=None, output_filename=None) -> None:
         """
         Writes the time series data to disk.
+
+        :param output_folder:   The folder in which the output file is located.
+                                If None, the original folder is used.
+        :param output_filename: The name of the output file without extension.
+                                If None, the original filename is used.
         """
+        xml_path = self.output_path(output_folder, output_filename)
+        binary_path = self.output_binary_path(output_folder, output_filename)
 
         if self.__binary:
-            f = io.open(self.binary_path, "wb")
+            f = io.open(binary_path, "wb")
 
         if self.make_new_file:
             # Force reinitialization in case write() is called more than once
@@ -876,29 +884,26 @@ class Timeseries:
                     events = series.findall("pi:event", ns)
 
                     t = self.__start_datetime
-                    for i in range(min(len(events), len(values))):
+                    for i, value in enumerate(values):
                         if self.dt is None:
                             t = self.times[i]
-                        # Set the date/time, so that any date/time steps that
-                        # are wrong in the placeholder file are corrected.
-                        events[i].set("date", t.strftime("%Y-%m-%d"))
-                        events[i].set("time", t.strftime("%H:%M:%S"))
 
-                        # Set the value
-                        events[i].set("value", str(values[i]))
-                        if self.dt:
-                            t += self.dt
-                    for i in range(len(events), len(values)):
-                        if self.dt is None:
-                            t = self.times[i]
-                        event = ET.Element("pi:event")
+                        if i < len(events):
+                            event = events[i]
+                        else:
+                            event = ET.Element("pi:event")
+                            series.append(event)
+
+                        # Always set the date/time, so that any date/time steps
+                        # that are wrong in the placeholder file are corrected.
                         event.set("date", t.strftime("%Y-%m-%d"))
                         event.set("time", t.strftime("%H:%M:%S"))
+
                         if nans[i]:
                             event.set("value", miss_val)
                         else:
-                            event.set("value", str(values[i]))
-                        series.append(event)
+                            event.set("value", str(value))
+
                         if self.dt:
                             t += self.dt
 
@@ -911,7 +916,7 @@ class Timeseries:
             f.close()
 
         self.format_xml_data()
-        self.__tree.write(self.__path_xml)
+        self.__tree.write(xml_path)
 
     def format_xml_data(self):
         """
@@ -1170,16 +1175,45 @@ class Timeseries:
         self.__end_datetime = end_datetime
 
     @property
-    def path(self):
-        return self.__path_xml
+    def path(self) -> str:
+        """
+        The path to the original xml file.
+        """
+        return os.path.join(self.__folder, self.__basename + ".xml")
 
     @property
-    def binary_path(self):
+    def binary_path(self) -> str:
         """
-        The path for the binary data .bin file.
+        The path to the original binary data .bin file.
         """
         return os.path.join(self.__folder, self.__basename + ".bin")
 
+    def _output_path_without_extension(self, output_folder=None, output_filename=None) -> str:
+        """
+        Get the output path without file extension.
+        """
+        if output_folder is None:
+            output_folder = self.__folder
+        if output_filename is None:
+            output_filename = self.__basename
+        return os.path.join(output_folder, output_filename)
+
+    def output_path(self, output_folder=None, output_filename=None) -> str:
+        """
+        Get the path to the output xml file.
+
+        The optional arguments are the same as in :py:method:`write`.
+        """
+        return self._output_path_without_extension(output_folder, output_filename) + ".xml"
+
+    def output_binary_path(self, output_folder=None, output_filename=None) -> str:
+        """
+        Get the path to the output binary file.
+
+        The optional arguments are the same as in :py:method:`write`.
+        """
+        return self._output_path_without_extension(output_folder, output_filename) + ".bin"
+
     def items(self, ensemble_member=0):
         """
         Returns an iterator over all timeseries IDs and value arrays for the given

rtctools/data/rtc.py

@@ -60,9 +60,9 @@ class DataConfig:
                         logger.error(message)
                         raise Exception(message)
                     else:
-                        self.__location_parameter_ids[
-                            internal_id
-                        ] = self.__pi_location_parameter_id(pi_timeseries, "fews")
+                        self.__location_parameter_ids[internal_id] = (
+                            self.__pi_location_parameter_id(pi_timeseries, "fews")
+                        )
                         self.__variable_map[external_id] = internal_id
 
             for k in ["import", "export"]:

rtctools/optimization/collocated_integrated_optimization_problem.py

@@ -898,11 +898,11 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                     function_options,
                 )
 
+                # Expand the residual function if possible.
                 try:
                     dae_residual_function_integrated = dae_residual_function_integrated.expand()
                 except RuntimeError as e:
-                    # We only expect to fail if the DAE was an external function
-                    if "'eval_sx' not defined for External" in str(e):
+                    if "'eval_sx' not defined for" in str(e):
                         pass
                     else:
                         raise
@@ -933,13 +933,13 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                     [dae_residual_collocated],
                     function_options,
                 )
+                # Expand the residual function if possible.
                 try:
                     self.__dae_residual_function_collocated = (
                         self.__dae_residual_function_collocated.expand()
                     )
                 except RuntimeError as e:
-                    # We only expect to fail if the DAE was an external function
-                    if "'eval_sx' not defined for External" in str(e):
+                    if "'eval_sx' not defined for" in str(e):
                         pass
                     else:
                         raise
@@ -1028,8 +1028,8 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
             + len(self.dae_variables["constant_inputs"])
         ]
         constant_inputs_1 = accumulated_U[
-            2 * len(collocated_variables)
-            + len(self.dae_variables["constant_inputs"]) : 2 * len(collocated_variables)
+            2 * len(collocated_variables) + len(self.dae_variables["constant_inputs"]) : 2
+            * len(collocated_variables)
             + 2 * len(self.dae_variables["constant_inputs"])
         ]
 
@@ -1803,9 +1803,9 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                     # Cast delay from DM to np.array
                     delay = delay.toarray().flatten()
 
-                    assert np.all(
-                        np.isfinite(delay)
-                    ), "Delay duration must be resolvable to real values at transcribe()"
+                    assert np.all(np.isfinite(delay)), (
+                        "Delay duration must be resolvable to real values at transcribe()"
+                    )
 
                     out_times = np.concatenate([history_times, collocation_times])
                     out_values = ca.veccat(
@@ -2043,9 +2043,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
     def controls(self):
         return self.__controls
 
-    def _collint_get_lbx_ubx(self, count, indices):
-        bounds = self.bounds()
-
+    def _collint_get_lbx_ubx(self, bounds, count, indices):
         lbx = np.full(count, -np.inf, dtype=np.float64)
         ubx = np.full(count, np.inf, dtype=np.float64)
 
@@ -2210,7 +2208,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                 count = max(count, control_indices_stop)
 
         discrete = self._collint_get_discrete(count, indices)
-        lbx, ubx = self._collint_get_lbx_ubx(count, indices)
+        lbx, ubx = self._collint_get_lbx_ubx(bounds, count, indices)
         x0 = self._collint_get_x0(count, indices)
 
         # Return number of control variables
@@ -2326,7 +2324,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                 offset += 1
 
         discrete = self._collint_get_discrete(count, indices)
-        lbx, ubx = self._collint_get_lbx_ubx(count, indices)
+        lbx, ubx = self._collint_get_lbx_ubx(bounds, count, indices)
         x0 = self._collint_get_x0(count, indices)
 
         # Return number of state variables
@@ -2869,8 +2867,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
 
         # Check coefficient matrix
         logger.info(
-            "Sanity check on objective and constraints Jacobian matrix"
-            "/constant coefficients values"
+            "Sanity check on objective and constraints Jacobian matrix/constant coefficients values"
         )
 
         in_var = nlp["x"]
@@ -3113,7 +3110,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
         variable_to_all_indices = {k: set(v) for k, v in indices[0].items()}
         for ensemble_indices in indices[1:]:
             for k, v in ensemble_indices.items():
-                variable_to_all_indices[k] |= v
+                variable_to_all_indices[k] |= set(v)
 
         if len(inds_up) > 0:
             exceedences = []

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

@@ -55,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"
             )
@@ -298,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
@@ -358,6 +359,7 @@ class CSVLookupTableMixin(OptimizationProblem):
                             k=k,
                             monotonicity=mono,
                             curvature=curv,
+                            ipopt_options={"nlp_scaling_method": "none"},
                         )
                     else:
                         raise Exception(

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,11 +104,8 @@ 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)
@@ -115,11 +116,12 @@ def download_examples(*args):
 
     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)

rtctools/simulation/simulation_problem.py

@@ -1,13 +1,21 @@
 import copy
+import importlib.resources
 import itertools
 import logging
 import math
+import sys
 from collections import OrderedDict
 from typing import List, 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
 
@@ -82,9 +90,21 @@ class SimulationProblem(DataStoreAccessor):
                 model_name = self.__class__.__name__
 
         # Load model from pymoca backend
-        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 as error:
+            if 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 = {}
@@ -319,6 +339,17 @@ class SimulationProblem(DataStoreAccessor):
         """
         Initialize state vector with default values
 
+        Initial values are first read from the given Modelica files.
+        If an initial value equals zero or is not provided by a Modelica file,
+        and the variable is not marked as fixed,
+        then the initial value is tried to be set with the initial_state method.
+        When using CSVMixin, this method by default looks for initial values
+        in an initial_state.csv file.
+        Furthermore, if a variable is not marked as fixed
+        and no initial value is given by the initial_state method,
+        the initial value can be overwritten using the seed method.
+        When a variable is marked as fixed, the initial value is only read from the Modelica file.
+
         :param config_file: Path to an initialization file.
         """
         if config_file:
@@ -393,29 +424,33 @@ class SimulationProblem(DataStoreAccessor):
         for var in itertools.chain(self.__pymoca_model.states, self.__pymoca_model.alg_states):
             var_name = var.symbol.name()
             var_nominal = self.get_variable_nominal(var_name)
+            start_values = {}
 
             # Attempt to cast var.start to python type
             mx_start = ca.MX(var.start)
             if mx_start.is_constant():
                 # cast var.start to python type
-                start_val = var.python_type(mx_start.to_DM())
+                start_value_pymoca = var.python_type(mx_start.to_DM())
+                if start_value_pymoca is not None and start_value_pymoca != 0:
+                    start_values["modelica"] = start_value_pymoca
             else:
-                # var.start is a symbolic expression with unknown value
-                start_val = None
+                start_values["modelica"] = mx_start
 
-            if start_val == 0.0 and not var.fixed:
+            if not var.fixed:
                 # To make initialization easier, we allow setting initial states by providing
                 # timeseries with names that match a symbol in the model. We only check for this
                 # matching if the start and fixed attributes were left as default
                 try:
-                    start_val = self.initial_state()[var_name]
+                    start_values["initial_state"] = self.initial_state()[var_name]
                 except KeyError:
                     pass
                 else:
                     # An initial state was found- add it to the constrained residuals
                     logger.debug(
                         "Initialize: Added {} = {} to initial equations "
-                        "(found matching timeseries).".format(var_name, start_val)
+                        "(found matching timeseries).".format(
+                            var_name, start_values["initial_state"]
+                        )
                     )
                     # Set var to be fixed
                     var.fixed = True
@@ -425,36 +460,82 @@ class SimulationProblem(DataStoreAccessor):
                 # timeseries with names that match a symbol in the model. We only check for this
                 # matching if the start and fixed attributes were left as default
                 try:
-                    start_val = self.seed()[var_name]
+                    start_values["seed"] = self.seed()[var_name]
                 except KeyError:
                     pass
                 else:
                     # An initial state was found- add it to the constrained residuals
                     logger.debug(
                         "Initialize: Added {} = {} as initial guess "
-                        "(found matching timeseries).".format(var_name, start_val)
+                        "(found matching timeseries).".format(var_name, start_values["seed"])
+                    )
+
+            # Set the start value based on the different inputs.
+            if "seed" in start_values:
+                input_source = "seed"
+                source_description = "seed method"
+            elif "modelica" in start_values:
+                input_source = "modelica"
+                source_description = "modelica file"
+            elif "initial_state" in start_values:
+                input_source = "initial_state"
+                source_description = "initial_state method (typically reads initial_state.csv)"
+            else:
+                start_values["modelica"] = start_value_pymoca
+                input_source = "modelica"
+                source_description = "modelica file or default value"
+            start_val = start_values.get(input_source, None)
+            start_is_numeric = start_val is not None and not isinstance(start_val, ca.MX)
+            numeric_start_val = start_val if start_is_numeric else 0.0
+            if len(start_values) > 1:
+                logger.warning(
+                    "Initialize: Multiple initial values for {} are provided: {}.".format(
+                        var_name, start_values
                     )
+                    + " Value from {} will be used to continue.".format(source_description)
+                )
 
             # Attempt to set start_val in the state vector. Default to zero if unknown.
             try:
-                self.set_var(var_name, start_val if start_val is not None else 0.0)
+                self.set_var(var_name, numeric_start_val)
             except KeyError:
                 logger.warning(
-                    "Initialize: {} not found in state vector. "
-                    "Initial value of {} not set.".format(var_name, start_val)
+                    "Initialize: {} not found in state vector. Initial value of {} not set.".format(
+                        var_name, numeric_start_val
+                    )
                 )
 
             # Add a residual for the difference between the state and its starting expression
-            start_expr = start_val if start_val is not None else var.start
+            start_expr = start_val
+            min_is_symbolic = isinstance(var.min, ca.MX)
+            max_is_symbolic = isinstance(var.max, ca.MX)
             if var.fixed:
                 # Set bounds to be equal to each other, such that IPOPT can
                 # turn the decision variable into a parameter.
+                if min_is_symbolic or max_is_symbolic or var.min != -np.inf or var.max != np.inf:
+                    logger.info(
+                        "Initialize: bounds of {} will be overwritten".format(var_name)
+                        + " by the start value given by {}.".format(source_description)
+                    )
                 var.min = start_expr
                 var.max = start_expr
             else:
                 # minimize residual
                 minimized_residuals.append((var.symbol - start_expr) / var_nominal)
 
+            # Check that the start_value is in between the variable bounds.
+            if start_is_numeric and not min_is_symbolic and not max_is_symbolic:
+                if not (var.min <= start_val and start_val <= var.max):
+                    logger.log(
+                        (
+                            logging.WARNING
+                            if source_description != "modelica file or default value"
+                            else logging.DEBUG
+                        ),
+                        f"Initialize: start value {var_name} = {start_val} "
+                        f"is not in between bounds {var.min} and {var.max} and will be adjusted.",
+                    )
+
         # Default start var for ders is zero
         for der_var in self.__mx["derivatives"]:
             self.set_var(der_var.name(), 0.0)
@@ -610,7 +691,15 @@ class SimulationProblem(DataStoreAccessor):
         # If unsuccessful, stop.
         return_status = solver.stats()["return_status"]
         if return_status not in {"Solve_Succeeded", "Solved_To_Acceptable_Level"}:
-            raise Exception('Initialization Failed with return status "{}"'.format(return_status))
+            if return_status == "Infeasible_Problem_Detected":
+                message = (
+                    "Initialization Failed with return status: {}. ".format(return_status)
+                    + "This means no initial state could be found "
+                    + "that satisfies all equations and constraints."
+                )
+            else:
+                message = "Initialization Failed with return status: {}. ".format(return_status)
+            raise Exception(message)
 
         # Update state vector with initial conditions
         self.__state_vector[: self.__n_states] = initial_state["x"][: self.__n_states].T
@@ -762,6 +851,8 @@ class SimulationProblem(DataStoreAccessor):
         self.set_var("time", self.get_current_time() + dt)
 
         # take a step
+        if np.isnan(self.__state_vector).any():
+            logger.error("Found a nan in the state vector (before making the step)")
         guess = self.__state_vector[: self.__n_states]
         if len(self.__mx["parameters"]) > 0:
             next_state = self.__do_step(
@@ -769,6 +860,23 @@ class SimulationProblem(DataStoreAccessor):
             )
         else:
             next_state = self.__do_step(guess, dt, self.__state_vector)
+
+        try:
+            if np.isnan(next_state).any():
+                index_to_name = {index[0]: name for name, index in self.__indices.items()}
+                named_next_state = {
+                    index_to_name[i]: float(next_state[i]) for i in range(0, next_state.shape[0])
+                }
+                variables_with_nan = [
+                    name for name, value in named_next_state.items() if np.isnan(value)
+                ]
+                if variables_with_nan:
+                    logger.error(
+                        f"Found nan(s) in the next_state vector for:\n\t {variables_with_nan}"
+                    )
+        except (KeyError, IndexError, TypeError):
+            logger.warning("Something went wrong while checking for nans in the next_state vector")
+
         # Check convergence of rootfinder
         rootfinder_stats = self.__do_step.stats()
 
@@ -964,9 +1072,9 @@ class SimulationProblem(DataStoreAccessor):
         :param dt: Timestep size of the simulation.
         """
         if self._dt_is_fixed:
-            assert math.isclose(
-                self.__dt, dt
-            ), "Timestep size dt is marked as constant and cannot be changed."
+            assert math.isclose(self.__dt, dt), (
+                "Timestep size dt is marked as constant and cannot be changed."
+            )
         else:
             self.__dt = dt
 
@@ -1149,9 +1257,9 @@ class SimulationProblem(DataStoreAccessor):
         # 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
 

rtctools/util.py

@@ -110,6 +110,7 @@ def run_optimization_problem(
             "GoalProgrammingMixin",
             "PIMixin",
             "CSVMixin",
+            "IOMixin",
             "ModelicaMixin",
             "PlanningMixin",
             "ControlTreeMixin",

rtc_tools-2.6.1.dist-info/RECORD

@@ -1,50 +0,0 @@
-rtctools/__init__.py,sha256=91hvS2-ryd2Pvw0COpsUzTwJwSnTZ035REiej-1hNI4,107
-rtctools/_version.py,sha256=2OZVO8ezWtCbihHdmc9B5Bt65ImW3guaiFSxxQKyAhA,497
-rtctools/rtctoolsapp.py,sha256=UnkuiJhv0crEEVs8H6PYvMuc2y_q6V_xLuyKEgXj9GM,4200
-rtctools/util.py,sha256=PaeKfDUA174ODZbY5fZjCTf-F-TdhW7yEuP189Ro190,9075
-rtctools/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rtctools/_internal/alias_tools.py,sha256=XuQSAhhFuVtwn0yrAObZWIKPsSF4j2axXRtEmitIFPs,5310
-rtctools/_internal/caching.py,sha256=p4gqSL7kCI7Hff-KjMEP7mhJCQSiU_lYm2MR7E18gBM,905
-rtctools/_internal/casadi_helpers.py,sha256=oAf5zyFkZbaMhvhgMnQkOi2A6dBOzj-VAUkYwBf-Jxk,1410
-rtctools/_internal/debug_check_helpers.py,sha256=UgQTEPw4PyR7MbYLewSSWQqTwQj7xr5yUBk820O9Kk4,1084
-rtctools/data/__init__.py,sha256=EllgSmCdrlvQZSd1VilvjPaeYJGhY9ErPiQtedmuFoA,157
-rtctools/data/csv.py,sha256=iYOEED3AaNxt4ews_aAkHfl9Tq9a-9vjxvYwjVR_lQE,5231
-rtctools/data/netcdf.py,sha256=xpk4Ggl7gItNG6lO7p3OJPR-elK8_CiCtxUI7cX0gwk,19109
-rtctools/data/pi.py,sha256=Ni1hBDdhQdcWYO-NUPhKA1WJdzbSXjZc5w5xauOBcJM,45437
-rtctools/data/rtc.py,sha256=1yGJZGq2Z36MYLiLuZaHnxupL4mgw-Wuu54PAG05kcM,9077
-rtctools/data/storage.py,sha256=67J4BRTl0AMEzlKNZ8Xdpy_4cGtwx8Lo_tL2n0G4S9w,13206
-rtctools/data/interpolation/__init__.py,sha256=GBubCIT5mFoSTV-lOk7cpwvZekNMEe5bvqSQJ9HE34M,73
-rtctools/data/interpolation/bspline.py,sha256=qevB842XWCH3fWlWMBqKMy1mw37ust-0YtSnb9PKCEc,948
-rtctools/data/interpolation/bspline1d.py,sha256=hQrok4rrBcJV_HciuFjZYSwrSP8w_VufQRP6JLZhA7U,6106
-rtctools/data/interpolation/bspline2d.py,sha256=ScmX0fPDxbUVtj3pbUE0L7UJocqroD_6fUT-4cvdRMc,1693
-rtctools/optimization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rtctools/optimization/collocated_integrated_optimization_problem.py,sha256=Bv1a1O4QTAdIpe9SOA9_oEDDph-oj-9q5yfN4SFMdW8,131343
-rtctools/optimization/control_tree_mixin.py,sha256=CC6TWp3kFQgMokx6213pRLx9iY17Fd0VcwG4Wpwa0Uo,8974
-rtctools/optimization/csv_lookup_table_mixin.py,sha256=h4WKuPR1BJbYuJfQ9lx4rXalB6yYK-zajINabRL7BrA,17298
-rtctools/optimization/csv_mixin.py,sha256=sRp5paHWfCw2bz-23Nw-HdFLS3CZTpVwaBdFo98DbvE,12252
-rtctools/optimization/goal_programming_mixin.py,sha256=GK25DrbAY_rMsra080pSCDZwzLQNN2Ppd-2d0_FEllg,32999
-rtctools/optimization/goal_programming_mixin_base.py,sha256=oh9CsEiyYTmthcfvRbX-9Z9bIo6SHv_DCiVt9kx0sjI,43781
-rtctools/optimization/homotopy_mixin.py,sha256=Kh0kMfxB-Fo1FBGW5tPOQk24Xx_Mmw_p0YuSQotdkMU,6905
-rtctools/optimization/initial_state_estimation_mixin.py,sha256=74QYfG-VYYTNVg-kAnCG6QoY3_sUmaID0ideF7bPkkY,3116
-rtctools/optimization/io_mixin.py,sha256=AsZQ7YOUcUbWoczmjTXaSje5MUEsPNbQyZBJ6qzSjzU,11821
-rtctools/optimization/linearization_mixin.py,sha256=mG5S7uwvwDydw-eBPyQKnLyKoy08EBjQh25vu97afhY,1049
-rtctools/optimization/linearized_order_goal_programming_mixin.py,sha256=LQ2qpYt0YGLpEoerif4FJ5wwzq16q--27bsRjcqIU5A,9087
-rtctools/optimization/min_abs_goal_programming_mixin.py,sha256=WMOv9EF8cfDJgTunzXfI_cUmBSQK26u1HJB_9EAarfM,14031
-rtctools/optimization/modelica_mixin.py,sha256=ysVMayNA4sSFoHkSdhjWOxT6UzOVbN0ZeM4v-RpvZXE,17161
-rtctools/optimization/netcdf_mixin.py,sha256=-zkXh3sMYE50c3kHsrmUVGWMSFm-0cXQpGrCm0yn-Tc,7563
-rtctools/optimization/optimization_problem.py,sha256=qzpc81NaZMeoXKuayFmBF15iXYuNAk5yxmaER_Gcz_A,44131
-rtctools/optimization/pi_mixin.py,sha256=63qda6i7hjtDuP3hL6RO29vCCP11aUpR9B4KoqlLFVI,11314
-rtctools/optimization/planning_mixin.py,sha256=O_Y74X8xZmaNZR4iYOe7BR06s9hnmcapbuHYHQTBPPQ,724
-rtctools/optimization/single_pass_goal_programming_mixin.py,sha256=Zb9szg3PGT2o6gkGsXluSfEaAswkw3TKfPQDzUrj_Y4,25784
-rtctools/optimization/timeseries.py,sha256=nCrsGCJThBMh9lvngEpbBDa834_QvklVvkxJqwX4a1M,1734
-rtctools/simulation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rtctools/simulation/csv_mixin.py,sha256=rGDUFPsqGHmF0_dWdXeWzWzMpkPmwCNweTBVrwSh31g,6704
-rtctools/simulation/io_mixin.py,sha256=SJasNGI--OQ9Y-Z61oeeaGCxSrNddYz4AOVfJYbmf74,6209
-rtctools/simulation/pi_mixin.py,sha256=uwl61LYjb8dmMz910EB2-bC0KSuhLzsrJzk0hxWYEhk,9359
-rtctools/simulation/simulation_problem.py,sha256=gTAimG2MLw_TTkeHLkIMxpYgAmR-voqzvje7pcFnw4U,44556
-rtc_tools-2.6.1.dist-info/COPYING.LESSER,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-rtc_tools-2.6.1.dist-info/METADATA,sha256=xRGaIE4XUCeH33cpMwv5LI_EbIqlYyoOChU6Epg8VAA,1492
-rtc_tools-2.6.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-rtc_tools-2.6.1.dist-info/entry_points.txt,sha256=-x622IB_l1duw2M6t6syfQ4yzOiQTp0IZxKGcYRgWgk,151
-rtc_tools-2.6.1.dist-info/top_level.txt,sha256=pnBrb58PFPd1kp1dqa-JHU7R55h3alDNJIJnF3Jf9Dw,9
-rtc_tools-2.6.1.dist-info/RECORD,,