pySimBlocks 0.1.0__py3-none-any.whl

examples/comparison/simulink/pid.py

@@ -0,0 +1,154 @@
+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, DiscreteDerivator
+from pySimBlocks.blocks.controllers import Pid
+
+
+def manual_sim(A, B, C, Kp, Ki, Kd, 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")
+    kd = Gain("Kd", Kd, multiplication="Matrix (K @ u)")
+    derivator = DiscreteDerivator("derivator")
+    sum = Sum("sum", "+++")
+
+    blocks = [ref, error, kp, integrator, ki, sum, motor, kd, derivator]
+
+    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("error", "out", "Ki", "in")
+    model.connect("error", "out", "Kd", "in")
+    model.connect("Kp", "out", "sum", "in1")
+    model.connect("Ki", "out", "integrator", "in")
+    model.connect("integrator", "out", "sum", "in3")
+    model.connect("Kd", "out", "derivator", "in")
+    model.connect("derivator", "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",
+                "derivator.outputs.out",
+                "integrator.outputs.out",
+                "Kp.outputs.out"])
+    sim = Simulator(model, sim_cfg, verbose=False)
+    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, Kd, 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, Kd=Kd)
+
+    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=False)
+    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]])
+    Kd = np.array([[.01]])
+
+    # 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, upid, wpid, rpid = manual_sim(A, B, C, Kp, Ki, Kd, T, dt)
+    time_block, upid_block, wpid_block, rpid_block = block_sim(A, B, C, Kp, Ki, Kd, T, dt)
+
+    # data from simulink
+    data = np.load("simulation.npz")
+    t_sim = data["time"]
+    upid_sim, wpid_sim, rpid_sim = data["upid"], data["wpid"], data['r']
+
+    print("Error simulink - manual: ", np.linalg.norm(wpid_sim - wpid))
+    print("Error simulink - block: ", np.linalg.norm(wpid_sim - wpid_block))
+
+    # Plot
+    plt.figure()
+    plt.step(t_sim, wpid_sim, '-r', label="w (simulink)", where="post")
+    plt.step(time, wpid, '--b', label="w (manual)", where="post")
+    plt.step(time_block, wpid_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, upid_sim, '-r', label="u (simulink)", where="post")
+    plt.step(time, upid, '--b', label="u (Manual)", where="post")
+    plt.step(time_block, upid_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, rpid_sim, '-r', label="r (simulink)", where="post")
+    plt.step(time, rpid, '--b', label="r (Manual)", where="post")
+    plt.step(time_block, rpid_block, ':g', label="r (block)", where="post")
+    plt.xlabel("Time (s)")
+    plt.legend()
+    plt.grid()
+    plt.title("Reference")
+
+    plt.show()
+
+if __name__ == "__main__":
+    main()

examples/comparison/simulink/pid_backward.py

@@ -0,0 +1,155 @@
+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, DiscreteDerivator
+from pySimBlocks.blocks.controllers import Pid
+
+
+def manual_sim(A, B, C, Kp, Ki, Kd, 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", method="euler backward")
+    kd = Gain("Kd", Kd, multiplication="Matrix (K @ u)")
+    derivator = DiscreteDerivator("derivator")
+    sum = Sum("sum", "+++")
+
+    blocks = [ref, error, kp, integrator, ki, sum, motor, kd, derivator]
+
+    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("error", "out", "Ki", "in")
+    model.connect("error", "out", "Kd", "in")
+    model.connect("Kp", "out", "sum", "in1")
+    model.connect("Ki", "out", "integrator", "in")
+    model.connect("integrator", "out", "sum", "in3")
+    model.connect("Kd", "out", "derivator", "in")
+    model.connect("derivator", "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",
+                    "derivator.outputs.out",
+                    "integrator.outputs.out",
+                    "Kp.outputs.out"
+                ])
+    sim = Simulator(model, sim_cfg, verbose=False)
+    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, Kd, 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, Kd=Kd, integration_method="euler backward")
+
+    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=False)
+    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]])
+    Kd = np.array([[.01]])
+
+    # 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, upid, wpid, rpid = manual_sim(A, B, C, Kp, Ki, Kd, T, dt)
+    time_block, upid_block, wpid_block, rpid_block = block_sim(A, B, C, Kp, Ki, Kd, T, dt)
+
+    # data from simulink
+    data = np.load("simulation.npz")
+    t_sim = data["time"]
+    upid_sim, wpid_sim, rpid_sim = data["upid_backward"], data["wpid_backward"], data['r']
+
+    print("Error simulink - manual: ", np.linalg.norm(wpid_sim - wpid))
+    print("Error simulink - block: ", np.linalg.norm(wpid_sim - wpid_block))
+
+    # Plot
+    plt.figure()
+    plt.step(t_sim, wpid_sim, '-r', label="w (simulink)", where="post")
+    plt.step(time, wpid, '--b', label="w (manual)", where="post")
+    plt.step(time_block, wpid_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, upid_sim, '-r', label="u (simulink)", where="post")
+    plt.step(time, upid, '--b', label="u (Manual)", where="post")
+    plt.step(time_block, upid_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, rpid_sim, '-r', label="r (simulink)", where="post")
+    plt.step(time, rpid, '--b', label="r (Manual)", where="post")
+    plt.step(time_block, rpid_block, ':g', label="r (block)", where="post")
+    plt.xlabel("Time (s)")
+    plt.legend()
+    plt.grid()
+    plt.title("Reference")
+
+    plt.show()
+
+if __name__ == "__main__":
+    main()

examples/quick_start/filter.py

@@ -0,0 +1,35 @@
+from pySimBlocks import Model, Simulator, SimulationConfig, PlotConfig
+from pySimBlocks.blocks.operators import Gain, Sum, Delay
+from pySimBlocks.blocks.sources import WhiteNoise
+from pySimBlocks.project.plot_from_config import plot_from_config
+
+# 1. Create the blocks
+noise = WhiteNoise(name="noise", std=1.0)
+delay = Delay(name="delay")
+filtered = Sum("filtered", signs="++")
+alpha_gain = Gain(name="alpha", gain=0.1)
+complement = Gain(name="complement", gain=0.9)
+
+# 2. Build the model
+model = Model("Example")
+for block in [noise, delay, filtered, alpha_gain, complement]:
+    model.add_block(block)
+
+model.connect("noise", "out", "alpha", "in")
+model.connect("delay", "out", "complement", "in")
+model.connect("alpha", "out", "filtered", "in1")
+model.connect("complement", "out", "filtered", "in2")
+model.connect("filtered", "out", "delay", "in")
+
+# 3. Simulate the model
+sim_cfg = SimulationConfig(dt=0.05, T=30.)
+sim = Simulator(model, sim_cfg)
+logs = sim.run(logging=["noise.outputs.out", "filtered.outputs.out"])
+
+# 4. Plot the results
+plot_cfg = PlotConfig([
+    {"title": "Noisy signal vs Filtered",
+     "signals": ["noise.outputs.out", "filtered.outputs.out"],},
+    ])
+plot_from_config(logs, plot_cfg)
+

examples/quick_start/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/tutorials/tutorial_1_python/main.py

@@ -0,0 +1,99 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+from pySimBlocks import Model, SimulationConfig, Simulator
+from pySimBlocks.blocks.controllers import Pid
+from pySimBlocks.blocks.operators import Sum
+from pySimBlocks.blocks.sources import Step
+from pySimBlocks.blocks.systems import LinearStateSpace
+
+
+def main():
+    """This example demonstrates how to use the pySimBlocks library to create a 
+    simple closed-loop control system with a step reference input, a PI controller, 
+    and a linear state-space system.
+    """
+
+    A = np.array([[0.9]])
+    B = np.array([[0.5]])
+    C = np.array([[1.0]])
+    x0 = np.zeros((A.shape[0], 1))
+
+    Kp = np.array([[0.5]])
+    Ki = np.array([[2.]])
+
+    # -------------------------------------------------------
+    # 1. Create the blocks
+    # -------------------------------------------------------
+    step = Step(
+        name="ref",
+        value_before=np.array([[0.0]]),
+        value_after=np.array([[1.0]]),
+        start_time=0.5
+    )
+    sum = Sum(name="error", signs="+-")
+    pid = Pid(name="PID", controller="PI", Kp=Kp, Ki=Ki)
+    system = LinearStateSpace(name="system", A=A, B=B, C=C, x0=x0)
+
+    # -------------------------------------------------------
+    # 2. Build the model
+    # -------------------------------------------------------
+    model = Model("test")
+    for block in [step, sum, pid, system]:
+        model.add_block(block)
+
+    model.connect("ref", "out", "error", "in1")
+    model.connect("system", "y", "error", "in2")
+    model.connect("error", "out", "PID", "e")
+    model.connect("PID", "u", "system", "u")
+
+    # -------------------------------------------------------
+    # 3. Create the simulator
+    # -------------------------------------------------------
+    dt = 0.01 # seconds
+    T = 5. # seconds
+    sim_cfg = SimulationConfig(dt, T)
+    sim = Simulator(model, sim_cfg, verbose=False)
+
+    # -------------------------------------------------------
+    # 4. Run the simulation with logging
+    # -------------------------------------------------------
+    logs = sim.run(logging=[
+            "ref.outputs.out",
+            "PID.outputs.u",
+            "system.outputs.y"
+        ]
+    )
+
+    # -------------------------------------------------------
+    # 5. Extract logged data
+    # -------------------------------------------------------
+    t = sim.get_data("time")
+    u = sim.get_data("PID.outputs.u").squeeze()
+    r = sim.get_data("ref.outputs.out").squeeze()
+    y = sim.get_data("system.outputs.y").squeeze()
+
+    # -------------------------------------------------------
+    # 6. Plot the result
+    # -------------------------------------------------------
+    fig, axs = plt.subplots(1, 2, sharex=True)
+    axs[0].step(t, r, "--r", label="ref", where="post")
+    axs[0].step(t, y, "--b", label="output", where="post")
+    axs[0].set_xlabel("Time [s]")
+    axs[0].set_ylabel("Amplitude")
+    axs[0].set_title("Closed-loop response")
+    axs[0].grid(True)
+    axs[0].legend()
+
+    axs[1].step(t, u, "--b", label="u[k] (pid output)", where="post")
+    axs[1].set_xlabel("Time [s]")
+    axs[1].set_ylabel("Amplitude")
+    axs[1].set_title("PID controller output")
+    axs[1].grid(True)
+    axs[1].legend()
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

examples/tutorials/tutorial_3_sofa/finger/Finger.py

@@ -0,0 +1,120 @@
+from pathlib import Path
+
+import Sofa
+
+dir_path = Path(__file__).parent.absolute()
+mesh_path = dir_path / "mesh"
+
+
+def createScene(rootNode):
+    from FingerController import FingerController
+
+    # --------------------------------------------------------------------------
+    # Scene setup
+    # --------------------------------------------------------------------------
+    rootNode.addObject("RequiredPlugin", name='SoftRobots')
+    rootNode.addObject("RequiredPlugin", name='SofaPython3')
+    rootNode.addObject('RequiredPlugin', pluginName=[
+                            "Sofa.Component.AnimationLoop",  # Needed to use components FreeMotionAnimationLoop
+                            "Sofa.Component.Constraint.Lagrangian.Correction",  # Needed to use components GenericConstraintCorrection
+                            "Sofa.Component.LinearSolver.Iterative",
+                            "Sofa.Component.Constraint.Lagrangian.Solver",  # Needed to use components GenericConstraintSolver
+                            "Sofa.Component.Engine.Select",  # Needed to use components BoxROI
+                            "Sofa.Component.IO.Mesh",  # Needed to use components MeshSTLLoader, MeshVTKLoader
+                            "Sofa.Component.LinearSolver.Direct",  # Needed to use components SparseLDLSolver
+                            "Sofa.Component.Mass",  # Needed to use components UniformMass
+                            "Sofa.Component.ODESolver.Backward",  # Needed to use components EulerImplicitSolver
+                            "Sofa.Component.Setting",  # Needed to use components BackgroundSetting
+                            "Sofa.Component.SolidMechanics.FEM.Elastic",  # Needed to use components TetrahedronFEMForceField
+                            "Sofa.Component.SolidMechanics.Spring",  # Needed to use components RestShapeSpringsForceField
+                            "Sofa.Component.Topology.Container.Constant",  # Needed to use components MeshTopology
+                            "Sofa.Component.Visual",  # Needed to use components VisualStyle
+                            "Sofa.GL.Component.Rendering3D",  # Needed to use components OglModel, OglSceneFrame
+                            "Sofa.Component.StateContainer",
+                            'Sofa.Component.Mapping.Linear'
+                        ])
+    rootNode.addObject('VisualStyle',
+                       displayFlags='showVisualModels hideBehaviorModels showCollisionModels hideBoundingCollisionModels hideForceFields showInteractionForceFields hideWireframe')
+
+    rootNode.addObject('FreeMotionAnimationLoop')
+    rootNode.addObject('DefaultVisualManagerLoop')
+
+    try: # Compatible with SOFA <= 25.06
+        rootNode.addObject('GenericConstraintSolver', tolerance=1e-5, maxIterations=100)
+    except Exception as e: # Fallback for SOFA >= 25.12 
+        print("GenericConstraintSolver not available, falling back to CGLinearSolver")
+        try:
+            rootNode.addObject('CGLinearSolver', name='solver', iterations=500, tolerance=1e-10, threshold=1e-10)
+            rootNode.addObject('BlockGaussSeidelConstraintSolver', maxIterations=100, tolerance=1e-5)
+        except Exception as e: # Error in both versions
+            print("Error adding CGLinearSolver:", e)
+            raise e
+
+    rootNode.gravity = [0, -9810, 0]
+    rootNode.dt = 0.01
+
+    # --------------------------------------------------------------------------
+    # FEM Model                              
+    # --------------------------------------------------------------------------
+    finger = rootNode.addChild('finger')
+    finger.addObject('EulerImplicitSolver', name='odesolver', rayleighMass=0.1, rayleighStiffness=0.1)
+    finger.addObject('SparseLDLSolver', template='CompressedRowSparseMatrixMat3x3d')
+
+    # Add a component to load a VTK tetrahedral mesh and expose the resulting topology in the scene .
+    finger.addObject('MeshVTKLoader', name='loader', filename=str(mesh_path / "finger.vtk"))
+    finger.addObject('MeshTopology', src='@loader', name='container')
+
+    # Create a MechanicaObject component to stores the DoFs of the model
+    finger.addObject('MechanicalObject', name='tetras', template='Vec3', showIndices=False, showIndicesScale=4e-5)
+
+    finger.addObject('UniformMass', totalMass=0.075)
+    finger.addObject('TetrahedronFEMForceField', template='Vec3', name='FEM', method='large', poissonRatio=0.45,
+                     youngModulus=600)
+    finger.addObject('BoxROI', name='roi', box=[-15, 0, 0, 5, 10, 15], drawBoxes=True)
+    finger.addObject('RestShapeSpringsForceField', points=finger.roi.indices.getLinkPath(), stiffness=1e12)
+    finger.addObject('GenericConstraintCorrection')
+
+    # --------------------------------------------------------------------------
+    # Cable                                  
+    # --------------------------------------------------------------------------
+    cable = finger.addChild('cable')
+    cable.addObject('MechanicalObject',
+                    position=[
+                        [-17.5, 12.5, 2.5],
+                        [-32.5, 12.5, 2.5],
+                        [-47.5, 12.5, 2.5],
+                        [-62.5, 12.5, 2.5],
+                        [-77.5, 12.5, 2.5],
+
+                        [-85.5, 12.5, 6.5],
+                        [-85.5, 12.5, 8.5],
+                        [-83.5, 12.5, 4.5],
+                        [-83.5, 12.5, 10.5],
+
+                        [-77.5, 12.5, 12.5],
+                        [-62.5, 12.5, 12.5],
+                        [-47.5, 12.5, 12.5],
+                        [-32.5, 12.5, 12.5],
+                        [-17.5, 12.5, 12.5]])
+
+    cable.addObject('CableConstraint', name="aCableActuator",
+                    indices=list(range(0, 14)),
+                    minForce=0,  # Set that the cable can't push
+                    pullPoint=[0.0, 12.5, 2.5])
+    cable.addObject('BarycentricMapping')
+
+    # --------------------------------------------------------------------------
+    # Visualization                          
+    # --------------------------------------------------------------------------
+    fingerVisu = finger.addChild('visu')
+    fingerVisu.addObject('MeshSTLLoader', filename=str(mesh_path / "finger.stl"), name="loader")
+    fingerVisu.addObject('OglModel', src="@loader", color=[0.0, 0.7, 0.7, 1])
+    fingerVisu.addObject('BarycentricMapping')
+
+    # --------------------------------------------------------------------------
+    # Controller
+    # --------------------------------------------------------------------------
+    controller = FingerController(rootNode, cable.aCableActuator, finger.tetras)
+    finger.addObject(controller)
+
+    return rootNode, controller

examples/tutorials/tutorial_3_sofa/finger/FingerController.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+
+import numpy as np
+
+from pySimBlocks.blocks.systems.sofa import SofaPysimBlocksController
+
+BASE_DIR = Path(__file__).resolve().parent
+
+
+class FingerController(SofaPysimBlocksController):
+
+    def __init__(self, root, actuator, mo, tip_index=121, name="FingerController"):
+        super().__init__(root, name=name)
+        self.project_yaml = str((BASE_DIR / '../project.yaml').resolve())
+
+        self.mo = mo
+        self.actuator = actuator
+        self.tip_index = tip_index
+        self.dt = root.dt.value
+        self.verbose = False # Set to True to print debug information at each step
+
+        # Inputs & outputs dictionaries
+        self.inputs = { "cable": None }
+        self.outputs = { "tip": None, "measure": None }
+
+
+    def get_outputs(self):
+        tip = self.mo.position[self.tip_index].copy()
+        self.outputs["tip"] = np.asarray(tip).reshape(-1, 1)
+        self.outputs["measure"] = np.asarray(tip[1]).reshape(-1, 1)
+
+    def set_inputs(self):
+        val = self.inputs["cable"]
+        if val is None:
+            raise ValueError("Input 'cable' is not set")
+        val = [val.item()]
+        self.actuator.value = val

pySimBlocks/__init__.py

@@ -0,0 +1,35 @@
+# ******************************************************************************
+#                                  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 importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("pySimBlocks")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+from pySimBlocks.core import Model, Simulator, SimulationConfig, PlotConfig
+
+__all__ = [
+    "Model",
+    "Simulator",
+    "SimulationConfig",
+    "PlotConfig"
+]