Remove some comments, function renames to reflect original names

Author: gasnica

genesis/engine/simulator.py

@@ -103,9 +103,9 @@ def __init__(
         self._dt: float = options.dt
         self._substep_dt: float = options.dt / options.substeps
         self._substeps: int = options.substeps
-        self._substeps_local: int | None = options.substeps_local  # todo change it ? None -> zero
+        self._substeps_local: int | None = options.substeps_local
         self._requires_grad: bool = options.requires_grad
-        self._steps_local: int | None = options._steps_local  # todo change it ? None -> zero
+        self._steps_local: int | None = options._steps_local
 
         self._cur_substep_global = 0
         self._gravity = np.array(options.gravity, dtype=gs.np_float)

genesis/engine/solvers/rigid/collider_decomp.py

@@ -272,7 +272,6 @@ def reset(self, envs_idx: npt.NDArray[np.int32] | None = None) -> None:
         )
         self._contacts_info_cache = {}
 
-    # ?? only used with hibernation ??
     def clear(self, envs_idx=None):
         if envs_idx is None:
             envs_idx = self._solver._scene._envs_idx

genesis/engine/solvers/rigid/contact_island.py

@@ -79,7 +79,6 @@ def __init__(self, collider: "Collider"):
 
         # num all collision edges in world
         self.n_edges = ti.field(dtype=gs.ti_int, shape=self.solver._B)
-
         self.n_islands = ti.field(dtype=gs.ti_int, shape=self.solver._B)
         self.n_stack = ti.field(dtype=gs.ti_int, shape=self.solver._B)
 
@@ -95,7 +94,7 @@ def __init__(self, collider: "Collider"):
         self.entity_idx_to_next_entity_idx_in_hibernated_island.fill(INVALID_NEXT_HIBERNATED_ENTITY_IDX)
 
     @ti.kernel
-    def clear_island_mapping(self):
+    def clear__island_mapping(self):
         ti.loop_config(serialize=self.solver._para_level < gs.PARA_LEVEL.ALL)
         for i_e, i_b in ti.ndrange(self.solver.n_entities, self.solver._B):
             self.entity_edge[i_e, i_b].n = 0
@@ -127,7 +126,7 @@ def add_edge(self, link_a, link_b, i_b):
         self.n_edges[i_b] = n_edge + 1
 
     @ti.kernel
-    def add_all_contact_edges(self):
+    def add_island__all_contact_edges(self):
         ti.loop_config(serialize=self.solver._para_level < gs.PARA_LEVEL.ALL)
         for i_b in range(self.solver._B):
             for i_col in range(self.collider._collider_state.n_contacts[i_b]):
@@ -137,7 +136,7 @@ def add_all_contact_edges(self):
                 self.add_edge(link_a, link_b, i_b)
 
     @ti.kernel
-    def add_all_hibernated_island_edges(self):
+    def add_island__all_hibernated_island_edges(self):
         _B = self.solver._B
         n_entities = self.solver.n_entities
         ti.loop_config(serialize=self.solver._para_level < gs.PARA_LEVEL.ALL)
@@ -155,9 +154,9 @@ def add_all_hibernated_island_edges(self):
                     self.add_edge(any_link_a, any_link_b, i_b)
 
     def construct(self):
-        self.clear_island_mapping()
-        self.add_all_contact_edges()
-        self.add_all_hibernated_island_edges()
+        self.clear__island_mapping()
+        self.add_island__all_contact_edges()
+        self.add_island__all_hibernated_island_edges()
         self.preprocess_island__map_entities_to_edges()
         self.construct_islands()
         self.postprocess_island__assign_contact_data_to_temp_islands()

genesis/engine/solvers/rigid/rigid_solver_decomp.py

@@ -921,7 +921,9 @@ def _init_constraint_solver(self):
     def substep(self):
         # from genesis.utils.tools import create_timer
 
-
+        # Note: ContactIsland param is needed when supporting hibernation. But the attribute does not exist
+        # in the solver when hibernation is disabled. In that case, we create a dummy ContactIsland object
+        # needed for compilation, but not being used in the kernel.
         if not hasattr(self, "optional_contact_island"):
             if hasattr(self, "constraint_solver") and hasattr(self.constraint_solver, "contact_island"):
                 self.optional_contact_island = self.constraint_solver.contact_island
@@ -961,9 +963,6 @@ def substep(self):
             collider_state=self.collider._collider_state,
             rigid_global_info=self._rigid_global_info,
             static_rigid_sim_config=self._static_rigid_sim_config,
-            # contact_island=getattr(self.constraint_solver, "contact_island", None),
-
-            # xxx: enable this and get things compiling
             contact_island=self.optional_contact_island,
         )
         # timer.stamp("kernel_step_2")
@@ -4043,7 +4042,7 @@ def kernel_step_2(
     )
 
     if ti.static(static_rigid_sim_config.use_hibernation):
-        func_for_all_awake_islands_either_hiberanate_or_update_aabb_sort_buffer(
+        func_hibernate__for_all_awake_islands_either_hiberanate_or_update_aabb_sort_buffer(
             dofs_state=dofs_state,
             entities_state=entities_state,
             entities_info=entities_info,
@@ -4924,7 +4923,7 @@ def kernel_update_vgeoms(
 
 
 @ti.func
-def func_for_all_awake_islands_either_hiberanate_or_update_aabb_sort_buffer(
+def func_hibernate__for_all_awake_islands_either_hiberanate_or_update_aabb_sort_buffer(
     dofs_state: array_class.DofsState,
     entities_state: array_class.EntitiesState,
     entities_info: array_class.EntitiesInfo,
@@ -4938,10 +4937,7 @@ def func_for_all_awake_islands_either_hiberanate_or_update_aabb_sort_buffer(
 
     n_entities = entities_state.hibernated.shape[0]
     _B = entities_state.hibernated.shape[1]
-
     ci = contact_island
-    # entity_ref_range_from_island_idx = ci.island_entity
-    # entity_idx_from_entity_ref = ci.entity_id
 
     ti.loop_config(serialize=static_rigid_sim_config.para_level < gs.PARA_LEVEL.PARTIAL)
     for i_b in range(_B):
@@ -4962,7 +4958,7 @@ def func_for_all_awake_islands_either_hiberanate_or_update_aabb_sort_buffer(
                     is_entity_fixed = entities_info.n_dofs[entity_idx] == 0
                     Debug.assertf(0x7ad00005, not is_entity_fixed)  # Fixed entity should not belong to an island
 
-                    # we can ignore entitiy_hibernated flag -> cos it implies dofs_state.vel/acc are zero
+                    # Hibernated entities already have zero dofs_state.acc/vel
                     is_entity_hibernated = entities_state.hibernated[entity_idx, i_b]
                     if is_entity_hibernated:
                         continue
@@ -5666,23 +5662,14 @@ def func_integrate(
                 i_l = rigid_global_info.awake_links[i_l_, i_b]
                 I_l = [i_l, i_b] if ti.static(static_rigid_sim_config.batch_links_info) else i_l
 
-
-                # why not links_info.dof_start, q_start, q_end ? 
                 for i_j in range(links_info.joint_start[I_l], links_info.joint_end[I_l]):
                     I_j = [i_j, i_b] if ti.static(static_rigid_sim_config.batch_joints_info) else i_j
                     dof_start = joints_info.dof_start[I_j]
                     q_start = joints_info.q_start[I_j]
                     q_end = joints_info.q_end[I_j]
 
-                # can we just do that ? 
-                # if True:
-                #     dof_start = links_info.dof_start[I_l]
-                #     q_start = links_info.q_start[I_l]
-                #     q_end = links_info.q_end[I_l]
-
                     joint_type = joints_info.type[I_j]
 
-                    # TODO: consider copying from no-hibernation version below
                     if joint_type == gs.JOINT_TYPE.FREE:
                         rot = ti.Vector(
                             [

genesis/engine/solvers/rigid/rigid_solver_decomp_util.py

@@ -77,4 +77,3 @@ def func_wakeup_entity_and_its_temp_island(
         validate_entity_hibernation_state_for_all_entities_in_temp_island( \
             island_idx, i_b, entities_state, contact_island, expected_hibernation_state=False)
         validate_next_hibernated_entity_indices_in_entire_scene(i_b, entities_state, contact_island)
-        

genesis/engine/solvers/rigid/rigid_validate.py

@@ -62,4 +62,4 @@ def validate_next_hibernated_entity_indices_in_entire_scene(
             Debug.assertf(0x7ad00027, entities_state.hibernated[i_e, i_b] == True)
         else:
             Debug.assertf(0x7ad00024, next_entity_idx == INVALID_NEXT_HIBERNATED_ENTITY_IDX)
-            Debug.assertf(0x7ad00026, entities_state.hibernated[i_e, i_b] == False)
+            Debug.assertf(0x7ad00026, entities_state.hibernated[i_e, i_b] == False)