rtc-tools 2.7.0.dev2__py3-none-any.whl → 2.8.0a1__py3-none-any.whl

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/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

@@ -50,7 +50,7 @@ class ControlTreeMixin(OptimizationProblem):
         return options
 
     def discretize_control(self, variable, ensemble_member, times, offset):
-        control_indices = np.zeros(len(times), dtype=np.int16)
+        control_indices = np.zeros(len(times), dtype=np.int64)
         for branch, members in self.__branches.items():
             if ensemble_member not in members:
                 continue
@@ -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

@@ -1,12 +1,13 @@
 import itertools
 import logging
 from collections import OrderedDict
-from typing import Dict, Union
+from typing import Dict, Optional, Union
 
 import casadi as ca
 import numpy as np
 
 from rtctools._internal.alias_tools import AliasDict
+from rtctools._internal.ensemble_bounds_decorator import ensemble_bounds_check
 
 from .goal_programming_mixin_base import (  # noqa: F401
     Goal,
@@ -65,8 +66,12 @@ class GoalProgrammingMixin(_GoalProgrammingMixinBase):
     def path_variables(self):
         return self.__problem_path_epsilons + self.__subproblem_path_epsilons
 
-    def bounds(self):
-        bounds = super().bounds()
+    @ensemble_bounds_check
+    def bounds(self, ensemble_member: Optional[int] = None):
+        bounds = (
+            super().bounds(ensemble_member) if self.ensemble_specific_bounds else super().bounds()
+        )
+
         for epsilon in (
             self.__subproblem_epsilons
             + self.__subproblem_path_epsilons
@@ -351,8 +356,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

rtctools/optimization/goal_programming_mixin_base.py

@@ -394,7 +394,31 @@ class StateGoal(Goal):
         # Extract state range from model
         if self.has_target_bounds:
             try:
-                self.function_range = optimization_problem.bounds()[self.state]
+                if optimization_problem.ensemble_specific_bounds:
+                    bounds = optimization_problem.bounds(0)
+                    bounds_state_ref = bounds[self.state]
+                    if np.array_equal(self.function_range, (np.nan, np.nan), equal_nan=True):
+                        # If the user has not set the function range themselves, we
+                        # try and set it automatically. This is only possible if the
+                        # bounds are the same for all ensemble members.
+                        for ensemble_member in range(optimization_problem.ensemble_size):
+                            bounds_state_ensemble = optimization_problem.bounds(ensemble_member)[
+                                self.state
+                            ]
+                            # First, check if the types are equal, and then check if the values are
+                            # equal. For Timeseries and floats, we can do `==` comparison, for
+                            # arrays we need to use np.all. To simplify we wrap the `==` for floats
+                            # in an `np.all` as well.
+                            if type(bounds_state_ref) is not type(
+                                bounds_state_ensemble
+                            ) or not np.all(bounds_state_ref == bounds_state_ensemble):
+                                raise ValueError(
+                                    f"Bounds for state {self.state} are not the same for all "
+                                    f"ensemble members; please set the function_range explicitly"
+                                )
+                else:
+                    bounds = optimization_problem.bounds()
+                self.function_range = bounds[self.state]
             except KeyError:
                 raise Exception(
                     "State {} has no bounds or does not exist in the model.".format(self.state)
@@ -437,7 +461,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 +1006,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

rtctools/optimization/io_mixin.py

@@ -2,11 +2,13 @@ import bisect
 import logging
 import warnings
 from abc import ABCMeta, abstractmethod
+from typing import Optional
 
 import casadi as ca
 import numpy as np
 
 from rtctools._internal.caching import cached
+from rtctools._internal.ensemble_bounds_decorator import ensemble_bounds_check
 from rtctools.optimization.optimization_problem import OptimizationProblem
 from rtctools.optimization.timeseries import Timeseries
 
@@ -174,9 +176,13 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
         return "_".join((variable, "Max"))
 
     @cached
-    def bounds(self):
-        # Call parent class first for default values.
-        bounds = super().bounds()
+    @ensemble_bounds_check
+    def bounds(self, ensemble_member: Optional[int] = None):
+        bounds = (
+            super().bounds(ensemble_member) if self.ensemble_specific_bounds else super().bounds()
+        )
+
+        ensemble_member = ensemble_member if self.ensemble_specific_bounds else 0
 
         io_times = self.io.times_sec
         t_pos = bisect.bisect_left(io_times, self.initial_time)
@@ -189,7 +195,7 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
 
             timeseries_id = self.min_timeseries_id(variable_name)
             try:
-                _, values = self.io.get_timeseries_sec(timeseries_id, 0)
+                _, values = self.io.get_timeseries_sec(timeseries_id, ensemble_member)
                 m = values[t_pos:]
             except KeyError:
                 pass
@@ -199,7 +205,7 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
 
             timeseries_id = self.max_timeseries_id(variable_name)
             try:
-                _, values = self.io.get_timeseries_sec(timeseries_id, 0)
+                _, values = self.io.get_timeseries_sec(timeseries_id, ensemble_member)
                 M = values[t_pos:]
             except KeyError:
                 pass