Merge branch 'ipc-coupling-squashed' into Roushelfy/ipc-coupling-squashed

Author: Roushelfy

RELEASE.md

@@ -1,5 +1,31 @@
 # Genesis Release Note
 
+## 0.3.7
+
+The performance of GsTaichi dynamic array mode has been greatly improved. Now it should be on par with fixed-size array mode (aka performance mode) for very large batch sizes, and up to 30% slower for non-batched simulations. This mode is still considered experimental and must be enabled manually by setting the env var 'GS_ENABLE_NDARRAY=1'. Just try it if you are tired of endlessly waiting for the simulation to compile!
+
+### New Features
+
+* Implement position-velocity controller. (@matthieuvigne) (#1948)
+
+### Bug Fixes
+
+* Fix missing option `diffuse_texture` to `Glass` surface. (@Kashu7100) (#1934)
+* Fix interactive viewer. (@YilingQiao) (#1931)
+* Fix external coupling forces from other solvers not affecting rigid bodies. (@SonSang) (#1941)
+* Fix silent process killing issue in MPM simulation by raising an exception. (@SonSang) (#1949)
+* Fix 'discrete_obstacles_terrain' being completely flat. (@jgillick) (#1972)
+
+### Miscellaneous
+
+* Added warning message about stable timestep for SPH solver. (@SonSang) (#1925)
+* Reduce memory usage due to diff constraint solver. (@YilingQiao) (#1930)
+* Faster non-batched simulation. (@duburcqa) (#1935)
+* Fix or silent dev warnings. (@duburcqa) (#1944)
+* Add caching to Rigid Link state getters to improve performance. (@duburcqa) (#1940, #1955)
+* Add support of Linux ARM. (@duburcqa) (#1961)
+* Add 'GS_PARA_LEVEL' env var to force kernel parallelization level. (@duburcqa) (#1968)
+
 ## 0.3.6
 
 A new experimental interface with the Incremental Potential Contact coupling solver [libuipc](https://github.com/spiriMirror/libuipc) has been introduced, mainly targeting cloth simulation.

examples/IPC_Solver/ipc_arm_cloth.py

@@ -110,8 +110,9 @@ def build_scene(use_ipc=False, show_viewer=False, enable_ipc_gui=False):
             euler=(0, 0, 0),
         ),
     )
-    scene.sim.coupler.set_ipc_link_filter(
+    scene.sim.coupler.set_link_ipc_coupling_type(
         entity=entities["robot"],
+        coupling_type="both",
         link_names=["left_finger", "right_finger"],
     )
 

examples/IPC_Solver/ipc_grasp.py

@@ -47,8 +47,9 @@ def main():
     )
 
     if args.ipc:
-        scene.sim.coupler.set_ipc_link_filter(
+        scene.sim.coupler.set_link_ipc_coupling_type(
             entity=franka,
+            coupling_type="both",
             link_names=["left_finger", "right_finger"],
         )
 

examples/rigid/control_mesh.py

@@ -1,7 +1,5 @@
 import argparse
 
-import numpy as np
-
 import genesis as gs
 
 
@@ -45,17 +43,13 @@ def main():
     scene.build()
 
     dofs_idx = duck.base_joint.dofs_idx
+    duck.set_dofs_kp((0.3,) * 6, dofs_idx)
+    duck.set_dofs_kv((1.0,) * 6, dofs_idx)
 
-    duck.set_dofs_kv(
-        np.array([1, 1, 1, 1, 1, 1]) * 50.0,
-        dofs_idx,
-    )
     pos = duck.get_dofs_position()
     pos[-1] = 1.0  # rotate around intrinsic z axis
-    duck.control_dofs_position(
-        pos,
-        dofs_idx,
-    )
+    duck.control_dofs_position(pos, dofs_idx)
+
     for i in range(1000):
         scene.step()
 

examples/tutorials/position_control_comparison.py

@@ -0,0 +1,129 @@
+# This example compares the position control accuracy between 'control_dofs_position' and
+# 'control_dofs_position_velocity' when tracking a dynamic trajectory.
+# While both are equivalent in static, the former lacks the target velocity term of  true PD controller in robotics,
+# making it underperform compared to 'control_dofs_position_velocity'.
+import argparse
+import math
+
+import matplotlib.pyplot as plt
+
+import genesis as gs
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-v", "--vis", action="store_true", default=False)
+    parser.add_argument("-c", "--cpu", action="store_true", default=False)
+    args = parser.parse_args()
+
+    ########################## init ##########################
+    gs.init(backend=gs.cpu if args.cpu else gs.gpu)
+
+    ########################## create a scene ##########################
+    scene = gs.Scene(
+        viewer_options=gs.options.ViewerOptions(
+            camera_pos=(0, -3.5, 2.5),
+            camera_lookat=(0.0, 0.0, 0.5),
+            camera_fov=30,
+            max_FPS=None,
+        ),
+        sim_options=gs.options.SimOptions(
+            dt=0.005,
+        ),
+        show_viewer=False,
+        show_FPS=True,
+    )
+
+    ########################## entities ##########################
+    plane = scene.add_entity(
+        gs.morphs.Plane(),
+    )
+    franka = scene.add_entity(
+        gs.morphs.MJCF(
+            file="xml/franka_emika_panda/panda.xml",
+        ),
+    )
+    ########################## build ##########################
+    scene.build()
+
+    joints_name = (
+        "joint1",
+        "joint2",
+        "joint3",
+        "joint4",
+        "joint5",
+        "joint6",
+        "joint7",
+        "finger_joint1",
+        "finger_joint2",
+    )
+    motors_dof_idx = [franka.get_joint(name).dofs_idx_local[0] for name in joints_name]
+
+    ############ Optional: set control gains ############
+    # set positional gains
+    franka.set_dofs_kp(
+        kp=[4500, 4500, 3500, 3500, 2000, 2000, 2000, 100, 100],
+        dofs_idx_local=motors_dof_idx,
+    )
+    # set velocity gains
+    franka.set_dofs_kv(
+        kv=[450, 450, 350, 350, 200, 200, 200, 10, 10],
+        dofs_idx_local=motors_dof_idx,
+    )
+    # set force range for safety
+    franka.set_dofs_force_range(
+        lower=[-87, -87, -87, -87, -12, -12, -12, -100, -100],
+        upper=[87, 87, 87, 87, 12, 12, 12, 100, 100],
+        dofs_idx_local=motors_dof_idx,
+    )
+    # Hard reset
+    # Follow a sinusoid trajectory
+    A = 0.5  # motion amplitude, rad
+    f = 1.0  # motion frequency, Hz
+
+    # Use control_dofs_position
+    pos_simulation_result = []
+    franka.set_dofs_position([A, 0, 0, 0, 0, 0, 0, 0, 0], motors_dof_idx)
+    t0 = scene.t
+    while (t := (scene.t - t0) * scene.dt) < 2.0:
+        target_position = A * (1 + math.sin(2 * math.pi * f * t))
+
+        current_position = float(franka.get_qpos()[0])
+        pos_simulation_result.append([t, current_position, target_position])
+        franka.control_dofs_position([target_position, 0, 0, 0, 0, 0, 0, 0, 0], motors_dof_idx)
+        scene.step()
+
+    # Use control_dofs_position_velocity
+    pos_vel_simulation_result = []
+    franka.set_dofs_position([A, 0, 0, 0, 0, 0, 0, 0, 0], motors_dof_idx)
+    t0 = scene.t
+    while (t := (scene.t - t0) * scene.dt) < 2.0:
+        target_position = A * (1 + math.sin(2 * math.pi * f * t))
+        target_velocity = 2 * math.pi * f * A * math.cos(2 * math.pi * f * t)
+
+        current_position = float(franka.get_qpos()[0])
+        pos_vel_simulation_result.append([t, current_position, target_position])
+        franka.control_dofs_position_velocity(
+            [target_position, 0, 0, 0, 0, 0, 0, 0, 0],
+            [target_velocity, 0, 0, 0, 0, 0, 0, 0, 0],
+            motors_dof_idx,
+        )
+        scene.step()
+
+    # Plot results
+    pos_simulation_result = tuple(zip(*pos_simulation_result))
+    pos_vel_simulation_result = tuple(zip(*pos_vel_simulation_result))
+
+    plt.plot(pos_simulation_result[0], pos_simulation_result[1], label="control_dofs_position")
+    plt.plot(pos_vel_simulation_result[0], pos_vel_simulation_result[1], label="control_dofs_position_velocity")
+    plt.plot(pos_vel_simulation_result[0], pos_vel_simulation_result[2], color="black", label="Target position")
+    plt.xlabel("Time (s)")
+    plt.ylabel("Joint position (rad)")
+    plt.title("Comparison of joint position tracking with two different controllers")
+    plt.grid()
+    plt.legend()
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

genesis/__init__.py

@@ -118,8 +118,7 @@ def init(
 
     # Configure GsTaichi fast cache and array type
     global use_ndarray, use_fastcache
-    # is_ndarray_disabled = (os.environ.get("GS_ENABLE_NDARRAY") or ("0" if sys.platform == "darwin" else "1")) == "0"
-    is_ndarray_disabled = os.environ.get("GS_ENABLE_NDARRAY", "0") == "0"
+    is_ndarray_disabled = (os.environ.get("GS_ENABLE_NDARRAY") or ("0" if sys.platform == "darwin" else "1")) == "0"
     if use_ndarray is None:
         _use_ndarray = not (is_ndarray_disabled or performance_mode)
     else: