pathsim 0.23.0__tar.gz → 0.23.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathsim
-Version: 0.23.0
+Version: 0.23.1
 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.1}/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.1'
+__version_tuple__ = version_tuple = (0, 23, 1)
 
-__commit_id__ = commit_id = 'g5fc53f553'
+__commit_id__ = commit_id = 'gf987e70cf'

{pathsim-0.23.0 → pathsim-0.23.1}/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.1}/src/pathsim.egg-info/PKG-INFO

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

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

@@ -0,0 +1,8 @@
+{
+  "tag": "0.23.1",
+  "distance": 0,
+  "node": "gf987e70cf3b1dd9ad4d30810f5590b0600804593",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-06-25"
+}

{pathsim-0.23.0 → pathsim-0.23.1}/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/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"
-}