pySimBlocks 0.1.0__py3-none-any.whl

examples/basics/state_space/linear/gui/run.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+from pySimBlocks.project import load_simulator_from_project
+from pySimBlocks.project.plot_from_config import plot_from_config
+
+try:
+    BASE_DIR = Path(__file__).parent.resolve()
+except Exception:
+    BASE_DIR = Path("")
+
+sim, plot_cfg = load_simulator_from_project(BASE_DIR / "project.yaml")
+
+logs = sim.run()
+if True and plot_cfg is not None:
+    plot_from_config(logs, plot_cfg)

examples/basics/state_space/linear/ss_block.py

@@ -0,0 +1,89 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+from pySimBlocks import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources import Step
+from pySimBlocks.blocks.systems import LinearStateSpace
+
+def main():
+    # --- 1. Define system matrices (SISO example) ---
+    A = np.array([[0., 0.25], [0.3, 0.91]]) 
+    B = np.array([[0.5], [0.3]])    
+    C = np.array([[0., 1.0]])     
+    x0 = np.zeros((A.shape[0], 1))
+
+
+    # --- 2. Create blocks ---
+    command = Step(
+        name="command",
+        value_before=np.array([[0.0]]),
+        value_after=np.array([[1.0]]),
+        start_time=0.5,
+    )
+
+    # Linear state-space system
+    plant = LinearStateSpace(
+        name="plant",
+        A=A, B=B, C=C,
+        x0=x0,
+    )
+
+    # --- 3. Build the model ---
+    model = Model(name="siso")
+    model.add_block(command)
+    model.add_block(plant)
+
+    model.connect("command", "out", "plant", "u")
+
+
+    # --- 4. Create the simulator ---
+    dt = 0.01
+    T = 5.
+    sim_cfg = SimulationConfig(dt, T)
+    sim = Simulator(model, sim_cfg)
+
+    # --- 5. Run simulation ---
+    logs = sim.run(logging=[
+            "command.outputs.out",
+            "plant.outputs.x",
+            "plant.outputs.y",
+        ],
+    )
+
+
+    # --- 6. Inspect / print some results ---
+    t = sim.get_data("time")
+    u = sim.get_data("command.outputs.out").squeeze()
+    x = sim.get_data("plant.outputs.x").squeeze()
+    y = sim.get_data("plant.outputs.y").squeeze()
+
+
+    # --- 6. Plot the result ---
+    plt.figure()
+    plt.step(t, x[:, 0], "--r", label="x[0]", where="post")
+    plt.step(t, x[:, 1], "--b", label="x[1]", where="post")
+    plt.xlabel("Time [s]")
+    plt.ylabel("State")
+    plt.grid(True)
+    plt.legend()
+    plt.title("State evolution")
+
+    plt.figure()
+    plt.step(t, y, "--g", label="y (output)", where="post")
+    plt.xlabel("Time [s]")
+    plt.ylabel("Output")
+    plt.grid(True)
+    plt.legend()
+    plt.title("Output evolution")
+
+    plt.figure()
+    plt.step(t, u, "--k", label="u (input)", where="post")
+    plt.xlabel("Time [s]")
+    plt.ylabel("Input")
+    plt.grid(True)
+    plt.legend()
+    plt.title("Input signal")
+    plt.show()
+
+if __name__ == "__main__":
+    main()

examples/basics/state_space/linear/ss_manual.py

@@ -0,0 +1,105 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+from pySimBlocks import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources import Step
+from pySimBlocks.blocks.operators import Gain, Sum, Delay
+
+
+def main():
+    """Closed chain block digram test.
+    x[k+1] = A*x[k] + B*u[k]
+    """
+
+    A = np.array([[0., 0.25], [0.3, 0.91]]) 
+    B = np.array([[0.5], [0.3]])    
+    C = np.array([[0., 1.0]])  
+    x0 = np.zeros((A.shape[0], 1))
+
+    # -------------------------------------------------------
+    # 1. Create the blocks
+    # -------------------------------------------------------
+    step = Step(
+        name="u",
+        value_before=np.array([[0.0]]),
+        value_after=np.array([[1.0]]),
+        start_time=0.5
+    )
+    state_matrix = Gain(name="A", gain=A, multiplication="Matrix (K @ u)")
+    input_matrix = Gain(name="B", gain=B, multiplication="Matrix (K @ u)")
+    output_matrix = Gain(name="C", gain=C, multiplication="Matrix (K @ u)")
+    sum = Sum(name="sum", signs="++")
+    delay = Delay(name="delay", initial_output=x0)
+
+    # -------------------------------------------------------
+    # 2. Build the model
+    # -------------------------------------------------------
+    model = Model("test")
+    for block in [step, input_matrix, state_matrix, sum, delay, output_matrix]:
+        model.add_block(block)
+
+    model.connect("u", "out", "B", "in")
+    model.connect("B", "out", "sum", "in1")
+    model.connect("A", "out", "sum", "in2")
+    model.connect("sum", "out", "delay", "in")
+    model.connect("delay", "out", "A", "in")
+    model.connect("delay", "out", "C", "in")
+
+    # -------------------------------------------------------
+    # 3. Create the simulator
+    # -------------------------------------------------------
+    dt = 0.01
+    T = 5.
+    sim_cfg = SimulationConfig(dt, T)
+    sim = Simulator(model, sim_cfg, verbose=True)
+
+    # -------------------------------------------------------
+    # 4. Run the simulation for 2 seconds
+    # -------------------------------------------------------
+    logs = sim.run(logging=[
+            "u.outputs.out",
+            "delay.outputs.out",
+            "C.outputs.out",
+        ]
+    )
+
+    # -------------------------------------------------------
+    # 5. Extract logged data
+    # -------------------------------------------------------
+    t = sim.get_data("time")
+    u = sim.get_data("u.outputs.out").squeeze()
+    x = sim.get_data("delay.outputs.out").squeeze()
+    y = sim.get_data("C.outputs.out").squeeze()
+
+    # -------------------------------------------------------
+    # 6. Plot the result
+    # -------------------------------------------------------
+    plt.figure()
+    plt.step(t, x[:, 0], "--r", label="x[0]", where="post")
+    plt.step(t, x[:, 1], "--b", label="x[1]", where="post")
+    plt.xlabel("Time [s]")
+    plt.ylabel("State")
+    plt.grid(True)
+    plt.legend()
+    plt.title("State evolution")
+
+    plt.figure()
+    plt.step(t, y, "--g", label="y (output)", where="post")
+    plt.xlabel("Time [s]")
+    plt.ylabel("Output")
+    plt.grid(True)
+    plt.legend()
+    plt.title("Output evolution")
+
+    plt.figure()
+    plt.step(t, u, "--k", label="u (input)", where="post")
+    plt.xlabel("Time [s]")
+    plt.ylabel("Input")
+    plt.grid(True)
+    plt.legend()
+    plt.title("Input signal")
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

examples/basics/state_space/non_linear/nlss.py

@@ -0,0 +1,47 @@
+import numpy as np 
+
+def f(t, dt, x, u):
+    """
+    Non-linear state-space function for a discrete-time system.
+
+    Parameters:
+    t : float
+        Current time.
+    dt : float
+        Time step.
+    x : ndarray
+        Current state vector.
+    u : ndarray
+        Current input vector.
+
+    Returns:
+    x_next : ndarray
+        Next state vector after applying the non-linear dynamics.
+    """
+    x_next = np.zeros_like(x)
+    x_next[0] = x[0] + dt * (x[1] +  np.sin(x[0]) + u[0]**2)
+    x_next[1] = x[1] + dt * (-x[0]**3 - 0.5 * x[1])
+    
+    return x_next
+
+
+def g(t, dt, x):
+    """
+    Non-linear output function for a discrete-time system.
+
+    Parameters:
+    t : float
+        Current time.
+    dt : float
+        Time step.
+    x : ndarray
+        Current state vector.
+
+    Returns:
+    y : ndarray
+        Output vector after applying the non-linear output function.
+    """
+    y = np.zeros((1, 1))
+    y[0] = x[0]**2 + np.cos(x[1])
+    
+    return {"y": y}

examples/basics/state_space/non_linear/run.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+from pySimBlocks.project import load_simulator_from_project
+from pySimBlocks.project.plot_from_config import plot_from_config
+
+try:
+    BASE_DIR = Path(__file__).parent.resolve()
+except Exception:
+    BASE_DIR = Path("")
+
+sim, plot_cfg = load_simulator_from_project(BASE_DIR / "project.yaml")
+
+logs = sim.run()
+if True and plot_cfg is not None:
+    plot_from_config(logs, plot_cfg)

examples/basics/state_space/polytope/params.py

@@ -0,0 +1,39 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Dimensions
+r = 3      # number of vertices
+nx = 4     # state dimension
+nu = 1     # input dimension
+ny = 2     # output dimension
+
+
+# Create A_i matrices
+A1 = np.array([
+    [0.8, 0.1, 0.0, 0.0],
+    [0.0, 0.7, 0.1, 0.0],
+    [0.0, 0.0, 0.6, 0.1],
+    [0.0, 0.0, 0.0, 0.5],
+])
+
+A2 = A1 + 0.05 * np.eye(nx)
+A3 = A1 - 0.05 * np.eye(nx)
+
+A = np.hstack([A1, A2, A3])
+
+
+# Create B_i matrices
+B1 = np.array([[1.0], [0.0], [0.0], [0.0]])
+B2 = np.array([[0.5], [0.5], [0.0], [0.0]])
+B3 = np.array([[0.2], [0.3], [0.3], [0.2]])
+
+B = np.hstack([B1, B2, B3])
+
+
+# Output matrix
+C = np.array([
+    [1.0, 0.0, 0.0, 0.0],
+    [0.0, 0.0, 1.0, 0.0],
+])
+
+

examples/basics/state_space/polytope/weights.py

@@ -0,0 +1,12 @@
+import numpy as np
+
+
+def get_weights(t, dt, c):
+    w1 = np.clip(0.4 + 0.2 * np.sin(0.5 * t) + c, 0.0, 1.0)
+    w2 = np.clip(0.3 + 0.1 * np.cos(0.3 * t), 0.0, 1-w1)
+    w3 = 1.0 - w1 - w2
+    w3 = np.clip(w3, 0.0, 1.0)
+
+    val = np.array([w1, w2, w3]).reshape(-1, 1)
+    return {"w": val}
+

examples/comparison/simulink/convert.py

@@ -0,0 +1,29 @@
+import csv
+import numpy as np
+
+filename = "simulation.csv"
+
+# Lecture du CSV
+with open(filename, "r") as f:
+    reader = csv.reader(f)
+    rows = list(reader)
+
+# Titres
+titles = rows[0]
+
+# Données converties en float
+data = np.array(rows[1:], dtype=float)
+
+# Construction dynamique du dictionnaire pour savez
+save_dict = {"titles": np.array(titles)}
+
+for i, name in enumerate(titles):
+    key = name.strip()
+
+    # Optionnel : sécuriser le nom si nécessaire
+    # key = key.replace(" ", "_").replace("-", "_")
+
+    save_dict[key] = data[:, i]
+
+# Sauvegarde
+np.savez("simulation.npz", **save_dict)

examples/comparison/simulink/openloop.py

@@ -0,0 +1,127 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from pySimBlocks import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources import Step
+from pySimBlocks.blocks.systems import LinearStateSpace
+from pySimBlocks.blocks.operators import Gain, Sum, Delay
+
+
+def manual_sim(A, B, C, T, dt):
+
+    # Blocks
+    ref = Step("u", start_time=1., value_before=0., value_after=1.)
+    delay_x = Delay("x", num_delays=1, initial_output=np.zeros((A.shape[0], 1)))
+    gain_A = Gain("A", A, multiplication="Matrix (K @ u)")
+    gain_B = Gain("B", B, multiplication="Matrix (K @ u)")
+    gain_C = Gain("C", C, multiplication="Matrix (K @ u)")
+    sum_x = Sum("sum_x", "++")
+
+    # model
+    model = Model("manual_ss")
+    for blk in [ref, delay_x, gain_A, gain_B, gain_C, sum_x]:
+        model.add_block(blk)
+
+    # connection
+    model.connect("u", "out", "B", "in")               # u -> B
+    model.connect("B", "out", "sum_x", "in1")          # B u -> sum
+    model.connect("x", "out", "A", "in")               # x -> A
+    model.connect("A", "out", "sum_x", "in2")          # A x -> sum
+    model.connect("sum_x", "out", "x", "in")           # x_next -> Delay
+    model.connect("x", "out", "C", "in")               # x -> C
+
+    # Simulator
+    sim_cfg = SimulationConfig(dt, T, logging=[
+                "u.outputs.out",
+                "C.outputs.out",
+                "x.outputs.out"
+            ])
+    sim = Simulator(model, sim_cfg, verbose=True)
+    logs = sim.run( )
+    
+    time = sim.get_data("time")
+    u = sim.get_data("u.outputs.out").squeeze()
+    w = sim.get_data("C.outputs.out").squeeze()
+
+    return time, u, w
+
+
+
+def block_sim(A, B, C, T, dt):
+    # Blocks
+    ref = Step("command", start_time=1., value_before=0., value_after=1.)
+    motor = LinearStateSpace("motor", A, B, C)
+
+    # Model
+    model = Model("DC Motor Control")
+    for block in [ref, motor]:
+        model.add_block(block)
+    model.connect("command", "out", "motor", "u")
+
+    # Simulator
+    sim_cfg = SimulationConfig(dt, T, logging=[
+                "command.outputs.out",
+                "motor.outputs.y"
+            ])
+    sim = Simulator(model, sim_cfg, verbose=False)
+    logs = sim.run()
+
+    time = sim.get_data("time")
+    u = sim.get_data("command.outputs.out").squeeze()
+    w = sim.get_data("motor.outputs.y").squeeze()
+
+    return time, u, w
+
+
+def main():
+    # DC Motor parameters
+    R = 0.1
+    L = 0.5
+    J = 0.01
+    K = 0.1
+    a = 0.001
+
+    # Simulation parameters
+    dt = 0.1
+    T = 30.
+
+    # State-space matrices
+    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]])
+
+    time, uol, wol = manual_sim(A, B, C, T, dt)
+    time_block, uol_block, wol_block = block_sim(A, B, C, T, dt)
+
+    # data from simulink
+    data = np.load("simulation.npz")
+    t_sim = data["time"]
+    uol_sim, wol_sim = data["uol"], data["wol"]
+
+    print("Error simulink - manual: ", np.linalg.norm(wol_sim - wol))
+    print("Error simulink - block: ", np.linalg.norm(wol_sim - wol_block))
+
+    # Plot
+    plt.figure()
+    plt.step(t_sim, wol_sim, '-r', label="w ((simulink)", where="post")
+    plt.step(time, wol, '--b', label="w (manual)", where="post")
+    plt.step(time_block, wol_block, ':g', label="w (block)", where="post")
+    plt.xlabel("Time (s)")
+    plt.ylabel("Speed (rad/s)")
+    plt.legend()
+    plt.grid()
+    plt.title("Open-Loop DC Motor Response")
+
+    plt.figure()
+    plt.step(t_sim, uol_sim, '-r', label="u (simulink)", where="post")
+    plt.step(time, uol, '--b', label="u (Manual)", where="post")
+    plt.step(time_block, uol_block, ':g', label="u (block)", where="post")
+    plt.xlabel("Time (s)")
+    plt.ylabel("motor (V)")
+    plt.legend()
+    plt.grid()
+    plt.title("Command")
+
+    plt.show()
+
+if __name__ == "__main__":
+    main()

examples/comparison/simulink/pi.py

@@ -0,0 +1,148 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from pySimBlocks import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources import Step
+from pySimBlocks.blocks.systems import LinearStateSpace
+from pySimBlocks.blocks.operators import Sum, Gain, DiscreteIntegrator
+from pySimBlocks.blocks.controllers import Pid
+
+
+def manual_sim(A, B, C, Kp, Ki, T, dt):
+    ref = Step("ref", start_time=1., value_before=0., value_after=1.)
+    motor = LinearStateSpace("motor", A, B, C)
+    error = Sum("error", "+-")
+    kp = Gain("Kp", Kp, multiplication="Matrix (K @ u)")
+    ki = Gain("Ki", Ki, multiplication="Matrix (K @ u)")
+    integrator = DiscreteIntegrator("integrator")
+    sum = Sum("sum", "++")
+
+    blocks = [ref, error, kp, integrator, ki, sum, motor]
+
+    model = Model("DC Motor Control")
+    for block in blocks:
+        model.add_block(block)
+    model.connect("ref", "out", "error", "in1")
+    model.connect("motor", "y", "error", "in2")
+    model.connect("error", "out", "Kp", "in")
+    model.connect("Kp", "out", "sum", "in1")
+    model.connect("error", "out", "Ki", "in")
+    model.connect("Ki", "out", "integrator", "in")
+    model.connect("integrator", "out", "sum", "in2")
+    model.connect("sum", "out", "motor", "u")
+
+    # Simulator
+    sim_cfg = SimulationConfig(dt, T, logging=[
+        "ref.outputs.out",
+        "motor.outputs.y",
+        "sum.outputs.out"])
+    sim = Simulator(model, sim_cfg, verbose=True)
+    logs = sim.run()
+
+    time = sim.get_data("time")
+    u = sim.get_data("sum.outputs.out").squeeze()
+    w = sim.get_data("motor.outputs.y").squeeze()
+    r = sim.get_data("ref.outputs.out").squeeze()
+
+    return time, u, w, r
+
+
+def block_sim(A, B, C, Kp, Ki, T, dt):
+    ref = Step("ref", start_time=1., value_before=0., value_after=1.)
+    motor = LinearStateSpace("motor", A, B, C)
+    error = Sum("error", "+-")
+    pid = Pid("pid", Kp=Kp, Ki=Ki, controller="PI")
+
+    blocks = [ref, error, pid, motor]
+
+    # Model
+    model = Model("DC Motor Control")
+    for block in blocks:
+        model.add_block(block)
+    model.connect("ref", "out", "error", "in1")
+    model.connect("motor", "y", "error", "in2")
+    model.connect("error", "out", "pid", "e")
+    model.connect("pid", "u", "motor", "u")
+
+    # Simulator
+    sim_cfg = SimulationConfig(dt, T, logging=[
+                "ref.outputs.out",
+                "motor.outputs.y",
+                "pid.outputs.u"
+            ])
+    sim = Simulator(model, sim_cfg, verbose=True)
+    logs = sim.run()
+
+    time = sim.get_data("time")
+    u = sim.get_data("pid.outputs.u").squeeze()
+    w = sim.get_data("motor.outputs.y").squeeze()
+    r = sim.get_data("ref.outputs.out").squeeze()
+
+    return time, u, w, r
+
+
+def main():
+    # DC Motor parameters
+    R = 0.1
+    L = 0.5
+    J = 0.01
+    K = 0.1
+    a = 0.001
+
+    Kp = np.array([[.001]])
+    Ki = np.array([[.02]])
+
+    # Simulation parameters
+    data = np.load("simulation.npz")
+    dt = 0.1
+    T = 30.
+
+    # State-space matrices
+    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]])
+
+    time, upi, wpi, rpi = manual_sim(A, B, C, Kp, Ki, T, dt)
+    time_block, upi_block, wpi_block, rpi_block = block_sim(A, B, C, Kp, Ki, T, dt)
+
+    # data from simulink
+    t_sim = data["time"]
+    upi_sim, wpi_sim, rpi_sim = data["upi"], data["wpi"], data['r']
+
+
+    print("Error simulink - manual: ", np.linalg.norm(wpi_sim - wpi))
+    print("Error simulink - block: ", np.linalg.norm(wpi_sim - wpi_block))
+
+    # Plot
+    plt.figure()
+    plt.step(t_sim, wpi_sim, '-r', label="w (simulink)", where="post")
+    plt.step(time, wpi, '--b', label="w (manual)", where="post")
+    plt.step(time_block, wpi_block, ':g', label="w (block)", where="post")
+    plt.xlabel("Time (s)")
+    plt.ylabel("Speed (rad/s)")
+    plt.legend()
+    plt.grid()
+    plt.title("PI DC Motor Response")
+
+    plt.figure()
+    plt.step(t_sim, upi_sim, '-r', label="u (simulink)", where="post")
+    plt.step(time, upi, '--b', label="u (Manual)", where="post")
+    plt.step(time_block, upi_block, ':g', label="u (block)", where="post")
+    plt.xlabel("Time (s)")
+    plt.ylabel("motor (V)")
+    plt.legend()
+    plt.grid()
+    plt.title("Command")
+
+    plt.figure()
+    plt.step(t_sim, rpi_sim, '-r', label="r (simulink)", where="post")
+    plt.step(time, rpi, '--b', label="r (Manual)", where="post")
+    plt.step(time_block, rpi_block, ':g', label="r (block)", where="post")
+    plt.xlabel("Time (s)")
+    plt.legend()
+    plt.grid()
+    plt.title("Reference")
+
+    plt.show()
+
+if __name__ == "__main__":
+    main()