How to Measure Robot Velocity During Evaluation in Isaac Sim Using SKRL?

[amirhnourian]

Hi everyone,

I'm working with IsaacLab 2.1 and Isaac Sim to implement deep reinforcement learning using the Leatherback environment tutorial. I'm currently using SKRL as my training library.

I'd like to know:
What is the best way to measure the robot's velocity during the evaluation phase?
Specifically:

How can I track the robot's velocity at each timestep?

How can I compute the average velocity over the course of the entire evaluation episode?

Any examples or pointers to relevant APIs in Isaac Sim would be greatly appreciated. Thank you!

[RandomOakForest]

Thank you for starting this discussion. The following summary is still under review but you may find it helpful. To measure and track the robot's velocity during the evaluation phase, you can leverage IsaacLab's direct access to simulation data structures and APIs. Here’s how you can accomplish both per-timestep velocity tracking and average velocity calculation over an episode:

1. Tracking Robot Velocity at Each Timestep

• In IsaacLab environments, robot state information—including root (base) velocity and link velocities—is typically stored in data structures like robot.data.root_vel_w (for root velocity in the world frame) and robot.data.body_vel_w (for link velocities in the world frame)¹.
• For a legged robot or mobile base (as in the Leatherback environment), you usually want the root velocity. You can access it at each simulation step as follows:

# Assuming 'robot' is your robot instance in the environment
velocity = robot.data.root_vel_w  # Shape: (num_envs, 6)
# The first three components are linear velocity (x, y, z), the next three are angular velocity
linear_velocity = velocity[:, :3]

• If you want the velocity of a specific link (e.g., an end-effector), use:

# For the ith link (e.g., end-effector)
link_velocity = robot.data.body_vel_w[:, i, :]  # Shape: (num_envs, 6)

• These tensors are updated at every simulation step, so you can record them at each timestep during evaluation¹.

2. Computing Average Velocity Over an Evaluation Episode

• Store the linear velocity (or the scalar speed, e.g., the norm of the velocity vector) at each timestep in a list or tensor.
• After the episode ends, compute the mean:

import torch

velocities = []  # Collect at each timestep
# During evaluation loop:
velocities.append(linear_velocity)  # or linear_velocity.norm(dim=-1) for speed

# After the episode:
velocities_tensor = torch.stack(velocities)  # Shape: (timesteps, num_envs, 3)
average_velocity = velocities_tensor.mean(dim=0)  # Mean over timesteps
# For average speed:
average_speed = velocities_tensor.norm(dim=-1).mean(dim=0)

• This gives you the average velocity vector or average speed for each environment (or robot instance) over the entire episode.

3. Integration with SKRL

• SKRL interacts with IsaacLab environments using standard Gym-style interfaces. You can access the underlying IsaacLab environment and robot objects from the SKRL environment wrapper, allowing you to extract the velocity data as described above²³.
• During evaluation, add hooks or callbacks to collect velocity data at each step, then compute statistics as needed.

Summary Table

Task	IsaacLab/Isaac Sim API Example	Notes
Track velocity per timestep	robot.data.root_vel_w or robot.data.body_vel_w	Linear and angular velocities
Compute average velocity	torch.stack(velocities).mean(dim=0)	Average over episode timesteps

References to NVIDIA Documentation and Forums

• IsaacLab documentation and tutorials show direct access to robot.data.root_vel_w and robot.data.body_vel_w for velocity extraction¹.
• NVIDIA Developer Forums confirm that for links, robot_articulation_view._physics_view.get_link_velocities() or similar internal data structures provide velocity data.
• IsaacLab is designed for integration with RL libraries like SKRL, and its modularity allows direct access to these simulation data structures during evaluation²³.

Footnotes

1. https://isaac-sim.github.io/IsaacLab/main/source/tutorials/05_controllers/run_osc.html ↩ ↩² ↩³

2. https://developer.nvidia.com/isaac/lab ↩ ↩²

3. https://github.com/isaac-sim/IsaacLab ↩ ↩²

[amirhnourian]

Thank you for your clear and concise explanation! I’m now able to track the velocity using the provided example. In the meantime, I’m wondering—what other metrics can be accessed in a similar way? For example, is it possible to track the energy consumption of the motors?

Based on your description, I assume I can estimate theoretical power using the following snippet:

        try:
            torque = leatherback_env.leatherback.data.applied_torque  # or use .computed_torque
            joint_vel = leatherback_env.leatherback.data.joint_vel
        except AttributeError:
            print("[WARN] Could not access torque or velocity data.")

            return

        # Mechanical Power P = τ * q̇ (per joint), summed over joints
        power = (torque * joint_vel).sum(dim=1)
        avg_power = float(power.mean().item())

However, I’m curious if there’s a more accurate or recommended approach to calculate mechanical energy, perhaps something more aligned with the methods described in the Isaac Sim documentation for evaluating joint mechanical power?

[RandomOakForest]

Absolutely—Isaac Lab and Isaac Sim expose a wide range of robot and environment metrics you can access in a similar way to velocity, including joint torques, positions, contact forces, and more. Here is a summary about energy consumption and other commonly available metrics.

1. Calculating Mechanical Power and Energy

Your approach is fundamentally correct and is in line with the standard method for estimating mechanical power in robotics:

$$ \text{Power}_\text{joint} = \tau \cdot \dot{q} $$

Where:

• $\tau$ is the joint torque
• $\dot{q}$ is the joint velocity

Summing over all joints gives you the total instantaneous mechanical power. Integrating (summing over timesteps and multiplying by the timestep duration) gives you the total mechanical energy.

Isaac Sim/IsaacLab Implementation

• Torque: Use either .applied_torque (commanded) or .computed_torque (actual, including dynamics).
• Joint Velocity: Use .joint_vel.

Example (PyTorch-style):

# At each timestep
torque = leatherback_env.leatherback.data.computed_torque  # or .applied_torque
joint_vel = leatherback_env.leatherback.data.joint_vel

# Instantaneous power per environment (sum over joints)
power = (torque * joint_vel).sum(dim=1)  # Shape: (num_envs,)

# Store power at each timestep to compute total energy later
power_log.append(power)

# After the episode
power_tensor = torch.stack(power_log)  # Shape: (timesteps, num_envs)
dt = leatherback_env.sim.dt  # Simulation timestep (seconds)
total_energy = (power_tensor * dt).sum(dim=0)  # Shape: (num_envs,)
average_power = power_tensor.mean(dim=0)

Best Practice:

• Use .computed_torque for real mechanical power, as it includes all dynamics (gravity, friction, etc.).
• If you want to estimate electrical energy (what the motors actually consume), you would need to account for motor efficiency, losses, and possibly use a more detailed actuator model.

2. Other Metrics You Can Track

Isaac Lab and Isaac Sim environments expose many useful metrics, including:

a. Joint States

• Position: robot.data.joint_pos
• Velocity: robot.data.joint_vel
• Torque: robot.data.computed_torque, robot.data.applied_torque

b. Contact Forces

• Contact force/torque on each link:
  • robot.data.contact_forces
  • Useful for estimating ground reaction forces, slip, etc.

c. Robot Pose

• Root position/orientation: robot.data.root_pos_w, robot.data.root_quat_w
• Root velocity: robot.data.root_vel_w

d. End-Effector States

• Position/velocity of end-effectors:
  • Use kinematics or robot.data.body_pos_w/robot.data.body_vel_w for specific links.

e. Environment States

• Sensor data: Cameras, IMUs, force sensors, etc., if configured.
• Reward components: Most environments expose reward breakdowns for analysis.

3. Example: Accessing and Logging Multiple Metrics

# At each timestep
joint_pos = robot.data.joint_pos
joint_vel = robot.data.joint_vel
computed_torque = robot.data.computed_torque
contact_forces = robot.data.contact_forces  # (num_envs, num_bodies, 3)
root_pos = robot.data.root_pos_w
root_vel = robot.data.root_vel_w

# Logging for analysis
metrics_log.append({
    "joint_pos": joint_pos.clone(),
    "joint_vel": joint_vel.clone(),
    "torque": computed_torque.clone(),
    "contact_forces": contact_forces.clone(),
    "root_pos": root_pos.clone(),
    "root_vel": root_vel.clone(),
})

4. Summary Table

Metric	IsaacLab/Isaac Sim Data Field	Description
Joint Position	robot.data.joint_pos	Per joint, radians/meters
Joint Velocity	robot.data.joint_vel	Per joint, rad/s or m/s
Joint Torque	robot.data.computed_torque	Per joint, Nm
Root Position	robot.data.root_pos_w	World frame, meters
Root Velocity	robot.data.root_vel_w	World frame, m/s and rad/s
Contact Forces	robot.data.contact_forces	Per link, Newtons
End-Effector States	robot.data.body_pos_w, body_vel_w	Per link
Power (Mechanical)	computed_torque * joint_vel	Sum for total mechanical power
Energy (Mechanical)	Integrate power over time	Total mechanical work done

In summary:
Your code snippet is correct for mechanical power estimation. For more accuracy, use .computed_torque and integrate over time for energy. Isaac Lab exposes a rich set of metrics (joint states, contact forces, poses, etc.) you can track in the same way.

[amirhnourian]

I've come across an unusual issue in Isaac Lab: when calculating power, the resulting value seems unexpectedly high. I suspect this might be due to the angular velocity being reported in degrees per second—can you confirm if that's the case? Is there a specific section in the documentation where the units for angular velocity are clearly stated?

https://forums.developer.nvidia.com/t/units-of-angular-velocity-in-e-g-revolute-joints-in-degree-per-second/284971