isaaclab_contrib.assets

Sub-package for externally contributed assets.

This package provides specialized asset classes for simulating externally contributed robots in Isaac Lab, such as multirotors. These assets are not part of the core Isaac Lab framework yet, but are planned to be added in the future. They are contributed by the community to extend the capabilities of Isaac Lab.

Classes

Multirotor	A multirotor articulation asset class.
MultirotorCfg	Configuration parameters for a multirotor articulation.
MultirotorData	Data container for a multirotor articulation.

Multirotor Asset

class isaaclab_contrib.assets.Multirotor

Bases: Articulation

A multirotor articulation asset class.

This class extends the base Articulation class to support multirotor vehicles (such as quadcopters, hexacopters, and octocopters) with thruster actuators that apply forces at specific body locations. It is based on the implementation from Kulkarni et al. [KRA25].

Unlike standard articulations that use joint-based control, multirotors are controlled through thrust forces generated by individual rotors/propellers. This class provides specialized functionality for managing multiple thruster actuators, computing combined wrenches from individual thrusts, and applying them to the multirotor’s base link.

Key Features:

• Thruster-based control: Uses Thruster actuators instead of joint actuators for realistic rotor dynamics simulation.

• Force allocation: Supports allocation matrices to convert individual thruster forces into combined body wrenches (forces and torques).

• Asymmetric dynamics: Thruster actuators can model asymmetric rise/fall dynamics that reflect real motor behavior.

• Flexible configuration: Supports arbitrary numbers and arrangements of thrusters through regex-based thruster naming patterns.

Usage Example:

import isaaclab.sim as sim_utils
from isaaclab_contrib.assets import MultirotorCfg
from isaaclab_contrib.actuators import ThrusterCfg

# Define thruster actuator configuration
thruster_cfg = ThrusterCfg(
    thruster_names_expr=["rotor_[0-3]"],  # Match rotors 0-3
    thrust_range=(0.0, 10.0),  # Min and max thrust in Newtons
    rise_time_constant=0.1,  # Time constant for thrust increase
    fall_time_constant=0.2,  # Time constant for thrust decrease
)

# Create multirotor configuration
multirotor_cfg = MultirotorCfg(
    prim_path="/World/envs/env_.*/Robot",
    spawn=sim_utils.UsdFileCfg(usd_path="path/to/quadcopter.usd"),
    actuators={"thrusters": thruster_cfg},
    allocation_matrix=[  # 6x4 matrix for quadcopter (6 DOF, 4 thrusters)
        [1.0, 1.0, 1.0, 1.0],  # Total vertical force
        [0.0, 0.0, 0.0, 0.0],  # Lateral force (x)
        [0.0, 0.0, 0.0, 0.0],  # Lateral force (y)
        [0.0, 0.1, 0.0, -0.1],  # Roll torque
        [-0.1, 0.0, 0.1, 0.0],  # Pitch torque
        [0.01, -0.01, 0.01, -0.01],  # Yaw torque
    ],
)

# Create the multirotor instance
multirotor = multirotor_cfg.class_type(multirotor_cfg)

Note

The allocation matrix maps individual thruster forces to a 6D wrench (3 forces + 3 torques) applied to the base link. The matrix dimensions should be (6, num_thrusters).

See also

• Articulation: Base articulation class

• MultirotorCfg: Configuration class for multirotors

• MultirotorData: Data container for multirotor state

• Thruster: Thruster actuator model

Attributes:

cfg	Configuration instance for the multirotor.
actuators	Dictionary of thruster actuator instances for the multirotor.
thruster_names	Ordered names of thrusters in the multirotor.
num_thrusters	Number of thrusters in the multirotor.
allocation_matrix	Allocation matrix for control allocation.
body_names	Ordered names of bodies in articulation.
data	Data related to the asset.
device	Memory device for computation.
fixed_tendon_names	Ordered names of fixed tendons in articulation.
has_debug_vis_implementation	Whether the asset has a debug visualization implemented.
instantaneous_wrench_composer	Instantaneous wrench composer.
is_fixed_base	Whether the articulation is a fixed-base or floating-base system.
is_initialized	Whether the asset is initialized.
joint_names	Ordered names of joints in articulation.
num_bodies	Number of bodies in articulation.
num_fixed_tendons	Number of fixed tendons in articulation.
num_instances	Number of instances of the asset.
num_joints	Number of joints in articulation.
num_spatial_tendons	Number of spatial tendons in articulation.
permanent_wrench_composer	Permanent wrench composer.
root_physx_view	Articulation view for the asset (PhysX).
spatial_tendon_names	Ordered names of spatial tendons in articulation.

Methods:

__init__(cfg)	Initialize the multirotor articulation.
set_thrust_target(target[, thruster_ids, ...])	Set target thrust values for thrusters.
reset([env_ids])	Reset the multirotor to default state.
write_data_to_sim()	Write thrust and torque commands to the simulation.
find_bodies(name_keys[, preserve_order])	Find bodies in the articulation based on the name keys.
find_fixed_tendons(name_keys[, ...])	Find fixed tendons in the articulation based on the name keys.
find_joints(name_keys[, joint_subset, ...])	Find joints in the articulation based on the name keys.
find_spatial_tendons(name_keys[, ...])	Find spatial tendons in the articulation based on the name keys.
set_debug_vis(debug_vis)	Sets whether to visualize the asset data.
set_external_force_and_torque(forces, torques)	Set external force and torque to apply on the asset's bodies in their local frame.
set_fixed_tendon_damping(damping[, ...])	Set fixed tendon damping into internal buffers.
set_fixed_tendon_limit(limit[, ...])	Set fixed tendon position limits into internal buffers.
set_fixed_tendon_limit_stiffness(limit_stiffness)	Set fixed tendon limit stiffness efforts into internal buffers.
set_fixed_tendon_offset(offset[, ...])	Set fixed tendon offset efforts into internal buffers.
set_fixed_tendon_position_limit(limit[, ...])	Set fixed tendon limit efforts into internal buffers.
set_fixed_tendon_rest_length(rest_length[, ...])	Set fixed tendon rest length efforts into internal buffers.
set_fixed_tendon_stiffness(stiffness[, ...])	Set fixed tendon stiffness into internal buffers.
set_joint_effort_target(target[, joint_ids, ...])	Set joint efforts into internal buffers.
set_joint_position_target(target[, ...])	Set joint position targets into internal buffers.
set_joint_velocity_target(target[, ...])	Set joint velocity targets into internal buffers.
set_spatial_tendon_damping(damping[, ...])	Set spatial tendon damping into internal buffers.
set_spatial_tendon_limit_stiffness(...[, ...])	Set spatial tendon limit stiffness into internal buffers.
set_spatial_tendon_offset(offset[, ...])	Set spatial tendon offset efforts into internal buffers.
set_spatial_tendon_stiffness(stiffness[, ...])	Set spatial tendon stiffness into internal buffers.
set_visibility(visible[, env_ids])	Set the visibility of the prims corresponding to the asset.
update(dt)	Update the internal buffers.
write_fixed_tendon_properties_to_sim([...])	Write fixed tendon properties into the simulation.
write_joint_armature_to_sim(armature[, ...])	Write joint armature into the simulation.
write_joint_damping_to_sim(damping[, ...])	Write joint damping into the simulation.
write_joint_effort_limit_to_sim(limits[, ...])	Write joint effort limits into the simulation.
write_joint_friction_coefficient_to_sim(...)	Write joint friction coefficients into the simulation.
write_joint_friction_to_sim(joint_friction)	Write joint friction coefficients into the simulation.
write_joint_limits_to_sim(limits[, ...])	Write joint limits into the simulation.
write_joint_position_limit_to_sim(limits[, ...])	Write joint position limits into the simulation.
write_joint_position_to_sim(position[, ...])	Write joint positions to the simulation.
write_joint_state_to_sim(position, velocity)	Write joint positions and velocities to the simulation.
write_joint_stiffness_to_sim(stiffness[, ...])	Write joint stiffness into the simulation.
write_joint_velocity_limit_to_sim(limits[, ...])	Write joint max velocity to the simulation.
write_joint_velocity_to_sim(velocity[, ...])	Write joint velocities to the simulation.
write_root_com_pose_to_sim(root_pose[, env_ids])	Set the root center of mass pose over selected environment indices into the simulation.
write_root_com_state_to_sim(root_state[, ...])	Set the root center of mass state over selected environment indices into the simulation.
write_root_com_velocity_to_sim(root_velocity)	Set the root center of mass velocity over selected environment indices into the simulation.
write_root_link_pose_to_sim(root_pose[, env_ids])	Set the root link pose over selected environment indices into the simulation.
write_root_link_state_to_sim(root_state[, ...])	Set the root link state over selected environment indices into the simulation.
write_root_link_velocity_to_sim(root_velocity)	Set the root link velocity over selected environment indices into the simulation.
write_root_pose_to_sim(root_pose[, env_ids])	Set the root pose over selected environment indices into the simulation.
write_root_state_to_sim(root_state[, env_ids])	Set the root state over selected environment indices into the simulation.
write_root_velocity_to_sim(root_velocity[, ...])	Set the root center of mass velocity over selected environment indices into the simulation.
write_spatial_tendon_properties_to_sim([...])	Write spatial tendon properties into the simulation.

cfg: MultirotorCfg

Configuration instance for the multirotor.

actuators: dict[str, Thruster]

Dictionary of thruster actuator instances for the multirotor.

The keys are the actuator names and the values are the actuator instances. The actuator instances are initialized based on the actuator configurations specified in the MultirotorCfg.actuators attribute. They are used to compute the thruster commands during the write_data_to_sim() function.

__init__(cfg: MultirotorCfg)

Initialize the multirotor articulation.

Parameters:

cfg – A configuration instance.

property thruster_names: list[str]

Ordered names of thrusters in the multirotor.

This property aggregates thruster names from all thruster actuator groups configured for the multirotor. The names are ordered according to their array indices, which is important for setting thrust targets and interpreting thruster data.

Returns:

A list of thruster names in order. Returns an empty list if actuators are not yet initialized.

Raises:

ValueError – If a non-thruster actuator is found in the multirotor actuators.

property num_thrusters: int

Number of thrusters in the multirotor.

Returns:

Total number of thrusters across all actuator groups.

property allocation_matrix: torch.Tensor

Allocation matrix for control allocation.

The allocation matrix maps individual thruster forces to a 6D wrench vector (3 forces + 3 torques) applied to the base link. This allows converting per-thruster commands into the resulting body-frame forces and moments.

The matrix has shape (6, num_thrusters), where:

• Rows 0-2: Force contributions in body frame (Fx, Fy, Fz)

• Rows 3-5: Torque contributions in body frame (Tx, Ty, Tz)

Returns:

Allocation matrix as a torch tensor on the device.

set_thrust_target(target: torch.Tensor, thruster_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set target thrust values for thrusters.

This method sets the desired thrust values for specific thrusters in specific environments. The thrust targets are stored and later processed by the thruster actuator models during the write_data_to_sim() call. The actuator models may apply dynamics (rise/fall times) and constraints (thrust limits) to these targets.

Parameters:

• target – Target thrust values. Shape is (num_envs, num_thrusters) or (num_envs,). The values are typically in the same units as configured in the thruster actuator (e.g., Newtons for force, or revolutions per second for RPS).

• thruster_ids – Indices of thrusters to set. Defaults to None (all thrusters). Can be a sequence of integers, a slice, or None.

• env_ids – Environment indices to set. Defaults to None (all environments). Can be a sequence of integers or None.

Example

# Set thrust for all thrusters in all environments
multirotor.set_thrust_target(torch.ones(num_envs, 4) * 5.0)

# Set thrust for specific thrusters
multirotor.set_thrust_target(
    torch.tensor([[5.0, 6.0]]),  # Different thrust for 2 thrusters
    thruster_ids=[0, 2],  # Apply to thrusters 0 and 2
    env_ids=[0],  # Only in environment 0
)

reset(env_ids: Sequence[int] | None = None)

Reset the multirotor to default state.

This method resets both the base articulation state (pose, velocities) and multirotor-specific state (thruster targets) to their default values as specified in the configuration.

Parameters:

env_ids – Environment indices to reset. Defaults to None (all environments). Can be a sequence of integers or None.

Note

The default thruster state is set via the MultirotorCfg.init_state.rps configuration parameter.

write_data_to_sim()

Write thrust and torque commands to the simulation.

This method performs the following operations in sequence:

1. Apply actuator models: Process thrust targets through thruster actuator models to compute actual thrust values considering dynamics (rise/fall times) and constraints (thrust limits).

2. Combine thrusts into wrench: Use the allocation matrix to convert individual thruster forces into a combined 6D wrench (force + torque) vector.

3. Apply to simulation: Apply the combined wrench to the base link of the multirotor in the PhysX simulation.

This method should be called after setting thrust targets with set_thrust_target() and before stepping the simulation.

Note

This method overrides the base class implementation because multirotors use thrust-based control rather than joint-based control.

property body_names: list[str]

Ordered names of bodies in articulation.

property data: ArticulationData

Data related to the asset.

property device: str

Memory device for computation.

find_bodies(name_keys: str | Sequence[str], preserve_order: bool = False) → tuple[list[int], list[str]]

Find bodies in the articulation based on the name keys.

Please check the isaaclab.utils.string_utils.resolve_matching_names() function for more information on the name matching.

Parameters:

• name_keys – A regular expression or a list of regular expressions to match the body names.

• preserve_order – Whether to preserve the order of the name keys in the output. Defaults to False.

Returns:

A tuple of lists containing the body indices and names.

find_fixed_tendons(name_keys: str | Sequence[str], tendon_subsets: list[str] | None = None, preserve_order: bool = False) → tuple[list[int], list[str]]

Find fixed tendons in the articulation based on the name keys.

Please see the isaaclab.utils.string.resolve_matching_names() function for more information on the name matching.

Parameters:

• name_keys – A regular expression or a list of regular expressions to match the joint names with fixed tendons.

• tendon_subsets – A subset of joints with fixed tendons to search for. Defaults to None, which means all joints in the articulation are searched.

• preserve_order – Whether to preserve the order of the name keys in the output. Defaults to False.

Returns:

A tuple of lists containing the tendon indices and names.

find_joints(name_keys: str | Sequence[str], joint_subset: list[str] | None = None, preserve_order: bool = False) → tuple[list[int], list[str]]

Find joints in the articulation based on the name keys.

Please see the isaaclab.utils.string.resolve_matching_names() function for more information on the name matching.

Parameters:

• name_keys – A regular expression or a list of regular expressions to match the joint names.

• joint_subset – A subset of joints to search for. Defaults to None, which means all joints in the articulation are searched.

• preserve_order – Whether to preserve the order of the name keys in the output. Defaults to False.

Returns:

A tuple of lists containing the joint indices and names.

find_spatial_tendons(name_keys: str | Sequence[str], tendon_subsets: list[str] | None = None, preserve_order: bool = False) → tuple[list[int], list[str]]

Find spatial tendons in the articulation based on the name keys.

Please see the isaaclab.utils.string.resolve_matching_names() function for more information on the name matching.

Parameters:

• name_keys – A regular expression or a list of regular expressions to match the tendon names.

• tendon_subsets – A subset of tendons to search for. Defaults to None, which means all tendons in the articulation are searched.

• preserve_order – Whether to preserve the order of the name keys in the output. Defaults to False.

Returns:

A tuple of lists containing the tendon indices and names.

property fixed_tendon_names: list[str]

Ordered names of fixed tendons in articulation.

property has_debug_vis_implementation: bool

Whether the asset has a debug visualization implemented.

property instantaneous_wrench_composer: WrenchComposer

Instantaneous wrench composer.

Returns a WrenchComposer instance. Wrenches added or set to this wrench composer are only valid for the current simulation step. At the end of the simulation step, the wrenches set to this object are discarded. This is useful to apply forces that change all the time, things like drag forces for instance.

Note

Permanent wrenches are composed into the instantaneous wrench before the instantaneous wrenches are applied to the simulation.

property is_fixed_base: bool

Whether the articulation is a fixed-base or floating-base system.

property is_initialized: bool

Whether the asset is initialized.

Returns True if the asset is initialized, False otherwise.

property joint_names: list[str]

Ordered names of joints in articulation.

property num_bodies: int

Number of bodies in articulation.

property num_fixed_tendons: int

Number of fixed tendons in articulation.

property num_instances: int

Number of instances of the asset.

This is equal to the number of asset instances per environment multiplied by the number of environments.

property num_joints: int

Number of joints in articulation.

property num_spatial_tendons: int

Number of spatial tendons in articulation.

property permanent_wrench_composer: WrenchComposer

Permanent wrench composer.

Returns a WrenchComposer instance. Wrenches added or set to this wrench composer are persistent and are applied to the simulation at every step. This is useful to apply forces that are constant over a period of time, things like the thrust of a motor for instance.

Note

Permanent wrenches are composed into the instantaneous wrench before the instantaneous wrenches are applied to the simulation.

property root_physx_view: omni.physics.tensors.impl.api.ArticulationView

Articulation view for the asset (PhysX).

Note

Use this view with caution. It requires handling of tensors in a specific way.

set_debug_vis(debug_vis: bool) → bool

Sets whether to visualize the asset data.

Parameters:

debug_vis – Whether to visualize the asset data.

Returns:

Whether the debug visualization was successfully set. False if the asset does not support debug visualization.

set_external_force_and_torque(forces: torch.Tensor, torques: torch.Tensor, positions: torch.Tensor | None = None, body_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None, is_global: bool = False)

Set external force and torque to apply on the asset’s bodies in their local frame.

For many applications, we want to keep the applied external force on rigid bodies constant over a period of time (for instance, during the policy control). This function allows us to store the external force and torque into buffers which are then applied to the simulation at every step. Optionally, set the position to apply the external wrench at (in the local link frame of the bodies).

Caution

If the function is called with empty forces and torques, then this function disables the application of external wrench to the simulation.

# example of disabling external wrench
asset.set_external_force_and_torque(forces=torch.zeros(0, 3), torques=torch.zeros(0, 3))

Note

This function does not apply the external wrench to the simulation. It only fills the buffers with the desired values. To apply the external wrench, call the write_data_to_sim() function right before the simulation step.

Parameters:

• forces – External forces in bodies’ local frame. Shape is (len(env_ids), len(body_ids), 3).

• torques – External torques in bodies’ local frame. Shape is (len(env_ids), len(body_ids), 3).

• positions – Positions to apply external wrench. Shape is (len(env_ids), len(body_ids), 3). Defaults to None.

• body_ids – Body indices to apply external wrench to. Defaults to None (all bodies).

• env_ids – Environment indices to apply external wrench to. Defaults to None (all instances).

• is_global – Whether to apply the external wrench in the global frame. Defaults to False. If set to False, the external wrench is applied in the link frame of the articulations’ bodies.

set_fixed_tendon_damping(damping: torch.Tensor, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set fixed tendon damping into internal buffers.

This function does not apply the tendon damping to the simulation. It only fills the buffers with the desired values. To apply the tendon damping, call the write_fixed_tendon_properties_to_sim() function.

Parameters:

• damping – Fixed tendon damping. Shape is (len(env_ids), len(fixed_tendon_ids)).

• fixed_tendon_ids – The tendon indices to set the damping for. Defaults to None (all fixed tendons).

• env_ids – The environment indices to set the damping for. Defaults to None (all environments).

set_fixed_tendon_limit(limit: torch.Tensor, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set fixed tendon position limits into internal buffers.

Deprecated since version 2.1.0: Please use set_fixed_tendon_position_limit() instead.

set_fixed_tendon_limit_stiffness(limit_stiffness: torch.Tensor, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set fixed tendon limit stiffness efforts into internal buffers.

This function does not apply the tendon limit stiffness to the simulation. It only fills the buffers with the desired values. To apply the tendon limit stiffness, call the write_fixed_tendon_properties_to_sim() method.

Parameters:

• limit_stiffness – Fixed tendon limit stiffness. Shape is (len(env_ids), len(fixed_tendon_ids)).

• fixed_tendon_ids – The tendon indices to set the limit stiffness for. Defaults to None (all fixed tendons).

• env_ids – The environment indices to set the limit stiffness for. Defaults to None (all environments).

set_fixed_tendon_offset(offset: torch.Tensor, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set fixed tendon offset efforts into internal buffers.

This function does not apply the tendon offset to the simulation. It only fills the buffers with the desired values. To apply the tendon offset, call the write_fixed_tendon_properties_to_sim() function.

Parameters:

• offset – Fixed tendon offset. Shape is (len(env_ids), len(fixed_tendon_ids)).

• fixed_tendon_ids – The tendon indices to set the offset for. Defaults to None (all fixed tendons).

• env_ids – The environment indices to set the offset for. Defaults to None (all environments).

set_fixed_tendon_position_limit(limit: torch.Tensor, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set fixed tendon limit efforts into internal buffers.

This function does not apply the tendon limit to the simulation. It only fills the buffers with the desired values. To apply the tendon limit, call the write_fixed_tendon_properties_to_sim() function.

Args:

limit: Fixed tendon limit. Shape is (len(env_ids), len(fixed_tendon_ids)). fixed_tendon_ids: The tendon indices to set the limit for. Defaults to None (all fixed tendons). env_ids: The environment indices to set the limit for. Defaults to None (all environments).

set_fixed_tendon_rest_length(rest_length: torch.Tensor, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set fixed tendon rest length efforts into internal buffers.

This function does not apply the tendon rest length to the simulation. It only fills the buffers with the desired values. To apply the tendon rest length, call the write_fixed_tendon_properties_to_sim() method.

Parameters:

• rest_length – Fixed tendon rest length. Shape is (len(env_ids), len(fixed_tendon_ids)).

• fixed_tendon_ids – The tendon indices to set the rest length for. Defaults to None (all fixed tendons).

• env_ids – The environment indices to set the rest length for. Defaults to None (all environments).

set_fixed_tendon_stiffness(stiffness: torch.Tensor, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set fixed tendon stiffness into internal buffers.

This function does not apply the tendon stiffness to the simulation. It only fills the buffers with the desired values. To apply the tendon stiffness, call the write_fixed_tendon_properties_to_sim() method.

Parameters:

• stiffness – Fixed tendon stiffness. Shape is (len(env_ids), len(fixed_tendon_ids)).

• fixed_tendon_ids – The tendon indices to set the stiffness for. Defaults to None (all fixed tendons).

• env_ids – The environment indices to set the stiffness for. Defaults to None (all environments).

set_joint_effort_target(target: torch.Tensor, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set joint efforts into internal buffers.

This function does not apply the joint targets to the simulation. It only fills the buffers with the desired values. To apply the joint targets, call the write_data_to_sim() function.

Parameters:

• target – Joint effort targets. Shape is (len(env_ids), len(joint_ids)).

• joint_ids – The joint indices to set the targets for. Defaults to None (all joints).

• env_ids – The environment indices to set the targets for. Defaults to None (all environments).

set_joint_position_target(target: torch.Tensor, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set joint position targets into internal buffers.

This function does not apply the joint targets to the simulation. It only fills the buffers with the desired values. To apply the joint targets, call the write_data_to_sim() function.

Parameters:

• target – Joint position targets. Shape is (len(env_ids), len(joint_ids)).

• joint_ids – The joint indices to set the targets for. Defaults to None (all joints).

• env_ids – The environment indices to set the targets for. Defaults to None (all environments).

set_joint_velocity_target(target: torch.Tensor, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set joint velocity targets into internal buffers.

This function does not apply the joint targets to the simulation. It only fills the buffers with the desired values. To apply the joint targets, call the write_data_to_sim() function.

Parameters:

• target – Joint velocity targets. Shape is (len(env_ids), len(joint_ids)).

• joint_ids – The joint indices to set the targets for. Defaults to None (all joints).

• env_ids – The environment indices to set the targets for. Defaults to None (all environments).

set_spatial_tendon_damping(damping: torch.Tensor, spatial_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set spatial tendon damping into internal buffers.

This function does not apply the tendon damping to the simulation. It only fills the buffers with the desired values. To apply the tendon damping, call the write_spatial_tendon_properties_to_sim() method.

Parameters:

• damping – Spatial tendon damping. Shape is (len(env_ids), len(spatial_tendon_ids)).

• spatial_tendon_ids – The tendon indices to set the damping for. Defaults to None, which means all spatial tendons.

• env_ids – The environment indices to set the damping for. Defaults to None, which means all environments.

set_spatial_tendon_limit_stiffness(limit_stiffness: torch.Tensor, spatial_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set spatial tendon limit stiffness into internal buffers.

This function does not apply the tendon limit stiffness to the simulation. It only fills the buffers with the desired values. To apply the tendon limit stiffness, call the write_spatial_tendon_properties_to_sim() method.

Parameters:

• limit_stiffness – Spatial tendon limit stiffness. Shape is (len(env_ids), len(spatial_tendon_ids)).

• spatial_tendon_ids – The tendon indices to set the limit stiffness for. Defaults to None, which means all spatial tendons.

• env_ids – The environment indices to set the limit stiffness for. Defaults to None (all environments).

set_spatial_tendon_offset(offset: torch.Tensor, spatial_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set spatial tendon offset efforts into internal buffers.

This function does not apply the tendon offset to the simulation. It only fills the buffers with the desired values. To apply the tendon offset, call the write_spatial_tendon_properties_to_sim() method.

Parameters:

• offset – Spatial tendon offset. Shape is (len(env_ids), len(spatial_tendon_ids)).

• spatial_tendon_ids – The tendon indices to set the offset for. Defaults to None (all spatial tendons).

• env_ids – The environment indices to set the offset for. Defaults to None (all environments).

set_spatial_tendon_stiffness(stiffness: torch.Tensor, spatial_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Set spatial tendon stiffness into internal buffers.

This function does not apply the tendon stiffness to the simulation. It only fills the buffers with the desired values. To apply the tendon stiffness, call the write_spatial_tendon_properties_to_sim() method.

Parameters:

• stiffness – Spatial tendon stiffness. Shape is (len(env_ids), len(spatial_tendon_ids)).

• spatial_tendon_ids – The tendon indices to set the stiffness for. Defaults to None (all spatial tendons).

• env_ids – The environment indices to set the stiffness for. Defaults to None (all environments).

set_visibility(visible: bool, env_ids: Sequence[int] | None = None)

Set the visibility of the prims corresponding to the asset.

This operation affects the visibility of the prims corresponding to the asset in the USD stage. It is useful for toggling the visibility of the asset in the simulator. For instance, one can hide the asset when it is not being used to reduce the rendering overhead.

Note

This operation uses the PXR API to set the visibility of the prims. Thus, the operation may have an overhead if the number of prims is large.

Parameters:

• visible – Whether to make the prims visible or not.

• env_ids – The indices of the object to set visibility. Defaults to None (all instances).

property spatial_tendon_names: list[str]

Ordered names of spatial tendons in articulation.

update(dt: float)

Update the internal buffers.

The time step dt is used to compute numerical derivatives of quantities such as joint accelerations which are not provided by the simulator.

Parameters:

dt – The amount of time passed from last update call.

write_fixed_tendon_properties_to_sim(fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Write fixed tendon properties into the simulation.

Parameters:

• fixed_tendon_ids – The fixed tendon indices to set the limits for. Defaults to None (all fixed tendons).

• env_ids – The environment indices to set the limits for. Defaults to None (all environments).

write_joint_armature_to_sim(armature: torch.Tensor | float, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Write joint armature into the simulation.

The armature is directly added to the corresponding joint-space inertia. It helps improve the simulation stability by reducing the joint velocities.

Parameters:

• armature – Joint armature. Shape is (len(env_ids), len(joint_ids)).

• joint_ids – The joint indices to set the joint torque limits for. Defaults to None (all joints).

• env_ids – The environment indices to set the joint torque limits for. Defaults to None (all environments).

write_joint_damping_to_sim(damping: torch.Tensor | float, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Write joint damping into the simulation.

Parameters:

• damping – Joint damping. Shape is (len(env_ids), len(joint_ids)).

• joint_ids – The joint indices to set the damping for. Defaults to None (all joints).

• env_ids – The environment indices to set the damping for. Defaults to None (all environments).

write_joint_effort_limit_to_sim(limits: torch.Tensor | float, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Write joint effort limits into the simulation.

The effort limit is used to constrain the computed joint efforts in the physics engine. If the computed effort exceeds this limit, the physics engine will clip the effort to this value.

Parameters:

• limits – Joint torque limits. Shape is (len(env_ids), len(joint_ids)).

• joint_ids – The joint indices to set the joint torque limits for. Defaults to None (all joints).

• env_ids – The environment indices to set the joint torque limits for. Defaults to None (all environments).

write_joint_friction_coefficient_to_sim(joint_friction_coeff: torch.Tensor | float, joint_dynamic_friction_coeff: torch.Tensor | float | None = None, joint_viscous_friction_coeff: torch.Tensor | float | None = None, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Write joint friction coefficients into the simulation.

For Isaac Sim versions below 5.0, only the static friction coefficient is set. This limits the resisting force or torque up to a maximum proportional to the transmitted spatial force: \(\|F_{resist}\| \leq \mu_s \, \|F_{spatial}\|\).

For Isaac Sim versions 5.0 and above, the static, dynamic, and viscous friction coefficients are set. The model combines Coulomb (static & dynamic) friction with a viscous term:

• Static friction \(\mu_s\) defines the maximum effort that prevents motion at rest.

• Dynamic friction \(\mu_d\) applies once motion begins and remains constant during motion.

• Viscous friction \(c_v\) is a velocity-proportional resistive term.

Parameters:

• joint_friction_coeff – Static friction coefficient \(\mu_s\). Shape is (len(env_ids), len(joint_ids)). Scalars are broadcast to all selections.

• joint_dynamic_friction_coeff – Dynamic (Coulomb) friction coefficient \(\mu_d\). Same shape as above. If None, the dynamic coefficient is not updated.

• joint_viscous_friction_coeff – Viscous friction coefficient \(c_v\). Same shape as above. If None, the viscous coefficient is not updated.

• joint_ids – The joint indices to set the friction coefficients for. Defaults to None (all joints).

• env_ids – The environment indices to set the friction coefficients for. Defaults to None (all environments).

write_joint_friction_to_sim(joint_friction: torch.Tensor | float, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Write joint friction coefficients into the simulation.

Deprecated since version 2.1.0: Please use write_joint_friction_coefficient_to_sim() instead.

write_joint_limits_to_sim(limits: torch.Tensor | float, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None, warn_limit_violation: bool = True)

Write joint limits into the simulation.

Deprecated since version 2.1.0: Please use write_joint_position_limit_to_sim() instead.

write_joint_position_limit_to_sim(limits: torch.Tensor | float, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None, warn_limit_violation: bool = True)

Write joint position limits into the simulation.

Parameters:

• limits – Joint limits. Shape is (len(env_ids), len(joint_ids), 2).

• joint_ids – The joint indices to set the limits for. Defaults to None (all joints).

• env_ids – The environment indices to set the limits for. Defaults to None (all environments).

• warn_limit_violation – Whether to use warning or info level logging when default joint positions exceed the new limits. Defaults to True.

write_joint_position_to_sim(position: torch.Tensor, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | slice | None = None)

Write joint positions to the simulation.

Parameters:

• position – Joint positions. Shape is (len(env_ids), len(joint_ids)).

• joint_ids – The joint indices to set the targets for. Defaults to None (all joints).

• env_ids – The environment indices to set the targets for. Defaults to None (all environments).

write_joint_state_to_sim(position: torch.Tensor, velocity: torch.Tensor, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | slice | None = None)

Write joint positions and velocities to the simulation.

Parameters:

• position – Joint positions. Shape is (len(env_ids), len(joint_ids)).

• velocity – Joint velocities. Shape is (len(env_ids), len(joint_ids)).

• joint_ids – The joint indices to set the targets for. Defaults to None (all joints).

• env_ids – The environment indices to set the targets for. Defaults to None (all environments).

write_joint_stiffness_to_sim(stiffness: torch.Tensor | float, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Write joint stiffness into the simulation.

Parameters:

• stiffness – Joint stiffness. Shape is (len(env_ids), len(joint_ids)).

• joint_ids – The joint indices to set the stiffness for. Defaults to None (all joints).

• env_ids – The environment indices to set the stiffness for. Defaults to None (all environments).

write_joint_velocity_limit_to_sim(limits: torch.Tensor | float, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Write joint max velocity to the simulation.

The velocity limit is used to constrain the joint velocities in the physics engine. The joint will only be able to reach this velocity if the joint’s effort limit is sufficiently large. If the joint is moving faster than this velocity, the physics engine will actually try to brake the joint to reach this velocity.

Parameters:

• limits – Joint max velocity. Shape is (len(env_ids), len(joint_ids)).

• joint_ids – The joint indices to set the max velocity for. Defaults to None (all joints).

• env_ids – The environment indices to set the max velocity for. Defaults to None (all environments).

write_joint_velocity_to_sim(velocity: torch.Tensor, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | slice | None = None)

Write joint velocities to the simulation.

Parameters:

• velocity – Joint velocities. Shape is (len(env_ids), len(joint_ids)).

• joint_ids – The joint indices to set the targets for. Defaults to None (all joints).

• env_ids – The environment indices to set the targets for. Defaults to None (all environments).

write_root_com_pose_to_sim(root_pose: torch.Tensor, env_ids: Sequence[int] | None = None)

Set the root center of mass pose over selected environment indices into the simulation.

The root pose comprises of the cartesian position and quaternion orientation in (w, x, y, z). The orientation is the orientation of the principle axes of inertia.

Parameters:

• root_pose – Root center of mass poses in simulation frame. Shape is (len(env_ids), 7).

• env_ids – Environment indices. If None, then all indices are used.

write_root_com_state_to_sim(root_state: torch.Tensor, env_ids: Sequence[int] | None = None)

Set the root center of mass state over selected environment indices into the simulation.

The root state comprises of the cartesian position, quaternion orientation in (w, x, y, z), and linear and angular velocity. All the quantities are in the simulation frame.

Parameters:

• root_state – Root state in simulation frame. Shape is (len(env_ids), 13).

• env_ids – Environment indices. If None, then all indices are used.

write_root_com_velocity_to_sim(root_velocity: torch.Tensor, env_ids: Sequence[int] | None = None)

Set the root center of mass velocity over selected environment indices into the simulation.

The velocity comprises linear velocity (x, y, z) and angular velocity (x, y, z) in that order. NOTE: This sets the velocity of the root’s center of mass rather than the roots frame.

Parameters:

• root_velocity – Root center of mass velocities in simulation world frame. Shape is (len(env_ids), 6).

• env_ids – Environment indices. If None, then all indices are used.

write_root_link_pose_to_sim(root_pose: torch.Tensor, env_ids: Sequence[int] | None = None)

Set the root link pose over selected environment indices into the simulation.

The root pose comprises of the cartesian position and quaternion orientation in (w, x, y, z).

Parameters:

• root_pose – Root poses in simulation frame. Shape is (len(env_ids), 7).

• env_ids – Environment indices. If None, then all indices are used.

write_root_link_state_to_sim(root_state: torch.Tensor, env_ids: Sequence[int] | None = None)

Set the root link state over selected environment indices into the simulation.

The root state comprises of the cartesian position, quaternion orientation in (w, x, y, z), and linear and angular velocity. All the quantities are in the simulation frame.

Parameters:

• root_state – Root state in simulation frame. Shape is (len(env_ids), 13).

• env_ids – Environment indices. If None, then all indices are used.

write_root_link_velocity_to_sim(root_velocity: torch.Tensor, env_ids: Sequence[int] | None = None)

Set the root link velocity over selected environment indices into the simulation.

The velocity comprises linear velocity (x, y, z) and angular velocity (x, y, z) in that order. NOTE: This sets the velocity of the root’s frame rather than the roots center of mass.

Parameters:

• root_velocity – Root frame velocities in simulation world frame. Shape is (len(env_ids), 6).

• env_ids – Environment indices. If None, then all indices are used.

write_root_pose_to_sim(root_pose: torch.Tensor, env_ids: Sequence[int] | None = None)

Set the root pose over selected environment indices into the simulation.

The root pose comprises of the cartesian position and quaternion orientation in (w, x, y, z).

Parameters:

• root_pose – Root poses in simulation frame. Shape is (len(env_ids), 7).

• env_ids – Environment indices. If None, then all indices are used.

write_root_state_to_sim(root_state: torch.Tensor, env_ids: Sequence[int] | None = None)

Set the root state over selected environment indices into the simulation.

The root state comprises of the cartesian position, quaternion orientation in (w, x, y, z), and linear and angular velocity. All the quantities are in the simulation frame.

Parameters:

• root_state – Root state in simulation frame. Shape is (len(env_ids), 13).

• env_ids – Environment indices. If None, then all indices are used.

write_root_velocity_to_sim(root_velocity: torch.Tensor, env_ids: Sequence[int] | None = None)

Set the root center of mass velocity over selected environment indices into the simulation.

The velocity comprises linear velocity (x, y, z) and angular velocity (x, y, z) in that order. NOTE: This sets the velocity of the root’s center of mass rather than the roots frame.

Parameters:

• root_velocity – Root center of mass velocities in simulation world frame. Shape is (len(env_ids), 6).

• env_ids – Environment indices. If None, then all indices are used.

write_spatial_tendon_properties_to_sim(spatial_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)

Write spatial tendon properties into the simulation.

Parameters:

• spatial_tendon_ids – The spatial tendon indices to set the properties for. Defaults to None, which means all spatial tendons.

• env_ids – The environment indices to set the properties for. Defaults to None, which means all environments.

class isaaclab_contrib.assets.MultirotorCfg

Bases: ArticulationCfg

Configuration parameters for a multirotor articulation.

This configuration class extends ArticulationCfg to add multirotor-specific parameters including thruster actuators, allocation matrices, and thruster-specific initial states.

Unlike standard articulations that use joint actuators, multirotors are configured with ThrusterCfg actuators that model individual rotor/propeller dynamics.

Key Configuration Parameters:

• actuators: Dictionary mapping actuator names to ThrusterCfg configurations. Each configuration defines a group of thrusters with shared properties.

• allocation_matrix: Maps individual thruster forces to 6D body wrenches. This matrix encodes the geometric configuration and should have shape (6, num_thrusters).

• thruster_force_direction: Direction vector in body frame that thrusters push along. Typically (0, 0, 1) for upward-facing thrusters.

• rotor_directions: Spin direction of each rotor (1 for CCW, -1 for CW). Used for computing reaction torques.

Example

from isaaclab_contrib.assets import MultirotorCfg
from isaaclab_contrib.actuators import ThrusterCfg
import isaaclab.sim as sim_utils

# Quadcopter configuration
quadcopter_cfg = MultirotorCfg(
    prim_path="/World/envs/env_.*/Quadcopter",
    spawn=sim_utils.UsdFileCfg(
        usd_path="path/to/quadcopter.usd",
    ),
    init_state=MultirotorCfg.InitialStateCfg(
        pos=(0.0, 0.0, 1.0),  # Start 1m above ground
        rps={".*": 110.0},  # All thrusters at 110 RPS (hover)
    ),
    actuators={
        "thrusters": ThrusterCfg(
            thruster_names_expr=["rotor_[0-3]"],
            thrust_range=(0.0, 12.0),  # 0-12N per thruster
            rise_time_constant=0.12,
            fall_time_constant=0.25,
        ),
    },
    allocation_matrix=[
        [1.0, 1.0, 1.0, 1.0],  # Vertical thrust
        [0.0, 0.0, 0.0, 0.0],  # Lateral force X
        [0.0, 0.0, 0.0, 0.0],  # Lateral force Y
        [0.0, 0.13, 0.0, -0.13],  # Roll torque
        [-0.13, 0.0, 0.13, 0.0],  # Pitch torque
        [0.01, -0.01, 0.01, -0.01],  # Yaw torque
    ],
    rotor_directions=[1, -1, 1, -1],  # Alternating CW/CCW
)

See also

• ArticulationCfg: Base articulation configuration

• ThrusterCfg: Thruster actuator configuration

• Multirotor: Multirotor asset class

Classes:

InitialStateCfg

Initial state of the multirotor articulation.

Attributes:

init_state	Initial state of the multirotor object.
actuators	Thruster actuators for the multirotor with corresponding thruster names.
prim_path	Prim path (or expression) to the asset.
spawn	Spawn configuration for the asset.
collision_group	Collision group of the asset.
debug_vis	Whether to enable debug visualization for the asset.
articulation_root_prim_path	Path to the articulation root prim under the prim_path.
soft_joint_pos_limit_factor	Fraction specifying the range of joint position limits (parsed from the asset) to use.
actuator_value_resolution_debug_print	Print the resolution of actuator final value when input cfg is different from USD value, Defaults to False
thruster_force_direction	Default force direction in body-local frame for thrusters.
allocation_matrix	Allocation matrix for control allocation.
rotor_directions	Sequence of rotor directions for each thruster.

class InitialStateCfg

Bases: InitialStateCfg

Initial state of the multirotor articulation.

This extends the base articulation initial state to include thruster-specific initial conditions. The thruster initial state is particularly important for multirotor stability, as it determines the starting thrust levels.

For hovering multirotors, the initial RPS should be set to values that produce enough thrust to counteract gravity.

Attributes:

rps	Revolutions per second (RPS) of the thrusters.
pos	Position of the root in simulation world frame.
rot	Quaternion rotation (w, x, y, z) of the root in simulation world frame.
lin_vel	Linear velocity of the root in simulation world frame.
ang_vel	Angular velocity of the root in simulation world frame.
joint_pos	Joint positions of the joints.
joint_vel	Joint velocities of the joints.

rps: dict[str, float]

Revolutions per second (RPS) of the thrusters. Default is 100 RPS.

This can be specified as:

• A dictionary mapping regex patterns to RPS values

• A single wildcard pattern like {".*": 100.0} for uniform RPS

• Explicit per-thruster values like {"rotor_0": 95.0, "rotor_1": 105.0}

The RPS values are used to initialize the thruster states and determine the default thrust targets when the multirotor is reset.

Example

# Uniform RPS for all thrusters
rps = {".*": 110.0}

# Different RPS for different thruster groups
rps = {"rotor_[0-1]": 105.0, "rotor_[2-3]": 115.0}

Note

The actual thrust produced depends on the thruster model’s thrust curve and other parameters in ThrusterCfg.

pos: tuple[float, float, float]

Position of the root in simulation world frame. Defaults to (0.0, 0.0, 0.0).

rot: tuple[float, float, float, float]

Quaternion rotation (w, x, y, z) of the root in simulation world frame. Defaults to (1.0, 0.0, 0.0, 0.0).

lin_vel: tuple[float, float, float]

Linear velocity of the root in simulation world frame. Defaults to (0.0, 0.0, 0.0).

ang_vel: tuple[float, float, float]

Angular velocity of the root in simulation world frame. Defaults to (0.0, 0.0, 0.0).

joint_pos: dict[str, float]

Joint positions of the joints. Defaults to 0.0 for all joints.

joint_vel: dict[str, float]

Joint velocities of the joints. Defaults to 0.0 for all joints.

init_state: InitialStateCfg

Initial state of the multirotor object.

This includes both the base articulation state (position, orientation, velocities) and multirotor-specific state (thruster RPS). See InitialStateCfg for details.

actuators: dict[str, isaaclab_contrib.actuators.thruster_cfg.ThrusterCfg]

Thruster actuators for the multirotor with corresponding thruster names.

This dictionary maps actuator group names to their configurations. Each ThrusterCfg defines a group of thrusters with shared dynamic properties (rise/fall times, thrust limits, etc.).

Example

actuators = {
    "thrusters": ThrusterCfg(
        thruster_names_expr=["rotor_.*"],  # Regex to match thruster bodies
        thrust_range=(0.0, 10.0),
        rise_time_constant=0.1,
        fall_time_constant=0.2,
    )
}

Note

Unlike standard articulations, multirotors should only contain thruster actuators. Mixing joint-based and thrust-based actuators is not currently supported.

prim_path: str

Prim path (or expression) to the asset.

Note

The expression can contain the environment namespace regex {ENV_REGEX_NS} which will be replaced with the environment namespace.

Example: {ENV_REGEX_NS}/Robot will be replaced with /World/envs/env_.*/Robot.

spawn: SpawnerCfg | None

Spawn configuration for the asset. Defaults to None.

If None, then no prims are spawned by the asset class. Instead, it is assumed that the asset is already present in the scene.

collision_group: Literal[0, -1]

Collision group of the asset. Defaults to 0.

• -1: global collision group (collides with all assets in the scene).

• 0: local collision group (collides with other assets in the same environment).

debug_vis: bool

Whether to enable debug visualization for the asset. Defaults to False.

articulation_root_prim_path: str | None

Path to the articulation root prim under the prim_path. Defaults to None, in which case the class will search for a prim with the USD ArticulationRootAPI on it.

This path should be relative to the prim_path of the asset. If the asset is loaded from a USD file, this path should be relative to the root of the USD stage. For instance, if the loaded USD file at prim_path contains two articulations, one at /robot1 and another at /robot2, and you want to use robot2, then you should set this to /robot2.

The path must start with a slash (/).

soft_joint_pos_limit_factor: float

Fraction specifying the range of joint position limits (parsed from the asset) to use. Defaults to 1.0.

The soft joint position limits are scaled by this factor to specify a safety region within the simulated joint position limits. This isn’t used by the simulation, but is useful for learning agents to prevent the joint positions from violating the limits, such as for termination conditions.

The soft joint position limits are accessible through the ArticulationData.soft_joint_pos_limits attribute.

actuator_value_resolution_debug_print: bool

Print the resolution of actuator final value when input cfg is different from USD value, Defaults to False

thruster_force_direction: tuple[float, float, float]

Default force direction in body-local frame for thrusters. Default is (0.0, 0.0, 1.0), which is upward along the Z-axis.

This 3D unit vector specifies the direction in which thrusters generate force in the multirotor’s body frame. For standard configurations:

• (0.0, 0.0, 1.0): Thrusters push upward (Z-axis, typical for quadcopters)

• (0.0, 0.0, -1.0): Thrusters push downward

• (1.0, 0.0, 0.0): Thrusters push forward (X-axis)

This is used in conjunction with the allocation matrix to compute the wrench produced by each thruster.

Default: (0.0, 0.0, 1.0) (upward along Z-axis)

allocation_matrix: Sequence[Sequence[float]] | None

Allocation matrix for control allocation. Default is None, which means that the thrusters are not used for control allocation.

This matrix maps individual thruster forces to the 6D wrench (force + torque) applied to the multirotor’s base link. It has shape (6, num_thrusters):

• Rows 0-2: Force contributions in body frame (Fx, Fy, Fz)

• Rows 3-5: Torque contributions in body frame (Tx, Ty, Tz)

The allocation matrix encodes the geometric configuration of the multirotor, including thruster positions, orientations, and moment arms.

Example for a quadcopter (4 thrusters in + configuration):

allocation_matrix = [
    [1.0,  1.0,  1.0,  1.0],     # Total vertical thrust
    [0.0,  0.0,  0.0,  0.0],     # No lateral force
    [0.0,  0.0,  0.0,  0.0],     # No lateral force
    [0.0,  0.13, 0.0, -0.13],    # Roll moment (left/right)
    [-0.13, 0.0, 0.13, 0.0],     # Pitch moment (forward/back)
    [0.01,-0.01, 0.01,-0.01],    # Yaw moment (rotation)
]

Note

If None, forces must be applied through other means. For typical multirotor control, this should always be specified.

rotor_directions: Sequence[int] | None

Sequence of rotor directions for each thruster. Default is None, which means that the rotor directions are not specified.

This specifies the spin direction of each rotor, which affects the reaction torques generated. Values should be:

• 1: Counter-clockwise (CCW) rotation

• -1: Clockwise (CW) rotation

For a quadcopter, a typical configuration is alternating directions to cancel reaction torques during hover: [1, -1, 1, -1].

Example

# Quadcopter with alternating rotor directions
rotor_directions = [1, -1, 1, -1]

# Hexacopter
rotor_directions = [1, -1, 1, -1, 1, -1]

Note

The length must match the total number of thrusters defined in the actuators configuration, otherwise a ValueError will be raised during initialization.

class isaaclab_contrib.assets.MultirotorData

Bases: ArticulationData

Data container for a multirotor articulation.

This class extends the base ArticulationData container to include multirotor-specific data such as thruster states, thrust targets, and computed forces. It provides access to all the state information needed for monitoring and controlling multirotor vehicles.

The data container is automatically created and managed by the Multirotor class. Users typically access this data through the Multirotor.data property.

Note

All tensor attributes have shape (num_instances, num_thrusters) where num_instances is the number of environment instances and num_thrusters is the total number of thrusters per multirotor.

See also

• ArticulationData: Base articulation data container

• Multirotor: Multirotor asset class

Attributes:

thruster_names	List of thruster names in the multirotor.
default_thruster_rps	Default thruster RPS (revolutions per second) state of all thrusters.
applied_torque	Joint torques applied from the actuator model (after clipping).
body_acc_w	Same as body_com_acc_w.
body_ang_acc_w	Same as body_com_ang_acc_w.
body_ang_vel_w	Same as body_com_ang_vel_w.
body_com_acc_w	Acceleration of all bodies center of mass [lin_acc, ang_acc].
body_com_ang_acc_w	Angular acceleration of all bodies in simulation world frame.
body_com_ang_vel_w	Angular velocity of all bodies in simulation world frame.
body_com_lin_acc_w	Linear acceleration of all bodies in simulation world frame.
body_com_lin_vel_w	Linear velocity of all bodies in simulation world frame.
body_com_pos_b	Center of mass position of all of the bodies in their respective link frames.
body_com_pos_w	Positions of all bodies in simulation world frame.
body_com_pose_b	Center of mass pose [pos, quat] of all bodies in their respective body's link frames.
body_com_pose_w	Body center of mass pose [pos, quat] in simulation world frame.
body_com_quat_b	Orientation (w, x, y, z) of the principle axis of inertia of all of the bodies in their respective link frames.
body_com_quat_w	Orientation (w, x, y, z) of the principle axis of inertia of all bodies in simulation world frame.
body_com_state_w	State of all bodies center of mass [pos, quat, lin_vel, ang_vel] in simulation world frame.
body_com_vel_w	Body center of mass velocity [lin_vel, ang_vel] in simulation world frame.
body_incoming_joint_wrench_b	Joint reaction wrench applied from body parent to child body in parent body frame.
body_lin_acc_w	Same as body_com_lin_acc_w.
body_lin_vel_w	Same as body_com_lin_vel_w.
body_link_ang_vel_w	Angular velocity of all bodies in simulation world frame.
body_link_lin_vel_w	Linear velocity of all bodies in simulation world frame.
body_link_pos_w	Positions of all bodies in simulation world frame.
body_link_pose_w	Body link pose [pos, quat] in simulation world frame.
body_link_quat_w	Orientation (w, x, y, z) of all bodies in simulation world frame.
body_link_state_w	State of all bodies' link frame`[pos, quat, lin_vel, ang_vel]` in simulation world frame.
body_link_vel_w	Body link velocity [lin_vel, ang_vel] in simulation world frame.
body_names	Body names in the order parsed by the simulation view.
body_pos_w	Same as body_link_pos_w.
body_pose_w	Same as body_link_pose_w.
body_quat_w	Same as body_link_quat_w.
body_state_w	State of all bodies [pos, quat, lin_vel, ang_vel] in simulation world frame.
body_vel_w	Same as body_com_vel_w.
com_pos_b	Same as body_com_pos_b.
com_quat_b	Same as body_com_quat_b.
computed_torque	Joint torques computed from the actuator model (before clipping).
default_fixed_tendon_damping	Default tendon damping of all fixed tendons.
default_fixed_tendon_limit	Deprecated property.
default_fixed_tendon_limit_stiffness	Default tendon limit stiffness of all fixed tendons.
default_fixed_tendon_offset	Default tendon offset of all fixed tendons.
default_fixed_tendon_pos_limits	Default tendon position limits of all fixed tendons.
default_fixed_tendon_rest_length	Default tendon rest length of all fixed tendons.
default_fixed_tendon_stiffness	Default tendon stiffness of all fixed tendons.
default_inertia	Default inertia for all the bodies in the articulation.
default_joint_armature	Default joint armature of all joints.
default_joint_damping	Default joint damping of all joints.
default_joint_dynamic_friction_coeff	Default joint dynamic friction coefficient of all joints.
default_joint_friction	Deprecated property.
default_joint_friction_coeff	Default joint static friction coefficient of all joints.
default_joint_limits	Deprecated property.
default_joint_pos	Default joint positions of all joints.
default_joint_pos_limits	Default joint position limits of all joints.
default_joint_stiffness	Default joint stiffness of all joints.
default_joint_vel	Default joint velocities of all joints.
default_joint_viscous_friction_coeff	Default joint viscous friction coefficient of all joints.
default_mass	Default mass for all the bodies in the articulation.
default_root_state	Default root state [pos, quat, lin_vel, ang_vel] in the local environment frame.
default_spatial_tendon_damping	Default tendon damping of all spatial tendons.
default_spatial_tendon_limit_stiffness	Default tendon limit stiffness of all spatial tendons.
default_spatial_tendon_offset	Default tendon offset of all spatial tendons.
default_spatial_tendon_stiffness	Default tendon stiffness of all spatial tendons.
fixed_tendon_damping	Fixed tendon damping provided to the simulation.
fixed_tendon_limit	Deprecated property.
fixed_tendon_limit_stiffness	Fixed tendon limit stiffness provided to the simulation.
fixed_tendon_names	Fixed tendon names in the order parsed by the simulation view.
fixed_tendon_offset	Fixed tendon offset provided to the simulation.
fixed_tendon_pos_limits	Fixed tendon position limits provided to the simulation.
fixed_tendon_rest_length	Fixed tendon rest length provided to the simulation.
fixed_tendon_stiffness	Fixed tendon stiffness provided to the simulation.
gear_ratio	Gear ratio for relating motor torques to applied Joint torques.
heading_w	Yaw heading of the base frame (in radians).
joint_acc	Joint acceleration of all joints.
joint_armature	Joint armature provided to the simulation.
joint_damping	Joint damping provided to the simulation.
joint_dynamic_friction_coeff	Joint dynamic friction coefficient provided to the simulation.
joint_effort_limits	Joint maximum effort provided to the simulation.
joint_effort_target	Joint effort targets commanded by the user.
joint_friction	Deprecated property.
joint_friction_coeff	Joint static friction coefficient provided to the simulation.
joint_limits	Deprecated property.
joint_names	Joint names in the order parsed by the simulation view.
joint_pos	Joint positions of all joints.
joint_pos_limits	Joint position limits provided to the simulation.
joint_pos_target	Joint position targets commanded by the user.
joint_stiffness	Joint stiffness provided to the simulation.
joint_vel	Joint velocities of all joints.
joint_vel_limits	Joint maximum velocity provided to the simulation.
joint_vel_target	Joint velocity targets commanded by the user.
joint_velocity_limits	Deprecated property.
joint_viscous_friction_coeff	Joint viscous friction coefficient provided to the simulation.
projected_gravity_b	Projection of the gravity direction on base frame.
root_ang_vel_b	Same as root_com_ang_vel_b.
root_ang_vel_w	Same as root_com_ang_vel_w.
root_com_ang_vel_b	Root center of mass angular velocity in base world frame.
root_com_ang_vel_w	Root center of mass angular velocity in simulation world frame.
root_com_lin_vel_b	Root center of mass linear velocity in base frame.
root_com_lin_vel_w	Root center of mass linear velocity in simulation world frame.
root_com_pos_w	Root center of mass position in simulation world frame.
root_com_pose_w	Root center of mass pose [pos, quat] in simulation world frame.
root_com_quat_w	Root center of mass orientation (w, x, y, z) in simulation world frame.
root_com_state_w	Root center of mass state [pos, quat, lin_vel, ang_vel] in simulation world frame.
root_com_vel_w	Root center of mass velocity [lin_vel, ang_vel] in simulation world frame.
root_lin_vel_b	Same as root_com_lin_vel_b.
root_lin_vel_w	Same as root_com_lin_vel_w.
root_link_ang_vel_b	Root link angular velocity in base world frame.
root_link_ang_vel_w	Root link angular velocity in simulation world frame.
root_link_lin_vel_b	Root link linear velocity in base frame.
root_link_lin_vel_w	Root linear velocity in simulation world frame.
root_link_pos_w	Root link position in simulation world frame.
root_link_pose_w	Root link pose [pos, quat] in simulation world frame.
root_link_quat_w	Root link orientation (w, x, y, z) in simulation world frame.
root_link_state_w	Root state [pos, quat, lin_vel, ang_vel] in simulation world frame.
root_link_vel_w	Root link velocity [lin_vel, ang_vel] in simulation world frame.
root_pos_w	Same as root_link_pos_w.
root_pose_w	Same as root_link_pose_w.
root_quat_w	Same as root_link_quat_w.
root_state_w	Root state [pos, quat, lin_vel, ang_vel] in simulation world frame.
root_vel_w	Same as root_com_vel_w.
soft_joint_pos_limits	Soft joint positions limits for all joints.
soft_joint_vel_limits	Soft joint velocity limits for all joints.
spatial_tendon_damping	Spatial tendon damping provided to the simulation.
spatial_tendon_limit_stiffness	Spatial tendon limit stiffness provided to the simulation.
spatial_tendon_names	Spatial tendon names in the order parsed by the simulation view.
spatial_tendon_offset	Spatial tendon offset provided to the simulation.
spatial_tendon_stiffness	Spatial tendon stiffness provided to the simulation.
thrust_target	Thrust targets commanded by the user or controller.
computed_thrust	Computed thrust from the actuator model before clipping.
applied_thrust	Applied thrust from the actuator model after clipping.

Methods:

__init__(root_physx_view, device)

Initializes the articulation data.

thruster_names: list[str] = None

List of thruster names in the multirotor.

This list contains the ordered names of all thrusters, matching the order used for indexing in the thrust tensors. The names correspond to the USD body prim names matched by the thruster name expressions in the actuator configuration.

Example

["rotor_0", "rotor_1", "rotor_2", "rotor_3"] for a quadcopter

default_thruster_rps: torch.Tensor = None

Default thruster RPS (revolutions per second) state of all thrusters. Shape is (num_instances, num_thrusters).

This quantity is configured through the MultirotorCfg.init_state.rps parameter and represents the baseline/hover RPS for each thruster. It is used to initialize thruster states during reset operations.

For a hovering multirotor, these values should produce enough collective thrust to counteract gravity.

Example

For a 1kg quadcopter with 4 thrusters, if each thruster produces 2.5N at 110 RPS, the default might be [[110.0, 110.0, 110.0, 110.0]] for hover.

__init__(root_physx_view: omni.physics.tensors.impl.api.ArticulationView, device: str)

Initializes the articulation data.

Parameters:

• root_physx_view – The root articulation view.

• device – The device used for processing.

applied_torque: torch.Tensor = None

Joint torques applied from the actuator model (after clipping). Shape is (num_instances, num_joints).

These torques are set into the simulation, after clipping the computed_torque based on the actuator model.

property body_acc_w: torch.Tensor

Same as body_com_acc_w.

property body_ang_acc_w: torch.Tensor

Same as body_com_ang_acc_w.

property body_ang_vel_w: torch.Tensor

Same as body_com_ang_vel_w.

property body_com_acc_w

Acceleration of all bodies center of mass [lin_acc, ang_acc]. Shape is (num_instances, num_bodies, 6).

All values are relative to the world.

property body_com_ang_acc_w: torch.Tensor

Angular acceleration of all bodies in simulation world frame. Shape is (num_instances, num_bodies, 3).

This quantity is the angular acceleration of the articulation bodies’ center of mass frame.

property body_com_ang_vel_w: torch.Tensor

Angular velocity of all bodies in simulation world frame. Shape is (num_instances, num_bodies, 3).

This quantity is the angular velocity of the articulation bodies’ center of mass frame.

property body_com_lin_acc_w: torch.Tensor

Linear acceleration of all bodies in simulation world frame. Shape is (num_instances, num_bodies, 3).

This quantity is the linear acceleration of the articulation bodies’ center of mass frame.

property body_com_lin_vel_w: torch.Tensor

Linear velocity of all bodies in simulation world frame. Shape is (num_instances, num_bodies, 3).

This quantity is the linear velocity of the articulation bodies’ center of mass frame.

property body_com_pos_b: torch.Tensor

Center of mass position of all of the bodies in their respective link frames. Shape is (num_instances, num_bodies, 3).

This quantity is the center of mass location relative to its body’slink frame.

property body_com_pos_w: torch.Tensor

Positions of all bodies in simulation world frame. Shape is (num_instances, num_bodies, 3).

This quantity is the position of the articulation bodies’ actor frame.

property body_com_pose_b: torch.Tensor

Center of mass pose [pos, quat] of all bodies in their respective body’s link frames. Shape is (num_instances, 1, 7).

This quantity is the pose of the center of mass frame of the rigid body relative to the body’s link frame. The orientation is provided in (w, x, y, z) format.

property body_com_pose_w: torch.Tensor

Body center of mass pose [pos, quat] in simulation world frame. Shape is (num_instances, num_bodies, 7).

This quantity is the pose of the center of mass frame of the articulation links relative to the world. The orientation is provided in (w, x, y, z) format.

property body_com_quat_b: torch.Tensor

Orientation (w, x, y, z) of the principle axis of inertia of all of the bodies in their respective link frames. Shape is (num_instances, num_bodies, 4).

This quantity is the orientation of the principles axes of inertia relative to its body’s link frame.

property body_com_quat_w: torch.Tensor

Orientation (w, x, y, z) of the principle axis of inertia of all bodies in simulation world frame. Shape is (num_instances, num_bodies, 4).

This quantity is the orientation of the articulation bodies’ actor frame.

property body_com_state_w

State of all bodies center of mass [pos, quat, lin_vel, ang_vel] in simulation world frame. Shape is (num_instances, num_bodies, 13).

The position, quaternion, and linear/angular velocity are of the body’s center of mass frame relative to the world. Center of mass frame is assumed to be the same orientation as the link rather than the orientation of the principle inertia.

property body_com_vel_w: torch.Tensor

Body center of mass velocity [lin_vel, ang_vel] in simulation world frame. Shape is (num_instances, num_bodies, 6).

This quantity contains the linear and angular velocities of the articulation links’ center of mass frame relative to the world.

property body_incoming_joint_wrench_b: torch.Tensor

Joint reaction wrench applied from body parent to child body in parent body frame.

Shape is (num_instances, num_bodies, 6). All body reaction wrenches are provided including the root body to the world of an articulation.

For more information on joint wrenches, please check the`PhysX documentation`_ and the underlying PhysX Tensor API.

property body_lin_acc_w: torch.Tensor

Same as body_com_lin_acc_w.

property body_lin_vel_w: torch.Tensor

Same as body_com_lin_vel_w.

property body_link_ang_vel_w: torch.Tensor

Angular velocity of all bodies in simulation world frame. Shape is (num_instances, num_bodies, 3).

This quantity is the angular velocity of the articulation bodies’ center of mass frame relative to the world.

property body_link_lin_vel_w: torch.Tensor

Linear velocity of all bodies in simulation world frame. Shape is (num_instances, num_bodies, 3).

This quantity is the linear velocity of the articulation bodies’ center of mass frame relative to the world.

property body_link_pos_w: torch.Tensor

Positions of all bodies in simulation world frame. Shape is (num_instances, num_bodies, 3).

This quantity is the position of the articulation bodies’ actor frame relative to the world.

property body_link_pose_w: torch.Tensor

Body link pose [pos, quat] in simulation world frame. Shape is (num_instances, num_bodies, 7).

This quantity is the pose of the articulation links’ actor frame relative to the world. The orientation is provided in (w, x, y, z) format.

property body_link_quat_w: torch.Tensor

Orientation (w, x, y, z) of all bodies in simulation world frame. Shape is (num_instances, num_bodies, 4).

This quantity is the orientation of the articulation bodies’ actor frame relative to the world.

property body_link_state_w

State of all bodies’ link frame`[pos, quat, lin_vel, ang_vel]` in simulation world frame. Shape is (num_instances, num_bodies, 13).

The position, quaternion, and linear/angular velocity are of the body’s link frame relative to the world.

property body_link_vel_w: torch.Tensor

Body link velocity [lin_vel, ang_vel] in simulation world frame. Shape is (num_instances, num_bodies, 6).

This quantity contains the linear and angular velocities of the articulation links’ actor frame relative to the world.

body_names: list[str] = None

Body names in the order parsed by the simulation view.

property body_pos_w: torch.Tensor

Same as body_link_pos_w.

property body_pose_w: torch.Tensor

Same as body_link_pose_w.

property body_quat_w: torch.Tensor

Same as body_link_quat_w.

property body_state_w

State of all bodies [pos, quat, lin_vel, ang_vel] in simulation world frame. Shape is (num_instances, num_bodies, 13).

The position and quaternion are of all the articulation links’ actor frame. Meanwhile, the linear and angular velocities are of the articulation links’s center of mass frame.

property body_vel_w: torch.Tensor

Same as body_com_vel_w.

property com_pos_b: torch.Tensor

Same as body_com_pos_b.

property com_quat_b: torch.Tensor

Same as body_com_quat_b.

computed_torque: torch.Tensor = None

Joint torques computed from the actuator model (before clipping). Shape is (num_instances, num_joints).

This quantity is the raw torque output from the actuator mode, before any clipping is applied. It is exposed for users who want to inspect the computations inside the actuator model. For instance, to penalize the learning agent for a difference between the computed and applied torques.

default_fixed_tendon_damping: torch.Tensor = None

Default tendon damping of all fixed tendons. Shape is (num_instances, num_fixed_tendons).

This quantity is parsed from the USD schema at the time of initialization.

property default_fixed_tendon_limit: torch.Tensor

Deprecated property. Please use default_fixed_tendon_pos_limits instead.

default_fixed_tendon_limit_stiffness: torch.Tensor = None

Default tendon limit stiffness of all fixed tendons. Shape is (num_instances, num_fixed_tendons).

This quantity is parsed from the USD schema at the time of initialization.

default_fixed_tendon_offset: torch.Tensor = None

Default tendon offset of all fixed tendons. Shape is (num_instances, num_fixed_tendons).

This quantity is parsed from the USD schema at the time of initialization.

default_fixed_tendon_pos_limits: torch.Tensor = None

Default tendon position limits of all fixed tendons. Shape is (num_instances, num_fixed_tendons, 2).

The position limits are in the order \([lower, upper]\). They are parsed from the USD schema at the time of initialization.

default_fixed_tendon_rest_length: torch.Tensor = None

Default tendon rest length of all fixed tendons. Shape is (num_instances, num_fixed_tendons).

This quantity is parsed from the USD schema at the time of initialization.

default_fixed_tendon_stiffness: torch.Tensor = None

Default tendon stiffness of all fixed tendons. Shape is (num_instances, num_fixed_tendons).

This quantity is parsed from the USD schema at the time of initialization.

default_inertia: torch.Tensor = None

Default inertia for all the bodies in the articulation. Shape is (num_instances, num_bodies, 9).

The inertia tensor should be given with respect to the center of mass, expressed in the articulation links’ actor frame. The values are stored in the order \([I_{xx}, I_{yx}, I_{zx}, I_{xy}, I_{yy}, I_{zy}, I_{xz}, I_{yz}, I_{zz}]\). However, due to the symmetry of inertia tensors, row- and column-major orders are equivalent.

This quantity is parsed from the USD schema at the time of initialization.

default_joint_armature: torch.Tensor = None

Default joint armature of all joints. Shape is (num_instances, num_joints).

This quantity is configured through the actuator model’s isaaclab.actuators.ActuatorBaseCfg.armature parameter. If the parameter’s value is None, the value parsed from the USD schema, at the time of initialization, is used.

default_joint_damping: torch.Tensor = None

Default joint damping of all joints. Shape is (num_instances, num_joints).

This quantity is configured through the actuator model’s isaaclab.actuators.ActuatorBaseCfg.damping parameter. If the parameter’s value is None, the value parsed from the USD schema, at the time of initialization, is used.

Attention

The default stiffness is the value configured by the user or the value parsed from the USD schema. It should not be confused with joint_damping, which is the value set into the simulation.

default_joint_dynamic_friction_coeff: torch.Tensor = None

Default joint dynamic friction coefficient of all joints. Shape is (num_instances, num_joints).

This quantity is configured through the actuator model’s isaaclab.actuators.ActuatorBaseCfg.dynamic_friction parameter. If the parameter’s value is None, the value parsed from the USD schema, at the time of initialization, is used.

Note

In Isaac Sim 4.5, this parameter is modeled as a coefficient. In Isaac Sim 5.0 and later, it is modeled as an effort (torque or force).

property default_joint_friction: torch.Tensor

Deprecated property. Please use default_joint_friction_coeff instead.

default_joint_friction_coeff: torch.Tensor = None

Default joint static friction coefficient of all joints. Shape is (num_instances, num_joints).

This quantity is configured through the actuator model’s isaaclab.actuators.ActuatorBaseCfg.friction parameter. If the parameter’s value is None, the value parsed from the USD schema, at the time of initialization, is used.

Note

In Isaac Sim 4.5, this parameter is modeled as a coefficient. In Isaac Sim 5.0 and later, it is modeled as an effort (torque or force).

property default_joint_limits: torch.Tensor

Deprecated property. Please use default_joint_pos_limits instead.

default_joint_pos: torch.Tensor = None

Default joint positions of all joints. Shape is (num_instances, num_joints).

This quantity is configured through the isaaclab.assets.ArticulationCfg.init_state parameter.

default_joint_pos_limits: torch.Tensor = None

Default joint position limits of all joints. Shape is (num_instances, num_joints, 2).

The limits are in the order \([lower, upper]\). They are parsed from the USD schema at the time of initialization.

default_joint_stiffness: torch.Tensor = None

Default joint stiffness of all joints. Shape is (num_instances, num_joints).

This quantity is configured through the actuator model’s isaaclab.actuators.ActuatorBaseCfg.stiffness parameter. If the parameter’s value is None, the value parsed from the USD schema, at the time of initialization, is used.

Attention

The default stiffness is the value configured by the user or the value parsed from the USD schema. It should not be confused with joint_stiffness, which is the value set into the simulation.

default_joint_vel: torch.Tensor = None

Default joint velocities of all joints. Shape is (num_instances, num_joints).

This quantity is configured through the isaaclab.assets.ArticulationCfg.init_state parameter.

default_joint_viscous_friction_coeff: torch.Tensor = None

Default joint viscous friction coefficient of all joints. Shape is (num_instances, num_joints).

This quantity is configured through the actuator model’s isaaclab.actuators.ActuatorBaseCfg.viscous_friction parameter. If the parameter’s value is None, the value parsed from the USD schema, at the time of initialization, is used.

default_mass: torch.Tensor = None

Default mass for all the bodies in the articulation. Shape is (num_instances, num_bodies).

This quantity is parsed from the USD schema at the time of initialization.

default_root_state: torch.Tensor = None

Default root state [pos, quat, lin_vel, ang_vel] in the local environment frame. Shape is (num_instances, 13).

The position and quaternion are of the articulation root’s actor frame. Meanwhile, the linear and angular velocities are of its center of mass frame.

This quantity is configured through the isaaclab.assets.ArticulationCfg.init_state parameter.

default_spatial_tendon_damping: torch.Tensor = None

Default tendon damping of all spatial tendons. Shape is (num_instances, num_spatial_tendons).

This quantity is parsed from the USD schema at the time of initialization.

default_spatial_tendon_limit_stiffness: torch.Tensor = None

Default tendon limit stiffness of all spatial tendons. Shape is (num_instances, num_spatial_tendons).

This quantity is parsed from the USD schema at the time of initialization.

default_spatial_tendon_offset: torch.Tensor = None

Default tendon offset of all spatial tendons. Shape is (num_instances, num_spatial_tendons).

This quantity is parsed from the USD schema at the time of initialization.

default_spatial_tendon_stiffness: torch.Tensor = None

Default tendon stiffness of all spatial tendons. Shape is (num_instances, num_spatial_tendons).

This quantity is parsed from the USD schema at the time of initialization.

fixed_tendon_damping: torch.Tensor = None

Fixed tendon damping provided to the simulation. Shape is (num_instances, num_fixed_tendons).

property fixed_tendon_limit: torch.Tensor

Deprecated property. Please use fixed_tendon_pos_limits instead.

fixed_tendon_limit_stiffness: torch.Tensor = None

Fixed tendon limit stiffness provided to the simulation. Shape is (num_instances, num_fixed_tendons).

fixed_tendon_names: list[str] = None

Fixed tendon names in the order parsed by the simulation view.

fixed_tendon_offset: torch.Tensor = None

Fixed tendon offset provided to the simulation. Shape is (num_instances, num_fixed_tendons).

fixed_tendon_pos_limits: torch.Tensor = None

Fixed tendon position limits provided to the simulation. Shape is (num_instances, num_fixed_tendons, 2).

fixed_tendon_rest_length: torch.Tensor = None

Fixed tendon rest length provided to the simulation. Shape is (num_instances, num_fixed_tendons).

fixed_tendon_stiffness: torch.Tensor = None

Fixed tendon stiffness provided to the simulation. Shape is (num_instances, num_fixed_tendons).

gear_ratio: torch.Tensor = None

Gear ratio for relating motor torques to applied Joint torques. Shape is (num_instances, num_joints).

property heading_w

Yaw heading of the base frame (in radians). Shape is (num_instances,).

Note

This quantity is computed by assuming that the forward-direction of the base frame is along x-direction, i.e. \((1, 0, 0)\).

property joint_acc

Joint acceleration of all joints. Shape is (num_instances, num_joints).

joint_armature: torch.Tensor = None

Joint armature provided to the simulation. Shape is (num_instances, num_joints).

joint_damping: torch.Tensor = None

Joint damping provided to the simulation. Shape is (num_instances, num_joints)

In the case of explicit actuators, the value for the corresponding joints is zero.

joint_dynamic_friction_coeff: torch.Tensor = None

Joint dynamic friction coefficient provided to the simulation. Shape is (num_instances, num_joints).

Note: In Isaac Sim 4.5, this parameter is modeled as a coefficient. In Isaac Sim 5.0 and later, it is modeled as an effort (torque or force).

joint_effort_limits: torch.Tensor = None

Joint maximum effort provided to the simulation. Shape is (num_instances, num_joints).

joint_effort_target: torch.Tensor = None

Joint effort targets commanded by the user. Shape is (num_instances, num_joints).

For an implicit actuator model, the targets are directly set into the simulation. For an explicit actuator model, the targets are used to compute the joint torques (see applied_torque), which are then set into the simulation.

property joint_friction: torch.Tensor

Deprecated property. Please use joint_friction_coeff instead.

joint_friction_coeff: torch.Tensor = None

Joint static friction coefficient provided to the simulation. Shape is (num_instances, num_joints).

Note: In Isaac Sim 4.5, this parameter is modeled as a coefficient. In Isaac Sim 5.0 and later, it is modeled as an effort (torque or force).

property joint_limits: torch.Tensor

Deprecated property. Please use joint_pos_limits instead.

joint_names: list[str] = None

Joint names in the order parsed by the simulation view.

property joint_pos

Joint positions of all joints. Shape is (num_instances, num_joints).

joint_pos_limits: torch.Tensor = None

Joint position limits provided to the simulation. Shape is (num_instances, num_joints, 2).

The limits are in the order \([lower, upper]\).

joint_pos_target: torch.Tensor = None

Joint position targets commanded by the user. Shape is (num_instances, num_joints).

For an implicit actuator model, the targets are directly set into the simulation. For an explicit actuator model, the targets are used to compute the joint torques (see applied_torque), which are then set into the simulation.

joint_stiffness: torch.Tensor = None

Joint stiffness provided to the simulation. Shape is (num_instances, num_joints).

In the case of explicit actuators, the value for the corresponding joints is zero.

property joint_vel

Joint velocities of all joints. Shape is (num_instances, num_joints).

joint_vel_limits: torch.Tensor = None

Joint maximum velocity provided to the simulation. Shape is (num_instances, num_joints).

joint_vel_target: torch.Tensor = None

Joint velocity targets commanded by the user. Shape is (num_instances, num_joints).

For an implicit actuator model, the targets are directly set into the simulation. For an explicit actuator model, the targets are used to compute the joint torques (see applied_torque), which are then set into the simulation.

property joint_velocity_limits: torch.Tensor

Deprecated property. Please use joint_vel_limits instead.

joint_viscous_friction_coeff: torch.Tensor = None

Joint viscous friction coefficient provided to the simulation. Shape is (num_instances, num_joints).

property projected_gravity_b

Projection of the gravity direction on base frame. Shape is (num_instances, 3).

property root_ang_vel_b: torch.Tensor

Same as root_com_ang_vel_b.

property root_ang_vel_w: torch.Tensor

Same as root_com_ang_vel_w.

property root_com_ang_vel_b: torch.Tensor

Root center of mass angular velocity in base world frame. Shape is (num_instances, 3).

This quantity is the angular velocity of the articulation root’s center of mass frame with respect to the its actor frame.

property root_com_ang_vel_w: torch.Tensor

Root center of mass angular velocity in simulation world frame. Shape is (num_instances, 3).

This quantity is the angular velocity of the root rigid body’s center of mass frame relative to the world.

property root_com_lin_vel_b: torch.Tensor

Root center of mass linear velocity in base frame. Shape is (num_instances, 3).

This quantity is the linear velocity of the articulation root’s center of mass frame with respect to the its actor frame.

property root_com_lin_vel_w: torch.Tensor

Root center of mass linear velocity in simulation world frame. Shape is (num_instances, 3).

This quantity is the linear velocity of the root rigid body’s center of mass frame relative to the world.

property root_com_pos_w: torch.Tensor

Root center of mass position in simulation world frame. Shape is (num_instances, 3).

This quantity is the position of the actor frame of the root rigid body relative to the world.

property root_com_pose_w: torch.Tensor

Root center of mass pose [pos, quat] in simulation world frame. Shape is (num_instances, 7).

This quantity is the pose of the articulation root’s center of mass frame relative to the world. The orientation is provided in (w, x, y, z) format.

property root_com_quat_w: torch.Tensor

Root center of mass orientation (w, x, y, z) in simulation world frame. Shape is (num_instances, 4).

This quantity is the orientation of the actor frame of the root rigid body relative to the world.

property root_com_state_w

Root center of mass state [pos, quat, lin_vel, ang_vel] in simulation world frame. Shape is (num_instances, 13).

The position, quaternion, and linear/angular velocity are of the articulation root link’s center of mass frame relative to the world. Center of mass frame is assumed to be the same orientation as the link rather than the orientation of the principle inertia.

property root_com_vel_w: torch.Tensor

Root center of mass velocity [lin_vel, ang_vel] in simulation world frame. Shape is (num_instances, 6).

This quantity contains the linear and angular velocities of the articulation root’s center of mass frame relative to the world.

property root_lin_vel_b: torch.Tensor

Same as root_com_lin_vel_b.

property root_lin_vel_w: torch.Tensor

Same as root_com_lin_vel_w.

property root_link_ang_vel_b: torch.Tensor

Root link angular velocity in base world frame. Shape is (num_instances, 3).

This quantity is the angular velocity of the articulation root’s actor frame with respect to the its actor frame.

property root_link_ang_vel_w: torch.Tensor

Root link angular velocity in simulation world frame. Shape is (num_instances, 3).

This quantity is the angular velocity of the actor frame of the root rigid body relative to the world.

property root_link_lin_vel_b: torch.Tensor

Root link linear velocity in base frame. Shape is (num_instances, 3).

This quantity is the linear velocity of the articulation root’s actor frame with respect to the its actor frame.

property root_link_lin_vel_w: torch.Tensor

Root linear velocity in simulation world frame. Shape is (num_instances, 3).

This quantity is the linear velocity of the root rigid body’s actor frame relative to the world.

property root_link_pos_w: torch.Tensor

Root link position in simulation world frame. Shape is (num_instances, 3).

This quantity is the position of the actor frame of the root rigid body relative to the world.

property root_link_pose_w: torch.Tensor

Root link pose [pos, quat] in simulation world frame. Shape is (num_instances, 7).

This quantity is the pose of the articulation root’s actor frame relative to the world. The orientation is provided in (w, x, y, z) format.

property root_link_quat_w: torch.Tensor

Root link orientation (w, x, y, z) in simulation world frame. Shape is (num_instances, 4).

This quantity is the orientation of the actor frame of the root rigid body.

property root_link_state_w

Root state [pos, quat, lin_vel, ang_vel] in simulation world frame. Shape is (num_instances, 13).

The position, quaternion, and linear/angular velocity are of the articulation root’s actor frame relative to the world.

property root_link_vel_w: torch.Tensor

Root link velocity [lin_vel, ang_vel] in simulation world frame. Shape is (num_instances, 6).

This quantity contains the linear and angular velocities of the articulation root’s actor frame relative to the world.

property root_pos_w: torch.Tensor

Same as root_link_pos_w.

property root_pose_w: torch.Tensor

Same as root_link_pose_w.

property root_quat_w: torch.Tensor

Same as root_link_quat_w.

property root_state_w

Root state [pos, quat, lin_vel, ang_vel] in simulation world frame. Shape is (num_instances, 13).

The position and quaternion are of the articulation root’s actor frame relative to the world. Meanwhile, the linear and angular velocities are of the articulation root’s center of mass frame.

property root_vel_w: torch.Tensor

Same as root_com_vel_w.

soft_joint_pos_limits: torch.Tensor = None

Soft joint positions limits for all joints. Shape is (num_instances, num_joints, 2).

The limits are in the order \([lower, upper]\).The soft joint position limits are computed as a sub-region of the joint_pos_limits based on the soft_joint_pos_limit_factor parameter.

Consider the joint position limits \([lower, upper]\) and the soft joint position limits \([soft_lower, soft_upper]\). The soft joint position limits are computed as:

\[soft\_lower = (lower + upper) / 2 - factor * (upper - lower) / 2 soft\_upper = (lower + upper) / 2 + factor * (upper - lower) / 2\]

The soft joint position limits help specify a safety region around the joint limits. It isn’t used by the simulation, but is useful for learning agents to prevent the joint positions from violating the limits.

soft_joint_vel_limits: torch.Tensor = None

Soft joint velocity limits for all joints. Shape is (num_instances, num_joints).

These are obtained from the actuator model. It may differ from joint_vel_limits if the actuator model has a variable velocity limit model. For instance, in a variable gear ratio actuator model.

spatial_tendon_damping: torch.Tensor = None

Spatial tendon damping provided to the simulation. Shape is (num_instances, num_spatial_tendons).

spatial_tendon_limit_stiffness: torch.Tensor = None

Spatial tendon limit stiffness provided to the simulation. Shape is (num_instances, num_spatial_tendons).

spatial_tendon_names: list[str] = None

Spatial tendon names in the order parsed by the simulation view.

spatial_tendon_offset: torch.Tensor = None

Spatial tendon offset provided to the simulation. Shape is (num_instances, num_spatial_tendons).

spatial_tendon_stiffness: torch.Tensor = None

Spatial tendon stiffness provided to the simulation. Shape is (num_instances, num_spatial_tendons).

thrust_target: torch.Tensor = None

Thrust targets commanded by the user or controller. Shape is (num_instances, num_thrusters)

This quantity contains the target thrust values set through the set_thrust_target() method or by action terms in RL environments. These targets are processed by the thruster actuator models to compute actual applied thrusts.

The units depend on the actuator model configuration (typically Newtons for force or RPS for rotational speed).

computed_thrust: torch.Tensor = None

Computed thrust from the actuator model before clipping. Shape is (num_instances, num_thrusters).

This quantity contains the thrust values computed by the thruster actuator models before any clipping or saturation is applied. It represents the “desired” thrust based on the actuator dynamics (rise/fall times) but may exceed physical limits.

The difference between computed_thrust and applied_thrust indicates when the actuator is saturating at its limits.

Example Use:

Monitor actuator saturation by comparing computed vs applied thrust:

saturation = multirotor.data.computed_thrust - multirotor.data.applied_thrust
is_saturated = saturation.abs() > 1e-6

applied_thrust: torch.Tensor = None

Applied thrust from the actuator model after clipping. Shape is (num_instances, num_thrusters).

This quantity contains the final thrust values that are actually applied to the simulation after all actuator model processing, including:

• Dynamic response (rise/fall time constants)

• Clipping to thrust range limits

• Any other actuator model constraints

This is the “ground truth” thrust that affects the multirotor’s motion in the physics simulation.