pathsim 0.24.0__tar.gz → 0.25.1__tar.gz

{pathsim-0.24.0 → pathsim-0.25.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathsim
-Version: 0.24.0
+Version: 0.25.1
 Summary: A differentiable block based hybrid system simulation framework.
 Author-email: Milan Rother <milan.rother@gmx.de>
 License: MIT
@@ -119,6 +119,7 @@ scp.plot()
 - [Documentation](https://docs.pathsim.org) — tutorials, examples, and API reference
 - [Homepage](https://pathsim.org) — overview and getting started
 - [Contributing](https://docs.pathsim.org/pathsim/latest/contributing) — how to contribute
+- [Consulting & commercial support](https://milanrother.com/consulting/) — integration, custom blocks, migration from closed tools
 
 ## Citation
 

{pathsim-0.24.0 → pathsim-0.25.1}/README.md

@@ -89,6 +89,7 @@ scp.plot()
 - [Documentation](https://docs.pathsim.org) — tutorials, examples, and API reference
 - [Homepage](https://pathsim.org) — overview and getting started
 - [Contributing](https://docs.pathsim.org/pathsim/latest/contributing) — how to contribute
+- [Consulting & commercial support](https://milanrother.com/consulting/) — integration, custom blocks, migration from closed tools
 
 ## Citation
 

{pathsim-0.24.0 → pathsim-0.25.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.24.0'
-__version_tuple__ = version_tuple = (0, 24, 0)
+__version__ = version = '0.25.1'
+__version_tuple__ = version_tuple = (0, 25, 1)
 
-__commit_id__ = commit_id = 'gf8f02298b'
+__commit_id__ = commit_id = 'gea36c5c1e'

{pathsim-0.24.0 → pathsim-0.25.1}/src/pathsim/blocks/dynsys.py

@@ -93,7 +93,8 @@ class DynamicalSystem(Block):
         alg_length : int
             length of algebraic path
         """
-        x, u = self.engine.state, self.inputs.to_array()
+        x = self.engine.state if self.engine else self.initial_value
+        u = self.inputs.to_array()
         has_passthrough = np.any(self.op_alg.jac_u(x, u, 0.0))
         return int(has_passthrough)
 

{pathsim-0.24.0 → pathsim-0.25.1}/src/pathsim/blocks/math.py

@@ -601,9 +601,9 @@ class Matrix(Math):
 
     Parameters
     ----------
-    A : np.ndarray
-        matrix, 2d array with dim=2
-        
+    A : array_like
+        matrix, 2d array-like (nested lists are accepted and converted)
+
     Attributes
     ----------
     op_alg : Operator
@@ -613,6 +613,10 @@ class Matrix(Math):
     def __init__(self, A=np.eye(1)):
         super().__init__()
 
+        # accept any array-like: a nested list is the natural way to write a
+        # small matrix inline, and every other block parameter takes one
+        A = np.asarray(A, dtype=float)
+
         # check matrix dimension and shape
         if not A.ndim == 2:
             raise ValueError("'A' must be dim 2")

{pathsim-0.24.0 → pathsim-0.25.1}/src/pathsim/blocks/relay.py

@@ -98,12 +98,25 @@ class Relay(Block):
                 ),
             ]
 
+        # start in the lower relay state
+        self.outputs[0] = self.value_down
+
 
     def __len__(self):
         """This block has no direct passthrough"""
         return 0
 
 
+    def reset(self):
+        """Reset the block and return to the lower relay state.
+
+        The base reset zeroes the outputs, which is not a relay state -- the
+        output must land back on `value_down`, same as after construction.
+        """
+        super().reset()
+        self.outputs[0] = self.value_down
+
+
     def update(self, t):
         """update system equation for fixed point loop, 
         here just setting the outputs

{pathsim-0.24.0 → pathsim-0.25.1}/src/pathsim/blocks/scope.py

@@ -53,12 +53,9 @@ class Scope(Block):
     _incremental_idx : int
         index for incremental reading of accumulated data since last
         call of incremental read
-    _sample_next_timestep : bool
-        flag to indicate this is a timestep to sample, only used for
-        event based sampling when `sampling_period` is provided as an arg
     events : list[Schedule]
         internal scheduled event for periodic input sampling when
-        `sampling_period` is provided
+        `sampling_period` is provided, recording directly in its action
     """
     
     input_port_labels = None
@@ -86,18 +83,15 @@ class Scope(Block):
         #sampling produces discrete time behavior
         if not (sampling_period is None):
 
-            #flag to indicate this is a timestep to sample
-            self._sample_next_timestep = False
-            
-            #internal scheduled list event
-            def _sample(t):
-                self._sample_next_timestep = True
-
+            #internal scheduled event, recording directly in its action so the
+            #timestamps are the scheduled times and no tick can be lost
+            #(a flag deferred to the end of the timestep collapses two ticks
+            #that land in one step into a single sample)
             self.events = [
                 Schedule(
                     t_start=t_wait,
                     t_period=sampling_period,
-                    func_act=_sample
+                    func_act=self._record
                     )
             ]
 
@@ -171,30 +165,15 @@ class Scope(Block):
                 )
 
 
-    def sample(self, t, dt):
-        """Sample the data from all inputs. Skips duplicate timestamps to maintain
-        unique time points in the recording.
-
-        If `sampling_period` is provided, this depends on the flag `_sample_next_timestep`,
-        set by the internal `Schedule` event.
+    def _record(self, t):
+        """Append one sample of all inputs at time 't'. Skips duplicate
+        timestamps to maintain unique time points in the recording.
 
         Parameters
         ----------
         t : float
-            evaluation time for sampling
+            timestamp for the sample
         """
-        #determine if we should sample
-        if self.sampling_period is None:
-            should_sample = t >= self.t_wait
-        elif self._sample_next_timestep:
-            should_sample = True
-            self._sample_next_timestep = False
-        else:
-            should_sample = False
-
-        if not should_sample:
-            return
-
         #skip duplicate timestamps (can happen when continuing simulation)
         if self.recording_time and self.recording_time[-1] == t:
             return
@@ -203,6 +182,26 @@ class Scope(Block):
         self.recording_data.append(self.inputs.to_array())
 
 
+    def sample(self, t, dt):
+        """Sample the data from all inputs at every timestep.
+
+        Only active without a `sampling_period`. With one, the internal
+        `Schedule` event records in its action instead, stamped with the
+        scheduled time rather than the end of the enclosing timestep.
+
+        Parameters
+        ----------
+        t : float
+            evaluation time for sampling
+        """
+        #event based sampling records in the Schedule action
+        if self.sampling_period is not None:
+            return
+
+        if t >= self.t_wait:
+            self._record(t)
+
+
     def plot(self, *args, **kwargs):
         """Directly create a plot of the recorded data for quick visualization and debugging.
 
@@ -453,8 +452,6 @@ class Scope(Block):
         json_data, npz_data = super().to_checkpoint(prefix, recordings=recordings)
 
         json_data["_incremental_idx"] = self._incremental_idx
-        if hasattr(self, '_sample_next_timestep'):
-            json_data["_sample_next_timestep"] = self._sample_next_timestep
 
         if recordings and self.recording_time:
             npz_data[f"{prefix}/recording_time"] = np.array(self.recording_time)
@@ -468,8 +465,6 @@ class Scope(Block):
         super().load_checkpoint(prefix, json_data, npz)
 
         self._incremental_idx = json_data.get("_incremental_idx", 0)
-        if hasattr(self, '_sample_next_timestep'):
-            self._sample_next_timestep = json_data.get("_sample_next_timestep", False)
 
         #restore recordings if present
         rt_key = f"{prefix}/recording_time"

{pathsim-0.24.0 → pathsim-0.25.1}/src/pathsim/events/schedule.py

@@ -82,6 +82,56 @@ class Schedule(Event):
         return self.t_start + len(self._times) * self.t_period
 
 
+    def _spacing(self):
+        """
+        return the time between the upcoming event and its successor,
+        used to bound the effective detection tolerance
+        """
+        return self.t_period
+
+
+    def _tolerance_at(self, t):
+        """Effective detection tolerance at evaluation time 't'.
+
+        The simulation time is accumulated by repeated addition of the
+        timestep, so it drifts away from the exact schedule times by a
+        floating point error that grows with 't'. The configured absolute
+        tolerance cannot cover this, which makes ticks that land within a
+        few ulp of a step boundary flip between neighboring timesteps and
+        lose the final tick of a run. The widened tolerance absorbs that
+        drift while staying far below the schedule spacing, so no genuine
+        tick can be swallowed.
+
+        Parameters
+        ----------
+        t : float
+            evaluation time for detection
+
+        Returns
+        -------
+        float
+            effective tolerance for the close-to-event check
+        """
+        return max(self.tolerance, min(1e-10 * abs(t), 0.1 * self._spacing()))
+
+
+    def resolve(self, t):
+        """Resolve the event at the exact scheduled time.
+
+        The caller passes the numerically reached time, which carries the
+        accumulated drift of the simulation clock. The schedule knows its
+        own exact event time, so that is what gets recorded and handed to
+        the action function - timestamps land exactly on the schedule.
+
+        Parameters
+        ----------
+        t : float
+            evaluation time for event resolution (ignored in favor of
+            the exact scheduled time)
+        """
+        super().resolve(self._next())
+
+
     def estimate(self, t):
         """Estimate the time until the next scheduled event.
 
@@ -135,21 +185,26 @@ class Schedule(Event):
         if self.t_end is not None and t_next > self.t_end:
             self.off()
             return False, False, 1.0
-        
-        #no event -> quit early
-        if t_next > t:
+
+        #effective tolerance, covering the drift of the simulation clock
+        _tol = self._tolerance_at(t)
+
+        #no event -> quit early (a tick within tolerance of the step end
+        #counts as inside the step, otherwise clock drift pushes it into
+        #the next step and the final tick of a run is lost)
+        if t_next > t + _tol:
             return False, False, 1.0
 
         #are we close enough to the scheduled event?
-        if abs(t_next - t) <= self.tolerance:
-            return True, True, 0.0 
+        if abs(t_next - t) <= _tol:
+            return True, True, 1.0
 
         #unpack history
         _, _t = self._history
 
         #have we already passed the event -> first timestep
         if _t >= t_next:
-            return True, True, 0.0        
+            return True, True, 0.0
 
         #whats the timestep ratio?
         ratio = (t_next - _t) / np.clip(t - _t, TOLERANCE, None)
@@ -214,11 +269,21 @@ class ScheduleList(Schedule):
     def _next(self):
         """return the next event from the event time list by index"""
         _n = len(self._times)
-        if _n < len(self.times_evt): 
+        if _n < len(self.times_evt):
             return self.times_evt[_n]
         return self.times_evt[-1]
 
 
+    def _spacing(self):
+        """return the gap between the upcoming event and its successor
+        in the time list, used to bound the effective detection tolerance
+        """
+        _n = len(self._times)
+        if _n + 1 < len(self.times_evt):
+            return self.times_evt[_n + 1] - self.times_evt[_n]
+        return float("inf")
+
+
     def detect(self, t):
         """Check if the event condition is satisfied, i.e. if the 
         time period switch is within the current timestep.
@@ -247,20 +312,23 @@ class ScheduleList(Schedule):
         #get next event time
         t_next = self._next()
 
-        #no event -> quit early
-        if t_next > t:
+        #effective tolerance, covering the drift of the simulation clock
+        _tol = self._tolerance_at(t)
+
+        #no event -> quit early (see 'Schedule.detect')
+        if t_next > t + _tol:
             return False, False, 1.0
 
         #are we close enough to the scheduled event?
-        if abs(t_next - t) <= self.tolerance:
-            return True, True, 0.0 
+        if abs(t_next - t) <= _tol:
+            return True, True, 1.0
 
         #unpack history
         _, _t = self._history
 
         #have we already passed the event -> first timestep
         if _t >= t_next:
-            return True, True, 0.0        
+            return True, True, 0.0
 
         #whats the timestep ratio?
         ratio = (t_next - _t) / np.clip(t - _t, TOLERANCE, None)

{pathsim-0.24.0 → pathsim-0.25.1}/src/pathsim/utils/graph.py

@@ -606,8 +606,10 @@ class Graph:
     def _has_algebraic_self_loop(self, block):
         """Check if a block has an algebraic path back to itself.
 
-        For self-loops, verifies that the path actually leaves the block and
-        returns through other algebraic blocks (not just a direct self-connection).
+        The path leaves the block and returns through algebraic blocks. The
+        block itself only bounds the path, so it doesn't have to be algebraic.
+        This is the case for the 'Interface' of a 'Subsystem', where a path
+        back to itself is an algebraic passthrough of the subsystem.
 
         Parameters
         ----------
@@ -619,18 +621,14 @@ class Graph:
         bool
             True if an algebraic self-loop exists, False otherwise
         """
-        # Check if block is algebraic
-        if block in self._dyn_blocks:
-            return False
-        
         # Get immediate neighbors
         neighbors = self._dnst_blk_blk_map[block]
-        
+
         if not neighbors:
             return False
-        
+
         # BFS from neighbors to see if any path back
-        visited = {block}  # Don't revisit start immediately
+        visited = set()
         stack = list(neighbors)
         
         while stack:

{pathsim-0.24.0 → pathsim-0.25.1}/src/pathsim.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathsim
-Version: 0.24.0
+Version: 0.25.1
 Summary: A differentiable block based hybrid system simulation framework.
 Author-email: Milan Rother <milan.rother@gmx.de>
 License: MIT
@@ -119,6 +119,7 @@ scp.plot()
 - [Documentation](https://docs.pathsim.org) — tutorials, examples, and API reference
 - [Homepage](https://pathsim.org) — overview and getting started
 - [Contributing](https://docs.pathsim.org/pathsim/latest/contributing) — how to contribute
+- [Consulting & commercial support](https://milanrother.com/consulting/) — integration, custom blocks, migration from closed tools
 
 ## Citation