rtc-tools 2.7.2__tar.gz → 2.7.3__tar.gz

{rtc_tools-2.7.2/src/rtc_tools.egg-info → rtc_tools-2.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rtc-tools
-Version: 2.7.2
+Version: 2.7.3
 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/

{rtc_tools-2.7.2 → rtc_tools-2.7.3}/README.md

@@ -50,6 +50,12 @@ pip install rtc-tools
 
 Documentation and examples can be found on [readthedocs](https://rtc-tools.readthedocs.io).
 
+## Contributing
+
+We welcome contributions to RTC-Tools! Please see our [Contributing Guidelines](CONTRIBUTING.md) for details on how to get started, coding standards, and our development process.
+
+The project is governed according to our [Technical Charter](CHARTER.md) and [Governance Model](GOVERNANCE.md).
+
 
 ## Migration from GitLab
 

{rtc_tools-2.7.2 → rtc_tools-2.7.3}/pyproject.toml

@@ -10,6 +10,7 @@ exclude = '''
 [tool.ruff]
 lint.ignore = [
 	"B904", # Fix someday: raising exceptions within except
+	"B905", # zip() without explicit strict parameter - not available in Python 3.9
 ]
 line-length = 100
 lint.select = [

{rtc_tools-2.7.2 → rtc_tools-2.7.3/src/rtc_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rtc-tools
-Version: 2.7.2
+Version: 2.7.3
 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/

{rtc_tools-2.7.2 → rtc_tools-2.7.3}/src/rtctools/_internal/casadi_helpers.py

@@ -1,9 +1,16 @@
+from __future__ import annotations
+
 import logging
 
 import casadi as ca
 
 logger = logging.getLogger("rtctools")
 
+# Limit the number of times we try to substitute in external functions, e.g. in
+# case of infinite recursion. Generally unlikely that we will hit this limit for
+# any reasonable use case.
+MAX_SUBSTITUTE_DEPTH = 10
+
 
 def is_affine(expr, symbols):
     try:
@@ -37,12 +44,41 @@ def reduce_matvec(e, v):
     return ca.reshape(ca.mtimes(A, v), e.shape)
 
 
-def substitute_in_external(expr, symbols, values):
-    if len(symbols) == 0 or all(isinstance(x, ca.DM) for x in expr):
+def substitute_in_external(
+    expr: list[ca.MX],
+    symbols: list[ca.MX],
+    values: list[ca.MX | ca.DM | float],
+    /,
+    resolve_numerically=False,
+):
+    # We expect expr to be a list of (at most) length 1
+    assert len(expr) <= 1
+
+    if not expr or len(symbols) == 0 or all(isinstance(x, ca.DM) for x in expr):
         return expr
-    else:
+    elif not resolve_numerically:
         f = ca.Function("f", symbols, expr)
         return f.call(values, True, False)
+    else:
+        # CasADi < 3.7 workaround: f.call() with MX values returns wrapped
+        # results like f(...){0}. Resolve symbolics with ca.substitute(), and
+        # convert resulting MX constants to floats first. Remove when dropping
+        # support for CasADi 3.6.x.
+        resolved_values = list(values)
+        for _ in range(MAX_SUBSTITUTE_DEPTH):
+            for i, v in enumerate(resolved_values):
+                if isinstance(v, ca.MX) and not v.is_constant():
+                    resolved_values[i] = ca.substitute([v], symbols, resolved_values)[0]
+                elif isinstance(v, ca.MX):
+                    resolved_values[i] = float(v)
+
+            # Substitute in expression using f.call() for external function support
+            f = ca.Function("f", symbols, expr).expand()
+            expr = f.call(resolved_values, True, False)
+            if expr[0].is_constant():
+                break
+
+        return expr
 
 
 def interpolate(ts, xs, t, equidistant, mode=0):

{rtc_tools-2.7.2 → rtc_tools-2.7.3}/src/rtctools/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-11-25T14:13:12+0100",
+ "date": "2026-01-20T14:58:22+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "280b3e8717728329dcbec06fd57fd2e61d5dadbf",
- "version": "2.7.2"
+ "full-revisionid": "20585c7d4d1b615468ea7f7dab44a240aeb1f05c",
+ "version": "2.7.3"
 }
 '''  # END VERSION_JSON
 

{rtc_tools-2.7.2 → rtc_tools-2.7.3}/src/rtctools/optimization/collocated_integrated_optimization_problem.py

@@ -1,11 +1,13 @@
+from __future__ import annotations
+
 import itertools
 import logging
 import warnings
 from abc import ABCMeta, abstractmethod
-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 +19,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")
@@ -44,11 +46,17 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
 
     :cvar check_collocation_linearity:
         If ``True``, check whether collocation constraints are linear. Default is ``True``.
+    :cvar inline_delay_expressions:
+        If ``True``, delay expressions are inlined into constraints and objectives instead of
+        being added as separate equality constraints. Default is ``False``.
     """
 
     #: Check whether the collocation constraints are linear
     check_collocation_linearity = True
 
+    #: Inline delay expressions instead of adding them as separate equality constraints
+    inline_delay_expressions = False
+
     #: Whether or not the collocation constraints are linear (affine)
     linear_collocation = None
 
@@ -172,7 +180,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
         #      algebraic parts. Theta then only applies to the ODE part.
         return 1.0
 
-    def map_options(self) -> Dict[str, Union[str, int]]:
+    def map_options(self) -> dict[str, str | int]:
         """
         Returns a dictionary of CasADi ``map()`` options.
 
@@ -312,7 +320,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
             for variable in self.__integrated_states:
                 if self.__variable_sizes.get(variable, 1) > 1:
                     raise NotImplementedError(
-                        "Vector symbol not supported for integrated state '{}'".format(variable)
+                        f"Vector symbol not supported for integrated state '{variable}'"
                     )
         else:
             self.__integrated_states = []
@@ -321,7 +329,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
         for variable in self.controls:
             if self.__variable_sizes.get(variable, 1) > 1:
                 raise NotImplementedError(
-                    "Vector symbol not supported for control state '{}'".format(variable)
+                    f"Vector symbol not supported for control state '{variable}'"
                 )
 
         # Collocation times
@@ -342,7 +350,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                 try:
                     constant_input = raw_constant_inputs[variable]
                 except KeyError:
-                    raise Exception("No values found for constant input {}".format(variable))
+                    raise Exception(f"No values found for constant input {variable}")
                 else:
                     values = constant_input.values
                     interpolation_method = self.interpolation_method(variable)
@@ -371,7 +379,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                 try:
                     parameter_values[i] = parameters[variable]
                 except KeyError:
-                    raise Exception("No value specified for parameter {}".format(variable))
+                    raise Exception(f"No value specified for parameter {variable}")
 
             if len(dynamic_parameters) > 0:
                 jac_1 = ca.jacobian(symbolic_parameters, ca.vertcat(*dynamic_parameters))
@@ -385,7 +393,10 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
             ):
                 parameter_values = nullvertcat(*parameter_values)
                 [parameter_values] = substitute_in_external(
-                    [parameter_values], self.dae_variables["parameters"], parameter_values
+                    [parameter_values],
+                    self.dae_variables["parameters"],
+                    ca.vertsplit(parameter_values),
+                    resolve_numerically=False,
                 )
             else:
                 parameter_values = nullvertcat(*parameter_values)
@@ -410,7 +421,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
         (
@@ -494,8 +508,8 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
         collocated_variables += self.dae_variables["control_inputs"]
 
         if logger.getEffectiveLevel() == logging.DEBUG:
-            logger.debug("Integrating variables {}".format(repr(integrated_variables)))
-            logger.debug("Collocating variables {}".format(repr(collocated_variables)))
+            logger.debug(f"Integrating variables {repr(integrated_variables)}")
+            logger.debug(f"Collocating variables {repr(collocated_variables)}")
 
         integrated_variable_names = [v.name() for v in integrated_variables]
         integrated_variable_nominals = np.array(
@@ -517,14 +531,14 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
             collocated_derivatives = self.dae_variables["derivatives"][:]
         self.__algebraic_and_control_derivatives = []
         for var in self.dae_variables["algebraics"]:
-            sym = ca.MX.sym("der({})".format(var.name()))
+            sym = ca.MX.sym(f"der({var.name()})")
             self.__algebraic_and_control_derivatives.append(sym)
             if self.integrate_states:
                 integrated_derivatives.append(sym)
             else:
                 collocated_derivatives.append(sym)
         for var in self.dae_variables["control_inputs"]:
-            sym = ca.MX.sym("der({})".format(var.name()))
+            sym = ca.MX.sym(f"der({var.name()})")
             self.__algebraic_and_control_derivatives.append(sym)
             collocated_derivatives.append(sym)
 
@@ -758,7 +772,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                 try:
                     lookup_table = lookup_tables[sym_name]
                 except KeyError:
-                    raise Exception("Unable to find lookup table function for {}".format(sym_name))
+                    raise Exception(f"Unable to find lookup table function for {sym_name}")
                 else:
                     input_syms = [
                         self.variable(input_sym.name()) for input_sym in lookup_table.inputs
@@ -823,9 +837,9 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
             if self.integrate_states:
                 I = ca.MX.sym("I", len(integrated_variables))  # noqa: E741
                 I0 = ca.MX.sym("I0", len(integrated_variables))
-                C0 = [ca.MX.sym("C0[{}]".format(i)) for i in range(len(collocated_variables))]
+                C0 = [ca.MX.sym(f"C0[{i}]") for i in range(len(collocated_variables))]
                 CI0 = [
-                    ca.MX.sym("CI0[{}]".format(i))
+                    ca.MX.sym(f"CI0[{i}]")
                     for i in range(len(self.dae_variables["constant_inputs"]))
                 ]
                 dt_sym = ca.MX.sym("dt")
@@ -1243,6 +1257,12 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
         # Integrators are saved for result extraction later on
         self.__integrators = []
 
+        # If inlining delay expressions, prepare for the single call to ca.substitute()
+        # at the end
+        if self.inline_delay_expressions:
+            delayed_feedback_variable_replacement = ca.MX.zeros(X.numel())
+            delayed_feedback_variable_replacement[:] = X
+
         # Process the objectives and constraints for each ensemble member separately.
         # Note that we don't use map here for the moment, so as to allow each ensemble member to
         # define its own constraints and objectives. Path constraints are applied for all ensemble
@@ -1250,9 +1270,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
         # ensemble member to specify its own path constraints as well, once CasADi has some kind
         # of loop detection.
         for ensemble_member in range(self.ensemble_size):
-            logger.info(
-                "Transcribing ensemble member {}/{}".format(ensemble_member + 1, self.ensemble_size)
-            )
+            logger.info(f"Transcribing ensemble member {ensemble_member + 1}/{self.ensemble_size}")
 
             initial_state = ensemble_aggregate["initial_state"][:, ensemble_member]
             initial_derivatives = ensemble_aggregate["initial_derivatives"][:, ensemble_member]
@@ -1299,9 +1317,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
 
                         if val < lbx[idx] or val > ubx[idx]:
                             logger.warning(
-                                "Initial value {} for variable '{}' outside bounds.".format(
-                                    val, variable
-                                )
+                                f"Initial value {val} for variable '{variable}' outside bounds."
                             )
 
                         lbx[idx] = ubx[idx] = val
@@ -1627,13 +1643,13 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                         states_and_algebraics_and_controls,
                         states_and_algebraics_and_controls_derivatives,
                         *[
-                            ca.horzcat(*constant_inputs[variable][1:])
+                            ca.MX(constant_inputs[variable][1:]).T
                             for variable in dae_constant_inputs_names
                         ],
-                        ca.horzcat(*collocation_times[1:]),
+                        ca.MX(collocation_times[1:]).T,
                         path_variables.T if path_variables.numel() > 0 else ca.MX(),
                         *[
-                            ca.horzcat(*extra_constant_inputs[variable][1:])
+                            ca.MX(extra_constant_inputs[variable][1:]).T
                             for (variable, _) in extra_constant_inputs_name_and_size
                         ],
                     ),
@@ -1826,8 +1842,8 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                         np.isnan(delayed_feedback_history[hist_start_ind:, i])
                     ):
                         logger.warning(
-                            "Incomplete history for delayed expression {}. "
-                            "Extrapolating t0 value backwards in time.".format(expression)
+                            f"Incomplete history for delayed expression {expression}. "
+                            "Extrapolating t0 value backwards in time."
                         )
                         out_times = out_times[len(history_times) :]
                         out_values = out_values[len(history_times) :]
@@ -1851,10 +1867,32 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
 
                     nominal = nominal_delayed_feedback[i]
 
-                    g.append((x_in - x_out_delayed) / nominal)
-                    zeros = np.zeros(n_collocation_times)
-                    lbg.extend(zeros)
-                    ubg.extend(zeros)
+                    if self.inline_delay_expressions:
+                        # Get the indices for the delayed feedback variable in the optimization
+                        # vector
+                        indices = self.__indices[ensemble_member][in_canonical]
+
+                        # Insert replacement values into appropriate slot
+                        delayed_feedback_variable_replacement[indices] = (
+                            x_out_delayed / in_nominal / in_sign
+                        )
+
+                        # Equate delayed feedback variable to zero so that the numerical solver can
+                        # remove it from the problem.
+                        #
+                        # Note: The alternative approach would be to shrink self.solver_input=X,
+                        # self.__indices, and any other variables that directly or indirectly
+                        # depend on the size and order of 'X'.  This would be a complex operation,
+                        # which would however be redundant for solvers that (like Ipopt) already
+                        # automatically detect and remove variables where lbx==ubx.
+                        lbx[indices] = 0.0
+                        ubx[indices] = 0.0
+                    else:
+                        # Default behavior: add delay expressions as equality constraints
+                        g.append((x_in - x_out_delayed) / nominal)
+                        zeros = np.zeros(n_collocation_times)
+                        lbg.extend(zeros)
+                        ubg.extend(zeros)
 
             # Objective
             f_member = self.objective(ensemble_member)
@@ -1868,7 +1906,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
             f.append(self.ensemble_member_probability(ensemble_member) * f_member)
 
             if logger.getEffectiveLevel() == logging.DEBUG:
-                logger.debug("Adding objective {}".format(f_member))
+                logger.debug(f"Adding objective {f_member}")
 
             # Constraints
             constraints = self.constraints(ensemble_member)
@@ -1898,9 +1936,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                         elif lbg_i.shape[0] != g_i.shape[0]:
                             raise Exception(
                                 "Shape mismatch between constraint "
-                                "#{} ({},) and its lower bound ({},)".format(
-                                    i, g_i.shape[0], lbg_i.shape[0]
-                                )
+                                f"#{i} ({g_i.shape[0]},) and its lower bound ({lbg_i.shape[0]},)"
                             )
 
                         if not isinstance(ubg_i, np.ndarray) or ubg_i.shape[0] == 1:
@@ -1908,9 +1944,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                         elif ubg_i.shape[0] != g_i.shape[0]:
                             raise Exception(
                                 "Shape mismatch between constraint "
-                                "#{} ({},) and its upper bound ({},)".format(
-                                    i, g_i.shape[0], ubg_i.shape[0]
-                                )
+                                f"#{i} ({g_i.shape[0]},) and its upper bound ({ubg_i.shape[0]},)"
                             )
 
                 g.extend(g_constraint)
@@ -1978,6 +2012,14 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                 lbg.extend(lbg_path_constraints.transpose().ravel())
                 ubg.extend(ubg_path_constraints.transpose().ravel())
 
+        # If inlining delay expressions, carry out the single call to ca.substitute()
+        # A single call is more efficient as it constructs a single ca.Function internally,
+        # rather than one for each element of the list. Also note that we do this _outside_
+        # the ensemble member loop for speed reasons, as each substitute() roughly takes the
+        # same amount of time regardless how many expressions we are replacing.
+        if self.inline_delay_expressions:
+            g = [ca.substitute(ca.vertcat(*g), X, delayed_feedback_variable_replacement)]
+
         # NLP function
         logger.info("Creating NLP dictionary")
 
@@ -2021,7 +2063,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
         return self.__solver_input
 
     def solver_options(self):
-        options = super(CollocatedIntegratedOptimizationProblem, self).solver_options()
+        options = super().solver_options()
 
         solver = options["solver"]
         assert solver in ["bonmin", "ipopt"]
@@ -2043,7 +2085,12 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
     def controls(self):
         return self.__controls
 
-    def _collint_get_lbx_ubx(self, bounds, count, indices):
+    def _collint_get_lbx_ubx(
+        self,
+        bounds: dict[str, BT] | list[dict[str, BT]],
+        count: int,
+        indices: list[dict[str, 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)
 
@@ -2054,6 +2101,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]
 
@@ -2065,7 +2117,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                     n_times = len(times)
 
                 try:
-                    bound = bounds[variable]
+                    bound = bounds_member[variable]
                 except KeyError:
                     pass
                 else:
@@ -2094,7 +2146,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):
@@ -2114,13 +2166,23 @@ 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])):
-                    logger.error("Lower bound on variable {} contains NaN".format(variable))
+                    logger.error(f"Lower bound on variable {variable} contains NaN")
                 if np.any(np.isnan(ubx[inds])):
-                    logger.error("Upper bound on variable {} contains NaN".format(variable))
+                    logger.error(f"Upper bound on variable {variable} contains NaN")
+
+                # 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(
+                        f"Lower bound {lbx[inds][error_inds[0]] * nominal} is higher than "
+                        f"upper bound {ubx[inds][error_inds[0]] * nominal} for variable {variable}"
+                    )
 
         return lbx, ubx
 
@@ -2154,15 +2216,16 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                         )
 
                     if isinstance(seed_k, Timeseries):
-                        x0[inds] = (
+                        seed_k = (
                             self.interpolate(
                                 times, seed_k.times, seed_k.values, 0, 0, interpolation_method
                             )
                             .transpose()
                             .ravel()
                         )
-                    else:
-                        x0[inds] = seed_k
+                    if isinstance(inds, int) and isinstance(seed_k, np.ndarray):
+                        seed_k = seed_k.item()
+                    x0[inds] = seed_k
 
                     x0[inds] /= nominal
                 except KeyError:
@@ -2492,10 +2555,8 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                     else:
                         if not extrapolate and (t < times[0] or t > times[-1]):
                             raise Exception(
-                                "Cannot interpolate for {}: "
-                                "Point {} outside of range [{}, {}]".format(
-                                    canonical, t, times[0], times[-1]
-                                )
+                                f"Cannot interpolate for {canonical}: "
+                                f"Point {t} outside of range [{times[0]}, {times[-1]}]"
                             )
 
                         interpolation_method = self.interpolation_method(canonical)
@@ -2583,9 +2644,8 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                 history_timeseries = history[canonical]
             except KeyError:
                 raise Exception(
-                    "No history found for variable {}, but a historical value was requested".format(
-                        variable
-                    )
+                    f"No history found for variable {variable}, "
+                    "but a historical value was requested"
                 )
             else:
                 history_times = history_timeseries.times[:-1]
@@ -2612,10 +2672,21 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
 
         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 = None,
+        tf: float | None = None,
+        ensemble_member: int = 0,
+        *,
+        return_times: bool = False,
+    ) -> 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)
@@ -2754,11 +2825,9 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
             if len(ensemble_members) == 1:
                 ensemble_members = ensemble_members[0]
             else:
-                ensemble_members = "[{}]".format(
-                    ",".join((str(x) for x in sorted(ensemble_members)))
-                )
+                ensemble_members = "[{}]".format(",".join(str(x) for x in sorted(ensemble_members)))
 
-            var_names.append("{}__e{}__t{}".format(var_name, ensemble_members, t_i))
+            var_names.append(f"{var_name}__e{ensemble_members}__t{t_i}")
 
         # Create named versions of the constraints
         named_x = ca.vertcat(*(ca.SX.sym(v) for v in var_names))
@@ -2805,62 +2874,62 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
             lb, ub = lbg[i], ubg[i]
 
             if np.isfinite(lb) and np.isfinite(ub) and lb == ub:
-                c_str = "{} = {}".format(c_str, lb)
+                c_str = f"{c_str} = {lb}"
             elif np.isfinite(lb) and np.isfinite(ub):
-                c_str = "{} <= {} <= {}".format(lb, c_str, ub)
+                c_str = f"{lb} <= {c_str} <= {ub}"
             elif np.isfinite(lb):
-                c_str = "{} >= {}".format(c_str, lb)
+                c_str = f"{c_str} >= {lb}"
             elif np.isfinite(ub):
-                c_str = "{} <= {}".format(c_str, ub)
+                c_str = f"{c_str} <= {ub}"
 
             return c_str
 
         # Checking for right hand side of constraints
-        logger.info("Sanity check of lbg and ubg, checking for small values (<{})".format(tol_zero))
+        logger.info(f"Sanity check of lbg and ubg, checking for small values (<{tol_zero})")
 
         lbg_abs_no_zero = np.abs(lbg.copy())
         lbg_abs_no_zero[lbg_abs_no_zero == 0.0] = +np.inf
         ind = np.argmin(lbg_abs_no_zero)
         if np.any(np.isfinite(lbg_abs_no_zero)):
-            logger.info("Smallest (absolute) lbg coefficient {}".format(lbg_abs_no_zero[ind]))
-            logger.info("E.g., {}".format(constr_to_str(ind)))
+            logger.info(f"Smallest (absolute) lbg coefficient {lbg_abs_no_zero[ind]}")
+            logger.info(f"E.g., {constr_to_str(ind)}")
         lbg_inds = lbg_abs_no_zero < tol_zero
         if np.any(lbg_inds):
-            logger.info("Too small of a (absolute) lbg found: {}".format(min(lbg[lbg_inds])))
+            logger.info(f"Too small of a (absolute) lbg found: {min(lbg[lbg_inds])}")
 
         ubg_abs_no_zero = np.abs(ubg.copy())
         ubg_abs_no_zero[ubg_abs_no_zero == 0.0] = +np.inf
         ind = np.argmin(ubg_abs_no_zero)
         if np.any(np.isfinite(ubg_abs_no_zero)):
-            logger.info("Smallest (absolute) ubg coefficient {}".format(ubg_abs_no_zero[ind]))
-            logger.info("E.g., {}".format(constr_to_str(ind)))
+            logger.info(f"Smallest (absolute) ubg coefficient {ubg_abs_no_zero[ind]}")
+            logger.info(f"E.g., {constr_to_str(ind)}")
         ubg_inds = ubg_abs_no_zero < tol_zero
         if np.any(ubg_inds):
-            logger.info("Too small of a (absolute) ubg found: {}".format(min(ubg[ubg_inds])))
+            logger.info(f"Too small of a (absolute) ubg found: {min(ubg[ubg_inds])}")
 
-        logger.info("Sanity check of lbg and ubg, checking for large values (>{})".format(tol_rhs))
+        logger.info(f"Sanity check of lbg and ubg, checking for large values (>{tol_rhs})")
 
         lbg_abs_no_inf = np.abs(lbg.copy())
         lbg_abs_no_inf[~np.isfinite(lbg_abs_no_inf)] = -np.inf
         ind = np.argmax(lbg_abs_no_inf)
         if np.any(np.isfinite(lbg_abs_no_inf)):
-            logger.info("Largest (absolute) lbg coefficient {}".format(lbg_abs_no_inf[ind]))
-            logger.info("E.g., {}".format(constr_to_str(ind)))
+            logger.info(f"Largest (absolute) lbg coefficient {lbg_abs_no_inf[ind]}")
+            logger.info(f"E.g., {constr_to_str(ind)}")
 
         lbg_inds = lbg_abs_no_inf > tol_rhs
         if np.any(lbg_inds):
-            raise Exception("Too large of a (absolute) lbg found: {}".format(max(lbg[lbg_inds])))
+            raise Exception(f"Too large of a (absolute) lbg found: {max(lbg[lbg_inds])}")
 
         ubg_abs_no_inf = np.abs(ubg.copy())
         ubg_abs_no_inf[~np.isfinite(ubg)] = -np.inf
         ind = np.argmax(ubg_abs_no_inf)
         if np.any(np.isfinite(ubg_abs_no_inf)):
-            logger.info("Largest (absolute) ubg coefficient {}".format(ubg_abs_no_inf[ind]))
-            logger.info("E.g., {}".format(constr_to_str(ind)))
+            logger.info(f"Largest (absolute) ubg coefficient {ubg_abs_no_inf[ind]}")
+            logger.info(f"E.g., {constr_to_str(ind)}")
 
         ubg_inds = ubg_abs_no_inf > tol_rhs
         if np.any(ubg_inds):
-            raise Exception("Too large of a (absolute) ubg found: {}".format(max(ubg[ubg_inds])))
+            raise Exception(f"Too large of a (absolute) ubg found: {max(ubg[ubg_inds])}")
 
         eval_point = x0 if evaluate_at_x0 else 1.0
         eval_point_str = "x0" if evaluate_at_x0 else "1.0"
@@ -2887,25 +2956,20 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
         # Objective
         A_obj, b_obj = out[0]
         logger.info(
-            "Statistics of objective: max & min of abs(jac(f, {}))) f({}), constants".format(
-                eval_point_str, eval_point_str
-            )
+            f"Statistics of objective: max & min of abs(jac(f, {eval_point_str}))) "
+            f"f({eval_point_str}), constants"
         )
         max_obj_A = max(np.abs(A_obj.data), default=None)
         min_obj_A = min(np.abs(A_obj.data[A_obj.data != 0.0]), default=None)
         obj_x0 = np.array(ca.Function("tmp", [in_var], [nlp["f"]])(eval_point)).ravel()[0]
         obj_b = b_obj.data[0] if len(b_obj.data) > 0 else 0.0
 
-        logger.info("{} & {}, {}, {}".format(max_obj_A, min_obj_A, obj_x0, obj_b))
+        logger.info(f"{max_obj_A} & {min_obj_A}, {obj_x0}, {obj_b}")
 
         if abs(obj_b) > tol_up:
-            logger.info(
-                "Constant '{}' in objective exceeds upper tolerance of '{}'".format(obj_b, tol_up)
-            )
+            logger.info(f"Constant '{obj_b}' in objective exceeds upper tolerance of '{tol_up}'")
         if abs(obj_b) > tol_up:
-            logger.info(
-                "Objective value at x0 '{}' exceeds upper tolerance of '{}'".format(obj_x0, tol_up)
-            )
+            logger.info(f"Objective value at x0 '{obj_x0}' exceeds upper tolerance of '{tol_up}'")
 
         # Constraints
         A_constr, b_constr = out[1]
@@ -2916,12 +2980,21 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
         min_constr_A = min(np.abs(A_constr.data[A_constr.data != 0.0]), default=None)
         max_constr_b = max(np.abs(b_constr.data), default=None)
         min_constr_b = min(np.abs(b_constr.data[b_constr.data != 0.0]), default=None)
-        logger.info(
-            "{} & {}, {} & {}".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]
+        logger.info(f"{max_constr_A} & {min_constr_A}, {max_constr_b} & {min_constr_b}")
+
+        # 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!")
 
@@ -2950,25 +3023,17 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
         if exceedences:
             logger.info(
                 "Exceedence in jacobian of constraints evaluated at x0"
-                " (max > {:g}, min < {:g}, or max / min > {:g}):".format(
-                    tol_up, tol_down, tol_range
-                )
+                f" (max > {tol_up:g}, min < {tol_down:g}, or max / min > {tol_range:g}):"
             )
 
             exceedences = sorted(exceedences, key=lambda x: x[1] / x[2], reverse=True)
 
             for i, (r, max_r, min_r, c) in enumerate(exceedences):
-                logger.info(
-                    "row {} (max: {}, min: {}, range: {}):  {}".format(
-                        r, max_r, min_r, max_r / min_r, c
-                    )
-                )
+                logger.info(f"row {r} (max: {max_r}, min: {min_r}, range: {max_r / min_r}):  {c}")
 
                 if i >= 9:
                     logger.info(
-                        "Too many warnings of same type ({} others remain).".format(
-                            len(exceedences) - 10
-                        )
+                        f"Too many warnings of same type ({len(exceedences) - 10} others remain)."
                     )
                     break
 
@@ -3021,24 +3086,18 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
 
         exceedences = sorted(exceedences, key=lambda x: x[1], reverse=True)
 
-        logger.info("Max range found: {}".format(max_range_found))
+        logger.info(f"Max range found: {max_range_found}")
         if exceedences:
-            logger.info("Exceedence in range per column (max / min > {:g}):".format(tol_range))
+            logger.info(f"Exceedence in range per column (max / min > {tol_range:g}):")
 
             for i, (c, exc, min_, max_, c_min_str, c_max_str) in enumerate(exceedences):
-                logger.info(
-                    "col {} ({}):  range {}, min {}, max {}".format(
-                        c, var_names[c], exc, min_, max_
-                    )
-                )
+                logger.info(f"col {c} ({var_names[c]}):  range {exc}, min {min_}, max {max_}")
                 logger.info(c_min_str)
                 logger.info(c_max_str)
 
                 if i >= 9:
                     logger.info(
-                        "Too many warnings of same type ({} others remain).".format(
-                            len(exceedences) - 10
-                        )
+                        f"Too many warnings of same type ({len(exceedences) - 10} others remain)."
                     )
                     break
 
@@ -3064,24 +3123,19 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
             if max_range > tol_range:
                 exceedences.append((c, max_range, obj_coeff, min_r, max_r))
 
-        logger.info("Max range found: {}".format(max_range_found))
+        logger.info(f"Max range found: {max_range_found}")
         if exceedences:
-            logger.info(
-                "Exceedence in range of objective variable (range > {:g}):".format(tol_range)
-            )
+            logger.info(f"Exceedence in range of objective variable (range > {tol_range:g}):")
 
             for i, (c, max_range, obj_coeff, min_r, max_r) in enumerate(exceedences):
                 logger.info(
-                    "col {} ({}): range: {}, obj: {}, min constr: {}, max constr {}".format(
-                        c, var_names[c], max_range, obj_coeff, min_r, max_r
-                    )
+                    f"col {c} ({var_names[c]}): range: {max_range}, obj: {obj_coeff}, "
+                    f"min constr: {min_r}, max constr {max_r}"
                 )
 
                 if i >= 9:
                     logger.info(
-                        "Too many warnings of same type ({} others remain).".format(
-                            len(exceedences) - 10
-                        )
+                        f"Too many warnings of same type ({len(exceedences) - 10} others remain)."
                     )
                     break
 
@@ -3125,11 +3179,11 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
             if exceedences:
                 logger.info(
                     "Variables with at least one (absolute) state vector entry/entries "
-                    "larger than {}".format(tol_up)
+                    f"larger than {tol_up}"
                 )
 
             for k, v in exceedences:
-                logger.info("{}: abs max = {}".format(k, v))
+                logger.info(f"{k}: abs max = {v}")
 
         if len(inds_down) > 0:
             exceedences = []
@@ -3144,11 +3198,11 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                 ignore_all_zero_string = " (but not all zero)" if ignore_all_zero else ""
                 logger.info(
                     "Variables with all (absolute) state vector entry/entries "
-                    "smaller than {}{}".format(tol_down, ignore_all_zero_string)
+                    f"smaller than {tol_down}{ignore_all_zero_string}"
                 )
 
             for k, v in exceedences:
                 if ignore_all_zero and v == 0.0:
                     continue
 
-                logger.info("{}: abs max = {}".format(k, v))
+                logger.info(f"{k}: abs max = {v}")

{rtc_tools-2.7.2 → rtc_tools-2.7.3}/src/rtctools/optimization/modelica_mixin.py

@@ -290,7 +290,10 @@ class ModelicaMixin(OptimizationProblem):
                     # If start contains symbolics, try substituting parameter values
                     if isinstance(start, ca.MX) and not start.is_constant():
                         [start] = substitute_in_external(
-                            [start], self.__mx["parameters"], parameter_values
+                            [start],
+                            self.__mx["parameters"],
+                            parameter_values,
+                            resolve_numerically=True,
                         )
                         if not start.is_constant() or np.isnan(float(start)):
                             raise Exception(
@@ -341,7 +344,9 @@ class ModelicaMixin(OptimizationProblem):
 
             m_ = v.min
             if isinstance(m_, ca.MX) and not m_.is_constant():
-                [m_] = substitute_in_external([m_], self.__mx["parameters"], parameter_values)
+                [m_] = substitute_in_external(
+                    [m_], self.__mx["parameters"], parameter_values, resolve_numerically=True
+                )
                 if not m_.is_constant() or np.isnan(float(m_)):
                     raise Exception(
                         "Could not resolve lower bound for variable {}".format(sym_name)
@@ -350,7 +355,9 @@ class ModelicaMixin(OptimizationProblem):
 
             M_ = v.max
             if isinstance(M_, ca.MX) and not M_.is_constant():
-                [M_] = substitute_in_external([M_], self.__mx["parameters"], parameter_values)
+                [M_] = substitute_in_external(
+                    [M_], self.__mx["parameters"], parameter_values, resolve_numerically=True
+                )
                 if not M_.is_constant() or np.isnan(float(M_)):
                     raise Exception(
                         "Could not resolve upper bound for variable {}".format(sym_name)
@@ -390,7 +397,7 @@ class ModelicaMixin(OptimizationProblem):
                 # If start contains symbolics, try substituting parameter values
                 if isinstance(start, ca.MX) and not start.is_constant():
                     [start] = substitute_in_external(
-                        [start], self.__mx["parameters"], parameter_values
+                        [start], self.__mx["parameters"], parameter_values, resolve_numerically=True
                     )
                     if not start.is_constant() or np.isnan(float(start)):
                         logger.error(
@@ -437,7 +444,7 @@ class ModelicaMixin(OptimizationProblem):
             # If nominal contains parameter symbols, substitute them
             if isinstance(nominal, ca.MX) and not nominal.is_constant():
                 [nominal] = substitute_in_external(
-                    [nominal], self.__mx["parameters"], parameter_values
+                    [nominal], self.__mx["parameters"], parameter_values, resolve_numerically=True
                 )
                 if not nominal.is_constant() or np.isnan(float(nominal)):
                     logger.error(

{rtc_tools-2.7.2 → rtc_tools-2.7.3}/src/rtctools/optimization/optimization_problem.py

@@ -46,6 +46,9 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
     _debug_check_level = DebugLevel.MEDIUM
     _debug_check_options = {}
 
+    #: Enable ensemble-specific bounds functionality
+    ensemble_specific_bounds = False
+
     def __init__(self, **kwargs):
         # Call parent class first for default behaviour.
         super().__init__(**kwargs)

{rtc_tools-2.7.2 → rtc_tools-2.7.3}/src/rtctools/optimization/single_pass_goal_programming_mixin.py

@@ -143,7 +143,26 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
 
     def seed(self, ensemble_member):
         assert self._gp_first_run
-        return super().seed(ensemble_member)
+
+        seed = super().seed(ensemble_member)
+
+        # Seed epsilons of current priority
+        for epsilon in self.__problem_epsilons:
+            eps_size = epsilon.size1()
+            if eps_size > 1:
+                seed[epsilon.name()] = np.ones(eps_size)
+            else:
+                seed[epsilon.name()] = 1.0
+
+        times = self.times()
+        for epsilon in self.__problem_path_epsilons:
+            eps_size = epsilon.size1()
+            if eps_size > 1:
+                seed[epsilon.name()] = Timeseries(times, np.ones((eps_size, len(times))))
+            else:
+                seed[epsilon.name()] = Timeseries(times, np.ones(len(times)))
+
+        return seed
 
     def constraints(self, ensemble_member):
         constraints = super().constraints(ensemble_member)