pySimBlocks 0.1.1__tar.gz → 0.2.0__tar.gz

{pysimblocks-0.1.1/pySimBlocks.egg-info → pysimblocks-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pySimBlocks
-Version: 0.1.1
+Version: 0.2.0
 Summary: A block-diagram simulation environment with PySide6 editor
 Author-email: Antoine Alessandrini <antoine.alessandrini@univ-lille.fr>
 License-Expression: LGPL-3.0-or-later
@@ -28,6 +28,7 @@ Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: myst-parser; extra == "docs"
 Requires-Dist: furo; extra == "docs"
+Requires-Dist: sphinxcontrib-video; extra == "docs"
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-qt; extra == "tests"
@@ -153,7 +154,7 @@ A collection of basic and advanced examples is available in the
 [examples](./examples) directory, including:
 
 - Control system demonstrations
-- SOFA-based simulations (tested with SOFA v24.06 and later.)
+- SOFA-based simulations (tested with SOFA v26.06 and later.)
 - Hardware and real-time use cases
 - Comparisons with external tools
 

{pysimblocks-0.1.1 → pysimblocks-0.2.0}/README.md

@@ -118,7 +118,7 @@ A collection of basic and advanced examples is available in the
 [examples](./examples) directory, including:
 
 - Control system demonstrations
-- SOFA-based simulations (tested with SOFA v24.06 and later.)
+- SOFA-based simulations (tested with SOFA v26.06 and later.)
 - Hardware and real-time use cases
 - Comparisons with external tools
 

{pysimblocks-0.1.1 → pysimblocks-0.2.0}/pySimBlocks/blocks/interfaces/__init__.py

@@ -20,8 +20,12 @@
 
 from pySimBlocks.blocks.interfaces.external_input import ExternalInput
 from pySimBlocks.blocks.interfaces.external_output import ExternalOutput
+from pySimBlocks.blocks.interfaces.goto import Goto
+from pySimBlocks.blocks.interfaces.bus_from import BusFrom
 
 __all__ = [
     "ExternalInput",
-    "ExternalOutput"
+    "ExternalOutput",
+    "Goto",
+    "BusFrom",
 ]

pysimblocks-0.2.0/pySimBlocks/blocks/interfaces/bus_from.py

@@ -0,0 +1,88 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+from pySimBlocks.core.block import Block
+from pySimBlocks.core import signal_bus
+
+
+class BusFrom(Block):
+    """Read a signal from the global signal bus by tag.
+
+    BusFrom and Goto blocks implement a virtual wiring mechanism: a Goto writes
+    its input to ``signal_bus._signal_bus[tag]`` each tick, and this block
+    reads that value without requiring an explicit connection in the model
+    graph.
+
+    The model's topological sort injects a virtual edge from each Goto to every
+    BusFrom sharing the same tag, ensuring the Goto executes before this block
+    within the same tick.
+    """
+
+    direct_feedthrough = True
+
+    def __init__(self, name: str, tag: str, sample_time: float | None = None):
+        """Initialize a BusFrom block.
+
+        Args:
+            name: Unique identifier for this block instance.
+            tag: Signal bus tag to read from. Must match the tag of the
+                corresponding Goto block.
+            sample_time: Sampling period in seconds, or None to use the
+                global simulation dt.
+        """
+        super().__init__(name, sample_time)
+        self.tag = tag
+        self.outputs["out"] = None
+
+    # --------------------------------------------------------------------------
+    # Public methods
+    # --------------------------------------------------------------------------
+
+    def initialize(self, t0: float) -> None:
+        """Read the initial value from the signal bus if available.
+
+        If the tag is not yet in the bus (Goto not yet initialized), the
+        output is set to None.
+
+        Args:
+            t0: Initial simulation time in seconds.
+        """
+        self.outputs["out"] = signal_bus._signal_bus.get(self.tag)
+
+    def output_update(self, t: float, dt: float) -> None:
+        """Read the current value from the signal bus.
+
+        Args:
+            t: Current simulation time in seconds.
+            dt: Current time step in seconds.
+
+        Raises:
+            KeyError: If no Goto with the matching tag has written to the bus
+                in this run.
+        """
+        if self.tag not in signal_bus._signal_bus:
+            raise KeyError(
+                f"[{self.name}] Tag '{self.tag}' not found in signal bus. "
+                "Ensure a Goto block with the same tag exists in the model."
+            )
+        self.outputs["out"] = signal_bus._signal_bus[self.tag]
+
+    def state_update(self, t: float, dt: float) -> None:
+        """No-op: BusFrom carries no internal state."""

pysimblocks-0.2.0/pySimBlocks/blocks/interfaces/goto.py

@@ -0,0 +1,78 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+from pySimBlocks.core.block import Block
+from pySimBlocks.core import signal_bus
+
+
+class Goto(Block):
+    """Publish a signal to the global signal bus under a named tag.
+
+    Goto and From blocks implement a virtual wiring mechanism: a Goto writes
+    its input to ``signal_bus._signal_bus[tag]`` each tick, and any From block
+    with the same tag reads that value without requiring an explicit connection
+    in the model graph.
+
+    The model's topological sort injects a virtual edge from each Goto to every
+    From sharing the same tag, ensuring the Goto executes before its consumers
+    within the same tick.
+    """
+
+    direct_feedthrough = True
+
+    def __init__(self, name: str, tag: str, sample_time: float | None = None):
+        """Initialize a Goto block.
+
+        Args:
+            name: Unique identifier for this block instance.
+            tag: Signal bus tag under which the input value is published.
+                Must match the tag of the corresponding From block(s).
+            sample_time: Sampling period in seconds, or None to use the
+                global simulation dt.
+        """
+        super().__init__(name, sample_time)
+        self.tag = tag
+        self.inputs["in"] = None
+
+    # --------------------------------------------------------------------------
+    # Public methods
+    # --------------------------------------------------------------------------
+
+    def initialize(self, t0: float) -> None:
+        """Publish the current input to the signal bus.
+
+        If no input has been connected yet (None), the bus entry is set to None.
+
+        Args:
+            t0: Initial simulation time in seconds.
+        """
+        signal_bus._signal_bus[self.tag] = self.inputs["in"]
+
+    def output_update(self, t: float, dt: float) -> None:
+        """Write the input value to the signal bus under this block's tag.
+
+        Args:
+            t: Current simulation time in seconds.
+            dt: Current time step in seconds.
+        """
+        signal_bus._signal_bus[self.tag] = self.inputs["in"]
+
+    def state_update(self, t: float, dt: float) -> None:
+        """No-op: Goto carries no internal state."""

{pysimblocks-0.1.1 → pysimblocks-0.2.0}/pySimBlocks/blocks/sources/file_source.py

@@ -38,9 +38,12 @@ class FileSource(BlockSource):
 
     - ``.npz`` / ``.npy``: 1D ``(N,)`` treated as ``(N, 1)``, or 2D ``(N, n)``
       where N is the number of samples and n the signal dimension. Each step
-      outputs a ``(n, 1)`` column vector.
+      outputs a ``(n, 1)`` column vector. If the stored array is instead
+      ``(n, N)`` (signals in rows, samples in columns), set ``transpose=True``
+      to have it transposed to ``(N, n)`` before use.
     - ``.csv``: a single column is selected by ``key``, always producing shape
-      ``(N, 1)``. Output per step is ``(1, 1)``.
+      ``(N, 1)``. Output per step is ``(1, 1)``. ``transpose`` is not
+      applicable to CSV input.
 
     Alternatively, when ``use_time=True``, the output is selected by
     looking up the closest past timestamp in a time column bundled with
@@ -52,6 +55,8 @@ class FileSource(BlockSource):
         key: Array key (NPZ) or column name (CSV) to load. None for NPY files.
         repeat: If True, restart from the first sample after the last one.
         use_time: If True, select samples by time lookup instead of index.
+        transpose: If True (NPZ/NPY only), transpose the loaded 2D array
+            before use, i.e. treat it as ``(n, N)`` instead of ``(N, n)``.
     """
 
     VALID_FILE_TYPES = {"npz", "npy", "csv"}
@@ -63,6 +68,7 @@ class FileSource(BlockSource):
         key: str | None = None,
         repeat: bool = False,
         use_time: bool = False,
+        transpose: bool = False,
         sample_time: float | None = None,
     ):
         """Initialize a FileSource block.
@@ -77,13 +83,18 @@ class FileSource(BlockSource):
             use_time: If True, select samples by nearest past timestamp
                 instead of advancing by step index. Requires a ``"time"``
                 key or column in the file.
+            transpose: If True, transpose the loaded 2D array before use.
+                Only supported for NPZ and NPY inputs, where it allows
+                loading data stored as ``(n, N)`` (signals in rows) instead
+                of the expected ``(N, n)`` (samples in rows).
             sample_time: Sampling period in seconds, or None to use the
                 global simulation dt.
 
         Raises:
             ValueError: If the file extension is unsupported, if ``use_time``
-                is combined with an NPY file or with ``repeat=True``, or if
-                the loaded data is invalid.
+                is combined with an NPY file or with ``repeat=True``, if
+                ``transpose`` is combined with a CSV file, or if the loaded
+                data is invalid.
             FileNotFoundError: If the file does not exist.
         """
         super().__init__(name, sample_time)
@@ -93,6 +104,7 @@ class FileSource(BlockSource):
         self.key = key
         self.repeat = self._to_bool(repeat, "repeat")
         self.use_time = self._to_bool(use_time, "use_time")
+        self.transpose = self._to_bool(transpose, "transpose")
 
         if self.use_time and self.file_type == "npy":
             raise ValueError(
@@ -102,6 +114,10 @@ class FileSource(BlockSource):
             raise ValueError(
                 f"[{self.name}] repeat cannot be used when use_time=True."
             )
+        if self.transpose and self.file_type == "csv":
+            raise ValueError(
+                f"[{self.name}] transpose is supported only for NPZ and NPY inputs."
+            )
 
         self._time: np.ndarray | None = None
         self._samples = self._load_samples()
@@ -198,7 +214,10 @@ class FileSource(BlockSource):
 
         if arr.ndim == 1:
             arr = arr.reshape(-1, 1)
-        elif arr.ndim != 2:
+        elif arr.ndim == 2:
+            if self.transpose:
+                arr = arr.T
+        else:
             raise ValueError(
                 f"[{self.name}] Loaded data must be 1D or 2D. Got shape {arr.shape}."
             )
@@ -206,6 +225,12 @@ class FileSource(BlockSource):
         if arr.shape[0] == 0:
             raise ValueError(f"[{self.name}] Loaded file contains no samples.")
 
+        if time is not None and time.shape[0] != arr.shape[0]:
+            raise ValueError(
+                f"[{self.name}] time length ({time.shape[0]}) must match number "
+                f"of samples ({arr.shape[0]}) after applying transpose."
+            )
+
         self._time = time
 
         return arr.astype(float, copy=False)

{pysimblocks-0.1.1 → pysimblocks-0.2.0}/pySimBlocks/blocks/systems/__init__.py

@@ -20,8 +20,10 @@
 
 from pySimBlocks.blocks.systems.linear_state_space import LinearStateSpace
 from pySimBlocks.blocks.systems.polytopic_state_space import PolytopicStateSpace
+from pySimBlocks.blocks.systems.transfer_function import TransferFunction
 
 __all__ = [
     "LinearStateSpace",
     "PolytopicStateSpace",
+    "TransferFunction"
 ]

{pysimblocks-0.1.1 → pysimblocks-0.2.0}/pySimBlocks/blocks/systems/linear_state_space.py

@@ -29,20 +29,25 @@ from pySimBlocks.core.block import Block
 class LinearStateSpace(Block):
     """Discrete-time linear state-space system block.
 
-    Implements a strictly proper discrete-time linear system:
+    Implements a discrete-time linear system:
 
         x[k+1] = A x[k] + B u[k]
-         
-        y[k]   = C x[k]
 
-    The D matrix is intentionally not supported to avoid algebraic loops.
+        y[k]   = C x[k]          (if D is None)
+        y[k]   = C x[k] + D u[k] (if D is provided)
+
+    When D is None the block is strictly proper (no direct feedthrough).
+    When D is provided the block has direct feedthrough and algebraic loops
+    involving this block will be detected and rejected at compile time.
 
     Attributes:
         A: State transition matrix of shape (n, n).
         B: Input matrix of shape (n, m).
         C: Output matrix of shape (p, n).
+        D: Feedthrough matrix of shape (p, m), or None.
     """
 
+    # Default at class level; overridden per-instance when D is provided.
     direct_feedthrough = False
 
     def __init__(
@@ -51,6 +56,7 @@ class LinearStateSpace(Block):
         A: ArrayLike,
         B: ArrayLike,
         C: ArrayLike,
+        D: ArrayLike | None = None,
         x0: ArrayLike | None = None,
         sample_time: float | None = None,
     ):
@@ -61,6 +67,9 @@ class LinearStateSpace(Block):
             A: State transition matrix, array-like of shape (n, n).
             B: Input matrix, array-like of shape (n, m).
             C: Output matrix, array-like of shape (p, n).
+            D: Feedthrough matrix, array-like of shape (p, m), or None.
+                When provided, the block gains direct feedthrough and
+                y[k] = C x[k] + D u[k].
             x0: Initial state vector, array-like of shape (n, 1) or (n,).
                 Defaults to zeros.
             sample_time: Sampling period in seconds, or None to use the
@@ -101,6 +110,23 @@ class LinearStateSpace(Block):
         self._m = self.B.shape[1]
         self._p = self.C.shape[0]
 
+        # --- D matrix (optional) ---
+        if D is not None:
+            self.D = np.asarray(D, dtype=float)
+            if self.D.ndim != 2:
+                raise ValueError(f"[{self.name}] D must be 2D. Got shape {self.D.shape}.")
+            if self.D.shape != (self._p, self._m):
+                raise ValueError(
+                    f"[{self.name}] D must have shape ({self._p}, {self._m}). "
+                    f"Got {self.D.shape}."
+                )
+            # Override direct_feedthrough at the instance level so the
+            # scheduler sees this block as having direct feedthrough.
+            self.direct_feedthrough = True
+        else:
+            self.D = None
+
+        # --- Initial state ---
         if x0 is None:
             x0_arr = np.zeros((n, 1), dtype=float)
         else:
@@ -143,12 +169,21 @@ class LinearStateSpace(Block):
     def output_update(self, t: float, dt: float) -> None:
         """Compute y and x outputs from the committed state.
 
+        When D is provided, u[k] is read at this step (direct feedthrough).
+
         Args:
             t: Current simulation time in seconds.
             dt: Current time step in seconds.
         """
         x = self.state["x"]
-        self.outputs["y"] = self.C @ x
+        if self.D is not None:
+            u = self.inputs["u"]
+            if u is None:
+                raise RuntimeError(f"[{self.name}] Input 'u' is not connected or not set.")
+            u_vec = self._to_col_vec("u", u, self._m)
+            self.outputs["y"] = self.C @ x + self.D @ u_vec
+        else:
+            self.outputs["y"] = self.C @ x
         self.outputs["x"] = x.copy()
 
     def state_update(self, t: float, dt: float) -> None:

{pysimblocks-0.1.1 → pysimblocks-0.2.0}/pySimBlocks/blocks/systems/non_linear_state_space.py

@@ -22,6 +22,7 @@ import importlib.util
 import inspect
 from pathlib import Path
 from typing import Any, Callable, Dict, List
+from numpy.typing import ArrayLike
 
 import numpy as np
 
@@ -87,10 +88,7 @@ class NonLinearStateSpace(Block):
         self.input_keys = list(input_keys)
         self.output_keys = list(output_keys)
 
-        if not isinstance(x0, np.ndarray):
-            raise TypeError(
-                f"{self.name}: x0 must be a numpy array"
-            )
+        x0 = np.asarray(x0, dtype=float)   # <-- conversion, comme dans les autres blocs
         if x0.ndim == 1:
             x0 = x0.reshape(-1, 1)
         elif x0.ndim != 2 or x0.shape[1] != 1: