pySimBlocks 0.1.0__py3-none-any.whl

pySimBlocks/gui/blocks/sources/function_source.py

@@ -0,0 +1,202 @@
+# ******************************************************************************
+#                                  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
+# ******************************************************************************
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import Literal
+
+from PySide6.QtWidgets import QFormLayout, QLabel, QLineEdit, QPushButton
+
+from pySimBlocks.gui.blocks.block_meta import BlockMeta, ParameterMeta
+from pySimBlocks.gui.blocks.port_meta import PortMeta
+from pySimBlocks.gui.models import BlockInstance, PortInstance
+
+
+class FunctionSourceMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "FunctionSource"
+        self.category = "sources"
+        self.type = "function_source"
+        self.summary = "User-defined source block y = f(t, dt)."
+        self.description = (
+            "This block evaluates a user-provided Python function with no inputs:\n\n"
+            "    y = f(t, dt)\n\n"
+            "The function is loaded from an external Python file and executed at each\n"
+            "activation. The function must return a dict whose keys match\n"
+            "`output_keys`. One output port is created for each key."
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="file_path",
+                type="string",
+                required=True,
+                description=(
+                    "Path to the Python file containing the function, relative to "
+                    "the project.yaml file."
+                ),
+            ),
+            ParameterMeta(
+                name="function_name",
+                type="string",
+                required=True,
+                description="Name of the function to call inside the Python file.",
+            ),
+            ParameterMeta(
+                name="output_keys",
+                type="list[string]",
+                required=True,
+                autofill=True,
+                default=["out"],
+                description="List of output port names. The function must return a dict with exactly these keys.",
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float",
+                description="Optional execution period of the block.",
+            ),
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="",
+                shape=[],
+                description="Function output signals defined by output_keys.",
+            )
+        ]
+
+    # --------------------------------------------------------------------------
+    # Port resolution
+    # --------------------------------------------------------------------------
+    def resolve_port_group(
+        self,
+        port_meta: PortMeta,
+        direction: Literal["input", "output"],
+        instance: "BlockInstance",
+    ) -> list["PortInstance"]:
+        if direction == "output":
+            keys = instance.parameters.get("output_keys", [])
+            if keys is None:
+                return []
+            return [
+                PortInstance(
+                    name=f"{key}",
+                    display_as=key,
+                    direction="output",
+                    block=instance,
+                )
+                for key in keys
+            ]
+
+        return super().resolve_port_group(port_meta, direction, instance)
+
+    # --------------------------------------------------------------------------
+    # Dialog methods
+    # --------------------------------------------------------------------------
+    def build_param(
+        self,
+        session,
+        form: QFormLayout,
+        readonly: bool = False,
+    ):
+        name_edit = QLineEdit(session.instance.name)
+        name_edit.textChanged.connect(
+            lambda val: self._on_param_changed(val, "name", session, readonly)
+        )
+        form.addRow(QLabel("Block name:"), name_edit)
+        if readonly:
+            name_edit.setReadOnly(True)
+        session.name_edit = name_edit
+
+        for pmeta in self.parameters:
+            if pmeta.name == "file_path":
+                self.build_file_param_row(
+                    session,
+                    form,
+                    pmeta,
+                    readonly=readonly,
+                    file_filter="Python files (*.py);;All files (*)",
+                )
+                continue
+
+            label, widget = self._create_param_row(session, pmeta, readonly)
+            if widget is None:
+                continue
+            if readonly:
+                self._set_readonly_style(widget)
+
+            form.addRow(label, widget)
+            session.param_widgets[pmeta.name] = widget
+            session.param_labels[pmeta.name] = label
+
+    # ------------------------------------------------------
+    def build_post_param(self, session, form: QFormLayout, readonly: bool = False):
+        open_btn = QPushButton("Open file")
+        open_btn.clicked.connect(lambda: self._open_file_from_session(session))
+        form.addRow(QLabel(""), open_btn)
+        session.open_file_btn = open_btn
+        self._refresh_open_button_state(session)
+
+    # ------------------------------------------------------
+    def refresh_form(self, session):
+        super().refresh_form(session)
+        self._refresh_open_button_state(session)
+
+    # ------------------------------------------------------
+    def _resolve_file_path(self, session) -> Path | None:
+        raw = session.local_params.get("file_path")
+        if not raw:
+            return None
+
+        path = Path(str(raw)).expanduser()
+        if not path.is_absolute() and session.project_dir is not None:
+            path = (session.project_dir / path).resolve()
+        return path
+
+    # ------------------------------------------------------
+    def _refresh_open_button_state(self, session) -> None:
+        btn = getattr(session, "open_file_btn", None)
+        if btn is None:
+            return
+
+        target = self._resolve_file_path(session)
+        exists = target is not None and target.is_file()
+        btn.setEnabled(exists)
+        if exists:
+            btn.setToolTip(str(target))
+        else:
+            btn.setToolTip("Set a valid existing file_path to open the file.")
+
+    # ------------------------------------------------------
+    def _open_file_from_session(self, session) -> None:
+        target = self._resolve_file_path(session)
+        if target is None or not target.is_file():
+            return
+
+        if sys.platform.startswith("darwin"):
+            subprocess.Popen(["open", str(target)])
+        elif os.name == "nt":
+            os.startfile(str(target))
+        else:
+            subprocess.Popen(["xdg-open", str(target)])

pySimBlocks/gui/blocks/sources/ramp.py

@@ -0,0 +1,73 @@
+# ******************************************************************************
+#                                  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.gui.blocks.block_meta import BlockMeta
+from pySimBlocks.gui.blocks.parameter_meta import ParameterMeta
+from pySimBlocks.gui.blocks.port_meta import PortMeta
+
+
+class RampMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "Ramp"
+        self.category = "sources"
+        self.type = "ramp"
+        self.summary = "Multi-dimensional ramp signal source."
+        self.description = (
+            "Generates a ramp signal defined by:\n"
+            "$$\n"
+            "y_i(t) = o_i + s_i \\max(0, t - t_{0,i})\n"
+            "$$\n"
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="slope",
+                type="scalar | vector | matrix",
+                required=True,
+                autofill=True,
+                default=[[1.0]],
+                description="Ramp slope for each output dimension."
+            ),
+            ParameterMeta(
+                name="start_time",
+                type="scalar | vector | matrix",
+                description="Time at which the ramp starts."
+            ),
+            ParameterMeta(
+                name="offset",
+                type="scalar | vector | matrix",
+                description="Output value before the ramp starts."
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float",
+                description="Block execution period."
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["n", "m"],
+                description="Ramp output signal."
+            )
+        ]

pySimBlocks/gui/blocks/sources/sinusoidal.py

@@ -0,0 +1,81 @@
+# ******************************************************************************
+#                                  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.gui.blocks.block_meta import BlockMeta
+from pySimBlocks.gui.blocks.parameter_meta import ParameterMeta
+from pySimBlocks.gui.blocks.port_meta import PortMeta
+
+
+class SinusoidalMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "Sinusoidal"
+        self.category = "sources"
+        self.type = "sinusoidal"
+        self.summary = "Multi-dimensional sinusoidal signal source."
+        self.description = (
+            "Generates a sinusoidal signal defined by:\n"
+            "$$\n"
+            "y_i(t) = A_i \\sin(2\\pi f_i t + \\varphi_i) + o_i\n"
+            "$$\n"
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="amplitude",
+                type="scalar | vector | matrix",
+                required=True,
+                autofill=True,
+                default=[[1.0]],
+                description="Sinusoidal amplitude."
+            ),
+            ParameterMeta(
+                name="frequency",
+                type="scalar | vector | matrix",
+                required=True,
+                autofill=True,
+                default=[[1.0]],
+                description="Sinusoidal frequency in Hertz."
+            ),
+            ParameterMeta(
+                name="phase",
+                type="scalar | vector | matrix",
+                description="Phase shift in radians."
+            ),
+            ParameterMeta(
+                name="offset",
+                type="scalar | vector | matrix",
+                description="Constant offset added to the signal."
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float",
+                description="Block execution period."
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["n", "m"],
+                description="Sinusoidal output signal."
+            )
+        ]

pySimBlocks/gui/blocks/sources/step.py

@@ -0,0 +1,83 @@
+# ******************************************************************************
+#                                  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.gui.blocks.block_meta import BlockMeta
+from pySimBlocks.gui.blocks.parameter_meta import ParameterMeta
+from pySimBlocks.gui.blocks.port_meta import PortMeta
+
+
+class StepMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "Step"
+        self.category = "sources"
+        self.type = "step"
+        self.summary = "Step signal source."
+        self.description = (
+            "Generates a step signal defined by:\n"
+            "$$\n"
+            "y(t) =\n"
+            "\\begin{cases}\n"
+            "y_{\\text{before}}, & t < t_0 \\\\\n"
+            "y_{\\text{after}},  & t \\geq t_0\n"
+            "\\end{cases}\n"
+            "$$\n"
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="value_before",
+                type="scalar | vector | matrix",
+                required=True,
+                autofill=True,
+                default=[[0.0]],
+                description="Output value before the step time."
+            ),
+            ParameterMeta(
+                name="value_after",
+                type="scalar | vector | matrix",
+                required=True,
+                autofill=True,
+                default=[[1.0]],
+                description="Output value after the step time."
+            ),
+            ParameterMeta(
+                name="start_time",
+                type="float",
+                required=True,
+                autofill=True,
+                default=1.0,
+                description="Time at which the step occurs."
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float",
+                description="Block execution period."
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["n", "m"],
+                description="Step output signal."
+            )
+        ]

pySimBlocks/gui/blocks/sources/white_noise.py

@@ -0,0 +1,70 @@
+# ******************************************************************************
+#                                  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.gui.blocks.block_meta import BlockMeta
+from pySimBlocks.gui.blocks.parameter_meta import ParameterMeta
+from pySimBlocks.gui.blocks.port_meta import PortMeta
+
+
+class WhiteNoiseMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "WhiteNoise"
+        self.category = "sources"
+        self.type = "white_noise"
+        self.summary = "Multi-dimensional Gaussian white noise source."
+        self.description = (
+            "Generates independent Gaussian noise samples at each simulation step:\n"
+            "$$\n"
+            "y_i(t) \\sim \\mathcal{N}(\\mu_i, \\sigma_i^2)\n"
+            "$$\n"
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="mean",
+                type="scalar | vector | matrix",
+                description="Mean value of the noise."
+            ),
+            ParameterMeta(
+                name="std",
+                type="scalar | vector | matrix",
+                description="Standard deviation of the noise."
+            ),
+            ParameterMeta(
+                name="seed",
+                type="int",
+                description="Random seed for reproducibility."
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float",
+                description="Block execution period."
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["n", "m"],
+                description="Gaussian noise output signal."
+            )
+        ]

pySimBlocks/gui/blocks/systems/linear_state_space.py

@@ -0,0 +1,102 @@
+# ******************************************************************************
+#                                  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.gui.blocks.block_meta import BlockMeta
+from pySimBlocks.gui.blocks.parameter_meta import ParameterMeta
+from pySimBlocks.gui.blocks.port_meta import PortMeta
+
+
+class LinearStateSpaceMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "LinearStateSpace"
+        self.category = "systems"
+        self.type = "linear_state_space"
+        self.summary = "Discrete-time linear state-space system."
+        self.description = (
+            "Implements the discrete-time state-space equations:\n"
+            "$$\n"
+            "x[k+1] = A x[k] + B u[k]\n"
+            "$$\n"
+            "$$\n"
+            "y[k] = C x[k]\n"
+            "$$\n"
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="A",
+                type="matrix",
+                required=True,
+                autofill=True,
+                default=[[0.99]],
+                description="State transition matrix."
+            ),
+            ParameterMeta(
+                name="B",
+                type="matrix",
+                required=True,
+                autofill=True,
+                default=[[1.0]],
+                description="Input matrix."
+            ),
+            ParameterMeta(
+                name="C",
+                type="matrix",
+                required=True,
+                autofill=True,
+                default=[[1.0]],
+                description="Output matrix."
+            ),
+            ParameterMeta(
+                name="x0",
+                type="vector",
+                description="Initial state vector."
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float",
+                description="Block execution period."
+            )
+        ]
+
+        self.inputs = [
+            PortMeta(
+                name="u",
+                display_as="u",
+                shape=["m", 1],
+                description="Input vector."
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="x",
+                display_as="x",
+                shape=["n", 1],
+                description="State vector."
+            ),
+            PortMeta(
+                name="y",
+                display_as="y",
+                shape=["p", 1],
+                description="Output vector."
+            )
+        ]