[CHANGING][MISC] Disable box-box by default. (#1982)

* Avoid memory allocation if possible.
* Disable box-box by default.
* Reduce max number of collision pairs by default.

Author: duburcqa

genesis/engine/solvers/rigid/constraint_solver_decomp.py

@@ -401,8 +401,9 @@ def constraint_solver_kernel_reset(
             constraint_state.qacc_ws[i_d, i_b] = 0
             for i_c in range(len_constraints):
                 constraint_state.jac[i_c, i_d, i_b] = 0
-        for i_c in range(len_constraints):
-            constraint_state.jac_n_relevant_dofs[i_c, i_b] = 0
+        if ti.static(static_rigid_sim_config.sparse_solve):
+            for i_c in range(len_constraints):
+                constraint_state.jac_n_relevant_dofs[i_c, i_b] = 0
 
 
 @ti.func
@@ -980,8 +981,9 @@ def func_equality_weld(
                 jac_qvel[i_con - n_con] + constraint_state.jac[i_con, i_d, i_b] * dofs_state.vel[i_d, i_b]
             )
 
-    for i_con in range(n_con, n_con + 3):
-        constraint_state.jac_n_relevant_dofs[i_con, i_b] = con_n_relevant_dofs
+    if ti.static(static_rigid_sim_config.sparse_solve):
+        for i_con in range(n_con, n_con + 3):
+            constraint_state.jac_n_relevant_dofs[i_con, i_b] = con_n_relevant_dofs
 
     for i_con in range(n_con, n_con + 3):
         imp, aref = gu.imp_aref(sol_params, -pos_imp, jac_qvel[i_con - n_con], rot_error[i_con - n_con])

genesis/options/solvers.py

@@ -363,7 +363,7 @@ class RigidOptions(Options):
     enable_self_collision: bool = True
     enable_adjacent_collision: bool = False
     disable_constraint: bool = False
-    max_collision_pairs: int = 300
+    max_collision_pairs: int = 200
     multiplier_collision_broad_phase: int = 8
     integrator: gs.integrator = gs.integrator.approximate_implicitfast
     IK_max_targets: int = 6
@@ -385,7 +385,7 @@ class RigidOptions(Options):
     contact_resolve_time: Optional[float] = None
     constraint_timeconst: float = 0.01
     use_contact_island: bool = False
-    box_box_detection: Optional[bool] = None
+    box_box_detection: bool = False
 
     # hibernation threshold
     use_hibernation: bool = False

genesis/utils/array_class.py

@@ -232,8 +232,8 @@ def get_constraint_state(constraint_solver, solver):
 
     efc_AR_shape = maybe_shape((len_constraints_, len_constraints_, _B), solver._options.noslip_iterations > 0)
     efc_b_shape = maybe_shape((len_constraints_, _B), solver._options.noslip_iterations > 0)
-    jac_relevant_dofs_shape = (len_constraints_, solver.n_dofs_, _B)
-    jac_n_relevant_dofs_shape = (len_constraints_, _B)
+    jac_relevant_dofs_shape = maybe_shape((len_constraints_, solver.n_dofs_, _B), constraint_solver.sparse_solve)
+    jac_n_relevant_dofs_shape = maybe_shape((len_constraints_, _B), constraint_solver.sparse_solve)
 
     return StructConstraintState(
         n_constraints=V(dtype=gs.ti_int, shape=(_B,)),
@@ -513,6 +513,19 @@ def get_collider_state(
     max_contact_pairs = max_collision_pairs * collider_static_config.n_contacts_per_pair
     requires_grad = static_rigid_sim_config.requires_grad
 
+    box_depth_shape = maybe_shape(
+        (collider_static_config.n_contacts_per_pair, _B), static_rigid_sim_config.box_box_detection
+    )
+    box_points_shape = maybe_shape(
+        (collider_static_config.n_contacts_per_pair, _B), static_rigid_sim_config.box_box_detection
+    )
+    box_pts_shape = maybe_shape((6, _B), static_rigid_sim_config.box_box_detection)
+    box_lines_shape = maybe_shape((4, _B), static_rigid_sim_config.box_box_detection)
+    box_linesu_shape = maybe_shape((4, _B), static_rigid_sim_config.box_box_detection)
+    box_axi_shape = maybe_shape((3, _B), static_rigid_sim_config.box_box_detection)
+    box_ppts2_shape = maybe_shape((4, 2, _B), static_rigid_sim_config.box_box_detection)
+    box_pu_shape = maybe_shape((4, _B), static_rigid_sim_config.box_box_detection)
+
     return StructColliderState(
         sort_buffer=get_sort_buffer(solver),
         contact_data=get_contact_data(solver, max_contact_pairs, requires_grad),
@@ -521,14 +534,14 @@ def get_collider_state(
         broad_collision_pairs=V_VEC(2, dtype=gs.ti_int, shape=(max(max_collision_pairs_broad, 1), _B)),
         active_buffer_awake=V(dtype=gs.ti_int, shape=(n_geoms, _B)),
         active_buffer_hib=V(dtype=gs.ti_int, shape=(n_geoms, _B)),
-        box_depth=V(dtype=gs.ti_float, shape=(collider_static_config.n_contacts_per_pair, _B)),
-        box_points=V_VEC(3, dtype=gs.ti_float, shape=(collider_static_config.n_contacts_per_pair, _B)),
-        box_pts=V_VEC(3, dtype=gs.ti_float, shape=(6, _B)),
-        box_lines=V_VEC(6, dtype=gs.ti_float, shape=(4, _B)),
-        box_linesu=V_VEC(6, dtype=gs.ti_float, shape=(4, _B)),
-        box_axi=V_VEC(3, dtype=gs.ti_float, shape=(3, _B)),
-        box_ppts2=V(dtype=gs.ti_float, shape=(4, 2, _B)),
-        box_pu=V_VEC(3, dtype=gs.ti_float, shape=(4, _B)),
+        box_depth=V(dtype=gs.ti_float, shape=box_depth_shape),
+        box_points=V_VEC(3, dtype=gs.ti_float, shape=box_points_shape),
+        box_pts=V_VEC(3, dtype=gs.ti_float, shape=box_pts_shape),
+        box_lines=V_VEC(6, dtype=gs.ti_float, shape=box_lines_shape),
+        box_linesu=V_VEC(6, dtype=gs.ti_float, shape=box_linesu_shape),
+        box_axi=V_VEC(3, dtype=gs.ti_float, shape=box_axi_shape),
+        box_ppts2=V(dtype=gs.ti_float, shape=box_ppts2_shape),
+        box_pu=V_VEC(3, dtype=gs.ti_float, shape=box_pu_shape),
         xyz_max_min=V(dtype=gs.ti_float, shape=(6, _B)),
         prism=V_VEC(3, dtype=gs.ti_float, shape=(6, _B)),
         n_contacts=V(dtype=gs.ti_int, shape=(_B,)),

tests/test_gstaichi.py

@@ -185,7 +185,7 @@ def test_static(
         env = dict(os.environ)
         env.update(env_changes)
 
-        proc = subprocess.run(cmd_line, capture_output=True, text=True, env=env, cwd=MODULE_ROOT_DIR)
+        proc = subprocess.run(cmd_line, capture_output=True, text=True, encoding="utf-8", env=env, cwd=MODULE_ROOT_DIR)
         if proc.returncode == RET_SKIP:
             pytest.skip(proc.stderr)
         elif proc.returncode != RET_SUCCESS:
@@ -277,7 +277,7 @@ def test_num_envs(use_ndarray: bool, enable_pure: bool, test_backend: str, tmp_p
             cmd_line += ["--expected-use-src-ll-cache"]
         if expected_src_ll_cache_hit:
             cmd_line += ["--expected-src-ll-cache-hit"]
-        proc = subprocess.run(cmd_line, capture_output=True, text=True, env=env, cwd=MODULE_ROOT_DIR)
+        proc = subprocess.run(cmd_line, capture_output=True, text=True, encoding="utf-8", env=env, cwd=MODULE_ROOT_DIR)
         if proc.returncode == RET_SKIP:
             pytest.skip(proc.stderr)
         elif proc.returncode != RET_SUCCESS:
@@ -380,7 +380,7 @@ def test_ndarray_no_compile(
         env["GS_ENABLE_NDARRAY"] = "1"
         env["TI_OFFLINE_CACHE"] = "1"
         env["TI_OFFLINE_CACHE_FILE_PATH"] = str(tmp_path)
-        proc = subprocess.run(cmd_line, capture_output=True, text=True, env=env, cwd=MODULE_ROOT_DIR)
+        proc = subprocess.run(cmd_line, capture_output=True, text=True, encoding="utf-8", env=env, cwd=MODULE_ROOT_DIR)
 
         # Display error message only in case of failure
         if proc.returncode == RET_SKIP:

tests/test_rigid_physics.py

@@ -3167,13 +3167,15 @@ def test_mesh_primitive_COM(show_viewer, tol):
 
 @pytest.mark.required
 @pytest.mark.parametrize("scale", [0.1, 10.0])
+@pytest.mark.parametrize("box_box_detection", [False, True])
 @pytest.mark.parametrize("backend", [gs.cpu, gs.gpu])
-def test_noslip_iterations(scale, show_viewer, tol):
+def test_noslip_iterations(scale, box_box_detection, show_viewer, tol):
     scene = gs.Scene(
         sim_options=gs.options.SimOptions(
             dt=0.01,
         ),
         rigid_options=gs.options.RigidOptions(
+            box_box_detection=box_box_detection,
             noslip_iterations=5,
         ),
         viewer_options=gs.options.ViewerOptions(
@@ -3186,21 +3188,19 @@ def test_noslip_iterations(scale, show_viewer, tol):
         show_viewer=show_viewer,
     )
 
-    boxes = []
     for i in range(3):
-        boxes.append(
-            scene.add_entity(
-                gs.morphs.Box(
-                    size=(scale, scale, scale),
-                    pos=(i * scale, 0, 0),
-                    fixed=(i == 0),
-                ),
-                surface=gs.surfaces.Default(
-                    color=(*np.random.rand(3), 0.7),
-                ),
-                visualize_contact=True,
-            )
+        scene.add_entity(
+            gs.morphs.Box(
+                size=(scale, scale, scale),
+                pos=(i * (1 - (not box_box_detection) * 1e-3) * scale, 0, 0),
+                fixed=(i == 0),
+            ),
+            surface=gs.surfaces.Default(
+                color=(*np.random.rand(3), 1.0 if i != 1 else 0.7),
+            ),
+            visualize_contact=True,
         )
+    box_1, box_2 = scene.entities[1:]
     scene.build()
 
     rho = 200
@@ -3211,24 +3211,24 @@ def test_noslip_iterations(scale, show_viewer, tol):
     safety = 2.5
 
     # simulate for 20 seconds
-    for i in range(2000):
-        boxes[2].control_dofs_force(np.array([-safety / coeff_f * n_box * rho * scale**3 * g]), np.array([0]))
+    for _ in range(2000):
+        # push to -x direction
+        box_2.control_dofs_force([-safety / coeff_f * n_box * rho * scale**3 * g], [0])
         scene.step()
 
-    box_1_z = tensor_to_array(boxes[1].get_qpos())[2]
     # allow some small sliding due to first few frames
     # scale = 0.1 is less stable than bigger scale
+    _, _, box_1_z = box_1.get_pos()
     assert_allclose(box_1_z, 0.0, atol=4e-2 * scale)
 
     # reduce the multiplier and it will slide
     safety = 0.9
-    for i in range(2000):
-        # push to -x direction
-        boxes[2].control_dofs_force(np.array([-safety / coeff_f * n_box * rho * scale**3 * g]), np.array([0]))
+    for _ in range(300):
+        box_2.control_dofs_force([-safety / coeff_f * n_box * rho * scale**3 * g], [0])
         scene.step()
 
-    box_1_z = tensor_to_array(boxes[1].get_qpos())[2]
     # it will slip away
+    _, _, box_1_z = box_1.get_pos()
     assert box_1_z < -scale