pySimBlocks 0.1.0__py3-none-any.whl

pySimBlocks/gui/blocks/operators/zero_order_hold.py

@@ -0,0 +1,64 @@
+# ******************************************************************************
+#                                  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 ZeroOrderHoldMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "ZeroOrderHold"
+        self.category = "operators"
+        self.type = "zero_order_hold"
+        self.summary = "Zero-Order Hold (ZOH) block."
+        self.description = (
+            "Samples the input signal at discrete instants and holds its value\n"
+            "constant between sampling instants. The held output is updated when\n"
+            "the elapsed time since the last sampling instant reaches the sampling\n"
+            "period."
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="sample_time",
+                type="float",
+                required=True
+            )
+        ]
+
+        self.inputs = [
+            PortMeta(
+                name="in",
+                display_as="in",
+                shape=["n", "m"],
+                description="Input signal."
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["n", "m"],
+                description="Held output signal."
+            )
+        ]

pySimBlocks/gui/blocks/optimizers/quadratic_program.py

@@ -0,0 +1,128 @@
+# ******************************************************************************
+#                                  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 QuadraticProgramMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "QuadraticProgram"
+        self.category = "optimizers"
+        self.type = "quadratic_program"
+        self.summary = "General time-varying quadratic program (QP) solver."
+        self.description = (
+            "Solves at each simulation step the quadratic program:\n"
+            "$$\n"
+            "\\begin{aligned}\n"
+            "\\min_x \\quad & \\tfrac12 x^T P x + q^T x \\\\\n"
+            "\\text{s.t.} \\quad\n"
+            "& Gx \\le h \\\\\n"
+            "& Ax = b \\\\\n"
+            "& \\ell \\le x \\le u\n"
+            "\\end{aligned}\n"
+            "$$\n"
+            "All problem data are provided as inputs and may vary with time.\n"
+            "Inequality, equality, and bound constraints are optional."
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="solver",
+                type="string",
+                autofill=True,
+                default="clarabel",
+                description="Name of the QP solver used by qpsolvers."
+            )
+        ]
+
+        self.inputs = [
+            PortMeta(
+                name="P",
+                display_as="P",
+                shape=["n", "n"],
+                description="Quadratic cost matrix (Hessian). Must be square and compatible with size."
+            ),
+            PortMeta(
+                name="q",
+                display_as="q",
+                shape=["n"],
+                description="Linear cost vector. Accepted shapes are (n,) or (n,1)."
+            ),
+            PortMeta(
+                name="G",
+                display_as="G",
+                shape=["m", "n"],
+                description="Inequality constraint matrix. Must be provided together with h."
+            ),
+            PortMeta(
+                name="h",
+                display_as="h",
+                shape=["m"],
+                description="Inequality constraint vector. Accepted shapes are (m,) or (m,1)."
+            ),
+            PortMeta(
+                name="A",
+                display_as="A",
+                shape=["p", "n"],
+                description="Equality constraint matrix. Must be provided together with b."
+            ),
+            PortMeta(
+                name="b",
+                display_as="b",
+                shape=["p"],
+                description="Equality constraint vector. Accepted shapes are (p,) or (p,1)."
+            ),
+            PortMeta(
+                name="lb",
+                display_as="lb",
+                shape=["n"],
+                description="Lower bound on decision variables. Accepted shapes are (n,) or (n,1)."
+            ),
+            PortMeta(
+                name="ub",
+                display_as="ub",
+                shape=["n"],
+                description="Upper bound on decision variables. Accepted shapes are (n,) or (n,1)."
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="x",
+                display_as="x",
+                shape=["n", 1],
+                description="Optimal solution of the quadratic program."
+            ),
+            PortMeta(
+                name="status",
+                display_as="status",
+                shape=[1, 1],
+                description="Solver status code:\n0 = optimal solution found,\n1 = problem infeasible,\n2 = solver or numerical error."
+            ),
+            PortMeta(
+                name="cost",
+                display_as="cost",
+                shape=[1, 1],
+                description="Optimal value of the quadratic cost function."
+            )
+        ]

pySimBlocks/gui/blocks/parameter_meta.py

@@ -0,0 +1,34 @@
+# ******************************************************************************
+#                                  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 dataclasses import dataclass, field
+from typing import Any, List, Optional
+
+
+@dataclass(frozen=True)
+class ParameterMeta:
+    name: str
+    type: str
+    required: bool = False
+    autofill: bool = False
+    default: Optional[Any] = None
+    enum: List[Any] = field(default_factory=list)
+    description: str = ""

pySimBlocks/gui/blocks/port_meta.py

@@ -0,0 +1,31 @@
+# ******************************************************************************
+#                                  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 dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class PortMeta:
+    name: str
+    display_as: str
+    shape: list[Any]
+    description: str = ""

pySimBlocks/gui/blocks/sources/chirp.py

@@ -0,0 +1,146 @@
+# ******************************************************************************
+#                                  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 ChirpMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "Chirp"
+        self.category = "sources"
+        self.type = "chirp"
+        self.summary = "Multi-dimensional chirp signal source (linear or logarithmic)."
+
+        self.description = (
+            "Generates a frequency-sweep (chirp) signal.\n\n"
+
+            "Linear mode:\n"
+            "$$\n"
+            "\\phi_i(t) = 2\\pi\\left(f_{0,i}\\tau + "
+            "\\tfrac{1}{2}k_i\\tau^2\\right) + \\varphi_i\n"
+            "$$\n"
+            "with:\n"
+            "$$\n"
+            "k_i = \\frac{f_{1,i} - f_{0,i}}{T_i}\n"
+            "$$\n\n"
+
+            "Logarithmic mode:\n"
+            "$$\n"
+            "\\phi_i(t) = "
+            "\\frac{2\\pi f_{0,i} T_i}{\\ln(f_{1,i}/f_{0,i})}"
+            "\\left[\\left(\\frac{f_{1,i}}{f_{0,i}}\\right)^{\\tau/T_i} - 1\\right]"
+            " + \\varphi_i\n"
+            "$$\n\n"
+
+            "Output:\n"
+            "$$\n"
+            "y_i(t) = A_i \\sin(\\phi_i(t)) + o_i\n"
+            "$$\n\n"
+
+            "with:\n"
+            "$$\n"
+            "\\tau = \\max(0, t - t_{0,i})\n"
+            "$$\n"
+        )
+
+        self.parameters = [
+
+            ParameterMeta(
+                name="amplitude",
+                type="scalar | vector | matrix",
+                required=True,
+                autofill=True,
+                default=[[1.0]],
+                description="Chirp amplitude."
+            ),
+
+            ParameterMeta(
+                name="f0",
+                type="scalar | vector | matrix",
+                required=True,
+                autofill=True,
+                default=[[1.0]],
+                description="Start frequency in Hertz."
+            ),
+
+            ParameterMeta(
+                name="f1",
+                type="scalar | vector | matrix",
+                required=True,
+                autofill=True,
+                default=[[10.0]],
+                description="End frequency in Hertz."
+            ),
+
+            ParameterMeta(
+                name="duration",
+                type="scalar | vector | matrix",
+                required=True,
+                autofill=True,
+                default=[[5.0]],
+                description="Frequency sweep duration in seconds."
+            ),
+
+            ParameterMeta(
+                name="mode",
+                type="enum",
+                required=True,
+                autofill=True,
+                default="linear",
+                enum=["linear", "log"],
+                description="Sweep mode: 'linear' or 'log'."
+            ),
+
+            ParameterMeta(
+                name="start_time",
+                type="scalar | vector | matrix",
+                description="Time at which the chirp starts."
+            ),
+
+            ParameterMeta(
+                name="phase",
+                type="scalar | vector | matrix",
+                description="Initial phase 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="Chirp output signal."
+            )
+        ]

pySimBlocks/gui/blocks/sources/constant.py

@@ -0,0 +1,63 @@
+# ******************************************************************************
+#                                  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 ConstantMeta(BlockMeta):
+    
+    def __init__(self):
+        self.name = "Constant"
+        self.category = "sources"
+        self.type = "constant"
+        self.summary = "Constant signal source."
+        self.description = (
+            "Generates a constant output signal:\n"
+            "$$\n"
+            "y(t) = c"
+            "$$\n"
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name = "value", 
+                type = "scalar | vector | matrix",
+                required = True,
+                autofill = True,
+                default = [[1.0]],
+                description = "Constant output value."
+            ),
+
+            ParameterMeta(
+                name = "sample_time",
+                type = "float",
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["n", "m"],
+                description="Constant output signal."
+            )
+        ]

pySimBlocks/gui/blocks/sources/file_source.py

@@ -0,0 +1,196 @@
+# ******************************************************************************
+#                                  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 Any, Dict
+
+from PySide6.QtWidgets import QFormLayout, QLabel, QLineEdit, QPushButton
+
+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 FileSourceMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "FileSource"
+        self.category = "sources"
+        self.type = "file_source"
+        self.summary = "Read a sequence of samples from a CSV, NPY, or NPZ file."
+        self.description = (
+            "Loads samples from file and outputs one sample per simulation step.\n\n"
+            "- `.npz`: reads one array from the archive (`key` mandatory).\n"
+            "- `.npy`: reads one array from a NPY file (`key` unused).\n"
+            "- `.csv`: reads one numeric CSV column (`key` = column name).\n\n"
+            "Each step emits one row as a column vector."
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="file_path",
+                type="str",
+                required=True,
+                description="Path to the source file."
+            ),
+            ParameterMeta(
+                name="key",
+                type="str",
+                description="NPZ array key or CSV column name."
+            ),
+            ParameterMeta(
+                name="repeat",
+                type="enum",
+                autofill=True,
+                default=False,
+                enum=[False, True],
+                description="If true, replay samples from the beginning after end of file."
+            ),
+            ParameterMeta(
+                name="use_time",
+                type="enum",
+                autofill=True,
+                default=False,
+                enum=[False, True],
+                description="If true (NPZ/CSV), use 'time' data and apply ZOH at simulation time t."
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float",
+                description="Block execution period."
+            ),
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["n", 1],
+                description="Current output sample."
+            )
+        ]
+
+    # ------------------------------------------------------
+    def is_parameter_active(self, 
+                            param_name: str, 
+                            instance_params: Dict[str, Any]) -> bool:
+        file_path = str(instance_params.get("file_path", "") or "")
+        ext = file_path.rsplit(".", 1)[-1].lower() if "." in file_path else ""
+
+        if param_name == "key":
+            return ext in {"npz", "csv"}
+
+        if param_name == "use_time":
+            return ext in {"npz", "csv"}
+
+        return super().is_parameter_active(param_name, instance_params)
+
+    # --------------------------------------------------------------------------
+    # 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="Data files (*.npz *.npy *.csv);;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)])