fix effort limit overwritten bug

Author: JuanaDd

source/isaaclab/isaaclab/actuators/actuator_base.py

@@ -159,10 +159,7 @@ def __init__(
         self.joint_property_resolution_table: dict[str, list] = {}
         # For explicit models, we do not want to enforce the effort limit through the solver
         # (unless it is explicitly set)
-        effort_limit_is_finite = (
-            effort_limit != torch.inf if isinstance(effort_limit, float) else torch.all(effort_limit != torch.inf)
-        )
-        if not self.is_implicit_model and self.cfg.effort_limit_sim is None and (not effort_limit_is_finite):
+        if not self.is_implicit_model and self.cfg.effort_limit_sim is None:
             self.cfg.effort_limit_sim = self._DEFAULT_MAX_EFFORT_SIM
 
         # resolve usd, actuator configuration values
@@ -184,8 +181,6 @@ def __init__(
             cfg_val = getattr(self.cfg, param_name)
             setattr(self, param_name, self._parse_joint_parameter(cfg_val, usd_val))
             new_val = getattr(self, param_name)
-            if param_name == "effort_limit_sim" or param_name == "effort_limit":
-                print(f"effort_limit_sim: {new_val}, usd_val: {usd_val}, cfg_val: {cfg_val}")
 
             allclose = (
                 torch.all(new_val == usd_val) if isinstance(usd_val, (float, int)) else torch.allclose(new_val, usd_val)
@@ -201,9 +196,9 @@ def __init__(
                 )
 
         self.velocity_limit = self._parse_joint_parameter(self.cfg.velocity_limit, self.velocity_limit_sim)
-        self.effort_limit = self._parse_joint_parameter(self.cfg.effort_limit, self.effort_limit_sim)
-
-        print(f"after: {self.effort_limit},  {self.effort_limit_sim}, cfg_val: {self.cfg.effort_limit}")
+        # For effort_limit, use the tensor passed to constructor if cfg.effort_limit is None
+        effort_default = self.effort_limit_sim if self.cfg.effort_limit is not None else effort_limit
+        self.effort_limit = self._parse_joint_parameter(self.cfg.effort_limit, effort_default)
 
         # create commands buffers for allocation
         self.computed_effort = torch.zeros(self._num_envs, self.num_joints, device=self._device)

source/isaaclab/isaaclab/assets/articulation/articulation.py

@@ -1681,7 +1681,7 @@ def _process_actuators_cfg(self):
                 friction=self._data.default_joint_friction_coeff[:, joint_ids],
                 dynamic_friction=self._data.default_joint_dynamic_friction_coeff[:, joint_ids],
                 viscous_friction=self._data.default_joint_viscous_friction_coeff[:, joint_ids],
-                effort_limit=self._data.joint_effort_limits[:, joint_ids],
+                effort_limit=self._data.joint_effort_limits[:, joint_ids].clone(),
                 velocity_limit=self._data.joint_vel_limits[:, joint_ids],
             )
             # log information on actuator groups
@@ -1811,6 +1811,7 @@ def _apply_actuator_model(self):
         """
         # process actions per group
         for actuator in self.actuators.values():
+
             # prepare input for actuator model based on cached data
             # TODO : A tensor dict would be nice to do the indexing of all tensors together
             control_action = ArticulationActions(

source/isaaclab/test/assets/test_articulation.py

@@ -1372,10 +1372,16 @@ def test_setting_velocity_limit_explicit(sim, num_articulations, device, vel_lim
 @pytest.mark.parametrize("num_articulations", [1, 2])
 @pytest.mark.parametrize("device", ["cuda:0", "cpu"])
 @pytest.mark.parametrize("effort_limit_sim", [1e5, None])
-@pytest.mark.parametrize("effort_limit", [1e2, None])
+@pytest.mark.parametrize("effort_limit", [1e2, 80.0, None])
 @pytest.mark.isaacsim_ci
 def test_setting_effort_limit_implicit(sim, num_articulations, device, effort_limit_sim, effort_limit):
-    """Test setting of the effort limit for implicit actuators."""
+    """Test setting of effort limit for implicit actuators.
+
+    This test verifies the effort limit resolution logic for actuator models implemented in :class:`ActuatorBase`:
+    - Case 1: If USD value == actuator config value: values match correctly
+    - Case 2: If USD value != actuator config value: actuator config value is used
+    - Case 3: If actuator config value is None: USD value is used as default
+    """
     articulation_cfg = generate_articulation_cfg(
         articulation_type="single_joint_implicit",
         effort_limit_sim=effort_limit_sim,
@@ -1419,10 +1425,18 @@ def test_setting_effort_limit_implicit(sim, num_articulations, device, effort_li
 @pytest.mark.parametrize("num_articulations", [1, 2])
 @pytest.mark.parametrize("device", ["cuda:0", "cpu"])
 @pytest.mark.parametrize("effort_limit_sim", [1e5, None])
-@pytest.mark.parametrize("effort_limit", [1e2, None])
+@pytest.mark.parametrize("effort_limit", [80.0, 1e2, None])
 @pytest.mark.isaacsim_ci
 def test_setting_effort_limit_explicit(sim, num_articulations, device, effort_limit_sim, effort_limit):
-    """Test setting of effort limit for explicit actuators."""
+    """Test setting of effort limit for explicit actuators.
+
+    This test verifies the effort limit resolution logic for actuator models implemented in :class:`ActuatorBase`:
+    - Case 1: If USD value == actuator config value: values match correctly
+    - Case 2: If USD value != actuator config value: actuator config value is used
+    - Case 3: If actuator config value is None: USD value is used as default
+
+    """
+
     articulation_cfg = generate_articulation_cfg(
         articulation_type="single_joint_explicit",
         effort_limit_sim=effort_limit_sim,
@@ -1436,6 +1450,9 @@ def test_setting_effort_limit_explicit(sim, num_articulations, device, effort_li
     # Play sim
     sim.reset()
 
+    # usd default is 80
+    usd_default = 80.0
+
     # collect limit init values
     physx_effort_limit = articulation.root_physx_view.get_dof_max_forces().to(device)
     actuator_effort_limit = articulation.actuators["joint"].effort_limit
@@ -1452,8 +1469,9 @@ def test_setting_effort_limit_explicit(sim, num_articulations, device, effort_li
         # check physx effort limit does not match the one explicit actuator has
         assert not (torch.allclose(actuator_effort_limit, physx_effort_limit))
     else:
-        # check actuator effort_limit is the same as the PhysX default
-        torch.testing.assert_close(actuator_effort_limit, physx_effort_limit)
+        # When effort_limit is None, actuator should use USD default values
+        expected_actuator_effort_limit = torch.full_like(physx_effort_limit, usd_default)
+        torch.testing.assert_close(actuator_effort_limit, expected_actuator_effort_limit)
 
     # when using explicit actuators, the limits are set to high unless user overrides
     if effort_limit_sim is not None:
@@ -1462,6 +1480,7 @@ def test_setting_effort_limit_explicit(sim, num_articulations, device, effort_li
         limit = ActuatorBase._DEFAULT_MAX_EFFORT_SIM  # type: ignore
     # check physx internal value matches the expected sim value
     expected_effort_limit = torch.full_like(physx_effort_limit, limit)
+    torch.testing.assert_close(actuator_effort_limit_sim, expected_effort_limit)
     torch.testing.assert_close(physx_effort_limit, expected_effort_limit)