isaaclab_contrib.assets

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[source]#

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`	Deprecated property.
`root_view`	Root view for the asset.
`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.
`assert_shape_and_dtype`(tensor, shape, dtype)	Assert the shape and dtype of a tensor or warp array.
`assert_shape_and_dtype_mask`(tensor, masks, dtype)	Assert the shape of a tensor or warp array against mask dimensions.
`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_coms`(coms[, body_ids, env_ids])	Deprecated, same as `set_coms_index()`.
`set_coms_index`(*, coms[, body_ids, env_ids, ...])	Set center of mass pose of all bodies using indices.
`set_coms_mask`(*, coms[, body_mask, env_mask])	Set center of mass pose of all bodies using masks.
`set_debug_vis`(debug_vis)	Sets whether to visualize the asset data.
`set_external_force_and_torque`(forces, torques)	Deprecated, same as `permanent_wrench_composer.set_forces_and_torques()`.
`set_fixed_tendon_damping`(damping[, ...])	Deprecated, same as `set_fixed_tendon_damping_index()`.
`set_fixed_tendon_damping_index`(*, damping[, ...])	Set fixed tendon damping into internal buffers using indices.
`set_fixed_tendon_damping_mask`(*, damping[, ...])	Set fixed tendon damping into internal buffers using masks.
`set_fixed_tendon_limit`(limit[, ...])	Set fixed tendon position limits into internal buffers.
`set_fixed_tendon_limit_stiffness`(limit_stiffness)	Deprecated, same as `set_fixed_tendon_limit_stiffness_index()`.
`set_fixed_tendon_limit_stiffness_index`(*, ...)	Set fixed tendon limit stiffness into internal buffers using indices.
`set_fixed_tendon_limit_stiffness_mask`(*, ...)	Set fixed tendon limit stiffness into internal buffers using masks.
`set_fixed_tendon_offset`(offset[, ...])	Deprecated, same as `set_fixed_tendon_offset_index()`.
`set_fixed_tendon_offset_index`(*, offset[, ...])	Set fixed tendon offset into internal buffers using indices.
`set_fixed_tendon_offset_mask`(*, offset[, ...])	Set fixed tendon offset into internal buffers using masks.
`set_fixed_tendon_position_limit`(limit[, ...])	Deprecated, same as `set_fixed_tendon_position_limit_index()`.
`set_fixed_tendon_position_limit_index`(*, limit)	Set fixed tendon position limit into internal buffers using indices.
`set_fixed_tendon_position_limit_mask`(*, limit)	Set fixed tendon position limit into internal buffers using masks.
`set_fixed_tendon_rest_length`(rest_length[, ...])	Deprecated, same as `set_fixed_tendon_rest_length_index()`.
`set_fixed_tendon_rest_length_index`(*, ...[, ...])	Set fixed tendon rest length into internal buffers using indices.
`set_fixed_tendon_rest_length_mask`(*, rest_length)	Set fixed tendon rest length into internal buffers using masks.
`set_fixed_tendon_stiffness`(stiffness[, ...])	Deprecated, same as `set_fixed_tendon_stiffness_index()`.
`set_fixed_tendon_stiffness_index`(*, stiffness)	Set fixed tendon stiffness into internal buffers using indices.
`set_fixed_tendon_stiffness_mask`(*, stiffness)	Set fixed tendon stiffness into internal buffers using masks.
`set_inertias`(inertias[, body_ids, env_ids])	Deprecated, same as `set_inertias_index()`.
`set_inertias_index`(*, inertias[, body_ids, ...])	Set inertias of all bodies using indices.
`set_inertias_mask`(*, inertias[, body_mask, ...])	Set inertias of all bodies using masks.
`set_joint_effort_target`(target[, joint_ids, ...])	Deprecated, same as `set_joint_effort_target_index()`.
`set_joint_effort_target_index`(*, target[, ...])	Set joint efforts into internal buffers using indices.
`set_joint_effort_target_mask`(*, target[, ...])	Set joint efforts into internal buffers using masks.
`set_joint_position_target`(target[, ...])	Deprecated, same as `set_joint_position_target_index()`.
`set_joint_position_target_index`(*, target[, ...])	Set joint position targets into internal buffers using indices.
`set_joint_position_target_mask`(*, target[, ...])	Set joint position targets into internal buffers using masks.
`set_joint_velocity_target`(target[, ...])	Deprecated, same as `set_joint_velocity_target_index()`.
`set_joint_velocity_target_index`(*, target[, ...])	Set joint velocity targets into internal buffers using indices.
`set_joint_velocity_target_mask`(*, target[, ...])	Set joint velocity targets into internal buffers using masks.
`set_masses`(masses[, body_ids, env_ids])	Deprecated, same as `set_masses_index()`.
`set_masses_index`(*, masses[, body_ids, ...])	Set masses of all bodies using indices.
`set_masses_mask`(*, masses[, body_mask, env_mask])	Set masses of all bodies using masks.
`set_spatial_tendon_damping`(damping[, ...])	Deprecated, same as `set_spatial_tendon_damping_index()`.
`set_spatial_tendon_damping_index`(*, damping)	Set spatial tendon damping into internal buffers using indices.
`set_spatial_tendon_damping_mask`(*, damping)	Set spatial tendon damping into internal buffers using masks.
`set_spatial_tendon_limit_stiffness`(...[, ...])	Deprecated, same as `set_spatial_tendon_limit_stiffness_index()`.
`set_spatial_tendon_limit_stiffness_index`(*, ...)	Set spatial tendon limit stiffness into internal buffers using indices.
`set_spatial_tendon_limit_stiffness_mask`(*, ...)	Set spatial tendon limit stiffness into internal buffers using masks.
`set_spatial_tendon_offset`(offset[, ...])	Deprecated, same as `set_spatial_tendon_offset_index()`.
`set_spatial_tendon_offset_index`(*, offset[, ...])	Set spatial tendon offset into internal buffers using indices.
`set_spatial_tendon_offset_mask`(*, offset[, ...])	Set spatial tendon offset into internal buffers using masks.
`set_spatial_tendon_stiffness`(stiffness[, ...])	Deprecated, same as `set_spatial_tendon_stiffness_index()`.
`set_spatial_tendon_stiffness_index`(*, stiffness)	Set spatial tendon stiffness into internal buffers using indices.
`set_spatial_tendon_stiffness_mask`(*, stiffness)	Set spatial tendon stiffness into internal buffers using masks.
`set_visibility`(visible[, env_ids])	Set the visibility of the prims corresponding to the asset.
`update`(dt)	Updates the simulation data.
`write_fixed_tendon_properties_to_sim`([...])	Deprecated, same as `write_fixed_tendon_properties_to_sim_index()`.
`write_fixed_tendon_properties_to_sim_index`(*)	Write fixed tendon properties into the simulation using indices.
`write_fixed_tendon_properties_to_sim_mask`(*)	Write fixed tendon properties into the simulation using masks.
`write_joint_armature_to_sim`(armature[, ...])	Deprecated, same as `write_joint_armature_to_sim_index()`.
`write_joint_armature_to_sim_index`(*, armature)	Write joint armature over selected environment indices into the simulation.
`write_joint_armature_to_sim_mask`(*, armature)	Write joint armature over selected environment mask into the simulation.
`write_joint_damping_to_sim`(damping[, ...])	Deprecated, same as `write_joint_damping_to_sim_index()`.
`write_joint_damping_to_sim_index`(*, damping)	Write joint damping over selected environment indices into the simulation.
`write_joint_damping_to_sim_mask`(*, damping)	Write joint damping over selected environment mask into the simulation.
`write_joint_dynamic_friction_coefficient_to_sim`(...)	Deprecated, same as `write_joint_dynamic_friction_coefficient_to_sim_index()`.
`write_joint_dynamic_friction_coefficient_to_sim_index`(*, ...)	Write joint dynamic friction coefficient over selected environment indices into the simulation.
`write_joint_dynamic_friction_coefficient_to_sim_mask`(*, ...)	Write joint dynamic friction coefficient over selected environment mask into the simulation.
`write_joint_effort_limit_to_sim`(limits[, ...])	Deprecated, same as `write_joint_effort_limit_to_sim_index()`.
`write_joint_effort_limit_to_sim_index`(*, limits)	Write joint effort limits over selected environment indices into the simulation.
`write_joint_effort_limit_to_sim_mask`(*, limits)	Write joint effort limits over selected environment mask into the simulation.
`write_joint_friction_coefficient_to_sim`(...)	Deprecated, same as `write_joint_friction_coefficient_to_sim_index()`.
`write_joint_friction_coefficient_to_sim_index`(*, ...)	Write joint friction coefficients over selected environment indices into the simulation.
`write_joint_friction_coefficient_to_sim_mask`(*, ...)	Write joint friction coefficients over selected environment mask 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[, ...])	Deprecated, same as `write_joint_position_limit_to_sim_index()`.
`write_joint_position_limit_to_sim_index`(*, ...)	Write joint position limits over selected environment indices into the simulation.
`write_joint_position_limit_to_sim_mask`(*, limits)	Write joint position limits over selected environment mask into the simulation.
`write_joint_position_to_sim`(position[, ...])	Deprecated, same as `write_joint_position_to_sim_index()`.
`write_joint_position_to_sim_index`(*, position)	Write joint positions over selected environment indices into the simulation.
`write_joint_position_to_sim_mask`(*, position)	Write joint positions over selected environment mask into the simulation.
`write_joint_state_to_sim`(position, velocity)	Deprecated, same as `write_joint_position_to_sim_index()` and `write_joint_velocity_to_sim_index()`.
`write_joint_state_to_sim_mask`(*, position, ...)	Write joint positions and velocities over selected environment mask into the simulation.
`write_joint_stiffness_to_sim`(stiffness[, ...])	Deprecated, same as `write_joint_stiffness_to_sim_index()`.
`write_joint_stiffness_to_sim_index`(*, stiffness)	Write joint stiffness over selected environment indices into the simulation.
`write_joint_stiffness_to_sim_mask`(*, stiffness)	Write joint stiffness over selected environment mask into the simulation.
`write_joint_velocity_limit_to_sim`(limits[, ...])	Deprecated, same as `write_joint_velocity_limit_to_sim_index()`.
`write_joint_velocity_limit_to_sim_index`(*, ...)	Write joint max velocity over selected environment indices into the simulation.
`write_joint_velocity_limit_to_sim_mask`(*, limits)	Write joint max velocity over selected environment mask into the simulation.
`write_joint_velocity_to_sim`(velocity[, ...])	Deprecated, same as `write_joint_velocity_to_sim_index()`.
`write_joint_velocity_to_sim_index`(*, velocity)	Write joint velocities to the simulation.
`write_joint_velocity_to_sim_mask`(*, velocity)	Write joint velocities over selected environment mask into the simulation.
`write_joint_viscous_friction_coefficient_to_sim`(...)	Deprecated, same as `write_joint_viscous_friction_coefficient_to_sim_index()`.
`write_joint_viscous_friction_coefficient_to_sim_index`(*, ...)	Write joint viscous friction coefficient over selected environment indices into the simulation.
`write_joint_viscous_friction_coefficient_to_sim_mask`(*, ...)	Write joint viscous friction coefficient over selected environment mask into the simulation.
`write_root_com_pose_to_sim`(root_pose[, env_ids])	Deprecated, same as `write_root_com_pose_to_sim_index()`.
`write_root_com_pose_to_sim_index`(*, root_pose)	Set the root center of mass pose over selected environment indices into the simulation.
`write_root_com_pose_to_sim_mask`(*, root_pose)	Set the root center of mass pose over selected environment mask into the simulation.
`write_root_com_state_to_sim`(root_state[, ...])	Deprecated, same as `write_root_com_pose_to_sim_index()` and `write_root_com_velocity_to_sim_index()`.
`write_root_com_velocity_to_sim`(root_velocity)	Deprecated, same as `write_root_com_velocity_to_sim_index()`.
`write_root_com_velocity_to_sim_index`(*, ...)	Set the root center of mass velocity over selected environment indices into the simulation.
`write_root_com_velocity_to_sim_mask`(*, ...)	Set the root center of mass velocity over selected environment mask into the simulation.
`write_root_link_pose_to_sim`(root_pose[, env_ids])	Deprecated, same as `write_root_link_pose_to_sim_index()`.
`write_root_link_pose_to_sim_index`(*, root_pose)	Set the root link pose over selected environment indices into the simulation.
`write_root_link_pose_to_sim_mask`(*, root_pose)	Set the root link pose over selected environment mask into the simulation.
`write_root_link_state_to_sim`(root_state[, ...])	Deprecated, same as `write_root_link_pose_to_sim_index()` and `write_root_link_velocity_to_sim_index()`.
`write_root_link_velocity_to_sim`(root_velocity)	Deprecated, same as `write_root_link_velocity_to_sim_index()`.
`write_root_link_velocity_to_sim_index`(*, ...)	Set the root link velocity over selected environment indices into the simulation.
`write_root_link_velocity_to_sim_mask`(*, ...)	Set the root link velocity over selected environment mask into the simulation.
`write_root_pose_to_sim`(root_pose[, env_ids])	Deprecated, same as `write_root_pose_to_sim_index()`.
`write_root_pose_to_sim_index`(*, root_pose[, ...])	Set the root pose over selected environment indices into the simulation.
`write_root_pose_to_sim_mask`(*, root_pose[, ...])	Set the root pose over selected environment mask into the simulation.
`write_root_state_to_sim`(root_state[, env_ids])	Deprecated, same as `write_root_link_pose_to_sim_index()` and `write_root_com_velocity_to_sim_index()`.
`write_root_velocity_to_sim`(root_velocity[, ...])	Deprecated, same as `write_root_velocity_to_sim_index()`.
`write_root_velocity_to_sim_index`(*, ...[, ...])	Set the root center of mass velocity over selected environment indices into the simulation.
`write_root_velocity_to_sim_mask`(*, root_velocity)	Set the root center of mass velocity over selected environment mask into the simulation.
`write_spatial_tendon_properties_to_sim`([...])	Deprecated, same as `write_spatial_tendon_properties_to_sim_index()`.
`write_spatial_tendon_properties_to_sim_index`(*)	Write spatial tendon properties into the simulation using indices.
`write_spatial_tendon_properties_to_sim_mask`(*)	Write spatial tendon properties into the simulation using masks.

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)[source]#

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)[source]#

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)[source]#

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()[source]#

Write thrust and torque commands to the simulation.

This method performs the following operations in sequence:

Apply actuator models: Process thrust targets through thruster actuator models to compute actual thrust values considering dynamics (rise/fall times) and constraints (thrust limits).
Combine thrusts into wrench: Use the allocation matrix to convert individual thruster forces into a combined 6D wrench (force + torque) vector.
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.

assert_shape_and_dtype(tensor: float | torch.Tensor | wp.array, shape: tuple[int, ...], dtype: type, name: str = '') → None#

Assert the shape and dtype of a tensor or warp array.

Parameters:

tensor – The tensor or warp array to assert the shape of. Floats are skipped.
shape – The expected leading dimensions (e.g. (num_envs, num_joints)).
dtype – The expected warp dtype.
name – Optional parameter name for error messages.

assert_shape_and_dtype_mask(tensor: float | torch.Tensor | wp.array, masks: tuple[wp.array, ...], dtype: type, name: str = '', trailing_dims: tuple[int, ...] = ()) → None#

Assert the shape of a tensor or warp array against mask dimensions.

Mask-based write methods expect full-sized data — one element per entry in each mask dimension, regardless of how many entries are True. The expected leading shape is therefore (mask_0.shape[0], mask_1.shape[0], ...) (i.e. the total size of each dimension, not the number of selected entries).

Parameters:

tensor – The tensor or warp array to assert the shape of. Floats are skipped.
masks – Tuple of mask arrays whose shape[0] dimensions form the expected leading shape.
dtype – The expected warp dtype.
name – Optional parameter name for error messages.
trailing_dims – Extra trailing dimensions to append (e.g. (9,) for inertias with wp.float32).

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.

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.

property root_physx_view: physx.RigidBodyView#: Deprecated property. Please use root_view instead.

property root_view: physx.ArticulationView#: Root view for the asset.

Note

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

set_coms(coms: torch.Tensor | wp.array, body_ids: Sequence[int] | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_coms_index().

Set center of mass pose of all bodies using indices.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

coms – Center of mass pose of all bodies. Shape is (len(env_ids), len(body_ids), 7) or (num_instances, num_bodies, 7) if full_data, or (len(env_ids), len(body_ids)) / (num_instances, num_bodies) with dtype wp.transformf.
body_ids – The body indices to set the center of mass pose for. Defaults to None (all bodies).
env_ids – The environment indices to set the center of mass pose for. Defaults to None (all environments).
full_data – Whether to expect full data. Defaults to False.

set_coms_mask(*, coms: torch.Tensor | wp.array, body_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set center of mass pose of all bodies using masks.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

coms – Center of mass pose of all bodies. Shape is (num_instances, num_bodies, 7) or (num_instances, num_bodies) with dtype wp.transformf.
body_mask – Body mask. If None, then all bodies are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

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 | wp.array, torques: torch.Tensor | wp.array, positions: torch.Tensor | wp.array | None = None, body_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, is_global: bool = False) → None#: Deprecated, same as permanent_wrench_composer.set_forces_and_torques().

set_fixed_tendon_damping(damping: torch.Tensor | wp.array, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_fixed_tendon_damping_index().

Set fixed tendon damping into internal buffers using indices.

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_index() function.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

damping – Fixed tendon damping. Shape is (len(env_ids), len(fixed_tendon_ids)) or (num_instances, num_fixed_tendons) if full_data.
fixed_tendon_ids – The tendon indices to set the damping for. Defaults to None (all fixed tendons).
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

set_fixed_tendon_damping_mask(*, damping: float | torch.Tensor | wp.array, fixed_tendon_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set fixed tendon damping into internal buffers using masks.

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_mask() method.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

damping – Fixed tendon damping. Shape is (num_instances, num_fixed_tendons).
fixed_tendon_mask – Fixed tendon mask. If None, then all fixed tendons are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

set_fixed_tendon_limit(limit: torch.Tensor | wp.array, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = 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 | wp.array, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_fixed_tendon_limit_stiffness_index().

Set fixed tendon limit stiffness into internal buffers using indices.

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_index() method.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

limit_stiffness – Fixed tendon limit stiffness. Shape is (len(env_ids), len(fixed_tendon_ids)) or (num_instances, num_fixed_tendons) if full_data.
fixed_tendon_ids – The tendon indices to set the limit stiffness for. Defaults to None (all fixed tendons).
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

set_fixed_tendon_limit_stiffness_mask(*, limit_stiffness: float | torch.Tensor | wp.array, fixed_tendon_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set fixed tendon limit stiffness into internal buffers using masks.

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_mask() method.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

limit_stiffness – Fixed tendon limit stiffness. Shape is (num_instances, num_fixed_tendons).
fixed_tendon_mask – Fixed tendon mask. If None, then all fixed tendons are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

set_fixed_tendon_offset(offset: torch.Tensor | wp.array, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_fixed_tendon_offset_index().

Set fixed tendon offset into internal buffers using indices.

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_index() method.

Note

This method expects partial data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

offset – Fixed tendon offset. Shape is (len(env_ids), len(fixed_tendon_ids)) or (num_instances, num_fixed_tendons) if full_data.
fixed_tendon_ids – The tendon indices to set the offset for. Defaults to None (all fixed tendons).
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

set_fixed_tendon_offset_mask(*, offset: float | torch.Tensor | wp.array, fixed_tendon_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set fixed tendon offset into internal buffers using masks.

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_mask() method.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

offset – Fixed tendon offset. Shape is (num_instances, num_fixed_tendons).
fixed_tendon_mask – Fixed tendon mask. If None, then all fixed tendons are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

set_fixed_tendon_position_limit(limit: torch.Tensor | wp.array, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_fixed_tendon_position_limit_index().

Set fixed tendon position limit into internal buffers using indices.

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

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

limit – Fixed tendon position limit. Shape is (len(env_ids), len(fixed_tendon_ids)) or (num_instances, num_fixed_tendons) if full_data.
fixed_tendon_ids – The tendon indices to set the position limit for. Defaults to None (all fixed tendons).
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

set_fixed_tendon_position_limit_mask(*, limit: float | torch.Tensor | wp.array, fixed_tendon_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set fixed tendon position limit into internal buffers using masks.

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

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

limit – Fixed tendon position limit. Shape is (num_instances, num_fixed_tendons).
fixed_tendon_mask – Fixed tendon mask. If None, then all fixed tendons are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

set_fixed_tendon_rest_length(rest_length: torch.Tensor | wp.array, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_fixed_tendon_rest_length_index().

Set fixed tendon rest length into internal buffers using indices.

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_index() method.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

rest_length – Fixed tendon rest length. Shape is (len(env_ids), len(fixed_tendon_ids)) or (num_instances, num_fixed_tendons) if full_data.
fixed_tendon_ids – The tendon indices to set the rest length for. Defaults to None (all fixed tendons).
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

set_fixed_tendon_rest_length_mask(*, rest_length: float | torch.Tensor | wp.array, fixed_tendon_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set fixed tendon rest length into internal buffers using masks.

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_mask() method.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

rest_length – Fixed tendon rest length. Shape is (num_instances, num_fixed_tendons).
fixed_tendon_mask – Fixed tendon mask. If None, then all fixed tendons are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

set_fixed_tendon_stiffness(stiffness: torch.Tensor | wp.array, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_fixed_tendon_stiffness_index().

Set fixed tendon stiffness into internal buffers using indices.

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_index() method.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

stiffness – Fixed tendon stiffness. Shape is (len(env_ids), len(fixed_tendon_ids)) or (num_instances, num_fixed_tendons) if full_data.
fixed_tendon_ids – The tendon indices to set the stiffness for. Defaults to None (all fixed tendons).
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

set_fixed_tendon_stiffness_mask(*, stiffness: float | torch.Tensor | wp.array, fixed_tendon_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set fixed tendon stiffness into internal buffers using masks.

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_mask() method.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

stiffness – Fixed tendon stiffness. Shape is (num_instances, num_fixed_tendons).
fixed_tendon_mask – Fixed tendon mask. If None, then all fixed tendons are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

set_inertias(inertias: torch.Tensor | wp.array, body_ids: Sequence[int] | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_inertias_index().

Set inertias of all bodies using indices.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

inertias – Inertias of all bodies. Shape is (len(env_ids), len(body_ids), 9) or (num_instances, num_bodies, 9) if full_data.
body_ids – The body indices to set the inertias for. Defaults to None (all bodies).
env_ids – The environment indices to set the inertias for. Defaults to None (all environments).
full_data – Whether to expect full data. Defaults to False.

set_inertias_mask(*, inertias: torch.Tensor | wp.array, body_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set inertias of all bodies using masks.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

inertias – Inertias of all bodies. Shape is (num_instances, num_bodies, 9).
body_mask – Body mask. If None, then all bodies are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

set_joint_effort_target(target: torch.Tensor | wp.array, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_joint_effort_target_index().

Set joint efforts into internal buffers using indices.

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.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

target – Joint effort targets. Shape is (len(env_ids), len(joint_ids)) or (num_instances, num_joints) if full_data.
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).
full_data – Whether to expect full data. Defaults to False.

set_joint_effort_target_mask(*, target: torch.Tensor | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set joint efforts into internal buffers using masks.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

target – Joint effort targets. Shape is (num_instances, num_joints).
joint_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

set_joint_position_target(target: torch.Tensor | wp.array, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_joint_position_target_index().

Set joint position targets into internal buffers using indices.

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.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

target – Joint position targets. Shape is (len(env_ids), len(joint_ids)) or (num_instances, num_joints) if full_data.
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).
full_data – Whether to expect full data. Defaults to False.

set_joint_position_target_mask(*, target: torch.Tensor | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set joint position targets into internal buffers using masks.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

target – Joint position targets. Shape is (num_instances, num_joints).
joint_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

set_joint_velocity_target(target: torch.Tensor | wp.array, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_joint_velocity_target_index().

Set joint velocity targets into internal buffers using indices.

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.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

target – Joint velocity targets. Shape is (len(env_ids), len(joint_ids)) or (num_instances, num_joints) if full_data.
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).
full_data – Whether to expect full data. Defaults to False.

set_joint_velocity_target_mask(*, target: torch.Tensor | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set joint velocity targets into internal buffers using masks.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

target – Joint velocity targets. Shape is (num_instances, num_joints).
joint_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

set_masses(masses: torch.Tensor | wp.array, body_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_masses_index().

Set masses of all bodies using indices.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

masses – Masses of all bodies. Shape is (len(env_ids), len(body_ids)) or (num_instances, num_bodies) if full_data.
body_ids – The body indices to set the masses for. Defaults to None (all bodies).
env_ids – The environment indices to set the masses for. Defaults to None (all environments).
full_data – Whether to expect full data. Defaults to False.

set_masses_mask(*, masses: torch.Tensor | wp.array, body_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set masses of all bodies using masks.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

masses – Masses of all bodies. Shape is (num_instances, num_bodies).
body_mask – Body mask. If None, then all bodies are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

set_spatial_tendon_damping(damping: torch.Tensor | wp.array, spatial_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_spatial_tendon_damping_index().

Set spatial tendon damping into internal buffers using indices.

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_index() method.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

damping – Spatial tendon damping. Shape is (len(env_ids), len(spatial_tendon_ids)) or (num_instances, num_spatial_tendons) if full_data.
spatial_tendon_ids – The tendon indices to set the damping for. Defaults to None (all spatial tendons).
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

set_spatial_tendon_damping_mask(*, damping: float | torch.Tensor | wp.array, spatial_tendon_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set spatial tendon damping into internal buffers using masks.

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_mask() method.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

damping – Spatial tendon damping. Shape is (num_instances, num_spatial_tendons).
spatial_tendon_mask – Spatial tendon mask. If None, then all spatial tendons are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

set_spatial_tendon_limit_stiffness(limit_stiffness: torch.Tensor | wp.array, spatial_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_spatial_tendon_limit_stiffness_index().

Set spatial tendon limit stiffness into internal buffers using indices.

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_index() method.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

limit_stiffness – Spatial tendon limit stiffness. Shape is (len(env_ids), len(spatial_tendon_ids)) or (num_instances, num_spatial_tendons) if full_data.
spatial_tendon_ids – The tendon indices to set the limit stiffness for. Defaults to None (all spatial tendons).
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

set_spatial_tendon_limit_stiffness_mask(*, limit_stiffness: float | torch.Tensor | wp.array, spatial_tendon_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set spatial tendon limit stiffness into internal buffers using masks.

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_mask() method.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

limit_stiffness – Spatial tendon limit stiffness. Shape is (num_instances, num_spatial_tendons).
spatial_tendon_mask – Spatial tendon mask. If None, then all spatial tendons are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

set_spatial_tendon_offset(offset: torch.Tensor, spatial_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_spatial_tendon_offset_index().

Set spatial tendon offset into internal buffers using indices.

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_index() method.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

offset – Spatial tendon offset. Shape is (len(env_ids), len(spatial_tendon_ids)) or (num_instances, num_spatial_tendons) if full_data.
spatial_tendon_ids – The tendon indices to set the offset for. Defaults to None (all spatial tendons).
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

set_spatial_tendon_offset_mask(*, offset: float | torch.Tensor | wp.array, spatial_tendon_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set spatial tendon offset into internal buffers using masks.

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_mask() method.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

offset – Spatial tendon offset. Shape is (num_instances, num_spatial_tendons).
spatial_tendon_mask – Spatial tendon mask. If None, then all spatial tendons are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

set_spatial_tendon_stiffness(stiffness: torch.Tensor | wp.array, spatial_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_spatial_tendon_stiffness_index().

Set spatial tendon stiffness into internal buffers using indices.

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_index() method.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

stiffness – Spatial tendon stiffness. Shape is (len(env_ids), len(spatial_tendon_ids)) or (num_instances, num_spatial_tendons) if full_data.
spatial_tendon_ids – The tendon indices to set the stiffness for. Defaults to None (all spatial tendons).
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

set_spatial_tendon_stiffness_mask(*, stiffness: float | torch.Tensor | wp.array, spatial_tendon_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Set spatial tendon stiffness into internal buffers using masks.

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_mask() method.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

stiffness – Spatial tendon stiffness. Shape is (num_instances, num_spatial_tendons).
spatial_tendon_mask – Spatial tendon mask. If None, then all spatial tendons are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

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)#

Updates the simulation data.

Parameters:: dt – The time step size in seconds.

write_fixed_tendon_properties_to_sim(fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_fixed_tendon_properties_to_sim_index().

write_fixed_tendon_properties_to_sim_index(*, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#

Write fixed tendon properties into the simulation using indices.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

fixed_tendon_ids – The fixed tendon indices to write the properties for. Defaults to None (all fixed tendons).
env_ids – Environment indices. If None, then all indices are used.

write_fixed_tendon_properties_to_sim_mask(*, env_mask: wp.array | None = None) → None#

Write fixed tendon properties into the simulation using masks.

Tip

For maximum performance we recommend using the mask method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:: env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_joint_armature_to_sim(armature: torch.Tensor | float | wp.array, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_joint_armature_to_sim_index().

Write joint armature over selected environment indices 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.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

armature – Joint armature. Shape is (len(env_ids), len(joint_ids)) or (num_instances, num_joints).
joint_ids – Joint indices. If None, then all joints are used.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

write_joint_armature_to_sim_mask(*, armature: torch.Tensor | wp.array | float, joint_mask: wp.array | None = None, env_mask: wp.array | None = None)#

Write joint armature over selected environment mask 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.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

armature – Joint armature. Shape is (num_instances, num_joints).
joint_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_joint_damping_to_sim(damping: torch.Tensor | float | wp.array, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_joint_damping_to_sim_index().

Write joint damping over selected environment indices into the simulation.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

damping – Joint damping. Shape is (len(env_ids), len(joint_ids)) or (num_instances, num_joints).
joint_ids – Joint indices. If None, then all joints are used.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

write_joint_damping_to_sim_mask(*, damping: torch.Tensor | wp.array | float, joint_mask: wp.array | None = None, env_mask: wp.array | None = None)#

Write joint damping over selected environment mask into the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

damping – Joint damping. Shape is (num_instances, num_joints).
joint_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_joint_dynamic_friction_coefficient_to_sim(joint_dynamic_friction_coeff: torch.Tensor | wp.array, joint_ids: Sequence[int] | torch.Tensor | wp.array | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, full_data: bool = False) → None#: Deprecated, same as write_joint_dynamic_friction_coefficient_to_sim_index().

Write joint dynamic friction coefficient over selected environment indices into the simulation.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

joint_dynamic_friction_coeff – Joint dynamic friction coefficient. Shape is (len(env_ids), len(joint_ids)) or (num_instances, num_joints) if full_data.
joint_ids – Joint indices. If None, then all joints are used.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

write_joint_dynamic_friction_coefficient_to_sim_mask(*, joint_dynamic_friction_coeff: torch.Tensor | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Write joint dynamic friction coefficient over selected environment mask into the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

joint_dynamic_friction_coeff – Joint dynamic friction coefficient. Shape is (num_instances, num_joints).
joint_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_joint_effort_limit_to_sim(limits: torch.Tensor | float | wp.array, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_joint_effort_limit_to_sim_index().

Write joint effort limits over selected environment indices 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.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

limits – Joint torque limits. Shape is (len(env_ids), len(joint_ids)) or (num_instances, num_joints).
joint_ids – Joint indices. If None, then all joints are used.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

write_joint_effort_limit_to_sim_mask(*, limits: torch.Tensor | wp.array | float, joint_mask: wp.array | None = None, env_mask: wp.array | None = None)#

Write joint effort limits over selected environment mask 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.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

limits – Joint torque limits. Shape is (num_instances, num_joints).
joint_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_joint_friction_coefficient_to_sim(joint_friction_coeff: torch.Tensor | wp.array | float, joint_dynamic_friction_coeff: torch.Tensor | wp.array | float | None = None, joint_viscous_friction_coeff: torch.Tensor | wp.array | float | None = None, joint_ids: Sequence[int] | torch.Tensor | wp.array | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, full_data: bool = False)#: Deprecated, same as write_joint_friction_coefficient_to_sim_index().

Write joint friction coefficients over selected environment indices 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.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

joint_friction_coeff – Static friction coefficient \(\mu_s\). Shape is (len(env_ids), len(joint_ids)) or (num_instances, num_joints).
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 – Joint indices. If None, then all joints are used.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

Write joint friction coefficients over selected environment mask 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.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

joint_friction_coeff – Static friction coefficient \(\mu_s\). Shape is (num_instances, num_joints).
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_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_joint_friction_to_sim(joint_friction: torch.Tensor | float | wp.array, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = 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 | wp.array, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, warn_limit_violation: bool = True) → None#: 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 | wp.array, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, warn_limit_violation: bool = True) → None#: Deprecated, same as write_joint_position_limit_to_sim_index().

Write joint position limits over selected environment indices into the simulation.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

limits – Joint limits. Shape is (len(env_ids), len(joint_ids), 2) or (num_instances, num_joints, 2). In warp the expected shape is (num_instances, num_joints), with dtype wp.vec2f.
joint_ids – Joint indices. If None, then all joints are used.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.
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_limit_to_sim_mask(*, limits: torch.Tensor | wp.array | float, joint_mask: wp.array | None = None, env_mask: wp.array | None = None, warn_limit_violation: bool = True)#

Write joint position limits over selected environment mask into the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

limits – Joint limits. Shape is (num_instances, num_joints, 2).
joint_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).
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 | wp.array, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | slice | None = None) → None#: Deprecated, same as write_joint_position_to_sim_index().

Write joint positions over selected environment indices into the simulation.

Note

This method expect partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

position – Joint positions. Shape is (len(env_ids), len(joint_ids)) or (num_instances, num_joints).
joint_ids – Joint indices. If None, then all joints are used.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

write_joint_position_to_sim_mask(*, position: torch.Tensor | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None)#

Write joint positions over selected environment mask into the simulation.

Note

This method expect full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

position – Joint positions. Shape is (num_instances, num_joints).
joint_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_joint_state_to_sim(position: torch.Tensor | wp.array, velocity: torch.Tensor | wp.array, joint_ids: Sequence[int] | torch.Tensor | wp.array | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None)#: Deprecated, same as write_joint_position_to_sim_index() and write_joint_velocity_to_sim_index().

write_joint_state_to_sim_mask(*, position: torch.Tensor | wp.array, velocity: torch.Tensor | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None)#

Write joint positions and velocities over selected environment mask into the simulation.

Note

This method expect full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

position – Joint positions. Shape is (num_instances, num_joints).
velocity – Joint velocities. Shape is (num_instances, num_joints).
joint_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_joint_stiffness_to_sim(stiffness: torch.Tensor | float | wp.array, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_joint_stiffness_to_sim_index().

Write joint stiffness over selected environment indices into the simulation.

Note

This method expect partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

stiffness – Joint stiffness. Shape is (len(env_ids), len(joint_ids)) or (num_instances, num_joints).
joint_ids – Joint indices. If None, then all joints are used.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

write_joint_stiffness_to_sim_mask(*, stiffness: torch.Tensor | wp.array | float, joint_mask: wp.array | None = None, env_mask: wp.array | None = None)#

Write joint stiffness over selected environment mask into the simulation.

Note

This method expect full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

stiffness – Joint stiffness. Shape is (num_instances, num_joints).
joint_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_joint_velocity_limit_to_sim(limits: torch.Tensor | float | wp.array, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_joint_velocity_limit_to_sim_index().

Write joint max velocity over selected environment indices into 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.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

limits – Joint max velocity. Shape is (len(env_ids), len(joint_ids)) or (num_instances, num_joints).
joint_ids – Joint indices. If None, then all joints are used.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

write_joint_velocity_limit_to_sim_mask(*, limits: torch.Tensor | wp.array | float, joint_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Write joint max velocity over selected environment mask into 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.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

limits – Joint max velocity. Shape is (num_instances, num_joints).
joint_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_joint_velocity_to_sim(velocity: torch.Tensor | wp.array, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | slice | None = None) → None#: Deprecated, same as write_joint_velocity_to_sim_index().

Write joint velocities to the simulation.

Note

This method expect partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

velocity – Joint velocities. Shape is (len(env_ids), len(joint_ids)) or (num_instances, num_joints).
joint_ids – Joint indices. If None, then all joints are used.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

write_joint_velocity_to_sim_mask(*, velocity: torch.Tensor | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None)#

Write joint velocities over selected environment mask into the simulation.

Note

This method expect full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

velocity – Joint velocities. Shape is (num_instances, num_joints).
joint_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_joint_viscous_friction_coefficient_to_sim(joint_viscous_friction_coeff: torch.Tensor | wp.array, joint_ids: Sequence[int] | torch.Tensor | wp.array | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, full_data: bool = False) → None#: Deprecated, same as write_joint_viscous_friction_coefficient_to_sim_index().

Write joint viscous friction coefficient over selected environment indices into the simulation.

Note

This method expects partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

joint_viscous_friction_coeff – Joint viscous friction coefficient. Shape is (len(env_ids), len(joint_ids)) or (num_instances, num_joints) if full_data.
joint_ids – Joint indices. If None, then all joints are used.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

write_joint_viscous_friction_coefficient_to_sim_mask(*, joint_viscous_friction_coeff: torch.Tensor | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Write joint viscous friction coefficient over selected environment mask into the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

joint_viscous_friction_coeff – Joint viscous friction coefficient. Shape is (num_instances, num_joints).
joint_mask – Joint mask. If None, then all joints are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_root_com_pose_to_sim(root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_root_com_pose_to_sim_index().

write_root_com_pose_to_sim_index(*, root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, full_data: bool = False) → 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 (x, y, z, w). The orientation is the orientation of the principal axes of inertia.

Note

This method expect partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

root_pose – Root center of mass poses in simulation frame. Shape is (len(env_ids), 7) or (num_instances, 7), or (len(env_ids),) / (num_instances,) with dtype wp.transformf.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

write_root_com_pose_to_sim_mask(*, root_pose: torch.Tensor | wp.array, env_mask: wp.array | None = None) → None#

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

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

Note

This method expect full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

root_pose – Root center of mass poses in simulation frame. Shape is (num_instances, 7) or (num_instances,) with dtype wp.transformf.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_root_com_state_to_sim(root_state: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_root_com_pose_to_sim_index() and write_root_com_velocity_to_sim_index().

write_root_com_velocity_to_sim(root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_root_com_velocity_to_sim_index().

write_root_com_velocity_to_sim_index(*, root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, full_data: bool = False) → 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 root’s frame.

Note

This method expect partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

root_velocity – Root center of mass velocities in simulation world frame. Shape is (len(env_ids), 6) or (num_instances, 6), or (len(env_ids),) / (num_instances,) with dtype wp.spatial_vectorf.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

write_root_com_velocity_to_sim_mask(*, root_velocity: torch.Tensor | wp.array, env_mask: wp.array | None = None) → None#

Set the root center of mass velocity over selected environment mask 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 root’s frame.

Note

This method expect full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

root_velocity – Root center of mass velocities in simulation world frame. Shape is (num_instances, 6) or (num_instances,) with dtype wp.spatial_vectorf.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_root_link_pose_to_sim(root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_root_link_pose_to_sim_index().

write_root_link_pose_to_sim_index(*, root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, full_data: bool = False) → 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 (x, y, z, w).

Note

This method expect partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

root_pose – Root poses in simulation frame. Shape is (len(env_ids), 7) or (num_instances, 7), or (len(env_ids),) / (num_instances,) with dtype wp.transformf.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

write_root_link_pose_to_sim_mask(*, root_pose: torch.Tensor | wp.array, env_mask: wp.array | None = None) → None#

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

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

Note

This method expect full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

root_pose – Root poses in simulation frame. Shape is (num_instances, 7) or (num_instances,) with dtype wp.transformf.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_root_link_state_to_sim(root_state: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_root_link_pose_to_sim_index() and write_root_link_velocity_to_sim_index().

write_root_link_velocity_to_sim(root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_root_link_velocity_to_sim_index().

write_root_link_velocity_to_sim_index(*, root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, full_data: bool = False) → 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 root’s center of mass.

Note

This method expect partial data or full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

root_velocity – Root frame velocities in simulation world frame. Shape is (len(env_ids), 6) or (num_instances, 6), or (len(env_ids),) / (num_instances,) with dtype wp.spatial_vectorf.
env_ids – Environment indices. If None, then all indices are used.
full_data – Whether to expect full data. Defaults to False.

write_root_link_velocity_to_sim_mask(*, root_velocity: torch.Tensor | wp.array, env_mask: wp.array | None = None) → None#

Set the root link velocity over selected environment mask 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 root’s center of mass.

Note

This method expect full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

root_velocity – Root frame velocities in simulation world frame. Shape is (num_instances, 6) or (num_instances,) with dtype wp.spatial_vectorf.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_root_pose_to_sim(root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_root_pose_to_sim_index().

write_root_pose_to_sim_index(*, root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = 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 (x, y, z, w).

Note

This method expect partial data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

root_pose – Root poses in simulation frame. Shape is (len(env_ids), 7) or (len(env_ids),) with dtype wp.transformf.
env_ids – Environment indices. If None, then all indices are used.

write_root_pose_to_sim_mask(*, root_pose: torch.Tensor | wp.array, env_mask: wp.array | None = None) → None#

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

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

Note

This method expect full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

root_pose – Root poses in simulation frame. Shape is (num_instances, 7) or (num_instances,) with dtype wp.transformf.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_root_state_to_sim(root_state: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_root_link_pose_to_sim_index() and write_root_com_velocity_to_sim_index().

write_root_velocity_to_sim(root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_root_velocity_to_sim_index().

write_root_velocity_to_sim_index(*, root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = 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 root’s frame.

Note

This method expect partial data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

root_velocity – Root center of mass velocities in simulation world frame. Shape is (len(env_ids), 6) or (len(env_ids),) with dtype wp.spatial_vectorf.
env_ids – Environment indices. If None, then all indices are used.

write_root_velocity_to_sim_mask(*, root_velocity: torch.Tensor | wp.array, env_mask: wp.array | None = None) → None#

Set the root center of mass velocity over selected environment mask 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 root’s frame.

Note

This method expect full data.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

root_velocity – Root center of mass velocities in simulation world frame. Shape is (num_instances, 6) or (num_instances,) with dtype wp.spatial_vectorf.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

write_spatial_tendon_properties_to_sim(spatial_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as write_spatial_tendon_properties_to_sim_index().

write_spatial_tendon_properties_to_sim_index(*, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#

Write spatial tendon properties into the simulation using indices.

Tip

For maximum performance we recommend using the index method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

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

write_spatial_tendon_properties_to_sim_mask(*, spatial_tendon_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Write spatial tendon properties into the simulation using masks.

Tip

For maximum performance we recommend using the mask method. This is because in PhysX, the tensor API is only supporting indexing, hence masks need to be converted to indices.

Parameters:

spatial_tendon_mask – Spatial tendon mask. If None, then all spatial tendons are used.
env_mask – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

class isaaclab_contrib.assets.MultirotorCfg[source]#

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

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`	Shorthand for `body_com_acc_w`.
`body_ang_acc_w`	Shorthand for `body_com_ang_acc_w`.
`body_ang_vel_w`	Shorthand for `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' center of mass 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 (x, y, z, w) of the principal axes of inertia of all of the bodies in their respective link frames.
`body_com_quat_w`	Orientation (x, y, z, w) of the principal axes 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_inertia`	Flattened body inertia in the world frame.
`body_lin_acc_w`	Shorthand for `body_com_lin_acc_w`.
`body_lin_vel_w`	Shorthand for `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 (x, y, z, w) 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_mass`	Body mass in the world frame.
`body_names`	Body names in the order parsed by the simulation view.
`body_pos_w`	Shorthand for `body_link_pos_w`.
`body_pose_w`	Shorthand for `body_link_pose_w`.
`body_quat_w`	Shorthand for `body_link_quat_w`.
`body_state_w`	State of all bodies [pos, quat, lin_vel, ang_vel] in simulation world frame.
`body_vel_w`	Shorthand for `body_com_vel_w`.
`com_pos_b`	Shorthand for `body_com_pos_b`.
`com_quat_b`	Shorthand for `body_com_quat_b`.
`computed_torque`	Joint torques computed from the actuator model (before clipping).
`default_fixed_tendon_damping`	Deprecated property.
`default_fixed_tendon_limit`	Deprecated property.
`default_fixed_tendon_limit_stiffness`	Deprecated property.
`default_fixed_tendon_offset`	Deprecated property.
`default_fixed_tendon_pos_limits`	Deprecated property.
`default_fixed_tendon_rest_length`	Deprecated property.
`default_fixed_tendon_stiffness`	Deprecated property.
`default_inertia`	Deprecated property.
`default_joint_armature`	Deprecated property.
`default_joint_damping`	Deprecated property.
`default_joint_friction`	Deprecated property.
`default_joint_friction_coeff`	Deprecated property.
`default_joint_limits`	Shorthand for `default_joint_pos_limits`.
`default_joint_pos`	Default joint positions of all joints.
`default_joint_pos_limits`	Deprecated property.
`default_joint_stiffness`	Deprecated property.
`default_joint_vel`	Default joint velocities of all joints.
`default_joint_viscous_friction_coeff`	Deprecated property.
`default_mass`	Deprecated property.
`default_root_pose`	Default root pose `[pos, quat]` in the local environment frame.
`default_root_state`	Default root state `[pos, quat, lin_vel, ang_vel]` in the local environment frame.
`default_root_vel`	Default root velocity `[lin_vel, ang_vel]` in the local environment frame.
`default_spatial_tendon_damping`	Deprecated property.
`default_spatial_tendon_limit_stiffness`	Deprecated property.
`default_spatial_tendon_offset`	Deprecated property.
`default_spatial_tendon_stiffness`	Deprecated property.
`fixed_tendon_damping`	Fixed tendon damping provided to the simulation.
`fixed_tendon_limit`	Shorthand for `fixed_tendon_pos_limits`.
`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).
`is_primed`	Whether the articulation data is fully instantiated and ready to use.
`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`	Shorthand for `joint_friction_coeff`.
`joint_friction_coeff`	Joint static friction coefficient provided to the simulation.
`joint_limits`	Shorthand for `joint_pos_limits`.
`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`	Shorthand for `joint_vel_limits`.
`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`	Shorthand for `root_com_ang_vel_b`.
`root_ang_vel_w`	Shorthand for `root_com_ang_vel_w`.
`root_com_ang_vel_b`	Root center of mass angular velocity in base 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 (x, y, z, w) in simulation world frame.
`root_com_state_w`	Deprecated, same as `root_com_pose_w` and `root_com_vel_w`.
`root_com_vel_w`	Root center of mass velocity `[lin_vel, ang_vel]` in simulation world frame.
`root_lin_vel_b`	Shorthand for `root_com_lin_vel_b`.
`root_lin_vel_w`	Shorthand for `root_com_lin_vel_w`.
`root_link_ang_vel_b`	Root link angular velocity in base 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 (x, y, z, w) in simulation world frame.
`root_link_state_w`	Deprecated, same as `root_link_pose_w` and `root_link_vel_w`.
`root_link_vel_w`	Root link velocity `[lin_vel, ang_vel]` in simulation world frame.
`root_pos_w`	Shorthand for `root_link_pos_w`.
`root_pose_w`	Shorthand for `root_link_pose_w`.
`root_quat_w`	Shorthand for `root_link_quat_w`.
`root_state_w`	Deprecated, same as `root_link_pose_w` and `root_com_vel_w`.
`root_vel_w`	Shorthand for `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_view, device)	Initializes the articulation data.
`update`(dt)	Updates the data for the articulation.

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_view: physx.ArticulationView, device: str)#

Initializes the articulation data.

Parameters:

root_view – The root articulation view.
device – The device used for processing.

property applied_torque: warp.array#

Joint torques applied from the actuator model (after clipping).

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (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: warp.array#: Shorthand for body_com_acc_w.

property body_ang_acc_w: warp.array#: Shorthand for body_com_ang_acc_w.

property body_ang_vel_w: warp.array#: Shorthand for 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), dtype = wp.spatial_vectorf. In torch this resolves to (num_instances, num_bodies, 6).

All values are relative to the world.

property body_com_ang_acc_w: warp.array#

Angular acceleration of all bodies in simulation world frame. Shape is (num_instances, num_bodies), dtype = wp.vec3f. In torch this resolves to (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: warp.array#

Angular velocity of all bodies in simulation world frame. Shape is (num_instances, num_bodies), dtype = wp.vec3f. In torch this resolves to (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: warp.array#

Linear acceleration of all bodies in simulation world frame. Shape is (num_instances, num_bodies), dtype = wp.vec3f. In torch this resolves to (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: warp.array#

Linear velocity of all bodies in simulation world frame. Shape is (num_instances, num_bodies), dtype = wp.vec3f. In torch this resolves to (num_instances, num_bodies, 3).

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

property body_com_pos_b: warp.array#

Center of mass position of all of the bodies in their respective link frames. Shape is (num_instances, num_bodies), dtype = wp.vec3f. In torch this resolves to (num_instances, num_bodies, 3).

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

property body_com_pos_w: warp.array#

Positions of all bodies’ center of mass in simulation world frame. Shape is (num_instances, num_bodies), dtype = wp.vec3f. In torch this resolves to (num_instances, num_bodies, 3).

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

property body_com_pose_b: warp.array#

Center of mass pose [pos, quat] of all bodies in their respective body’s link frames. Shape is (num_instances, num_bodies), dtype = wp.transformf. In torch this resolves to (num_instances, num_bodies, 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 (x, y, z, w) format.

property body_com_pose_w: warp.array#

Body center of mass pose [pos, quat] in simulation world frame. Shape is (num_instances, num_bodies), dtype = wp.transformf. In torch this resolves to (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 (x, y, z, w) format.

property body_com_quat_b: warp.array#

Orientation (x, y, z, w) of the principal axes of inertia of all of the bodies in their respective link frames. Shape is (num_instances, num_bodies), dtype = wp.quatf. In torch this resolves to (num_instances, num_bodies, 4).

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

property body_com_quat_w: warp.array#

Orientation (x, y, z, w) of the principal axes of inertia of all bodies in simulation world frame. Shape is (num_instances, num_bodies), dtype = wp.quatf. In torch this resolves to (num_instances, num_bodies, 4).

This quantity is the orientation of the articulation bodies’ principal axes of inertia.

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 principal inertia.

property body_com_vel_w: warp.array#

Body center of mass velocity [lin_vel, ang_vel] in simulation world frame. Shape is (num_instances, num_bodies), dtype = wp.spatial_vectorf. In torch this resolves to (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: warp.array#

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_inertia: warp.array#

Flattened body inertia in the world frame.

Shape is (num_instances, num_bodies, 9), dtype = wp.float32. In torch this resolves to (num_instances, num_bodies, 9).

property body_lin_acc_w: warp.array#: Shorthand for body_com_lin_acc_w.

property body_lin_vel_w: warp.array#: Shorthand for body_com_lin_vel_w.

property body_link_ang_vel_w: warp.array#

Angular velocity of all bodies in simulation world frame. Shape is (num_instances, num_bodies), dtype = wp.vec3f. In torch this resolves to (num_instances, num_bodies, 3).

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

property body_link_lin_vel_w: warp.array#

Linear velocity of all bodies in simulation world frame. Shape is (num_instances, num_bodies), dtype = wp.vec3f. In torch this resolves to (num_instances, num_bodies, 3).

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

property body_link_pos_w: warp.array#

Positions of all bodies in simulation world frame. Shape is (num_instances, num_bodies), dtype = wp.vec3f. In torch this resolves to (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: warp.array#

Body link pose [pos, quat] in simulation world frame. Shape is (num_instances, num_bodies), dtype = wp.transformf. In torch this resolves to (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 (x, y, z, w) format.

property body_link_quat_w: warp.array#

Orientation (x, y, z, w) of all bodies in simulation world frame. Shape is (num_instances, num_bodies), dtype = wp.quatf. In torch this resolves to (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: warp.array#

Body link velocity [lin_vel, ang_vel] in simulation world frame. Shape is (num_instances, num_bodies), dtype = wp.spatial_vectorf. In torch this resolves to (num_instances, num_bodies, 6).

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

property body_mass: warp.array#

Body mass in the world frame.

Shape is (num_instances, num_bodies), dtype = wp.float32. In torch this resolves to (num_instances, num_bodies).

body_names: list[str] = None#: Body names in the order parsed by the simulation view.

property body_pos_w: warp.array#: Shorthand for body_link_pos_w.

property body_pose_w: warp.array#: Shorthand for body_link_pose_w.

property body_quat_w: warp.array#: Shorthand for 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’ center of mass frame.

property body_vel_w: warp.array#: Shorthand for body_com_vel_w.

property com_pos_b: warp.array#: Shorthand for body_com_pos_b.

property com_quat_b: warp.array#: Shorthand for body_com_quat_b.

property computed_torque: warp.array#

Joint torques computed from the actuator model (before clipping).

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (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.

property default_fixed_tendon_damping: warp.array#: Deprecated property. Please use fixed_tendon_damping instead and manage the default fixed tendon damping manually.

property default_fixed_tendon_limit: warp.array#: Deprecated property. Please use default_fixed_tendon_pos_limits instead.

property default_fixed_tendon_limit_stiffness: warp.array#: Deprecated property. Please use fixed_tendon_limit_stiffness instead and manage the default fixed tendon limit stiffness manually.

property default_fixed_tendon_offset: warp.array#: Deprecated property. Please use fixed_tendon_offset instead and manage the default fixed tendon offset manually.

property default_fixed_tendon_pos_limits: warp.array#: Deprecated property. Please use fixed_tendon_pos_limits instead and manage the default fixed tendon position limits manually.

property default_fixed_tendon_rest_length: warp.array#: Deprecated property. Please use fixed_tendon_rest_length instead and manage the default fixed tendon rest length manually.

property default_fixed_tendon_stiffness: warp.array#: Deprecated property. Please use fixed_tendon_stiffness instead and manage the default fixed tendon stiffness manually.

property default_inertia: warp.array#: Deprecated property. Please use body_inertia instead and manage the default inertia manually.

property default_joint_armature: warp.array#: Deprecated property. Please use joint_armature instead and manage the default joint armature manually.

property default_joint_damping: warp.array#: Deprecated property. Please use joint_damping instead and manage the default joint damping manually.

property default_joint_friction: warp.array#: Deprecated property. Please use default_joint_friction_coeff instead.

property default_joint_friction_coeff: warp.array#: Deprecated property. Please use joint_friction_coeff instead and manage the default joint friction coefficient manually.

property default_joint_limits: warp.array#: Shorthand for default_joint_pos_limits.

property default_joint_pos: warp.array#

Default joint positions of all joints.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (num_instances, num_joints).

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

property default_joint_pos_limits: warp.array#: Deprecated property. Please use joint_pos_limits instead and manage the default joint position limits manually.

property default_joint_stiffness: warp.array#: Deprecated property. Please use joint_stiffness instead and manage the default joint stiffness manually.

property default_joint_vel: warp.array#

Default joint velocities of all joints.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (num_instances, num_joints).

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

property default_joint_viscous_friction_coeff: warp.array#: Deprecated property. Please use joint_viscous_friction_coeff instead and manage the default joint viscous friction coefficient manually.

property default_mass: warp.array#: Deprecated property. Please use body_mass instead and manage the default mass manually.

property default_root_pose: warp.array#

Default root pose [pos, quat] in the local environment frame.

The position and quaternion are of the articulation root’s actor frame. Shape is (num_instances,), dtype = wp.transformf. In torch this resolves to (num_instances, 7).

property default_root_state: warp.array#

Default root state [pos, quat, lin_vel, ang_vel] in the local environment frame.

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. Shape is (num_instances, 13).

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

property default_root_vel: warp.array#

Default root velocity [lin_vel, ang_vel] in the local environment frame.

The linear and angular velocities are of the articulation root’s center of mass frame. Shape is (num_instances,), dtype = wp.spatial_vectorf. In torch this resolves to (num_instances, 6).

property default_spatial_tendon_damping: warp.array#: Deprecated property. Please use spatial_tendon_damping instead and manage the default spatial tendon damping manually.

property default_spatial_tendon_limit_stiffness: warp.array#: Deprecated property. Please use spatial_tendon_limit_stiffness instead and manage the default spatial tendon limit stiffness manually.

property default_spatial_tendon_offset: warp.array#: Deprecated property. Please use spatial_tendon_offset instead and manage the default spatial tendon offset manually.

property default_spatial_tendon_stiffness: warp.array#: Deprecated property. Please use spatial_tendon_stiffness instead and manage the default spatial tendon stiffness manually.

property fixed_tendon_damping: warp.array#

Fixed tendon damping provided to the simulation.

Shape is (num_instances, num_fixed_tendons), dtype = wp.float32. In torch this resolves to (num_instances, num_fixed_tendons).

property fixed_tendon_limit: warp.array#: Shorthand for fixed_tendon_pos_limits.

property fixed_tendon_limit_stiffness: warp.array#

Fixed tendon limit stiffness provided to the simulation.

Shape is (num_instances, num_fixed_tendons), dtype = wp.float32. In torch this resolves to (num_instances, num_fixed_tendons).

fixed_tendon_names: list[str] = None#: Fixed tendon names in the order parsed by the simulation view.

property fixed_tendon_offset: warp.array#

Fixed tendon offset provided to the simulation.

Shape is (num_instances, num_fixed_tendons), dtype = wp.float32. In torch this resolves to (num_instances, num_fixed_tendons).

property fixed_tendon_pos_limits: warp.array#

Fixed tendon position limits provided to the simulation.

Shape is (num_instances, num_fixed_tendons), dtype = wp.vec2f. In torch this resolves to (num_instances, num_fixed_tendons, 2).

property fixed_tendon_rest_length: warp.array#

Fixed tendon rest length provided to the simulation.

Shape is (num_instances, num_fixed_tendons), dtype = wp.float32. In torch this resolves to (num_instances, num_fixed_tendons).

property fixed_tendon_stiffness: warp.array#

Fixed tendon stiffness provided to the simulation.

Shape is (num_instances, num_fixed_tendons), dtype = wp.float32. In torch this resolves to (num_instances, num_fixed_tendons).

property gear_ratio: warp.array#

Gear ratio for relating motor torques to applied Joint torques.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (num_instances, num_joints).

property heading_w#: Yaw heading of the base frame (in radians). Shape is (num_instances,), dtype = wp.float32.

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 is_primed: bool#: Whether the articulation data is fully instantiated and ready to use.

property joint_acc: warp.array#

Joint acceleration of all joints.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (num_instances, num_joints).

property joint_armature: warp.array#

Joint armature provided to the simulation.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (num_instances, num_joints).

property joint_damping: warp.array#

Joint damping provided to the simulation.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (num_instances, num_joints).

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

property joint_dynamic_friction_coeff: warp.array#

Joint dynamic friction coefficient provided to the simulation.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (num_instances, num_joints).

property joint_effort_limits: warp.array#

Joint maximum effort provided to the simulation.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (num_instances, num_joints).

property joint_effort_target: warp.array#

Joint effort targets commanded by the user.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (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: warp.array#: Shorthand for joint_friction_coeff.

property joint_friction_coeff: warp.array#

Joint static friction coefficient provided to the simulation.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (num_instances, num_joints).

property joint_limits: warp.array#: Shorthand for joint_pos_limits.

joint_names: list[str] = None#: Joint names in the order parsed by the simulation view.

property joint_pos: warp.array#

Joint positions of all joints.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (num_instances, num_joints).

property joint_pos_limits: warp.array#

Joint position limits provided to the simulation.

Shape is (num_instances, num_joints), dtype = wp.vec2f. In torch this resolves to (num_instances, num_joints, 2).

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

property joint_pos_target: warp.array#

Joint position targets commanded by the user.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (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_stiffness: warp.array#

Joint stiffness provided to the simulation.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (num_instances, num_joints).

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

property joint_vel: warp.array#

Joint velocities of all joints.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (num_instances, num_joints).

property joint_vel_limits: warp.array#

Joint maximum velocity provided to the simulation.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (num_instances, num_joints).

property joint_vel_target: warp.array#

Joint velocity targets commanded by the user.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (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: warp.array#: Shorthand for joint_vel_limits.

property joint_viscous_friction_coeff: warp.array#

Joint viscous friction coefficient provided to the simulation.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (num_instances, num_joints).

property projected_gravity_b#: Projection of the gravity direction on base frame. Shape is (num_instances,), dtype = wp.vec3f. In torch this resolves to (num_instances, 3).

property root_ang_vel_b: warp.array#: Shorthand for root_com_ang_vel_b.

property root_ang_vel_w: warp.array#: Shorthand for root_com_ang_vel_w.

property root_com_ang_vel_b: warp.array#

Root center of mass angular velocity in base frame. Shape is (num_instances,), dtype = wp.vec3f. In torch this resolves to (num_instances, 3).

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

property root_com_ang_vel_w: warp.array#

Root center of mass angular velocity in simulation world frame. Shape is (num_instances,), dtype = wp.vec3f. In torch this resolves to (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: warp.array#

Root center of mass linear velocity in base frame. Shape is (num_instances,), dtype = wp.vec3f. In torch this resolves to (num_instances, 3).

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

property root_com_lin_vel_w: warp.array#

Root center of mass linear velocity in simulation world frame. Shape is (num_instances,), dtype = wp.vec3f. In torch this resolves to (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: warp.array#

Root center of mass position in simulation world frame. Shape is (num_instances,), dtype = wp.vec3f. In torch this resolves to (num_instances, 3).

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

property root_com_pose_w: warp.array#

Root center of mass pose [pos, quat] in simulation world frame. Shape is (num_instances,), dtype = wp.transformf. In torch this resolves to (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 (x, y, z, w) format.

property root_com_quat_w: warp.array#

Root center of mass orientation (x, y, z, w) in simulation world frame. Shape is (num_instances,), dtype = wp.quatf. In torch this resolves to (num_instances, 4).

This quantity is the orientation of the principal axes of inertia of the root rigid body relative to the world.

property root_com_state_w: warp.array#: Deprecated, same as root_com_pose_w and root_com_vel_w.

property root_com_vel_w: warp.array#

Root center of mass velocity [lin_vel, ang_vel] in simulation world frame. Shape is (num_instances,), dtype = wp.spatial_vectorf. In torch this resolves to (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: warp.array#: Shorthand for root_com_lin_vel_b.

property root_lin_vel_w: warp.array#: Shorthand for root_com_lin_vel_w.

property root_link_ang_vel_b: warp.array#

Root link angular velocity in base frame. Shape is (num_instances,), dtype = wp.vec3f. In torch this resolves to (num_instances, 3).

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

property root_link_ang_vel_w: warp.array#

Root link angular velocity in simulation world frame. Shape is (num_instances,), dtype = wp.vec3f. In torch this resolves to (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: warp.array#

Root link linear velocity in base frame. Shape is (num_instances,), dtype = wp.vec3f. In torch this resolves to (num_instances, 3).

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

property root_link_lin_vel_w: warp.array#

Root linear velocity in simulation world frame. Shape is (num_instances,), dtype = wp.vec3f. In torch this resolves to (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: warp.array#

Root link position in simulation world frame. Shape is (num_instances,), dtype = wp.vec3f. In torch this resolves to (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: warp.array#

Root link pose [pos, quat] in simulation world frame. Shape is (num_instances,), dtype = wp.transformf. In torch this resolves to (num_instances, 7).

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

property root_link_quat_w: warp.array#

Root link orientation (x, y, z, w) in simulation world frame. Shape is (num_instances,), dtype = wp.quatf. In torch this resolves to (num_instances, 4).

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

property root_link_state_w: warp.array#: Deprecated, same as root_link_pose_w and root_link_vel_w.

property root_link_vel_w: warp.array#

Root link velocity [lin_vel, ang_vel] in simulation world frame. Shape is (num_instances,), dtype = wp.spatial_vectorf. In torch this resolves to (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: warp.array#: Shorthand for root_link_pos_w.

property root_pose_w: warp.array#: Shorthand for root_link_pose_w.

property root_quat_w: warp.array#: Shorthand for root_link_quat_w.

property root_state_w: warp.array#: Deprecated, same as root_link_pose_w and root_com_vel_w.

property root_vel_w: warp.array#: Shorthand for root_com_vel_w.

property soft_joint_pos_limits: warp.array#

Soft joint positions limits for all joints.

Shape is (num_instances, num_joints), dtype = wp.vec2f. In torch this resolves to (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.

property soft_joint_vel_limits: warp.array#

Soft joint velocity limits for all joints.

Shape is (num_instances, num_joints), dtype = wp.float32. In torch this resolves to (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.

property spatial_tendon_damping: warp.array#

Spatial tendon damping provided to the simulation.

Shape is (num_instances, num_spatial_tendons), dtype = wp.float32. In torch this resolves to (num_instances, num_spatial_tendons).

property spatial_tendon_limit_stiffness: warp.array#

Spatial tendon limit stiffness provided to the simulation.

Shape is (num_instances, num_spatial_tendons), dtype = wp.float32. In torch this resolves to (num_instances, num_spatial_tendons).

spatial_tendon_names: list[str] = None#: Spatial tendon names in the order parsed by the simulation view.

property spatial_tendon_offset: warp.array#

Spatial tendon offset provided to the simulation.

Shape is (num_instances, num_spatial_tendons), dtype = wp.float32. In torch this resolves to (num_instances, num_spatial_tendons).

property spatial_tendon_stiffness: warp.array#

Spatial tendon stiffness provided to the simulation.

Shape is (num_instances, num_spatial_tendons), dtype = wp.float32. In torch this resolves to (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).

update(dt: float) → None#

Updates the data for the articulation.

Parameters:: dt – The time step for the update. This must be a positive value.

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.

`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.

`rps`	Revolutions per second (RPS) of the thrusters.
`pos`	Position of the root in simulation world frame.
`rot`	Quaternion rotation (x, y, z, w) 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.

isaaclab_contrib.assets

Contents

isaaclab_contrib.assets#

Multirotor Asset#