Modules:
| Name | Description |
|---|---|
actions |
|
commands |
|
rewards |
|
Classes:
| Name | Description |
|---|---|
FlightActionMapper |
Map batched normalized actions into controller targets, wrench, or RPM. |
Mixer |
Map batched thrust and moment demands to rotor speed commands. |
VehicleParams |
Generic multi-rotor vehicle physics. |
RotorDynamics |
Batched motor dynamics model for rotor thrust and torque. |
FlightControlActionManager |
Base class for action managers that control actuators. |
HeadingVelocityCommandRange |
4-D velocity command range: vx, vy, vz, wz. |
HeadingVelocityCommandManager |
Velocity command manager with heading-based yaw rate control and z velocity. |
Functions:
| Name | Description |
|---|---|
wrap_to_pi |
Wraps input angles (in radians) to the range :math: |
lin_vel_l2 |
Penalize base linear velocity using L2 squared kernel. |
ang_vel_l2 |
Penalize base angular velocity using L2 squared kernel. |
pos_error_l2 |
Penalize asset pos from its target pos using L2 squared kernel. |
pos_error_tanh |
Penalize asset pos from its target pos using tanh kernel. |
yaw_error_l2 |
Penalize heading error from target heading using L2 squared kernel. |
yaw_error_tanh |
Penalize heading error from target heading. |
command_tracking_lin_vel |
Reward for tracking commanded linear velocity (xyz axes). |
command_tracking_ang_vel |
Reward for tracking commanded angular velocity (yaw). |
FlightActionMapper(control_mode: str, params: VehicleParams = VehicleParams(), mapping: FlightMappingConfig | None = None, control_mask: dict | None = None, num_envs: int = 1, device=None, *, backend: BackendName | None = None, xp: ModuleType | None = None)
Map batched normalized actions into controller targets, wrench, or RPM.
Initialize the batched action mapper and backend namespace.
Methods:
| Name | Description |
|---|---|
randomize |
Randomize. |
action_to_collective_acc |
Action to collective acc. |
collective_acc_to_thrust |
Collective acc to thrust. |
action_to_collective_thrust |
Action to collective thrust. |
decode_action |
Decode normalized batched action into a runtime-neutral control request. |
map_action |
Resolve normalized batched action into simulation rotor RPM commands. |
Attributes:
| Name | Type | Description |
|---|---|---|
requires_controller |
bool
|
Requires controller. |
property
requires_controller: bool
Requires controller.
randomize(env_ids=None, randomization: dict | None = None)
Randomize.
action_to_collective_acc(action: ArrayLike, mixer) -> ArrayLike
Action to collective acc.
collective_acc_to_thrust(collective_acc: ArrayLike) -> ArrayLike
Collective acc to thrust.
action_to_collective_thrust(action: ArrayLike, mixer) -> ArrayLike
Action to collective thrust.
decode_action(action: ArrayLike, mixer, *, state: ControllerState | None = None) -> FlightMapping
Decode normalized batched action into a runtime-neutral control request.
map_action(action: ArrayLike, mixer, *, state: ControllerState | None = None, flight_controller: ControllerBase | None = None) -> FlightMapping
Resolve normalized batched action into simulation rotor RPM commands.
Mixer(params: VehicleParams = VehicleParams(), num_envs: int = 1, device=None, *, backend: BackendName | None = None, xp: ModuleType | None = None, allocation_mode: Literal['pinv', 'saturation'] = 'pinv')
Map batched thrust and moment demands to rotor speed commands.
The default "pinv" allocator applies direct pseudo-inverse allocation.
"saturation" enables a staged trim strategy: roll/pitch authority is
trimmed first if needed, and yaw authority is allocated from the remaining
rotor-speed margin.
Initialize the mixer matrix and backend namespace.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
|
VehicleParams
|
Vehicle parameters used to build the allocation matrix. |
VehicleParams()
|
|
int
|
Number of parallel environments represented by the batch. |
1
|
|
Optional backend device, mainly used by Torch. |
None
|
|
|
BackendName | None
|
Explicit Array API backend. If omitted, NumPy is used when
|
None
|
|
ModuleType | None
|
Pre-resolved Array API namespace. Overrides |
None
|
|
Literal['pinv', 'saturation']
|
|
'pinv'
|
Methods:
| Name | Description |
|---|---|
randomize |
Randomize mixer parameters for selected environments. |
calculate_rotor_commands |
Allocate |
randomize(env_ids=None, randomization: dict | None = None)
Randomize mixer parameters for selected environments.
calculate_rotor_commands(control: ArrayLike) -> ArrayLike
Allocate [thrust, roll, pitch, yaw] controls to rotor RPM.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
|
ArrayLike
|
Batched control array with shape |
required |
Returns:
| Type | Description |
|---|---|
ArrayLike
|
Batched rotor speed magnitudes with shape |
dataclass
VehicleParams(*, rho: float = 1.184, g: float = 9.81, sim_dt: float = 0.01, step_dt: float = 0.01, randomization: dict[str, dict[str, tuple[float, float]]] = dict(), mass: float = 2.1, inertia: list = (lambda: [[0.015, 0.0, 0.0], [0.0, 0.0348, 0.0], [0.0, 0.0, 0.042503]])(), x: float = 0.0952, y: float = 0.114423, h: float = -0.0125, alpha: float = math.radians(8.0), diameter: float = 0.476, Cdx: float = 0.5, r_p: float = 0.0775, Ct: float = 0.666, Cq: float = 0.0716, theta0: float = math.radians(14.6), thetaTip: float = math.radians(6.8), theta1: float = math.nan, lock: float = 0.6051, cT: float = math.nan, cM: float = math.nan, spin_dir: tuple[float, float, float, float] = (1.0, 1.0, -1.0, -1.0), tau_f: float = 0.01, tau_m: float = 0.05, max_rpm: float = 10000.0, init_rpm: float = math.nan, rotor_rpm_rate_limit: float = 50000.0, tau_up: float = math.nan, tau_down: float = math.nan, mpc_xy_vel_max: float = 12.0, mpc_z_vel_max_up: float = 3.0, mpc_z_vel_max_dn: float = 1.5, mpc_acc_hor_max: float = 5.0, mpc_acc_up_max: float = 4.0, mpc_acc_down_max: float = 3.0, mpc_man_tilt_max: float = math.radians(35.0), mc_rollrate_max: float = math.radians(220.0), mc_pitchrate_max: float = math.radians(220.0), mc_yawrate_max: float = math.radians(200.0))
Generic multi-rotor vehicle physics.
The base class carries LAV2-compatible defaults for the shared multi-rotor
parameters so that VehicleParams() continues to produce a working
LAV2-flavoured flight configuration (without track / airframe specifics).
Concrete subclasses add robot-specific locomotion and geometry:
TrackVehicleParams— LAV2: tracked ground locomotion + ducted airframeTiltWheelVehicleParams— ATMO: tilting arms + two side motors whose belt transmissions synchronize four wheel shells
Methods:
| Name | Description |
|---|---|
__post_init__ |
Calculate derived parameters and resolve default sentinels. |
Attributes:
| Name | Type | Description |
|---|---|---|
rho |
float
|
Air density (kg/m³). |
g |
float
|
Gravitational acceleration (m/s²). |
sim_dt |
float
|
Simulation time step (s). |
step_dt |
float
|
Control time step (s). |
randomization |
dict[str, dict[str, tuple[float, float]]]
|
Per-component parameter-randomisation scale ranges. |
mass |
float
|
Total vehicle mass (kg — LAV2 default; override for other robots). |
inertia |
list
|
Inertia matrix (kg*m^2). |
x |
float
|
Arm length in x — rotor moment-arm for roll (m). |
y |
float
|
Arm length in y — rotor moment-arm for pitch (m). |
h |
float
|
CG height below rotor plane (m, negative = below). |
alpha |
float
|
Duct / rotor cant angle about y-axis (rad — 0 for flat rotors like ATMO). |
diameter |
float
|
Overall vehicle diameter (m). |
Cdx |
float
|
Body drag coefficient. |
r_p |
float
|
Propeller radius (m). |
Ct |
float
|
Thrust coefficient (blade-element). |
Cq |
float
|
Torque coefficient (blade-element). |
theta0 |
float
|
Blade root pitch angle (rad). |
thetaTip |
float
|
Blade tip pitch angle (rad). |
theta1 |
float
|
Blade twist (rad), defaults to theta0 - thetaTip. |
lock |
float
|
Lock number. |
cT |
float
|
Thrust coefficient T = cT·rpm² (N / rpm²); defaults from Ct. |
cM |
float
|
Reaction-torque coefficient M = cM·rpm² (N·m / rpm²); defaults from Cq. |
spin_dir |
tuple[float, float, float, float]
|
Rotor spin direction signs; + means clockwise, - means counter-clockwise. |
tau_f |
float
|
Motor filter time constant (s). |
tau_m |
float
|
Legacy motor time constant (s). |
max_rpm |
float
|
Maximum rotor speed (rpm — LAV2 default). |
init_rpm |
float
|
Initial rotor speed — defaults to 0.2·max_rpm. |
rotor_rpm_rate_limit |
float
|
Rotor-speed rate-of-change limit (rpm/s). |
tau_up |
float
|
Motor spin-up time constant (s), defaults to tau_m. |
tau_down |
float
|
Motor spin-down time constant (s), defaults to tau_m. |
mpc_xy_vel_max |
float
|
Maximum horizontal velocity setpoint magnitude in m/s (0 - 20). |
mpc_z_vel_max_up |
float
|
Maximum upward velocity setpoint in m/s (0.5 - 8). |
mpc_z_vel_max_dn |
float
|
Maximum downward velocity setpoint magnitude in m/s (0.5 - 4). |
mpc_acc_hor_max |
float
|
Maximum horizontal acceleration setpoint magnitude in m/s^2 (2 - 15). |
mpc_acc_up_max |
float
|
Maximum upward acceleration setpoint in m/s^2 (2 - 15). |
mpc_acc_down_max |
float
|
Maximum downward acceleration setpoint magnitude in m/s^2 (2 - 15). |
mpc_man_tilt_max |
float
|
Maximum manual tilt angle in radians (deg: 0 - 90). |
mc_rollrate_max |
float
|
Maximum roll-rate setpoint in rad/s (deg/s: 0 - 1800). |
mc_pitchrate_max |
float
|
Maximum pitch-rate setpoint in rad/s (deg/s: 0 - 1800). |
mc_yawrate_max |
float
|
Maximum yaw-rate setpoint in rad/s (deg/s: 0 - 1800). |
class-attribute
instance-attribute
rho: float = 1.184
Air density (kg/m³).
class-attribute
instance-attribute
g: float = 9.81
Gravitational acceleration (m/s²).
class-attribute
instance-attribute
sim_dt: float = 0.01
Simulation time step (s).
class-attribute
instance-attribute
step_dt: float = 0.01
Control time step (s).
class-attribute
instance-attribute
randomization: dict[str, dict[str, tuple[float, float]]] = field(default_factory=dict)
Per-component parameter-randomisation scale ranges.
class-attribute
instance-attribute
mass: float = 2.1
Total vehicle mass (kg — LAV2 default; override for other robots).
class-attribute
instance-attribute
inertia: list = field(default_factory=lambda: [[0.015, 0.0, 0.0], [0.0, 0.0348, 0.0], [0.0, 0.0, 0.042503]])
Inertia matrix (kg*m^2).
class-attribute
instance-attribute
x: float = 0.0952
Arm length in x — rotor moment-arm for roll (m).
class-attribute
instance-attribute
y: float = 0.114423
Arm length in y — rotor moment-arm for pitch (m).
class-attribute
instance-attribute
h: float = -0.0125
CG height below rotor plane (m, negative = below).
class-attribute
instance-attribute
alpha: float = math.radians(8.0)
Duct / rotor cant angle about y-axis (rad — 0 for flat rotors like ATMO).
class-attribute
instance-attribute
diameter: float = 0.476
Overall vehicle diameter (m).
class-attribute
instance-attribute
Cdx: float = 0.5
Body drag coefficient.
class-attribute
instance-attribute
r_p: float = 0.0775
Propeller radius (m).
class-attribute
instance-attribute
Ct: float = 0.666
Thrust coefficient (blade-element).
class-attribute
instance-attribute
Cq: float = 0.0716
Torque coefficient (blade-element).
class-attribute
instance-attribute
theta0: float = math.radians(14.6)
Blade root pitch angle (rad).
class-attribute
instance-attribute
thetaTip: float = math.radians(6.8)
Blade tip pitch angle (rad).
class-attribute
instance-attribute
theta1: float = math.nan
Blade twist (rad), defaults to theta0 - thetaTip.
class-attribute
instance-attribute
lock: float = 0.6051
Lock number.
class-attribute
instance-attribute
cT: float = math.nan
Thrust coefficient T = cT·rpm² (N / rpm²); defaults from Ct.
class-attribute
instance-attribute
cM: float = math.nan
Reaction-torque coefficient M = cM·rpm² (N·m / rpm²); defaults from Cq.
class-attribute
instance-attribute
spin_dir: tuple[float, float, float, float] = (1.0, 1.0, -1.0, -1.0)
Rotor spin direction signs; + means clockwise, - means counter-clockwise.
LAV2 defaults to rotors 0/1 clockwise and 2/3 counter-clockwise, so the
signs are (+,+,-,-).
class-attribute
instance-attribute
tau_f: float = 0.01
Motor filter time constant (s).
class-attribute
instance-attribute
tau_m: float = 0.05
Legacy motor time constant (s).
class-attribute
instance-attribute
max_rpm: float = 10000.0
Maximum rotor speed (rpm — LAV2 default).
class-attribute
instance-attribute
init_rpm: float = math.nan
Initial rotor speed — defaults to 0.2·max_rpm.
class-attribute
instance-attribute
rotor_rpm_rate_limit: float = 50000.0
Rotor-speed rate-of-change limit (rpm/s).
class-attribute
instance-attribute
tau_up: float = math.nan
Motor spin-up time constant (s), defaults to tau_m.
class-attribute
instance-attribute
tau_down: float = math.nan
Motor spin-down time constant (s), defaults to tau_m.
class-attribute
instance-attribute
mpc_xy_vel_max: float = 12.0
Maximum horizontal velocity setpoint magnitude in m/s (0 - 20).
class-attribute
instance-attribute
mpc_z_vel_max_up: float = 3.0
Maximum upward velocity setpoint in m/s (0.5 - 8).
class-attribute
instance-attribute
mpc_z_vel_max_dn: float = 1.5
Maximum downward velocity setpoint magnitude in m/s (0.5 - 4).
class-attribute
instance-attribute
mpc_acc_hor_max: float = 5.0
Maximum horizontal acceleration setpoint magnitude in m/s^2 (2 - 15).
class-attribute
instance-attribute
mpc_acc_up_max: float = 4.0
Maximum upward acceleration setpoint in m/s^2 (2 - 15).
class-attribute
instance-attribute
mpc_acc_down_max: float = 3.0
Maximum downward acceleration setpoint magnitude in m/s^2 (2 - 15).
class-attribute
instance-attribute
mpc_man_tilt_max: float = math.radians(35.0)
Maximum manual tilt angle in radians (deg: 0 - 90).
class-attribute
instance-attribute
mc_rollrate_max: float = math.radians(220.0)
Maximum roll-rate setpoint in rad/s (deg/s: 0 - 1800).
class-attribute
instance-attribute
mc_pitchrate_max: float = math.radians(220.0)
Maximum pitch-rate setpoint in rad/s (deg/s: 0 - 1800).
class-attribute
instance-attribute
mc_yawrate_max: float = math.radians(200.0)
Maximum yaw-rate setpoint in rad/s (deg/s: 0 - 1800).
__post_init__()
Calculate derived parameters and resolve default sentinels.
RotorDynamics(params: VehicleParams = VehicleParams(), num_envs: int = 1, device=None, *, backend: BackendName | None = None, xp: ModuleType | None = None)
Bases: DynamicsBase
Batched motor dynamics model for rotor thrust and torque.
This is the backend-agnostic Array API implementation. It keeps
the same low-pass motor response, RPM rate limiting, quadratic thrust/torque
coefficients, and motor-direction torque signs while operating on
(num_envs, 4) batches.
See :mod:lav2.dynamics.numpy.rotor and :mod:lav2.dynamics.torch.rotor
for the legacy backend-specific implementations.
Initialize rotor dynamics and backend arrays.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
|
VehicleParams
|
Vehicle parameters used by the motor model. |
VehicleParams()
|
|
int
|
Number of parallel environments represented by the batch. |
1
|
|
Optional backend device, mainly used by Torch. |
None
|
|
|
BackendName | None
|
Explicit Array API backend name. |
None
|
|
ModuleType | None
|
Pre-resolved Array API namespace. Overrides |
None
|
Methods:
| Name | Description |
|---|---|
randomize |
Randomize motor parameters for selected environments. |
update |
Update motor state and return thrust/torque outputs. |
reset |
Reset selected environments to initial rotor speeds. |
Attributes:
| Name | Type | Description |
|---|---|---|
params |
VehicleParams
|
Vehicle parameters for the dynamics model. |
instance-attribute
params: VehicleParams = params
Vehicle parameters for the dynamics model.
randomize(env_ids=None, randomization: dict[str, tuple[float, float]] | None = None)
Randomize motor parameters for selected environments.
update(commands: ArrayLike) -> ArrayLike
Update motor state and return thrust/torque outputs.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
|
ArrayLike
|
Desired rotor speeds with shape |
required |
Returns:
| Type | Description |
|---|---|
ArrayLike
|
Batched thrusts followed by torques with shape |
reset(env_ids=None)
Reset selected environments to initial rotor speeds.
FlightControlActionManager(env: GenesisEnv, delay_step: int = 0, params: VehicleParams = VehicleParams(), entity_attr: str = 'robot', rotor_link_names: tuple[str, ...] = ('rotor0', 'rotor1', 'rotor2', 'rotor3'))
Bases: BaseActionManager
Base class for action managers that control actuators.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
|
GenesisEnv
|
The environment to manage the DOF actuators for. |
required |
|
int
|
The number of steps to delay the actions for. This is an easy way to emulate the latency in the system. |
0
|
|
VehicleParams
|
Vehicle physical parameters. |
VehicleParams()
|
|
str
|
Attribute name on the environment for the robot entity. |
'robot'
|
Methods:
| Name | Description |
|---|---|
step |
Process the incoming actions (analogous to Isaac Lab |
send_actions_to_simulation |
Apply the processed actions to the simulation (Isaac Lab |
reset |
Reset environments. |
get_actions |
Get the current actions for the environments. |
Attributes:
| Name | Type | Description |
|---|---|---|
num_actions |
int
|
The total number of actions. |
action_space |
tuple[float, float]
|
If using the default action handler, the action space is [-1, 1]. |
actions |
Tensor
|
The actions for for the current step. |
raw_actions |
Tensor
|
The actions received from the policy, before being converted. |
property
num_actions: int
The total number of actions.
property
action_space: tuple[float, float]
If using the default action handler, the action space is [-1, 1].
property
actions: Tensor
The actions for for the current step.
property
raw_actions: Tensor
The actions received from the policy, before being converted.
step(actions: Tensor) -> torch.Tensor
Process the incoming actions (analogous to Isaac Lab process_actions).
Only the raw and clamped policy actions are stored here; the mixer,
rotor dynamics and body-force application run in
:meth:send_actions_to_simulation (the apply phase).
send_actions_to_simulation(processed_actions: Tensor) -> torch.Tensor
Apply the processed actions to the simulation (Isaac Lab apply_actions).
genesis_forge>=0.5 splits action handling into step (process) and
send_actions_to_simulation (apply), which runs at a different cadence
than processing. This maps the processed actions to a rotor RPM command
via the mixer, steps the rotor dynamics, and writes the resulting body
forces/torques to the solver.
reset(envs_idx: list[int] | None)
Reset environments.
get_actions() -> torch.Tensor
Get the current actions for the environments.
Bases: TypedDict
4-D velocity command range: vx, vy, vz, wz.
HeadingVelocityCommandManager(env: GenesisEnv, range: HeadingVelocityCommandRange, resample_time_sec: float = 5.0, standing_probability: float = 0.0, heading_command: bool = False, heading_control_stiffness: float = 1.0, rel_heading_envs: float = 1.0, heading_range: tuple[float, float] = (-math.pi, math.pi), debug_visualizer: bool = False, debug_visualizer_cfg: VelocityDebugVisualizerConfig = DEFAULT_VISUALIZER_CONFIG)
Bases: VelocityCommandManager
Velocity command manager with heading-based yaw rate control and z velocity.
Uses its own HeadingVelocityCommandRange config with 4 velocity dimensions.
The parent's _command buffer stores 4-D [vx, vy, vz, wz].
The public command property returns the same 4-D tensor.
When heading_command=True, the angular velocity (wz) is overridden for
heading-enabled environments by a proportional controller on the heading error::
wz = clip(stiffness * wrap_to_pi(heading_target - heading_w), ang_vel_z_range)
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
|
GenesisEnv
|
The environment to control. |
required |
|
HeadingVelocityCommandRange
|
The ranges of linear & angular velocities (4-D: vx, vy, vz, wz). |
required |
|
float
|
The time interval between changing the command. |
5.0
|
|
float
|
Probability of standing still. |
0.0
|
|
bool
|
Enable heading-based angular velocity control. |
False
|
|
float
|
P-gain for heading error to yaw rate. |
1.0
|
|
float
|
Fraction of environments that use heading control. |
1.0
|
|
tuple[float, float]
|
Range for sampling heading targets (radians). |
(-pi, pi)
|
|
bool
|
Enable debug arrow visualization. |
False
|
|
VelocityDebugVisualizerConfig
|
Configuration for the debug visualizer. |
DEFAULT_VISUALIZER_CONFIG
|
Attributes:
| Name | Type | Description |
|---|---|---|
command |
Tensor
|
The desired velocity command in base frame. Shape is (num_envs, 4). |
property
command: Tensor
The desired velocity command in base frame. Shape is (num_envs, 4).
Columns: [vx, vy, vz, wz].
wrap_to_pi(angles: Tensor) -> torch.Tensor
Wraps input angles (in radians) to the range :math:[-\pi, \pi].
This function wraps angles in radians to the range :math:[-\pi, \pi], such that
:math:\pi maps to :math:\pi, and :math:-\pi maps to :math:-\pi. In general,
odd positive multiples of :math:\pi are mapped to :math:\pi, and odd negative
multiples of :math:\pi are mapped to :math:-\pi.
The function behaves similar to MATLAB's wrapToPi <https://www.mathworks.com/help/map/ref/wraptopi.html>_
function.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
|
Tensor
|
Input angles of any shape. |
required |
Returns:
| Type | Description |
|---|---|
Tensor
|
torch.Tensor: Angles in the range :math: |
lin_vel_l2(env: GenesisEnv, entity_attr: str = 'robot', entity_manager: EntityManager = None) -> torch.Tensor
Penalize base linear velocity using L2 squared kernel.
ang_vel_l2(env: GenesisEnv, entity_attr: str = 'robot', entity_manager: EntityManager = None) -> torch.Tensor
Penalize base angular velocity using L2 squared kernel.
pos_error_l2(env: GenesisEnv, target_pose: Tensor, pose_command: CommandManager = None, entity_attr: str = 'robot', entity_manager: EntityManager = None) -> torch.Tensor
Penalize asset pos from its target pos using L2 squared kernel.
pos_error_tanh(env: GenesisEnv, target_pose: Tensor, pose_command: CommandManager = None, entity_attr: str = 'robot', entity_manager: EntityManager = None) -> torch.Tensor
Penalize asset pos from its target pos using tanh kernel.
yaw_error_l2(env: GenesisEnv, target_pose: Tensor, pose_command: CommandManager = None, entity_attr: str = 'robot', entity_manager: EntityManager = None) -> torch.Tensor
Penalize heading error from target heading using L2 squared kernel.
yaw_error_tanh(env: GenesisEnv, target_pose: Tensor, pose_command: CommandManager = None, entity_attr: str = 'robot', entity_manager: EntityManager = None, std: float = 0.8) -> torch.Tensor
Penalize heading error from target heading.
command_tracking_lin_vel(env: GenesisEnv, vel_cmd_manager: VelocityCommandManager, sensitivity: float = 0.25, entity_attr: str = 'robot', entity_manager: EntityManager = None) -> torch.Tensor
Reward for tracking commanded linear velocity (xyz axes).
Uses 4-D command [vx, vy, vz, wz] and tracks all three linear axes.
command_tracking_ang_vel(env: GenesisEnv, vel_cmd_manager: VelocityCommandManager, sensitivity: float = 0.25, entity_attr: str = 'robot', entity_manager: EntityManager = None) -> torch.Tensor
Reward for tracking commanded angular velocity (yaw).
Uses 4-D command [vx, vy, vz, wz] where wz is at index 3.