pySimBlocks 0.1.0__py3-none-any.whl

tests/gui/main_window_open_test.py

@@ -0,0 +1,162 @@
+import pytest
+
+from pySimBlocks.gui.main_window import MainWindow
+
+def test_main_window_opens(qtbot, tmp_path):
+
+    window = MainWindow(tmp_path)
+
+    qtbot.addWidget(window)
+    window.show()
+
+    qtbot.waitUntil(lambda: window.isVisible())
+
+    assert window.isVisible()
+    assert window.view is not None
+    assert window.blocks is not None
+    assert window.toolbar is not None
+    assert window.project_controller is not None
+    assert len(window.block_registry) > 0
+
+
+@pytest.fixture
+def minimal_project(tmp_path):
+    """Create a minimal pySimBlocks project.yaml."""
+    project_yaml = tmp_path / "project.yaml"
+    project_yaml.write_text(
+        """schema_version: 1
+project:
+  name: test_gui_project
+simulation:
+  dt: 0.01
+  T: 3.0
+  solver: fixed
+  logging:
+  - ref.outputs.out
+  - plant.outputs.y
+  - pid.outputs.u
+  plots:
+  - title: Ref vs Output
+    signals: [ref.outputs.out, plant.outputs.y]
+  - title: Command
+    signals: [pid.outputs.u]
+diagram:
+  blocks:
+  - name: ref
+    category: sources
+    type: step
+    parameters:
+      value_before: [[0.0]]
+      value_after: [[1.0]]
+      start_time: 0.5
+  - name: error
+    category: operators
+    type: sum
+    parameters:
+      signs: +-
+  - name: pid
+    category: controllers
+    type: pid
+    parameters:
+      controller: PI
+      Kp: [[2.0]]
+      Ki: [[1.0]]
+      Kd: 0.0
+  - name: plant
+    category: systems
+    type: linear_state_space
+    parameters:
+      A: [[0.95]]
+      B: [[0.5]]
+      C: [[1.0]]
+      x0: [[0.0]]
+  connections:
+  - name: c1
+    ports: [ref.out, error.in1]
+  - name: c2
+    ports: [plant.y, error.in2]
+  - name: c3
+    ports: [error.out, pid.e]
+  - name: c4
+    ports: [pid.u, plant.u]
+gui:
+  layout:
+    blocks:
+      ref:
+        x: 0.0
+        y: -80.0
+        orientation: normal
+      error:
+        x: 195.0
+        y: -71.0
+        orientation: normal
+      pid:
+        x: 364.0
+        y: -71.0
+        orientation: normal
+      plant:
+        x: 535.0
+        y: -70.0
+        orientation: normal
+"""
+    )
+
+    return tmp_path
+
+def test_main_window_loads_project(qtbot, minimal_project):
+    """Test that MainWindow opens and auto-loads a project from project.yaml."""
+    window = MainWindow(minimal_project)
+    qtbot.addWidget(window)
+    window.show()
+    qtbot.waitUntil(lambda: window.isVisible())
+
+    assert window.isVisible()
+    assert window.project_controller.project_state.directory_path == minimal_project
+    assert window.view is not None
+    assert window.blocks is not None
+    assert window.toolbar is not None
+
+    assert len(window.block_registry) > 0
+    block_names = [item.instance.name for item in window.view.block_items.values()]
+    for expected in ["ref", "error", "pid", "plant"]:
+        assert expected in block_names
+
+    expected_connections = [
+        ("ref", "out", "error", "in1"),
+        ("plant", "y", "error", "in2"),
+        ("error", "out", "pid", "e"),
+        ("pid", "u", "plant", "u"),
+    ]
+
+    actual_connections = [
+        (
+            conn.src_block().name,
+            conn.src_port.name,
+            conn.dst_block().name,
+            conn.dst_port.name
+        )
+        for conn in window.view.connections.keys()
+    ]
+
+    for conn in expected_connections:
+        assert conn in actual_connections
+
+def test_run_simulation(qtbot, minimal_project):
+    """
+    Smoke test: Load a minimal project and run the simulation via ToolBarView.
+    """
+    window = MainWindow(minimal_project)
+    qtbot.addWidget(window)
+    window.show()
+    qtbot.waitUntil(lambda: window.isVisible())
+
+    project_state = window.project_state
+    toolbar = window.toolbar
+
+    assert not bool(project_state.logs)
+
+    toolbar.on_run_sim()
+
+    assert bool(project_state.logs)
+    assert isinstance(project_state.logs, dict)
+    assert all(isinstance(v, list) for v in project_state.logs.values())

tests/gui/test_block_meta_param_cache.py

@@ -0,0 +1,16 @@
+from pySimBlocks.gui.blocks.block_dialog_session import BlockDialogSession
+from pySimBlocks.gui.blocks.controllers.pid import PIDMeta
+from pySimBlocks.gui.models.block_instance import BlockInstance
+
+
+def test_gather_params_keeps_inactive_values_for_cache():
+    meta = PIDMeta()
+    instance = BlockInstance(meta)
+    session = BlockDialogSession(meta, instance)
+
+    session.local_params["controller"] = "PD"  # Ki inactive for PD
+    session.local_params["Ki"] = 10
+
+    gathered = meta.gather_params(session)
+
+    assert gathered["Ki"] == 10

tests/gui/test_file_source_meta.py

@@ -0,0 +1,17 @@
+from pySimBlocks.gui.blocks.sources.file_source import FileSourceMeta
+
+
+def test_file_source_meta_conditional_parameters():
+    meta = FileSourceMeta()
+
+    npz_values = {"file_path": "data.npz"}
+    assert meta.is_parameter_active("key", npz_values) is True
+    assert meta.is_parameter_active("use_time", npz_values) is True
+
+    npy_values = {"file_path": "data.npy"}
+    assert meta.is_parameter_active("key", npy_values) is False
+    assert meta.is_parameter_active("use_time", npy_values) is False
+
+    csv_values = {"file_path": "data.csv"}
+    assert meta.is_parameter_active("key", csv_values) is True
+    assert meta.is_parameter_active("use_time", csv_values) is True

tests/gui/test_function_source_meta.py

@@ -0,0 +1,28 @@
+from pySimBlocks.gui.blocks.sources.function_source import FunctionSourceMeta
+from pySimBlocks.gui.models.block_instance import BlockInstance
+
+
+def test_function_source_meta_definition():
+    meta = FunctionSourceMeta()
+
+    assert meta.category == "sources"
+    assert meta.type == "function_source"
+    assert [p.name for p in meta.parameters] == [
+        "file_path",
+        "function_name",
+        "output_keys",
+        "sample_time",
+    ]
+    assert len(meta.inputs) == 0
+    assert len(meta.outputs) == 1
+    assert meta.outputs[0].name == "out"
+
+
+def test_function_source_meta_resolves_dynamic_output_ports():
+    meta = FunctionSourceMeta()
+    instance = BlockInstance(meta)
+    instance.update_params({"output_keys": ["y", "z"]})
+    instance.resolve_ports()
+
+    outputs = [p for p in instance.ports if p.direction == "output"]
+    assert [p.name for p in outputs] == ["y", "z"]

tests/regression/test_simulink_dc_motor.py

@@ -0,0 +1,217 @@
+import numpy as np
+from pathlib import Path
+
+from pySimBlocks import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources import Step
+from pySimBlocks.blocks.systems import LinearStateSpace
+from pySimBlocks.blocks.operators import Sum
+from pySimBlocks.blocks.controllers import Pid
+
+
+# ---------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------
+
+def _dc_motor_discrete_matrices(dt: float) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    DC motor discrete-time model used in the Simulink reference dataset.
+
+    Parameters match the reference scripts:
+        R=0.1, L=0.5, J=0.01, K=0.1, a=0.001
+    """
+    R = 0.1
+    L = 0.5
+    J = 0.01
+    K = 0.1
+    a = 0.001
+
+    A = np.array([[1 - dt * R / L, -dt * K / L],
+                  [dt * K / J, 1 - dt * a / J]])
+    B = np.array([[dt / L], [0]])
+    C = np.array([[0, 1]])
+    return A, B, C
+
+
+def _load_simulink_npz() -> dict[str, np.ndarray]:
+    """
+    Loads the reference dataset shipped in the repository.
+
+    Expected location:
+        tests/data/simulink/simulation.npz
+    """
+    data_path = Path(__file__).resolve().parent / "data" / "simulink" / "dc_motor.npz"
+    if not data_path.exists():
+        raise FileNotFoundError(
+            f"Simulink reference dataset not found: {data_path}\n"
+            "Place simulation.npz under tests/data/simulink/ (or update this path)."
+        )
+    return dict(np.load(str(data_path)))
+
+
+def _extract(logs: dict, key: str) -> np.ndarray:
+    v = np.array(logs[key])
+    return v.reshape(-1).astype(float)
+
+
+def _assert_close(ref: np.ndarray, got: np.ndarray, *, atol: float, rtol: float, label: str):
+    assert ref.shape == got.shape, f"{label}: shape mismatch ref={ref.shape} got={got.shape}"
+    if not np.allclose(ref, got, atol=atol, rtol=rtol):
+        err = np.linalg.norm(ref - got)
+        mx = np.max(np.abs(ref - got))
+        raise AssertionError(
+            f"{label}: not close (atol={atol}, rtol={rtol}). "
+            f"L2={err:.3e}, max_abs={mx:.3e}"
+        )
+
+
+# ---------------------------------------------------------------------
+# Reference simulations (pySimBlocks)
+# ---------------------------------------------------------------------
+
+def _sim_openloop(A: np.ndarray, B: np.ndarray, C: np.ndarray, T: float, dt: float) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    ref = Step("command", start_time=1.0, value_before=0.0, value_after=1.0)
+    motor = LinearStateSpace("motor", A, B, C)
+
+    model = Model("openloop")
+    model.add_block(ref)
+    model.add_block(motor)
+    model.connect("command", "out", "motor", "u")
+
+    sim_cfg = SimulationConfig(dt, T, logging=["command.outputs.out", "motor.outputs.y"])
+    sim = Simulator(model, sim_cfg, verbose=False)
+    logs = sim.run()
+
+    t = _extract(logs, "time")
+    u = _extract(logs, "command.outputs.out")
+    w = _extract(logs, "motor.outputs.y")
+    return t, u, w
+
+
+def _sim_pi(A: np.ndarray, B: np.ndarray, C: np.ndarray, Kp: np.ndarray, Ki: np.ndarray, T: float, dt: float) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    ref = Step("ref", start_time=1.0, value_before=0.0, value_after=1.0)
+    motor = LinearStateSpace("motor", A, B, C)
+    error = Sum("error", signs="+-")
+    pid = Pid("pid", Kp=Kp, Ki=Ki, controller="PI")
+
+    model = Model("pi")
+    for b in [ref, motor, error, pid]:
+        model.add_block(b)
+
+    model.connect("ref", "out", "error", "in1")
+    model.connect("motor", "y", "error", "in2")
+    model.connect("error", "out", "pid", "e")
+    model.connect("pid", "u", "motor", "u")
+
+    sim_cfg = SimulationConfig(dt, T, logging=["ref.outputs.out", "motor.outputs.y", "pid.outputs.u"])
+    sim = Simulator(model, sim_cfg, verbose=False)
+    logs = sim.run()
+
+    t = _extract(logs, "time")
+    r = _extract(logs, "ref.outputs.out")
+    w = _extract(logs, "motor.outputs.y")
+    u = _extract(logs, "pid.outputs.u")
+    return t, u, w, r
+
+
+def _sim_pid(A: np.ndarray, B: np.ndarray, C: np.ndarray, Kp: np.ndarray, Ki: np.ndarray, Kd: np.ndarray,
+             T: float, dt: float, integration_method: str | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    ref = Step("ref", start_time=1.0, value_before=0.0, value_after=1.0)
+    motor = LinearStateSpace("motor", A, B, C)
+    error = Sum("error", signs="+-")
+
+    if integration_method is None:
+        pid = Pid("pid", Kp=Kp, Ki=Ki, Kd=Kd)
+    else:
+        pid = Pid("pid", Kp=Kp, Ki=Ki, Kd=Kd, integration_method=integration_method)
+
+    model = Model("pid")
+    for b in [ref, motor, error, pid]:
+        model.add_block(b)
+
+    model.connect("ref", "out", "error", "in1")
+    model.connect("motor", "y", "error", "in2")
+    model.connect("error", "out", "pid", "e")
+    model.connect("pid", "u", "motor", "u")
+
+    sim_cfg = SimulationConfig(dt, T, logging=["ref.outputs.out", "motor.outputs.y", "pid.outputs.u"])
+    sim = Simulator(model, sim_cfg, verbose=False)
+    logs = sim.run()
+
+    t = _extract(logs, "time")
+    r = _extract(logs, "ref.outputs.out")
+    w = _extract(logs, "motor.outputs.y")
+    u = _extract(logs, "pid.outputs.u")
+    return t, u, w, r
+
+
+# ---------------------------------------------------------------------
+# Regression tests vs Simulink reference
+# ---------------------------------------------------------------------
+def test_regression_openloop_matches_simulink():
+    data = _load_simulink_npz()
+
+    dt = 0.1
+    T = 30.0
+    A, B, C = _dc_motor_discrete_matrices(dt)
+
+    t, u, w = _sim_openloop(A, B, C, T, dt)
+
+    _assert_close(data["time"].reshape(-1), t, atol=1e-12, rtol=1e-12, label="time")
+    _assert_close(data["uol"].reshape(-1), u, atol=1e-12, rtol=1e-12, label="uol")
+    _assert_close(data["wol"].reshape(-1), w, atol=1e-12, rtol=1e-12, label="wol")
+
+
+def test_regression_pi_matches_simulink():
+    data = _load_simulink_npz()
+
+    dt = 0.1
+    T = 30.0
+    A, B, C = _dc_motor_discrete_matrices(dt)
+
+    Kp = np.array([[0.001]])
+    Ki = np.array([[0.02]])
+
+    t, u, w, r = _sim_pi(A, B, C, Kp, Ki, T, dt)
+
+    _assert_close(data["time"].reshape(-1), t, atol=1e-12, rtol=1e-12, label="time")
+    _assert_close(data["r"].reshape(-1), r, atol=1e-12, rtol=1e-12, label="r (reference)")
+    _assert_close(data["upi"].reshape(-1), u, atol=1e-12, rtol=1e-12, label="upi")
+    _assert_close(data["wpi"].reshape(-1), w, atol=1e-12, rtol=1e-12, label="wpi")
+
+
+def test_regression_pid_matches_simulink():
+    data = _load_simulink_npz()
+
+    dt = 0.1
+    T = 30.0
+    A, B, C = _dc_motor_discrete_matrices(dt)
+
+    Kp = np.array([[0.001]])
+    Ki = np.array([[0.02]])
+    Kd = np.array([[0.01]])
+
+    t, u, w, r = _sim_pid(A, B, C, Kp, Ki, Kd, T, dt)
+
+    _assert_close(data["time"].reshape(-1), t, atol=1e-12, rtol=1e-12, label="time")
+    _assert_close(data["r"].reshape(-1), r, atol=1e-12, rtol=1e-12, label="r (reference)")
+    _assert_close(data["upid"].reshape(-1), u, atol=1e-12, rtol=1e-12, label="upid")
+    _assert_close(data["wpid"].reshape(-1), w, atol=1e-12, rtol=1e-12, label="wpid")
+
+
+def test_regression_pid_backward_euler_matches_simulink():
+    data = _load_simulink_npz()
+
+    dt = 0.1
+    T = 30.0
+    A, B, C = _dc_motor_discrete_matrices(dt)
+
+    Kp = np.array([[0.001]])
+    Ki = np.array([[0.02]])
+    Kd = np.array([[0.01]])
+
+    t, u, w, r = _sim_pid(A, B, C, Kp, Ki, Kd, T, dt, integration_method="euler backward")
+
+    _assert_close(data["time"].reshape(-1), t, atol=1e-12, rtol=1e-12, label="time")
+    _assert_close(data["r"].reshape(-1), r, atol=1e-12, rtol=1e-12, label="r (reference)")
+    _assert_close(data["upid_backward"].reshape(-1), u, atol=1e-12, rtol=1e-12, label="upid_backward")
+    _assert_close(data["wpid_backward"].reshape(-1), w, atol=1e-12, rtol=1e-12, label="wpid_backward")