pathsim 0.23.0__tar.gz → 0.23.2__tar.gz

{pathsim-0.23.0 → pathsim-0.23.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathsim
-Version: 0.23.0
+Version: 0.23.2
 Summary: A differentiable block based hybrid system simulation framework.
 Author-email: Milan Rother <milan.rother@gmx.de>
 License: MIT

{pathsim-0.23.0 → pathsim-0.23.2}/src/pathsim/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.23.0'
-__version_tuple__ = version_tuple = (0, 23, 0)
+__version__ = version = '0.23.2'
+__version_tuple__ = version_tuple = (0, 23, 2)
 
-__commit_id__ = commit_id = 'g5fc53f553'
+__commit_id__ = commit_id = 'g6079208a8'

{pathsim-0.23.0 → pathsim-0.23.2}/src/pathsim/blocks/bvp.py

@@ -116,6 +116,10 @@ class BVP1D(Block):
         initial guess for the free parameters, `None` if there are none
     tol : float
         solver tolerance passed to :func:`scipy.integrate.solve_bvp`
+    max_nodes : int
+        maximum number of mesh nodes allowed during refinement, passed to
+        :func:`scipy.integrate.solve_bvp`. A solve that would exceed this cap
+        fails and the previous output and warm-start are retained.
 
     Attributes
     ----------
@@ -135,7 +139,8 @@ class BVP1D(Block):
         x_eval=None,
         y0=None,
         p0=None,
-        tol=1e-6
+        tol=1e-6,
+        max_nodes=1000
         ):
 
         super().__init__()
@@ -157,8 +162,9 @@ class BVP1D(Block):
         self.x_eval = (np.linspace(a, b, n_nodes) if x_eval is None
                        else np.asarray(x_eval, dtype=float))
 
-        #solver tolerance
+        #solver tolerance and mesh node cap
         self.tol = tol
+        self.max_nodes = int(max_nodes)
 
         #initial mesh and solution guess (used as warm-start)
         self._x0 = np.linspace(a, b, n_nodes)
@@ -254,11 +260,13 @@ class BVP1D(Block):
         if self._has_p:
             _fun = lambda x, y, p: self.fun(x, y, p, u)
             _bc = lambda ya, yb, p: self.bc(ya, yb, p, u)
-            sol = solve_bvp(_fun, _bc, self._x, self._y, p=self._p, tol=self.tol)
+            sol = solve_bvp(_fun, _bc, self._x, self._y, p=self._p,
+                            tol=self.tol, max_nodes=self.max_nodes)
         else:
             _fun = lambda x, y: self.fun(x, y, None, u)
             _bc = lambda ya, yb: self.bc(ya, yb, None, u)
-            sol = solve_bvp(_fun, _bc, self._x, self._y, tol=self.tol)
+            sol = solve_bvp(_fun, _bc, self._x, self._y,
+                            tol=self.tol, max_nodes=self.max_nodes)
 
         self.success = bool(sol.success)
 

{pathsim-0.23.0 → pathsim-0.23.2}/src/pathsim/blocks/rf.py

@@ -18,6 +18,7 @@ from typing import TYPE_CHECKING, TypeVar
 
 try:
     import skrf as rf
+    from skrf.vectorFitting import VectorFitting as _VectorFitting
 
     HAS_SKRF = True
 except ImportError:
@@ -85,12 +86,12 @@ class RFNetwork(StateSpace):
 
         # Select the vector fitting function from scikit-rf
         vf_fun_name = "auto_fit" if auto_fit else "vector_fit"
-        vf_fun = getattr(rf.VectorFitting, vf_fun_name)
+        vf_fun = getattr(_VectorFitting, vf_fun_name)
         # Filter kwargs for the selected vf function
         vf_fun_keys = signature(vf_fun).parameters
         vf_kwargs = {k: v for k, v in kwargs.items() if k in vf_fun_keys}
         # Apply vector fitting
-        vf = rf.VectorFitting(ntwk)
+        vf = _VectorFitting(ntwk)
         getattr(vf, vf_fun_name)(**vf_kwargs)
         A, B, C, D, _ = vf._get_ABCDE()
         # keep a copy of the network and VF
@@ -113,6 +114,6 @@ class RFNetwork(StateSpace):
         s : :py:class:`~numpy.ndarray`
             Complex-valued S-matrices (fxNxN) calculated at frequencies `freqs`.
         """
-        return rf.VectorFitting._get_s_from_ABCDE(
+        return _VectorFitting._get_s_from_ABCDE(
             freqs, self.A, self.B, self.C, self.D, 0
         )

{pathsim-0.23.0 → pathsim-0.23.2}/src/pathsim/solvers/rkf45.py

@@ -15,16 +15,18 @@ from ._rungekutta import ExplicitRungeKutta
 # SOLVERS ==============================================================================
 
 class RKF45(ExplicitRungeKutta):
-    """Runge-Kutta-Fehlberg 4(5) pair. Six stages, 4th order propagation with
-    5th order error estimate.
+    """Runge-Kutta-Fehlberg 5(4) pair. Six stages, 5th order propagation with
+    an embedded 4th order solution for local error estimation (local
+    extrapolation, matching the ``RKCK54`` / ``RKDP54`` convention).
 
     The historically first widely-used embedded pair for automatic step-size
-    control. The 4th order solution is propagated; the difference to the 5th
-    order solution provides a local error estimate.
+    control. The 5th order solution ``b5`` is propagated; the difference to the
+    4th order solution ``b4`` (``TR = b5 - b4``) provides a local error estimate
+    of the lower-order result.
 
     Characteristics
     ---------------
-    * Order: 4 (propagating) / 5 (error estimate)
+    * Order: 5 (propagating) / 4 (error estimate)
     * Stages: 6
     * Explicit, adaptive timestep
 
@@ -63,15 +65,15 @@ class RKF45(ExplicitRungeKutta):
         #intermediate evaluation times
         self.eval_stages = [0.0, 1/4, 3/8, 12/13, 1, 1/2]
 
-        #extended butcher table 
+        #extended butcher table (propagates the 5th order weights b5)
         self.BT = {
             0: [      1/4],
             1: [     3/32,       9/32],
-            2: [1932/2197, -7200/2197,  7296/2197],
-            3: [  439/216,         -8,   3680/513, -845/4104],
-            4: [    -8/27,          2, -3554/2565, 1859/4104, -11/40],
-            5: [   25/216,          0,  1408/2565, 2197/4104,   -1/5, 0]
+            2: [1932/2197, -7200/2197,   7296/2197],
+            3: [  439/216,         -8,    3680/513,  -845/4104],
+            4: [    -8/27,          2,  -3544/2565,  1859/4104,  -11/40],
+            5: [   16/135,          0, 6656/12825, 28561/56430,   -9/50, 2/55]
             }
 
-        #coefficients for local truncation error estimate
+        #coefficients for local truncation error estimate (TR = b5 - b4)
         self.TR = [1/360, 0, -128/4275, -2197/75240, 1/50, 2/55]

{pathsim-0.23.0 → pathsim-0.23.2}/src/pathsim.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathsim
-Version: 0.23.0
+Version: 0.23.2
 Summary: A differentiable block based hybrid system simulation framework.
 Author-email: Milan Rother <milan.rother@gmx.de>
 License: MIT

pathsim-0.23.2/src/pathsim.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.23.2",
+  "distance": 0,
+  "node": "g6079208a8cee1d89d8a05a5dadc004bb7f5d2f9a",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-04"
+}

{pathsim-0.23.0 → pathsim-0.23.2}/tests/pathsim/blocks/rf/test_rf.py

@@ -69,7 +69,7 @@ class TestOnePort(unittest.TestCase):
         "Test space-state ABCD parameters."
         # ABCD(E) arrays from scikit-rf
         ntwk = rf.data.ring_slot_meas
-        vf = rf.VectorFitting(ntwk)
+        vf = rf.vectorFitting.VectorFitting(ntwk)
         vf.auto_fit()
         A, B, C, D, E = vf._get_ABCDE()
 

{pathsim-0.23.0 → pathsim-0.23.2}/tests/pathsim/blocks/test_bvp.py

@@ -106,10 +106,49 @@ class TestBVP1D(unittest.TestCase):
     def test_info(self):
         info = BVP1D.info()
         self.assertEqual(info["type"], "BVP1D")
-        for p in ("fun", "bc", "n", "domain", "n_nodes", "x_eval", "y0", "p0", "tol"):
+        for p in ("fun", "bc", "n", "domain", "n_nodes", "x_eval", "y0", "p0",
+                  "tol", "max_nodes"):
             self.assertIn(p, info["parameters"])
 
 
+    def test_max_nodes_passthrough(self):
+        #max_nodes is stored as int and forwarded to solve_bvp
+        fun = lambda x, y, p, u: np.vstack([y[1], -y[0]])
+        bc = lambda ya, yb, p, u: np.array([ya[0], yb[0] - 1.0])
+        bvp = BVP1D(fun, bc, n=2, domain=(0.0, np.pi/2), max_nodes=5000)
+        self.assertEqual(bvp.max_nodes, 5000)
+
+        import pathsim.blocks.bvp as bvpmod
+        captured = {}
+        orig = bvpmod.solve_bvp
+        def _capture(*a, **k):
+            captured["max_nodes"] = k.get("max_nodes")
+            return orig(*a, **k)
+        bvpmod.solve_bvp = _capture
+        try:
+            bvp.update(0.0)
+        finally:
+            bvpmod.solve_bvp = orig
+        self.assertEqual(captured["max_nodes"], 5000)
+
+
+    def test_max_nodes_too_small_fails(self):
+        #a cap below the nodes required for convergence makes the solve fail,
+        #raising max_nodes recovers it
+        fun = lambda x, y, p, u: np.vstack([y[1], -y[0]])
+        bc = lambda ya, yb, p, u: np.array([ya[0], yb[0] - 1.0])
+
+        tight = BVP1D(fun, bc, n=2, domain=(0.0, np.pi/2), n_nodes=3,
+                      tol=1e-10, max_nodes=4)
+        tight.update(0.0)
+        self.assertFalse(tight.success)
+
+        loose = BVP1D(fun, bc, n=2, domain=(0.0, np.pi/2), n_nodes=3,
+                      tol=1e-10, max_nodes=10000)
+        loose.update(0.0)
+        self.assertTrue(loose.success)
+
+
     def test_simulation(self):
         #drive the right boundary with a constant source, output tracks u*sin(x)
         from pathsim import Simulation, Connection

{pathsim-0.23.0 → pathsim-0.23.2}/tests/pathsim/solvers/test_rkf45.py

@@ -118,12 +118,28 @@ class TestRKF45(unittest.TestCase):
                     err = np.mean(abs(numerical_solution - analytical_solution))
                     errors.append(err)
 
-                #test if errors are monotonically decreasing
-                self.assertTrue(np.all(np.diff(errors)<0))
-
-                #test convergence order, expected n-1 (global)
-                p, _ = np.polyfit(np.log10(timesteps), np.log10(errors), deg=1)
-                self.assertGreater(p, solver.n-1)
+                errors = np.array(errors)
+                timesteps = np.array(timesteps)
+
+                #restrict the convergence assessment to the region above the
+                #roundoff floor: now that RKF45 propagates the 5th order weights
+                #it drives some reference problems to machine precision at fine
+                #dt, where the error saturates and is no longer a clean power law
+                above_floor = errors > 1e-11
+                errs_fit = errors[above_floor]
+                dts_fit = timesteps[above_floor]
+
+                #test if errors are monotonically decreasing (above the floor)
+                self.assertTrue(np.all(np.diff(errs_fit) < 0))
+
+                #test convergence order (global). A conservative n-2 bound is
+                #used here because the now-5th-order propagation makes a plain
+                #fixed-step fit sensitive to fixture effects on the stiffer
+                #reference problems (rapidly growing higher derivatives near the
+                #blow-up of 1/(1-t) pollute the asymptotic slope). The clean
+                #order fit lives in test_convergence_order_fixed_step.
+                p, _ = np.polyfit(np.log10(dts_fit), np.log10(errs_fit), deg=1)
+                self.assertGreater(p, solver.n-2)
 
             #log stats
             stats[problem.name] = {"n":p, "err":errors, "dt":timesteps}
@@ -137,6 +153,37 @@ class TestRKF45(unittest.TestCase):
         # plt.show()
 
 
+    def test_convergence_order_fixed_step(self):
+
+        #RKF45 propagates the 5th order weights -> fixed-step global convergence
+        #order must be ~5 on a smooth problem. Driven step-by-step to an exact
+        #endpoint (no overshoot) so the fitted slope reflects the tableau order.
+        #x' = x, x(0) = 1  ->  exact x(1) = e.
+        func = lambda x, t: x
+        exact = np.exp(1.0)
+
+        n_steps = [10, 20, 40, 80, 160]
+        dts = [1.0 / n for n in n_steps]
+        errors = []
+        for n in n_steps:
+            solver = RKF45(1.0)
+            solver.reset()
+            t, dt = 0.0, 1.0 / n
+            for _ in range(n):
+                solver.integrate_singlestep(func, time=t, dt=dt)
+                t += dt
+            errors.append(abs(float(np.ravel(solver.x)[0]) - exact))
+
+        #errors must decrease monotonically
+        self.assertTrue(np.all(np.diff(errors) < 0))
+
+        #least-squares order fit must be close to 5 (the pre-fix 4th order
+        #propagation gives ~4; a broken high-order row would give < 4)
+        p, _ = np.polyfit(np.log10(dts), np.log10(errors), deg=1)
+        self.assertGreater(p, 4.6)
+        self.assertLess(p, 5.4)
+
+
     def test_integrate_adaptive(self):
 
         #integrate test problem and assess convergence order

pathsim-0.23.0/src/pathsim.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.23.0",
-  "distance": 0,
-  "node": "g5fc53f5537e347b855719bd7176bab2b6ff72222",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-06-23"
-}