pathsim 0.27.0__tar.gz → 0.27.1__tar.gz

{pathsim-0.27.0 → pathsim-0.27.1}/PKG-INFO

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

{pathsim-0.27.0 → pathsim-0.27.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.27.0'
-__version_tuple__ = version_tuple = (0, 27, 0)
+__version__ = version = '0.27.1'
+__version_tuple__ = version_tuple = (0, 27, 1)
 
-__commit_id__ = commit_id = 'g2cbb2f919'
+__commit_id__ = commit_id = 'ga4e824de2'

{pathsim-0.27.0 → pathsim-0.27.1}/src/pathsim/blocks/dae.py

@@ -51,7 +51,10 @@ class SemiExplicitDAE(Block):
         \\dot{x} = f_\\mathrm{dyn}(x, z(x, u, t), u, t)
 
     to the integration engine, so the DAE integrates with any solver, explicit
-    or implicit. The block output is the stacked state :math:`[x, z]`.
+    or implicit. The block output is the stacked state :math:`[x, z]`, or
+    :math:`y = f_\\mathrm{out}(x, z, u, t)` if an output function is supplied.
+    Without algebraic states (empty `z0`) the block reduces to a plain ODE and
+    the constraint solve is skipped.
 
     Note
     ----
@@ -126,6 +129,9 @@ class SemiExplicitDAE(Block):
         convergence tolerance on the residual norm of the algebraic constraint
         solve, loosen it for ill-conditioned constraints whose residual cannot
         reach the default due to roundoff
+    func_out : callable, None
+        optional output function with signature `func_out(x, z, u, t)`, the
+        block output is the stacked state `[x, z]` if `None`
 
     Attributes
     ----------
@@ -148,7 +154,8 @@ class SemiExplicitDAE(Block):
         jac_dyn_x=None,
         jac_dyn_z=None,
         jac_alg_x=None,
-        tolerance=SOL_TOLERANCE_FPI
+        tolerance=SOL_TOLERANCE_FPI,
+        func_out=None
         ):
 
         super().__init__()
@@ -157,6 +164,9 @@ class SemiExplicitDAE(Block):
         self.func_dyn = func_dyn
         self.func_alg = func_alg
 
+        #optional output function, stacked state [x, z] if 'None'
+        self.func_out = func_out
+
         #convergence tolerance of the algebraic constraint solve
         self.tolerance = tolerance
 
@@ -187,9 +197,10 @@ class SemiExplicitDAE(Block):
         self.op_dyn = DynamicOperator(func=self._rhs, jac_x=_jac_x)
 
         #pre-size the output register to the stacked state [x, z]
-        self.outputs.update_from_array(
-            np.concatenate([self.initial_value, self.z0])
-            )
+        if self.func_out is None:
+            self.outputs.update_from_array(
+                np.concatenate([self.initial_value, self.z0])
+                )
 
 
     def __len__(self):
@@ -204,10 +215,11 @@ class SemiExplicitDAE(Block):
         """
         super().reset()
         self._z = self.z0.copy()
-        x = self.engine.state if self.engine else self.initial_value
-        self.outputs.update_from_array(
-            np.concatenate([np.atleast_1d(x), self._z])
-            )
+        if self.func_out is None:
+            x = self.engine.state if self.engine else self.initial_value
+            self.outputs.update_from_array(
+                np.concatenate([np.atleast_1d(x), self._z])
+                )
 
 
     def _solve_z(self, x, u, t):
@@ -229,6 +241,10 @@ class SemiExplicitDAE(Block):
         z : array[float]
             algebraic states satisfying the constraint
         """
+        #nothing to solve without algebraic states
+        if self._z.size == 0:
+            return self._z
+
         _func = lambda z: self.func_alg(x, z, u, t)
         _jac = None if self.jac_z is None else (lambda z: self.jac_z(x, z, u, t))
         z, _, _ = solve_root(self.opt, _func, self._z, _jac, tolerance=self.tolerance)
@@ -277,6 +293,8 @@ class SemiExplicitDAE(Block):
         """
         z = self._solve_z(x, u, t)
         fx = np.atleast_2d(self.jac_dyn_x(x, z, u, t))
+        if z.size == 0:
+            return fx
         fz = np.atleast_2d(self.jac_dyn_z(x, z, u, t))
         gx = np.atleast_2d(self.jac_alg_x(x, z, u, t))
         gz = np.atleast_2d(self.jac_z(x, z, u, t))
@@ -285,7 +303,7 @@ class SemiExplicitDAE(Block):
 
     def update(self, t):
         """Eliminate the algebraic states for the current input and expose the
-        stacked state [x, z] at the output.
+        output function, or the stacked state [x, z], at the output.
 
         Parameters
         ----------
@@ -294,9 +312,11 @@ class SemiExplicitDAE(Block):
         """
         x, u = self.engine.state, self.inputs.to_array()
         self._z = self._solve_z(x, u, t)
-        self.outputs.update_from_array(
-            np.concatenate([np.atleast_1d(x), self._z])
-            )
+        if self.func_out is None:
+            y = np.concatenate([np.atleast_1d(x), self._z])
+        else:
+            y = self.func_out(x, self._z, u, t)
+        self.outputs.update_from_array(y)
 
 
     def solve(self, t, dt):

{pathsim-0.27.0 → pathsim-0.27.1}/src/pathsim/simulation.py

@@ -2025,6 +2025,10 @@ class Simulation:
         #main simulation loop
         while self.time < end_time and self._active:
 
+            if not _adaptive and np.isclose(
+                    self.time - start_time, duration, rtol=1e-12, atol=0.0):
+                break
+
             #advance the simulation by one (effective) timestep '_dt'
             try:
                 success, error_norm, scale, *_ = self.timestep(

{pathsim-0.27.0 → pathsim-0.27.1}/src/pathsim.egg-info/PKG-INFO

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

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

@@ -0,0 +1,8 @@
+{
+  "tag": "0.27.1",
+  "distance": 0,
+  "node": "ga4e824de226c5a76509d6163b3c1e33445861144",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-12"
+}

{pathsim-0.27.0 → pathsim-0.27.1}/tests/pathsim/blocks/test_dae.py

@@ -141,10 +141,62 @@ class TestSemiExplicitDAE(unittest.TestCase):
         info = SemiExplicitDAE.info()
         self.assertEqual(info["type"], "SemiExplicitDAE")
         for p in ("func_dyn", "func_alg", "initial_value", "z0", "jac_z",
-                  "jac_dyn_x", "jac_dyn_z", "jac_alg_x", "tolerance"):
+                  "jac_dyn_x", "jac_dyn_z", "jac_alg_x", "tolerance", "func_out"):
             self.assertIn(p, info["parameters"])
 
 
+    def test_func_out(self):
+        #output function replaces the stacked state [x, z] at the output
+        dae = SemiExplicitDAE(
+            lambda x, z, u, t: -x + z, lambda x, z, u, t: z - x**2, 0.5, 0.25,
+            func_out=lambda x, z, u, t: np.array([x[0] + z[0]])
+            )
+        self.assertEqual(len(dae.outputs), 1)
+
+        dae.set_solver(ESDIRK43, None)
+        dae.update(0.0)
+        self.assertAlmostEqual(float(dae.outputs[0]), 0.5 + 0.25, places=8)
+
+        #reset keeps the output size of the output function
+        dae.reset()
+        self.assertEqual(len(dae.outputs), 1)
+
+
+    def test_no_algebraic_states(self):
+        #empty z reduces the block to a plain ODE without a constraint solve
+        calls = []
+        def f_alg(x, z, u, t):
+            calls.append(1)
+            return np.zeros(0)
+
+        dae = SemiExplicitDAE(
+            lambda x, z, u, t: -x, f_alg, initial_value=[1.0, 2.0], z0=np.zeros(0),
+            jac_z=lambda x, z, u, t: np.zeros((0, 0)),
+            jac_dyn_x=lambda x, z, u, t: -np.eye(2),
+            jac_dyn_z=lambda x, z, u, t: np.zeros((2, 0)),
+            jac_alg_x=lambda x, z, u, t: np.zeros((0, 2))
+            )
+
+        x, u = np.array([1.0, 2.0]), np.array([0.0])
+        self.assertEqual(dae._solve_z(x, u, 0.0).size, 0)
+        np.testing.assert_array_equal(dae.op_dyn.jac_x(x, u, 0.0), -np.eye(2))
+        self.assertEqual(len(calls), 0)
+
+
+    def test_simulation_no_algebraic_states(self):
+        #x' = -x with empty z integrates like the ODE block
+        from pathsim import Simulation
+
+        dae = SemiExplicitDAE(
+            lambda x, z, u, t: -x, lambda x, z, u, t: np.zeros(0),
+            initial_value=[1.0, 2.0], z0=np.zeros(0)
+            )
+        sim = Simulation(blocks=[dae], dt=0.01, Solver=ESDIRK43, log=False)
+        sim.run(1.0)
+
+        np.testing.assert_allclose(dae.engine.state, np.exp(-1.0)*np.array([1.0, 2.0]), rtol=1e-4)
+
+
     def test_tolerance_default(self):
         self.assertEqual(self._make_block().tolerance, SOL_TOLERANCE_FPI)
 

{pathsim-0.27.0 → pathsim-0.27.1}/tests/pathsim/test_simulation.py

@@ -396,10 +396,10 @@ class TestSimulation(unittest.TestCase):
         stats = Sim.run(10)
 
         #check stats
-        self.assertEqual(stats["total_steps"], 1001)
+        self.assertEqual(stats["total_steps"], 1000)
             
-        #check internal time progression (fixed step solvers naturally overshoot)
-        self.assertAlmostEqual(Sim.time, 10, 1)
+        #check internal time progression stops at the requested endpoint
+        self.assertAlmostEqual(Sim.time, 10.0)
 
 
 
@@ -552,6 +552,88 @@ class TestSimulationIVP(unittest.TestCase):
 
 
 
+class TestSimulationRunBoundaries(unittest.TestCase):
+
+    def test_fixed_run_stops_at_aligned_endpoint(self):
+        for dt, duration, steps in [(0.1, 1.0, 10), (0.01, 10.0, 1000),
+                                    (0.2, 2.0, 10)]:
+            with self.subTest(dt=dt, duration=duration):
+                source = Constant(1.0)
+                integrator = Integrator()
+                scope = Scope()
+                simulation = Simulation(
+                    [source, integrator, scope],
+                    [Connection(source, integrator), Connection(integrator, scope)],
+                    dt=dt, log=False
+                    )
+
+                simulation.run(duration, adaptive=False)
+
+                self.assertAlmostEqual(simulation.time / duration, 1.0)
+                self.assertAlmostEqual(integrator.outputs[0] / duration, 1.0)
+                times, _ = scope.read()
+                self.assertEqual(len(times), steps + 1)
+                self.assertEqual(simulation.dt, dt)
+
+
+    def test_fixed_run_keeps_full_steps_for_non_aligned_endpoint(self):
+        for dt, duration, endpoint, steps in [(0.3, 1.0, 1.2, 4),
+                                             (2.0, 1.0, 2.0, 1),
+                                             (0.1, 0.05, 0.1, 1)]:
+            with self.subTest(dt=dt, duration=duration):
+                source = Constant(1.0)
+                integrator = Integrator()
+                scope = Scope()
+                simulation = Simulation(
+                    [source, integrator, scope],
+                    [Connection(source, integrator), Connection(integrator, scope)],
+                    dt=dt, log=False
+                    )
+
+                simulation.run(duration, adaptive=False)
+
+                self.assertAlmostEqual(simulation.time, endpoint)
+                self.assertAlmostEqual(integrator.outputs[0], endpoint)
+                times, _ = scope.read()
+                self.assertEqual(len(times), steps + 1)
+                self.assertEqual(simulation.dt, dt)
+
+
+    def test_streaming_run_stops_at_requested_endpoint(self):
+        simulation = Simulation(dt=0.1, log=False)
+        list(simulation.run_streaming(1.0, adaptive=False))
+        self.assertAlmostEqual(simulation.time, 1.0)
+
+
+    def test_fixed_split_runs_match_single_run(self):
+        source = Constant(1.0)
+        integrator = Integrator()
+        ticks = []
+
+        def sample(time):
+            ticks.append(time)
+            source.value = 2.0 * integrator.outputs[0] + 1.0
+
+        simulation = Simulation(
+            [source, integrator], [Connection(source, integrator)],
+            events=[Schedule(t_start=0.0, t_period=1.0, func_act=sample)],
+            dt=0.1, log=False
+            )
+
+        simulation.run(1.0, adaptive=False)
+        self.assertAlmostEqual(simulation.time, 1.0)
+        simulation.run(1.0, adaptive=False)
+        self.assertAlmostEqual(simulation.time, 2.0)
+        self.assertEqual(ticks, [0.0, 1.0, 2.0])
+        split_output = integrator.outputs[0]
+
+        ticks.clear()
+        simulation.run(2.0, reset=True, adaptive=False)
+        self.assertAlmostEqual(simulation.time, 2.0)
+        self.assertEqual(ticks, [0.0, 1.0, 2.0])
+        self.assertAlmostEqual(integrator.outputs[0], split_output)
+
+
 class TestSimulationEvents(unittest.TestCase):
     """Test event management and event handling during simulation"""
 

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

@@ -1,8 +0,0 @@
-{
-  "tag": "0.27.0",
-  "distance": 0,
-  "node": "g2cbb2f9191f0a2aeaa2154b3a54601c2ca92ea6b",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-04"
-}