rtc-tools 2.7.0.dev1__py3-none-any.whl → 2.8.0.dev0__py3-none-any.whl

{rtc_tools-2.7.0.dev1.dist-info → rtc_tools-2.8.0.dev0.dist-info}/METADATA

@@ -1,9 +1,9 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: rtc-tools
-Version: 2.7.0.dev1
+Version: 2.8.0.dev0
 Summary: Toolbox for control and optimization of water systems.
 Home-page: https://oss.deltares.nl/web/rtc-tools/home
-Download-URL: http://gitlab.com/deltares/rtc-tools/
+Download-URL: http://github.com/deltares/rtc-tools/
 Author: Deltares
 Maintainer: Deltares
 Platform: Windows
@@ -25,12 +25,13 @@ Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS
 Requires-Python: >=3.9
 License-File: COPYING.LESSER
-Requires-Dist: casadi!=3.6.6,==3.6.*,>=3.6.3
+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"
 Provides-Extra: all
@@ -40,6 +41,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: download-url
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: maintainer
 Dynamic: platform
 Dynamic: provides-extra

rtc_tools-2.8.0.dev0.dist-info/RECORD

@@ -0,0 +1,51 @@
+rtc_tools-2.8.0.dev0.dist-info/licenses/COPYING.LESSER,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+rtctools/__init__.py,sha256=91hvS2-ryd2Pvw0COpsUzTwJwSnTZ035REiej-1hNI4,107
+rtctools/_version.py,sha256=vPQa8xovfhixPF0_vDyitAlfdCnf7AuYQ3pxw6oMyCU,502
+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=UcVSBsOs9f8gAGk4s3CQRS7TSE1CIvKt0uhrD4gLwu4,1727
+rtctools/_internal/debug_check_helpers.py,sha256=UgQTEPw4PyR7MbYLewSSWQqTwQj7xr5yUBk820O9Kk4,1084
+rtctools/_internal/ensemble_bounds_decorator.py,sha256=-eMSvkgKQ0Ew3EBDzsikQjIOlEP_iZOpbGGuX8R0F_A,2917
+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=cmcjcrv5EdVcZfAZNB8V-BwPC7M1IJYnalvPaP8BhYo,133037
+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=GEseE9DNT39eZSKHP83N_pPo0DE_U9loH6Ymqp4XSRQ,33570
+rtctools/optimization/goal_programming_mixin_base.py,sha256=asvPSUZnmpCvRNTHCs-orwjQGBMCOlJZTFtByBVnXUU,45508
+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=L_afeqWjO722ZI5asN_3ykn-xvcbFO360A6Qqo8H2OA,12145
+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=1ZXILToZjni3y6bvDFiruV3s-tocFwv363kNlevXb9M,14282
+rtctools/optimization/modelica_mixin.py,sha256=rl-ZUuH811wqNwQR1-eLrG68uVo2kwwKpj1-oEGSbI0,18329
+rtctools/optimization/netcdf_mixin.py,sha256=-zkXh3sMYE50c3kHsrmUVGWMSFm-0cXQpGrCm0yn-Tc,7563
+rtctools/optimization/optimization_problem.py,sha256=40AzasL_WmXzu97C-GFFuaZtroduGLYaoEGfCQRqlOo,46096
+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=4ybHNcrgyI5i8RrVqSd6Xp3riy0j2Vb5JcrkTt9-kUQ,26035
+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.8.0.dev0.dist-info/METADATA,sha256=VdZNL25Ea4rCEr0ECV86LPLByA9ajJYnJBr_OTQAnQw,1777
+rtc_tools-2.8.0.dev0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rtc_tools-2.8.0.dev0.dist-info/entry_points.txt,sha256=DVS8sWf3b9ph9h8srEr6zmQ7ZKGwblwgZgGPZg-jRNQ,150
+rtc_tools-2.8.0.dev0.dist-info/top_level.txt,sha256=pnBrb58PFPd1kp1dqa-JHU7R55h3alDNJIJnF3Jf9Dw,9
+rtc_tools-2.8.0.dev0.dist-info/RECORD,,

{rtc_tools-2.7.0.dev1.dist-info → rtc_tools-2.8.0.dev0.dist-info}/WHEEL

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

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
@@ -52,4 +52,12 @@ def interpolate(ts, xs, t, equidistant, mode=0):
         mode_str = "floor"
     else:
         mode_str = "ceil"
+
+    # CasADi fails if there is just a single point. Just "extrapolate" based on
+    # that point, just as CasADi would do for entries in 't' outside the range
+    # of 'ts'.
+    if len(ts) == 1:
+        assert xs.size1() == 1
+        return ca.vertcat(*[xs] * len(t))
+
     return ca.interp1d(ts, xs, t, mode_str, equidistant)

rtctools/_internal/ensemble_bounds_decorator.py

@@ -0,0 +1,71 @@
+import functools
+import inspect
+
+
+def ensemble_bounds_check(func):
+    """
+    Decorator for bounds() methods that enforces ensemble_member parameter handling
+    based on the ensemble_specific_bounds feature flag.
+
+    When ensemble_specific_bounds is True:
+    - ensemble_member parameter must be passed (and must be integer)
+
+    When ensemble_specific_bounds is False:
+    - ensemble_member parameter must NOT be passed
+
+    Raises appropriate TypeErrors with feature flag context.
+    """
+
+    @functools.wraps(func)
+    def wrapper(self, *args, **kwargs):
+        # Check that the decorator is used on a method that matches the
+        # expected signature
+        sig = inspect.signature(func)
+
+        has_ensemble_member_param = "ensemble_member" in sig.parameters
+
+        if not has_ensemble_member_param:
+            raise RuntimeError(
+                f"bounds() method {func.__qualname__} must have 'ensemble_member' parameter. "
+                f"Expected signature: def bounds(self, ensemble_member: Optional[int] = None)"
+            )
+
+        # Determine if ensemble_member was provided in the call
+        ensemble_member_provided = False
+        ensemble_member_value = None
+
+        if args:
+            # ensemble_member was passed as positional argument
+            ensemble_member_provided = True
+            ensemble_member_value = args[0]
+        elif "ensemble_member" in kwargs:
+            # ensemble_member was passed as keyword argument
+            ensemble_member_provided = True
+            ensemble_member_value = kwargs["ensemble_member"]
+
+        # Check feature flag and enforce rules
+        if self.ensemble_specific_bounds:
+            # Feature flag is ON - ensemble_member should be passed
+            if not ensemble_member_provided:
+                raise TypeError(
+                    f"{func.__name__}() missing 1 required positional argument: 'ensemble_member'. "
+                    f"This is required when the 'ensemble_specific_bounds' feature flag is enabled."
+                )
+            if ensemble_member_provided and not isinstance(ensemble_member_value, int):
+                raise TypeError(
+                    f"ensemble_member must be an int, got {type(ensemble_member_value).__name__}"
+                    f"This is required when the 'ensemble_specific_bounds' feature flag is enabled."
+                )
+        else:
+            # Feature flag is OFF - ensemble_member should NOT be passed. Not even None.
+            if ensemble_member_provided:
+                raise TypeError(
+                    f"{func.__name__}() takes 1 positional argument but 2 were given. "
+                    f"The 'ensemble_member' parameter should not be provided when the "
+                    f"'ensemble_specific_bounds' feature flag is disabled."
+                )
+
+        # Call the original function
+        return func(self, *args, **kwargs)
+
+    return wrapper

rtctools/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-01-29T10:45:25+0100",
+ "date": "2025-06-17T11:37:07+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "41dd2517c9c4cd952cd3da53b551b988bc5b64ba",
- "version": "2.7.0.dev1"
+ "full-revisionid": "3db6db805a899864946b3357bc619f5f1db7c09d",
+ "version": "2.8.0.dev0"
 }
 '''  # END VERSION_JSON
 

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),
                 )
 
 

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

@@ -6,6 +6,7 @@ from typing import Dict, Union
 
 import casadi as ca
 import numpy as np
+from numpy.typing import NDArray
 
 from rtctools._internal.alias_tools import AliasDict
 from rtctools._internal.casadi_helpers import (
@@ -17,7 +18,7 @@ from rtctools._internal.casadi_helpers import (
 )
 from rtctools._internal.debug_check_helpers import DebugLevel, debug_check
 
-from .optimization_problem import OptimizationProblem
+from .optimization_problem import BT, OptimizationProblem
 from .timeseries import Timeseries
 
 logger = logging.getLogger("rtctools")
@@ -410,7 +411,10 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                 if v.ndim == 1:
                     ensemble_data["extra_constant_inputs"][k] = v[:, None]
 
-        bounds = self.bounds()
+        if self.ensemble_specific_bounds:
+            bounds = [self.bounds(ensemble_member=i) for i in range(self.ensemble_size)]
+        else:
+            bounds = self.bounds()
 
         # Initialize control discretization
         (
@@ -670,7 +674,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                 for ensemble_member in range(self.ensemble_size)
             ]
             if (
-                len(values) == 1 or (np.all(values) == values[0])
+                len(values) == 1 or all(v == values[0] for v in values)
             ) and parameter.name() not in dynamic_parameter_names:
                 constant_parameters.append(parameter)
                 constant_parameter_values.append(values[0])
@@ -898,11 +902,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 +937,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 +1032,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 +1807,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 +2047,12 @@ 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: Union[dict[str, BT], list[dict[str, BT]]],
+        count: int,
+        indices: list[dict[str, Union[slice, int]]],
+    ) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
         lbx = np.full(count, -np.inf, dtype=np.float64)
         ubx = np.full(count, np.inf, dtype=np.float64)
 
@@ -2056,6 +2063,11 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
 
         # Bounds, defaulting to +/- inf, if not set
         for ensemble_member in range(self.ensemble_size):
+            if self.ensemble_specific_bounds:
+                bounds_member = bounds[ensemble_member]
+            else:
+                bounds_member = bounds
+
             for variable, inds in indices[ensemble_member].items():
                 variable_size = variable_sizes[variable]
 
@@ -2067,7 +2079,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                     n_times = len(times)
 
                 try:
-                    bound = bounds[variable]
+                    bound = bounds_member[variable]
                 except KeyError:
                     pass
                 else:
@@ -2096,7 +2108,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                             )
                         else:
                             lower_bound = bound[0]
-                        lbx[inds] = lower_bound / nominal
+                        lbx[inds] = np.maximum(lbx[inds], lower_bound / nominal)
 
                     if bound[1] is not None:
                         if isinstance(bound[1], Timeseries):
@@ -2116,7 +2128,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                             )
                         else:
                             upper_bound = bound[1]
-                        ubx[inds] = upper_bound / nominal
+                        ubx[inds] = np.minimum(ubx[inds], upper_bound / nominal)
 
                 # Warn for NaNs
                 if np.any(np.isnan(lbx[inds])):
@@ -2124,6 +2136,19 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                 if np.any(np.isnan(ubx[inds])):
                     logger.error("Upper bound on variable {} contains NaN".format(variable))
 
+                # Check that the lower bounds are not higher than the upper
+                # bounds. To avoid spam, we just log the first offending one per
+                # variable, not _all_ time steps.
+                if np.any(lbx[inds] > ubx[inds]):
+                    error_inds = np.where(lbx[inds] > ubx[inds])[0].tolist()
+                    logger.error(
+                        "Lower bound {} is higher than upper bound {} for variable {}".format(
+                            lbx[inds][error_inds[0]] * nominal,
+                            ubx[inds][error_inds[0]] * nominal,
+                            variable,
+                        )
+                    )
+
         return lbx, ubx
 
     def _collint_get_x0(self, count, indices):
@@ -2210,7 +2235,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 +2351,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
@@ -2610,14 +2635,25 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
         else:
             tf = xf = ca.MX()
         t = ca.vertcat(t0, history_times[history_indices], times[indices], tf)
-        x = ca.vertcat(x0, history[history_indices], state[indices[0] : indices[-1] + 1], xf)
+        x = ca.vertcat(x0, history[history_indices], state[indices], xf)
 
         return x, t
 
-    def states_in(self, variable, t0=None, tf=None, ensemble_member=0):
-        x, _ = self.__states_times_in(variable, t0, tf, ensemble_member)
+    def states_in(
+        self,
+        variable: str,
+        t0: float = None,
+        tf: float = None,
+        ensemble_member: int = 0,
+        *,
+        return_times: bool = False,
+    ) -> Union[ca.MX, tuple[ca.DM, ca.MX]]:
+        x, t = self.__states_times_in(variable, t0, tf, ensemble_member)
 
-        return x
+        if return_times:
+            return x, t
+        else:
+            return x
 
     def integral(self, variable, t0=None, tf=None, ensemble_member=0):
         x, t = self.__states_times_in(variable, t0, tf, ensemble_member)
@@ -2869,8 +2905,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"]
@@ -2923,8 +2958,19 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
             "{} & {}, {} & {}".format(max_constr_A, min_constr_A, max_constr_b, min_constr_b)
         )
 
-        maxs = [x for x in [max_constr_A, max_constr_b, max_obj_A, obj_b] if x is not None]
-        mins = [x for x in [min_constr_A, min_constr_b, min_obj_A, obj_b] if x is not None]
+        # Filter out exactly zero, as those entries do not show up in the
+        # matrix. Shut up SonarCloud warning about this exact-to-zero
+        # comparison.
+        maxs = [
+            x
+            for x in [max_constr_A, max_constr_b, max_obj_A, obj_b]
+            if x is not None and x != 0.0  # NOSONAR
+        ]
+        mins = [
+            x
+            for x in [min_constr_A, min_constr_b, min_obj_A, obj_b]
+            if x is not None and x != 0.0  # NOSONAR
+        ]
         if (maxs and max(maxs) > tol_up) or (mins and min(mins) < tol_down):
             logger.info("Jacobian matrix /constants coefficients values outside typical range!")
 
@@ -3113,7 +3159,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")