rtc-tools 2.7.3__py3-none-any.whl

rtc_tools-2.7.3.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: rtc-tools
+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/
+Author: Deltares
+Maintainer: Deltares
+Platform: Windows
+Platform: Linux
+Platform: Mac OS-X
+Platform: Unix
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.9
+License-File: COPYING.LESSER
+Requires-Dist: casadi!=3.6.6,<3.8,>=3.6.3
+Requires-Dist: numpy>=1.16.0
+Requires-Dist: scipy>=1.0.0
+Requires-Dist: pymoca==0.9.*,>=0.9.1
+Requires-Dist: rtc-tools-channel-flow>=1.2.0
+Requires-Dist: defusedxml>=0.7.0
+Requires-Dist: importlib_metadata>=5.0.0; python_version < "3.10"
+Provides-Extra: netcdf
+Requires-Dist: netCDF4; extra == "netcdf"
+Provides-Extra: all
+Requires-Dist: netCDF4; extra == "all"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: platform
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+RTC-Tools is the Deltares toolbox for control and optimization of water systems.
+

rtc_tools-2.7.3.dist-info/RECORD

@@ -0,0 +1,50 @@
+rtc_tools-2.7.3.dist-info/licenses/COPYING.LESSER,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+rtctools/__init__.py,sha256=91hvS2-ryd2Pvw0COpsUzTwJwSnTZ035REiej-1hNI4,107
+rtctools/_version.py,sha256=FPeE0b8LMExvwWratemPrdlvRPvhjDk884SpY1gsgOA,497
+rtctools/rtctoolsapp.py,sha256=o9T64PSScxtusfWNh9ZaiCfwFBSC7fl0o6K0zH-thJE,4337
+rtctools/util.py,sha256=8IGva7xWcAH-9Xcr1LaxUpYoZjF6vbo1eqdNJ9pKgGA,9098
+rtctools/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rtctools/_internal/alias_tools.py,sha256=XuQSAhhFuVtwn0yrAObZWIKPsSF4j2axXRtEmitIFPs,5310
+rtctools/_internal/caching.py,sha256=p4gqSL7kCI7Hff-KjMEP7mhJCQSiU_lYm2MR7E18gBM,905
+rtctools/_internal/casadi_helpers.py,sha256=j_j-StW37jgacXiiJJbzBySWX9zL9-CYxzch_VoRVoI,3146
+rtctools/_internal/debug_check_helpers.py,sha256=UgQTEPw4PyR7MbYLewSSWQqTwQj7xr5yUBk820O9Kk4,1084
+rtctools/data/__init__.py,sha256=EllgSmCdrlvQZSd1VilvjPaeYJGhY9ErPiQtedmuFoA,157
+rtctools/data/csv.py,sha256=hEpoTH3nhZaAvRN4r-9-nYeAjaFiNDRoiZWg8GxM3yo,5539
+rtctools/data/netcdf.py,sha256=tMs-zcSlOR0HhajUKJVbXGNoi3GeKCM3X4DjuW8FDo8,19130
+rtctools/data/pi.py,sha256=Q7WS0sMkDrTQcCSWmOnuAknt76TWXjooCayt2Qz6j10,47345
+rtctools/data/rtc.py,sha256=tYPOzZSFE02bAXX3lgcGR1saoQNIv6oWVWH8CS0dl5Q,9079
+rtctools/data/storage.py,sha256=67J4BRTl0AMEzlKNZ8Xdpy_4cGtwx8Lo_tL2n0G4S9w,13206
+rtctools/data/interpolation/__init__.py,sha256=GBubCIT5mFoSTV-lOk7cpwvZekNMEe5bvqSQJ9HE34M,73
+rtctools/data/interpolation/bspline.py,sha256=qevB842XWCH3fWlWMBqKMy1mw37ust-0YtSnb9PKCEc,948
+rtctools/data/interpolation/bspline1d.py,sha256=HAh7m5xLBuiFKzMzuYEqZX_GmCPChKjV7ynTS6iRZOc,6166
+rtctools/data/interpolation/bspline2d.py,sha256=ScmX0fPDxbUVtj3pbUE0L7UJocqroD_6fUT-4cvdRMc,1693
+rtctools/optimization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rtctools/optimization/collocated_integrated_optimization_problem.py,sha256=0s44Ft3e673SMid95bew-OVCyal6Px4eRbgXxNqakRs,134190
+rtctools/optimization/control_tree_mixin.py,sha256=6OMvjT5rFvvXU3_O6Uwz8xvBQpRH9d5z4mMOtOQ4-a4,9036
+rtctools/optimization/csv_lookup_table_mixin.py,sha256=TUYAT-u-mzH6HLP0iJHnLBVqV5tWnhYAqDC4Aj17MJg,17399
+rtctools/optimization/csv_mixin.py,sha256=_6iPVK_EJ8PxnukepzkhFtidceucsozRML_DDEycYik,12453
+rtctools/optimization/goal_programming_mixin.py,sha256=vdnKnz1Ov3OFN-J9KQiiAwHbrLjWH6o_PeZz2YfLz6k,33320
+rtctools/optimization/goal_programming_mixin_base.py,sha256=qJQQcJlJdio4GTcrKfuBi6Nho9u16pDuuprzK0LUyhA,43835
+rtctools/optimization/homotopy_mixin.py,sha256=Kh0kMfxB-Fo1FBGW5tPOQk24Xx_Mmw_p0YuSQotdkMU,6905
+rtctools/optimization/initial_state_estimation_mixin.py,sha256=74QYfG-VYYTNVg-kAnCG6QoY3_sUmaID0ideF7bPkkY,3116
+rtctools/optimization/io_mixin.py,sha256=AsZQ7YOUcUbWoczmjTXaSje5MUEsPNbQyZBJ6qzSjzU,11821
+rtctools/optimization/linearization_mixin.py,sha256=mG5S7uwvwDydw-eBPyQKnLyKoy08EBjQh25vu97afhY,1049
+rtctools/optimization/linearized_order_goal_programming_mixin.py,sha256=LQ2qpYt0YGLpEoerif4FJ5wwzq16q--27bsRjcqIU5A,9087
+rtctools/optimization/min_abs_goal_programming_mixin.py,sha256=WMOv9EF8cfDJgTunzXfI_cUmBSQK26u1HJB_9EAarfM,14031
+rtctools/optimization/modelica_mixin.py,sha256=RIRJs6V7evduKydXtNZqov_0PchyCV4XxTJRwu3FC0s,18328
+rtctools/optimization/netcdf_mixin.py,sha256=-zkXh3sMYE50c3kHsrmUVGWMSFm-0cXQpGrCm0yn-Tc,7563
+rtctools/optimization/optimization_problem.py,sha256=45cJplYqluAqets4-MLtqrxce6g1woYQoDuU7GyqH6E,44909
+rtctools/optimization/pi_mixin.py,sha256=G_6RPlXO-IOjqYxNsMZGY4fmnfxVpwN-_T5Ka3rDwK4,11788
+rtctools/optimization/planning_mixin.py,sha256=O_Y74X8xZmaNZR4iYOe7BR06s9hnmcapbuHYHQTBPPQ,724
+rtctools/optimization/single_pass_goal_programming_mixin.py,sha256=5lo7L4sFPWkR7Dm8NxrnN3f3WDXEXzc30ZecdPpxaOI,26422
+rtctools/optimization/timeseries.py,sha256=nCrsGCJThBMh9lvngEpbBDa834_QvklVvkxJqwX4a1M,1734
+rtctools/simulation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rtctools/simulation/csv_mixin.py,sha256=rGDUFPsqGHmF0_dWdXeWzWzMpkPmwCNweTBVrwSh31g,6704
+rtctools/simulation/io_mixin.py,sha256=WIKOQxr3fS-aNbgjet9iWoUayuD22zLIYmqlWEqxXHo,6215
+rtctools/simulation/pi_mixin.py,sha256=_TU2DrK2MQqVsyrHBD9W4SDEuot9dYmgTDNiXkDAJfk,9833
+rtctools/simulation/simulation_problem.py,sha256=v5Lk2x-yuVb5s7ne5fFgxONxGniLHTyTR0XRzYRl1fw,50005
+rtc_tools-2.7.3.dist-info/METADATA,sha256=xqNyDcIphu2nP_A7ltzab5hGbCkI-HQmSgGf4Qhf_u0,1771
+rtc_tools-2.7.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rtc_tools-2.7.3.dist-info/entry_points.txt,sha256=DVS8sWf3b9ph9h8srEr6zmQ7ZKGwblwgZgGPZg-jRNQ,150
+rtc_tools-2.7.3.dist-info/top_level.txt,sha256=pnBrb58PFPd1kp1dqa-JHU7R55h3alDNJIJnF3Jf9Dw,9
+rtc_tools-2.7.3.dist-info/RECORD,,

rtc_tools-2.7.3.dist-info/WHEEL

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

rtc_tools-2.7.3.dist-info/entry_points.txt

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

rtc_tools-2.7.3.dist-info/licenses/COPYING.LESSER

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

rtc_tools-2.7.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+rtctools

rtctools/__init__.py

@@ -0,0 +1,5 @@
+# Get version
+from ._version import get_versions
+
+__version__ = get_versions()["version"]
+del get_versions

rtctools/_internal/alias_tools.py

@@ -0,0 +1,188 @@
+from collections.abc import MutableSet
+from typing import Generic, Iterator, Mapping, Tuple, TypeVar
+
+from pymoca.backends.casadi.alias_relation import AliasRelation  # noqa: F401
+
+
+class OrderedSet(MutableSet):
+    """
+    Adapted from https://code.activestate.com/recipes/576694/
+    with some additional methods:
+    __getstate__, __setstate__, __getitem__
+    """
+
+    def __init__(self, iterable=None):
+        self.end = end = []
+        end += [None, end, end]  # sentinel node for doubly linked list
+        self.map = {}  # key --> [key, prev, next]
+        if iterable is not None:
+            self |= iterable
+
+    def __len__(self):
+        return len(self.map)
+
+    def __contains__(self, key):
+        return key in self.map
+
+    def __getstate__(self):
+        """Avoids max depth RecursionError when using pickle"""
+        return list(self)
+
+    def __setstate__(self, state):
+        """Tells pickle how to restore instance"""
+        self.__init__(state)
+
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            start, stop, stride = index.indices(len(self))
+            return [self.__getitem__(i) for i in range(start, stop, stride)]
+        else:
+            end = self.end
+            curr = end[2]
+            i = 0
+            while curr is not end:
+                if i == index:
+                    return curr[0]
+                curr = curr[2]
+                i += 1
+            raise IndexError("set index {} out of range with length {}".format(index, len(self)))
+
+    def add(self, key):
+        if key not in self.map:
+            end = self.end
+            curr = end[1]
+            curr[2] = end[1] = self.map[key] = [key, curr, end]
+
+    def discard(self, key):
+        if key in self.map:
+            key, prev, next = self.map.pop(key)
+            prev[2] = next
+            next[1] = prev
+
+    def __iter__(self):
+        end = self.end
+        curr = end[2]
+        while curr is not end:
+            yield curr[0]
+            curr = curr[2]
+
+    def __reversed__(self):
+        end = self.end
+        curr = end[1]
+        while curr is not end:
+            yield curr[0]
+            curr = curr[1]
+
+    def pop(self, last=True):
+        if not self:
+            raise KeyError("set is empty")
+        key = self.end[1][0] if last else self.end[2][0]
+        self.discard(key)
+        return key
+
+    def __repr__(self):
+        if not self:
+            return "%s()" % (self.__class__.__name__,)
+        return "%s(%r)" % (self.__class__.__name__, list(self))
+
+    def __eq__(self, other):
+        if isinstance(other, OrderedSet):
+            return len(self) == len(other) and list(self) == list(other)
+        return set(self) == set(other)
+
+
+# End snippet
+
+
+KT = TypeVar("KT")
+VT = TypeVar("VT")
+
+
+class AliasDict(Generic[KT, VT]):
+    def __init__(self, relation, other=None, signed_values=True):
+        self.__relation = relation
+        self.__d = {}
+        self.__signed_values = signed_values
+        if other:
+            self.update(other)
+
+    def __canonical_signed(self, key: KT):
+        var, sign = self.__relation.canonical_signed(key)
+        if self.__signed_values:
+            return var, sign
+        else:
+            return var, 1
+
+    def __setitem__(self, key: KT, val: VT):
+        var, sign = self.__canonical_signed(key)
+        if isinstance(val, tuple):
+            assert len(val) == 2
+            if sign < 0:
+                self.__d[var] = (-val[1], -val[0])
+            else:
+                self.__d[var] = val
+        elif isinstance(val, list) and sign < 0:
+            self.__d[var] = [-x for x in val]
+        else:
+            self.__d[var] = -val if sign < 0 else val
+
+    def __getitem__(self, key: KT):
+        var, sign = self.__canonical_signed(key)
+        val = self.__d[var]
+        if isinstance(val, tuple):
+            if sign < 0:
+                return (-val[1], -val[0])
+            else:
+                return val
+        elif isinstance(val, list) and sign < 0:
+            return [-x for x in val]
+        else:
+            return -val if sign < 0 else val
+
+    def __delitem__(self, key: KT):
+        var, sign = self.__canonical_signed(key)
+        del self.__d[var]
+
+    def __contains__(self, key: KT):
+        var, sign = self.__canonical_signed(key)
+        return var in self.__d
+
+    def __len__(self) -> int:
+        return len(self.__d)
+
+    def __iter__(self) -> Iterator[KT]:
+        return iter(self.__d)
+
+    def update(self, other: Mapping[KT, VT]):
+        for key, value in other.items():
+            self[key] = value
+
+    def get(self, key: KT, default: VT = None):
+        if key in self:
+            return self[key]
+        else:
+            return default
+
+    def setdefault(self, key: KT, default: VT):
+        if key in self:
+            return self[key]
+        else:
+            self[key] = default
+            return default
+
+    def keys(self) -> Iterator[KT]:
+        return self.__d.keys()
+
+    def values(self) -> Iterator[VT]:
+        return self.__d.values()
+
+    def items(self) -> Iterator[Tuple[KT, VT]]:
+        return self.__d.items()
+
+    def copy(self):
+        copy = AliasDict(self.__relation, None, self.__signed_values)
+        copy.__d = self.__d.copy()
+        return copy
+
+    def __repr__(self):
+        return self.__d.__repr__()

rtctools/_internal/caching.py

@@ -0,0 +1,25 @@
+def cached(f):
+    def wrapper(self, ensemble_member=None):
+        def call():
+            if ensemble_member is not None:
+                return f(self, ensemble_member)
+            else:
+                return f(self)
+
+        # Add a check so that caching is applied to the 'toplevel'
+        # method implementation in the class hierarchy only.
+        call_in_progress = "__" + f.__name__ + "_in_progress"
+        if hasattr(self, call_in_progress):
+            return call()
+        cache_name = "__" + f.__name__
+        if ensemble_member is not None:
+            cache_name = "{}[{}]".format(cache_name, ensemble_member)
+        if hasattr(self, cache_name):
+            return getattr(self, cache_name)
+        setattr(self, call_in_progress, True)
+        value = call()
+        setattr(self, cache_name, value)
+        delattr(self, call_in_progress)
+        return value
+
+    return wrapper

rtctools/_internal/casadi_helpers.py

@@ -0,0 +1,99 @@
+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:
+        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
+
+
+def nullvertcat(*L):
+    """
+    Like vertcat, but creates an MX with consistent dimensions even if L is empty.
+    """
+    if len(L) == 0:
+        return ca.DM(0, 1)
+    else:
+        return ca.vertcat(*L)
+
+
+def reduce_matvec(e, v):
+    """
+    Reduces the MX graph e of linear operations on p into a matrix-vector product.
+
+    This reduces the number of nodes required to represent the linear operations.
+    """
+    Af = ca.Function("Af", [ca.MX()], [ca.jacobian(e, v)])
+    A = Af(ca.DM())
+    return ca.reshape(ca.mtimes(A, v), e.shape)
+
+
+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
+    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):
+    if mode == 0:
+        mode_str = "linear"
+    elif mode == 1:
+        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/debug_check_helpers.py

@@ -0,0 +1,41 @@
+import logging
+from enum import IntEnum
+
+logger = logging.getLogger("rtctools")
+
+
+class DebugLevel(IntEnum):
+    NONE = 0
+    LOW = 10
+    MEDIUM = 20
+    HIGH = 30
+    VERYHIGH = 40
+
+
+def debug_check(level):
+    def noop(*args, **kwargs):
+        pass
+
+    def wrap(func):
+        def func_wrapper(*args, **kwargs):
+            this = args[0]
+            filter_ = this._debug_check_level
+            do_check = False
+            if callable(filter_):
+                if filter_(level, func.__qualname__):
+                    do_check = True
+            elif filter_ >= level:
+                do_check = True
+
+            if do_check:
+                logger.info("Starting debug check '{}'".format(func.__qualname__))
+                extra_options = this._debug_check_options.get(func.__qualname__, {})
+                ret = func(*args, **kwargs, **extra_options)
+                logger.info("Finished debug check '{}'".format(func.__qualname__))
+                return ret
+            else:
+                return noop(*args, **kwargs)
+
+        return func_wrapper
+
+    return wrap

rtctools/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.29) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2026-01-20T14:58:22+0100",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "20585c7d4d1b615468ea7f7dab44a240aeb1f05c",
+ "version": "2.7.3"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

rtctools/data/__init__.py

@@ -0,0 +1,4 @@
+import xml.etree.ElementTree as ET
+
+ET.register_namespace("fews", "http://www.wldelft.nl/fews")
+ET.register_namespace("pi", "http://www.wldelft.nl/fews/PI")