rtc-tools 2.8.0a0__tar.gz → 2.8.0a2__tar.gz

rtc_tools-2.8.0a2/.github/actions/setup-python/action.yml

@@ -0,0 +1,52 @@
+name: "Setup Python Environment"
+description: "Sets up Python environment with uv package manager"
+
+inputs:
+  uv-version:
+    description: "Version of uv to install"
+    required: false
+    default: "0.7.9"
+  dependency-groups:
+    description: "Space-separated list of dependency groups to install (e.g. 'deploy tests')"
+    required: false
+    default: ""
+  resolution-mode:
+    description: "Dependency resolution mode: 'frozen' (use uv.lock), 'lowest' (lowest-direct), 'highest' (upgrade to newest)."
+    required: false
+    default: "frozen"
+
+runs:
+  using: "composite"
+  steps:
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        version: ${{ inputs.uv-version }}
+        enable-cache: true
+        cache-dependency-glob: "uv.lock"
+
+    - name: Install dependencies
+      shell: bash
+      run: |
+        CMD_PARTS=("uv" "sync")
+
+        if [[ "${{ inputs.resolution-mode }}" == "lowest" ]]; then
+          CMD_PARTS+=("--resolution" "lowest-direct")
+        elif [[ "${{ inputs.resolution-mode }}" == "highest" ]]; then
+          CMD_PARTS+=("--upgrade")
+        else # Default to "frozen"
+          CMD_PARTS+=("--frozen")
+        fi
+
+        # Always exclude the default 'dev' group unless specific groups are requested that might include dev ones by intent.
+        # uv sync --no-dev is the default to exclude [tool.uv.dev-dependencies] or [dependency-groups.dev]
+        CMD_PARTS+=("--no-dev")
+
+        if [[ -n "${{ inputs.dependency-groups }}" ]]; then
+          for group in ${{ inputs.dependency-groups }}; do
+            CMD_PARTS+=("--group" "$group")
+          done
+        fi
+
+        echo "Executing: ${CMD_PARTS[*]}"
+        "${CMD_PARTS[@]}"

{rtc_tools-2.8.0a0 → rtc_tools-2.8.0a2}/.github/workflows/rtc-tools.yml

@@ -42,6 +42,7 @@ jobs:
         path: dist/
 
   test-linux:
+    name: Test Linux (Python ${{ matrix.version }}${{ matrix.label }})
     needs: build
     runs-on: ubuntu-latest
     container:
@@ -51,17 +52,25 @@ jobs:
       TOXENV: py
     strategy:
       matrix:
-        version:  # Also update sonar-project.properties when updating the python versions.
-        - '3.9'
-        - '3.10'
-        - '3.11'
-        - '3.12'
-        - '3.13'
+        include:
+          - version: '3.9'  # Also update sonar-project.properties when updating the python versions.
+          - version: '3.10'
+          - version: '3.11'
+          - version: '3.12'
+          - version: '3.13'
+          # Lowest and highest resolution modes to test oldest and newest dependencies.
+          - version: '3.9'
+            resolution_mode: 'lowest'
+            label: ' (Oldest Dependencies)'
+          - version: '3.13'
+            resolution_mode: 'highest'
+            label: ' (Newest Dependencies)'
     steps:
     - uses: actions/checkout@v4
     - uses: ./.github/actions/setup-python
       with:
         dependency-groups: "tests"
+        resolution-mode: ${{ matrix.resolution_mode }}
     - run: uv run tox -vv
 
   coverage:

{rtc_tools-2.8.0a0 → rtc_tools-2.8.0a2}/AUTHORS

@@ -1,10 +1,13 @@
+Farid Alavi
 Jorn Baayen
 Joris Bentvelsen
 Olav van Duin
 Sjoerd Geevers
+Joris Gillis
 Klaudia Horváth
 Ailbhe Mitchell
 Teresa Piovesan
+Jesús A. Rodríguez
 Matthijs den Toom
 Jesse VanderWees
 Tjerk Vreeken

{rtc_tools-2.8.0a0 → rtc_tools-2.8.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rtc-tools
-Version: 2.8.0a0
+Version: 2.8.0a2
 Summary: Toolbox for control and optimization of water systems.
 Project-URL: Homepage, https://oss.deltares.nl/web/rtc-tools/home
 Project-URL: Download, http://github.com/deltares/rtc-tools/
@@ -188,13 +188,13 @@ Classifier: Topic :: Scientific/Engineering :: GIS
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: >=3.9
-Requires-Dist: casadi!=3.6.6,<=3.7,>=3.6.3
+Requires-Dist: casadi!=3.6.6,<3.8,>=3.6.3
 Requires-Dist: defusedxml>=0.7.0
 Requires-Dist: importlib-metadata>=5.0.0; python_version < '3.10'
-Requires-Dist: numpy>=1.16.0
+Requires-Dist: numpy>=1.20.0
 Requires-Dist: pymoca==0.9.*,>=0.9.1
 Requires-Dist: rtc-tools-channel-flow>=1.2.0
-Requires-Dist: scipy>=1.0.0
+Requires-Dist: scipy>=1.6.0
 Provides-Extra: all
 Requires-Dist: netcdf4; extra == 'all'
 Provides-Extra: netcdf
@@ -219,13 +219,11 @@ RTC-Tools offers the following functionalities:
 
 - **Model building using extensible libraries**: Build complex system models using extensible libraries of model components. Modelers can also implement their custom modeling components, for instance, using the [Modelica language](https://modelica.org/language/) or Python script.
 
-    RTC-Tools can be used with the following libraries and packages for specific applications:
+    RTC-Tools can be used with the following libraries and packages for specific applications. Please note that this list is not exhaustive. Users can also create libraries for other types of applications.
     - [rtc-tools-channel-flow](https://gitlab.com/deltares/rtc-tools-channel-flow): water system models
     - [rtc-tools-hydraulic-structures](https://gitlab.com/deltares/rtc-tools-channel-flow): hydraulic assets, such as weirs and pumps
     - [rtc-tools-heat-network](https://github.com/Nieuwe-Warmte-Nu/rtc-tools-heat-network): heat networks
-
-Please note that this list is not exhaustive. Users can also create libraries for other types of applications.
-
+            
 - **Running simulations**: Simulate a given model.
 
 - **Specifying and solving optimization problems**: Define optimization goals, constraints and decision variables to specify the optimization problem for a given model. RTC-Tools supports both open-source solvers (CBC, HiGHS, Ipopt) and commercial solvers (Gurobi, CPLEX) for solving several types of optimization problems:

{rtc_tools-2.8.0a0 → rtc_tools-2.8.0a2}/README.md

@@ -16,13 +16,11 @@ RTC-Tools offers the following functionalities:
 
 - **Model building using extensible libraries**: Build complex system models using extensible libraries of model components. Modelers can also implement their custom modeling components, for instance, using the [Modelica language](https://modelica.org/language/) or Python script.
 
-    RTC-Tools can be used with the following libraries and packages for specific applications:
+    RTC-Tools can be used with the following libraries and packages for specific applications. Please note that this list is not exhaustive. Users can also create libraries for other types of applications.
     - [rtc-tools-channel-flow](https://gitlab.com/deltares/rtc-tools-channel-flow): water system models
     - [rtc-tools-hydraulic-structures](https://gitlab.com/deltares/rtc-tools-channel-flow): hydraulic assets, such as weirs and pumps
     - [rtc-tools-heat-network](https://github.com/Nieuwe-Warmte-Nu/rtc-tools-heat-network): heat networks
-
-Please note that this list is not exhaustive. Users can also create libraries for other types of applications.
-
+            
 - **Running simulations**: Simulate a given model.
 
 - **Specifying and solving optimization problems**: Define optimization goals, constraints and decision variables to specify the optimization problem for a given model. RTC-Tools supports both open-source solvers (CBC, HiGHS, Ipopt) and commercial solvers (Gurobi, CPLEX) for solving several types of optimization problems:

{rtc_tools-2.8.0a0 → rtc_tools-2.8.0a2}/doc/optimization/modelica_models.rst

@@ -1,7 +1,7 @@
 Modelica models
 ===============
 
-To learn the basics of modelling with Modelica, please refer to the online book `Modelica by Example <http://book.xogeny.com/>`_. 
+To learn the basics of modelling with Modelica, please refer to the online book `Modelica by Example <https://mbe.modelica.university/>`_. 
 
 .. autoclass:: rtctools.optimization.modelica_mixin.ModelicaMixin
     :members: compiler_options

{rtc_tools-2.8.0a0 → rtc_tools-2.8.0a2}/pyproject.toml

@@ -31,9 +31,9 @@ classifiers = [
     "Operating System :: MacOS"
 ]
 dependencies = [
-    "casadi >= 3.6.3, <= 3.7, !=3.6.6",
-    "numpy >= 1.16.0",
-    "scipy >= 1.0.0",
+    "casadi >= 3.6.3, < 3.8, !=3.6.6",
+    "numpy >= 1.20.0",
+    "scipy >= 1.6.0",
     "pymoca >= 0.9.1, == 0.9.*",
     "rtc-tools-channel-flow >= 1.2.0",
     "defusedxml >= 0.7.0",

{rtc_tools-2.8.0a0 → rtc_tools-2.8.0a2}/src/rtctools/_internal/casadi_helpers.py

@@ -1,9 +1,15 @@
 import logging
+from typing import Union
 
 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 +43,24 @@ 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[Union[ca.MX, ca.DM, float]]
+):
+    # 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
+    elif not expr:
+        return []
     else:
-        f = ca.Function("f", symbols, expr)
-        return f.call(values, True, False)
+        for _ in range(MAX_SUBSTITUTE_DEPTH):
+            f = ca.Function("f", symbols, expr).expand()
+            expr = f.call(values, True, False)
+            if expr[0].is_constant():
+                break
+
+        return expr
 
 
 def interpolate(ts, xs, t, equidistant, mode=0):

{rtc_tools-2.8.0a0 → rtc_tools-2.8.0a2}/src/rtctools/optimization/collocated_integrated_optimization_problem.py

@@ -45,11 +45,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
 
@@ -386,7 +392,9 @@ 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),
                 )
             else:
                 parameter_values = nullvertcat(*parameter_values)
@@ -1789,6 +1797,12 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                     + [constant_inputs[v.name()] for v in self.dae_variables["constant_inputs"]]
                 )
 
+                # 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
+
                 for i in range(len(delayed_feedback_expressions)):
                     in_variable_name = delayed_feedback_states[i]
                     expression = delayed_feedback_expressions[i]
@@ -1855,10 +1869,38 @@ 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)
+
+            # 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.
+            if self.inline_delay_expressions:
+                g = [ca.substitute(ca.vertcat(*g), X, delayed_feedback_variable_replacement)]
 
             # Objective
             f_member = self.objective(ensemble_member)

{rtc_tools-2.8.0a0 → rtc_tools-2.8.0a2}/src/rtctools/optimization/optimization_problem.py

@@ -203,12 +203,12 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
                         log_level = logging.INFO
                 logger.log(
                     log_level,
-                    "Solver succeeded with status {} ({}).".format(return_status, wall_clock_time),
+                    "Solver failed with status {} ({}).".format(return_status, wall_clock_time),
                 )
             except (AttributeError, ValueError):
                 logger.log(
                     log_level,
-                    "Solver succeeded with status {} ({}).".format(return_status, wall_clock_time),
+                    "Solver failed with status {} ({}).".format(return_status, wall_clock_time),
                 )
 
         # Do any postprocessing

{rtc_tools-2.8.0a0 → rtc_tools-2.8.0a2}/tests/optimization/data/ModelSymbolicParameters.mo

@@ -7,8 +7,11 @@ model ModelSymbolicParameters
 
 	parameter Real k = 1.0;
 
+	parameter Real a = -1.0;
+	parameter Real b = 2.0;
+	parameter Real u_min = a * b;
 	parameter Real u_max;
-	input Real u(fixed=false, min = -2, max = u_max);
+	input Real u(fixed=false, min = u_min, max = u_max);
 equation
 	der(x) = k * x + u;
 	der(w) = x;

{rtc_tools-2.8.0a0 → rtc_tools-2.8.0a2}/tests/optimization/test_delay_expressions.py

@@ -17,13 +17,14 @@ logger.setLevel(logging.DEBUG)
 
 
 class Model(ModelicaMixin, CollocatedIntegratedOptimizationProblem):
-    def __init__(self):
+    def __init__(self, inline_delay_expressions=False):
         super().__init__(
             input_folder=data_path(),
             output_folder=data_path(),
             model_name="ModelDelay",
             model_folder=data_path(),
         )
+        self.inline_delay_expressions = inline_delay_expressions
 
     def times(self, variable=None):
         # Collocation points
@@ -63,7 +64,8 @@ class ModelCompleteHistory(Model):
 
 class TestDelayHistoryWarnings(TestCase, unittest.TestCase):
     def test_no_history(self):
-        problem = ModelNoHistory()
+        # Test default mode
+        problem = ModelNoHistory(inline_delay_expressions=False)
         with self.assertLogs(logger, level="WARN") as cm:
             problem.optimize()
             self.assertEqual(
@@ -75,6 +77,31 @@ class TestDelayHistoryWarnings(TestCase, unittest.TestCase):
                     "Extrapolating t0 value backwards in time.",
                 ],
             )
+        results = problem.extract_results()
+
+        # Test inline mode
+        problem_inline = ModelNoHistory(inline_delay_expressions=True)
+        with self.assertLogs(logger, level="WARN") as cm:
+            problem_inline.optimize()
+            self.assertEqual(
+                cm.output,
+                [
+                    "WARNING:rtctools:Incomplete history for delayed expression x. "
+                    "Extrapolating t0 value backwards in time.",
+                    "WARNING:rtctools:Incomplete history for delayed expression w. "
+                    "Extrapolating t0 value backwards in time.",
+                ],
+            )
+        results_inline = problem_inline.extract_results()
+
+        # Check that the results align
+        self.assertAlmostEqual(results["x"], results_inline["x"], 1e-6)
+        self.assertAlmostEqual(results["w"], results_inline["w"], 1e-6)
+
+        # Check that the inline results has fewer constraints
+        self.assertLess(
+            len(problem_inline.transcribed_problem["lbg"]), len(problem.transcribed_problem["lbg"])
+        )
 
     def test_partial_history(self):
         problem = ModelPartialHistory()

{rtc_tools-2.8.0a0 → rtc_tools-2.8.0a2}/tests/optimization/test_modelica_mixin.py

@@ -266,7 +266,10 @@ class ModelHistory(Model):
 
 
 class ModelSymbolicParameters(ModelicaMixin, CollocatedIntegratedOptimizationProblem):
-    def __init__(self):
+    def __init__(self, resolve_parameters=True, override_u_min=True):
+        self.__resolve_parameters = resolve_parameters
+        self.__override_u_min = override_u_min
+
         super().__init__(
             input_folder=data_path(),
             output_folder=data_path(),
@@ -283,6 +286,10 @@ class ModelSymbolicParameters(ModelicaMixin, CollocatedIntegratedOptimizationPro
         parameters["u_max"] = 2.0
         parameters["x_initial"] = 1.1
         parameters["w_seed"] = 0.2
+        parameters["a"] = -2.0
+
+        if self.__override_u_min:
+            parameters["u_min"] = -1.5
         return parameters
 
     def objective(self, ensemble_member):
@@ -294,6 +301,11 @@ class ModelSymbolicParameters(ModelicaMixin, CollocatedIntegratedOptimizationPro
         compiler_options = super().compiler_options()
         compiler_options["cache"] = False
         compiler_options["library_folders"] = []
+
+        if not self.__resolve_parameters:
+            compiler_options["replace_parameter_expressions"] = False
+            compiler_options["resolve_parameter_values"] = False
+
         return compiler_options
 
 
@@ -621,6 +633,45 @@ class TestModelicaMixinSymbolicParameters(TestCase, unittest.TestCase):
         self.assertAlmostEqual(self.problem.extract_results()["x"][0], 1.1, self.tolerance)
 
 
+class TestModelicaMixinSymbolicParametersResolve(TestCase, unittest.TestCase):
+    def test_parameters_resolve_or_not(self):
+        """
+        We set a 'default' value of u_min = a * b in the Pymoca model. If we
+        tell pymoca to replace parameter expressions (default behavior), we can
+        no longer override 'u_min' via the parameters() method. If we tell
+        Pymoca to _not_ inline, we expect to be able to override 'u_min', but
+        for it to also still have the default value of a * b.
+        """
+        problem = ModelSymbolicParameters()
+        problem.optimize()
+        parameters = problem.parameters(0)
+        bounds = problem.bounds()
+
+        # Check that overriding "u_min" has no effect if parameters are resolved
+        self.assertNotEqual(bounds["u"][0], parameters["u_min"])
+
+        # Check that overriding "u_min" has effect if parameters are not resolved
+        problem_no_resolved = ModelSymbolicParameters(resolve_parameters=False)
+        problem_no_resolved.optimize()
+        parameters_no_resolved = problem_no_resolved.parameters(0)
+        bounds_no_resolved = problem_no_resolved.bounds()
+
+        self.assertEqual(bounds_no_resolved["u"][0], parameters_no_resolved["u_min"])
+
+        # Check that if we do not override "u_min", it takes the default value a
+        # * b, and that overriding the value of 'a' works.
+        problem_no_override = ModelSymbolicParameters(
+            resolve_parameters=False, override_u_min=False
+        )
+        problem_no_override.optimize()
+        parameters_no_override = problem_no_override.parameters(0)
+        bounds_no_override = problem_no_override.bounds()
+
+        self.assertEqual(
+            bounds_no_override["u"][0], parameters_no_override["a"] * parameters_no_override["b"]
+        )
+
+
 class ModelAliasBounds(Model):
     def bounds(self):
         bounds = super().bounds()

rtc_tools-2.8.0a0/.github/actions/setup-python/action.yml

@@ -1,33 +0,0 @@
-name: "Setup Python Environment"
-description: "Sets up Python environment with uv package manager"
-
-inputs:
-  uv-version:
-    description: "Version of uv to install"
-    required: false
-    default: "0.7.9"
-  dependency-groups:
-    description: "Space-separated list of dependency groups to install (e.g. 'deploy tests')"
-    required: false
-    default: ""
-
-runs:
-  using: "composite"
-  steps:
-    - name: Install uv
-      uses: astral-sh/setup-uv@v5
-      with:
-        version: ${{ inputs.uv-version }}
-        enable-cache: true
-        cache-dependency-glob: "uv.lock"
-
-    - name: Install dependencies
-      shell: bash
-      run: |
-        CMD="uv sync --frozen --no-dev"
-        if [[ -n "${{ inputs.dependency-groups }}" ]]; then
-          for group in ${{ inputs.dependency-groups }}; do
-            CMD="$CMD --group $group"
-          done
-        fi
-        $CMD