isaaclab.assets

isaaclab.assets#

Sub-package for different assets, such as rigid objects and articulations.

An asset is a physical object that can be spawned in the simulation. The class handles both the spawning of the asset into the USD stage as well as initialization of necessary physics handles to interact with the asset.

Upon construction of the asset instance, the prim corresponding to the asset is spawned into the USD stage if the spawn configuration is not None. The spawn configuration is defined in the AssetBaseCfg.spawn attribute. In case the configured AssetBaseCfg.prim_path is an expression, then the prim is spawned at all the matching paths. Otherwise, a single prim is spawned at the configured path. For more information on the spawn configuration, see the isaaclab.sim.spawners module.

The asset class also registers callbacks for the stage play/stop events. These are used to construct the physics handles for the asset as the physics engine is only available when the stage is playing. Additionally, the class registers a callback for debug visualization of the asset. This can be enabled by setting the AssetBaseCfg.debug_vis attribute to True.

The asset class follows the following naming convention for its methods:

set_xxx(): These are used to only set the buffers into the data instance. However, they do not write the data into the simulator. The writing of data only happens when the write_data_to_sim() method is called.
write_xxx_to_sim(): These are used to set the buffers into the data instance and write the corresponding data into the simulator as well.
update(dt): These are used to update the buffers in the data instance. This should be called after a simulation step is performed.

The main reason to separate the set and write operations is to provide flexibility to the user when they need to perform a post-processing operation of the buffers before applying them into the simulator. A common example for this is dealing with explicit actuator models where the specified joint targets are not directly applied to the simulator but are instead used to compute the corresponding actuator torques.

Classes

`AssetBase`	The base interface class for assets.
`AssetBaseCfg`	The base configuration class for an asset's parameters.
`RigidObject`	Factory for creating rigid object instances.
`RigidObjectData`	Factory for creating rigid object data instances.
`RigidObjectCfg`	Configuration parameters for a rigid object.
`RigidObjectCollection`	Factory for creating rigid object collection instances.
`RigidObjectCollectionData`	Factory for creating rigid object collection data instances.
`RigidObjectCollectionCfg`	Configuration parameters for a rigid object collection.
`BaseDeformableObject`	Abstract base class for deformable object assets.
`BaseDeformableObjectData`	Abstract data container for a deformable object.
`DeformableObject`	Factory for creating deformable object instances.
`DeformableObjectData`	Factory for creating deformable object data instances.
`DeformableObjectCfg`	Configuration parameters for a deformable object.
`BaseArticulation`	An articulation asset class.
`BaseArticulationData`	Data container for an articulation.
`Articulation`	Factory for creating articulation instances.
`ArticulationData`	Factory for creating articulation data instances.
`ArticulationCfg`	Configuration parameters for an articulation.
`ArticulationOrderingConvention`	Built-in non-default public articulation name-ordering conventions.
`ArticulationNameMap`	Frozen permutation between backend and public articulation order.

Functions

`apply_articulation_ordering_preset`(cfg, ordering)	Apply one public ordering preset to both joints and bodies.
`parse_articulation_ordering_convention`(ordering)	Parse a symbolic public articulation ordering convention.
`get_articulation_name_ordering`(articulation, ...)	Return articulation names in the order defined by a naming convention.

Asset Base#

class isaaclab.assets.AssetBase[source]#

The base interface class for assets.

An asset corresponds to any physics-enabled object that can be spawned in the simulation. These include rigid objects, articulated objects, deformable objects etc. The core functionality of an asset is to provide a set of buffers that can be used to interact with the simulator. The buffers are updated by the asset class and can be written into the simulator using the their respective write methods. This allows a convenient way to perform post-processing operations on the buffers before writing them into the simulator and obtaining the corresponding simulation results.

The class handles both the spawning of the asset into the USD stage as well as initialization of necessary physics handles to interact with the asset. Upon construction of the asset instance, the prim corresponding to the asset is spawned into the USD stage if the spawn configuration is not None. The spawn configuration is defined in the AssetBaseCfg.spawn attribute. In case the configured AssetBaseCfg.prim_path is an expression, then the prim is spawned at all the matching paths. Otherwise, a single prim is spawned at the configured path. For more information on the spawn configuration, see the isaaclab.sim.spawners module.

Unlike backend-specific interfaces (e.g. Isaac Sim PhysX) where one usually needs to call initialize explicitly, the asset class automatically initializes and invalidates physics handles when the simulation is ready or stopped. This is done by registering callbacks for the physics lifecycle events (PhysicsEvent.PHYSICS_READY, PhysicsEvent.STOP).

Additionally, the class registers a callback for debug visualization of the asset if a debug visualization is implemented in the asset class. This can be enabled by setting the AssetBaseCfg.debug_vis attribute to True. The debug visualization is implemented through the _set_debug_vis_impl() and _debug_vis_callback() methods.

Methods:

`__init__`(cfg)	Initialize the asset base.
`set_visibility`(visible[, env_ids])	Set the visibility of the prims corresponding to the asset.
`set_debug_vis`(debug_vis)	Sets whether to visualize the asset data.
`reset`([env_ids])	Resets all internal buffers of selected environments.
`write_data_to_sim`()	Writes data to the simulator.
`update`(dt)	Update the internal buffers.
`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.

Attributes:

`is_initialized`	Whether the asset is initialized.
`num_instances`	Number of instances of the asset.
`device`	Memory device for computation.
`data`	Data related to the asset.
`has_debug_vis_implementation`	Whether the asset has a debug visualization implemented.

__init__(cfg: AssetBaseCfg)[source]#

Initialize the asset base.

Parameters:: cfg¶ – The configuration class for the asset.
Raises:: RuntimeError – If no prims found at input prim path or prim path expression.

property is_initialized: bool#

Whether the asset is initialized.

Returns True if the asset is initialized, False otherwise.

abstract 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 device: str#: Memory device for computation.

abstract property data: Any#: Data related to the asset.

property has_debug_vis_implementation: bool#: Whether the asset has a debug visualization implemented.

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

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

set_debug_vis(debug_vis: bool) → bool[source]#

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.

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

Resets all internal buffers of selected environments.

Parameters:: env_ids¶ – The indices of the object to reset. Defaults to None (all instances).

abstractmethod write_data_to_sim()[source]#: Writes data to the simulator.

abstractmethod update(dt: float)[source]#

Update the internal buffers.

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

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

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

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

Controlled by AssetBaseCfg.disable_shape_checks. When checks are disabled this method is a no-op.

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

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

Controlled by AssetBaseCfg.disable_shape_checks. When checks are disabled this method is a no-op.

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

class isaaclab.assets.AssetBaseCfg[source]#

The base configuration class for an asset’s parameters.

Please see the AssetBase class for more information on the asset class.

Attributes:

`prim_path`	Prim path (or expression) to the asset.
`spawn`	Spawn configuration for the asset.
`init_state`	Initial state of the rigid object.
`collision_group`	Collision group of the asset.
`debug_vis`	Whether to enable debug visualization for the asset.
`disable_shape_checks`	Disable shape/dtype validation in setter and writer methods.

prim_path: str#: Prim path (or expression) to the asset.

Note

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

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

spawn: SpawnerCfg | None#

Spawn configuration for the asset. Defaults to None.

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

init_state: InitialStateCfg#: Initial state of the rigid object. Defaults to identity pose.

collision_group: Literal[0, -1]#

Collision group of the asset. Defaults to 0.

-1: global collision group (collides with all assets in the scene).
0: local collision group (collides with other assets in the same environment).

debug_vis: bool#: Whether to enable debug visualization for the asset. Defaults to False.

disable_shape_checks: bool | None#

Disable shape/dtype validation in setter and writer methods.

When True, assert_shape_and_dtype() and assert_shape_and_dtype_mask() become no-ops, eliminating per-call assertion overhead.

When False, shape checks are always enabled, even under python -O.

When None (the default), shape checks follow Python’s __debug__ flag — enabled in normal mode, disabled with python -O.

Rigid Object#

class isaaclab.assets.RigidObject[source]#

Bases: FactoryBase, BaseRigidObject

Factory for creating rigid object instances.

Attributes:

`data`	Data related to the asset.
`body_names`	Ordered names of bodies in the rigid object.
`device`	Memory device for computation.
`has_debug_vis_implementation`	Whether the asset has a debug visualization implemented.
`instantaneous_wrench_composer`	Instantaneous wrench composer.
`is_initialized`	Whether the asset is initialized.
`num_bodies`	Number of bodies in the asset.
`num_instances`	Number of instances of the asset.
`permanent_wrench_composer`	Permanent wrench composer.
`root_view`	Root view for the asset.
`cfg`	Configuration instance for the rigid object.

Methods:

`__new__`(cls, args, *kwargs)	Create a new instance of a rigid object based on the backend.
`__init__`(cfg)	Initialize the rigid object.
`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 rigid body based on the name keys.
`get_registry_keys`()	Returns a list of registered backend names.
`register`(name, sub_class)	Register a new implementation class.
`reset`([env_ids, env_mask])	Reset the rigid object.
`resolve_class`(args, *kwargs)	Resolve the concrete backend implementation class without instantiating it.
`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 positions of all bodies.
`set_coms_mask`(*, coms[, body_mask, env_mask])	Set center of mass positions of all bodies.
`set_debug_vis`(debug_vis)	Sets whether to visualize the asset data.
`set_external_force_and_torque`(forces, torques)	Deprecated.
`set_inertias`(inertias[, body_ids, env_ids])	Deprecated, same as `set_inertias_index()`.
`set_inertias_index`(*, inertias[, body_ids, ...])	Set inertias of all bodies.
`set_inertias_mask`(*, inertias[, body_mask, ...])	Set inertias of all bodies.
`set_masses`(masses[, body_ids, env_ids])	Deprecated, same as `set_masses_index()`.
`set_masses_index`(*, masses[, body_ids, env_ids])	Set masses of all bodies.
`set_masses_mask`(*, masses[, body_mask, env_mask])	Set masses of all bodies.
`set_visibility`(visible[, env_ids])	Set the visibility of the prims corresponding to the asset.
`update`(dt)	Updates the simulation data.
`write_data_to_sim`()	Write external wrench to 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_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_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_pose_to_sim_index()` and `write_root_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.

abstract property data: RigidObjectData#: Data related to the asset.

static __new__(cls, *args, **kwargs) → BaseRigidObject | PhysXRigidObject[source]#: Create a new instance of a rigid object based on the backend.

__init__(cfg: RigidObjectCfg)#

Initialize the rigid object.

Parameters:: cfg¶ – A configuration instance.

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.

Controlled by AssetBaseCfg.disable_shape_checks. When checks are disabled this method is a no-op.

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

Controlled by AssetBaseCfg.disable_shape_checks. When checks are disabled this method is a no-op.

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

abstract property body_names: list[str]#: Ordered names of bodies in the rigid object.

property device: str#: Memory device for computation.

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

Find bodies in the rigid body 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.

classmethod get_registry_keys() → list[str]#: Returns a list of registered backend names.

property has_debug_vis_implementation: bool#: Whether the asset has a debug visualization implemented.

abstract 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_initialized: bool#

Whether the asset is initialized.

Returns True if the asset is initialized, False otherwise.

abstract property num_bodies: int#

Number of bodies in the asset.

This is always 1 since each object is a single rigid body.

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

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

classmethod register(name: str, sub_class) → None#: Register a new implementation class.

abstractmethod reset(env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, env_mask: wp.array | None = None) → None#

Reset the rigid object.

Caution

If both env_ids and env_mask are provided, then env_mask takes precedence over env_ids.

Parameters:

env_ids¶ – Environment indices. If None, then all indices are used.
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

classmethod resolve_class(*args, **kwargs) → type#

Resolve the concrete backend implementation class without instantiating it.

Selects the backend via _get_backend(), lazily importing and registering the implementation class on first use, and returns it. Takes the same arguments as the constructor (the backend selector reads from them). Useful for querying class-level behavior (e.g. capability classmethods) before a sim/instance exists.

abstract property root_view#: 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 positions of all bodies.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

coms¶ – Center of mass positions of all bodies. Shape is (len(env_ids), len(body_ids), 3).
body_ids¶ – The body indices to set the center of mass positions for. Defaults to None (all bodies).
env_ids¶ – The environment indices to set the center of mass positions for. Defaults to None (all environments).

abstractmethod 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 positions of all bodies.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

coms¶ – Center of mass positions of all bodies. Shape is (num_instances, num_bodies, 3) or (num_instances, num_bodies) with dtype wp.vec3f.
body_mask¶ – Body mask. If None, then all bodies are used. Shape is (num_bodies,).
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. Resets target environments, then adds forces and torques via the permanent wrench composer.

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.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

inertias¶ – Inertias of all bodies. Shape is (len(env_ids), len(body_ids), 9).
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).

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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. Shape is (num_bodies,).
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.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

masses¶ – Masses of all bodies. Shape is (len(env_ids), len(body_ids)).
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).

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

masses¶ – Masses of all bodies. Shape is (num_instances, num_bodies).
body_mask¶ – Body mask. If None, then all bodies are used. Shape is (num_bodies,).
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).

abstractmethod update(dt: float) → None#

Updates the simulation data.

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

abstractmethod write_data_to_sim() → None#: Write external wrench to the simulation.

Note

We write external wrench to the simulation here since this function is called before the simulation step. This ensures that the external wrench is applied at every simulation step.

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

abstractmethod write_root_com_pose_to_sim_index(*, root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: 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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

root_pose¶ – Root center of mass 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_com_pose_to_sim_mask(*, root_pose: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → 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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod 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_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().

abstractmethod write_root_com_velocity_to_sim_index(*, root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: 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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_com_velocity_to_sim_mask(*, root_velocity: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → 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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

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

abstractmethod write_root_link_pose_to_sim_index(*, root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: 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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

root_pose¶ – Root link 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_link_pose_to_sim_mask(*, root_pose: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → 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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

root_pose¶ – Root link 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod 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_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().

abstractmethod write_root_link_velocity_to_sim_index(*, root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: 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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

root_velocity¶ – Root frame 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_link_velocity_to_sim_mask(*, root_velocity: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → 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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

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

abstractmethod write_root_pose_to_sim_index(*, root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: bool = False) → 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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_pose_to_sim_mask(*, root_pose: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → 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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod 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_pose_to_sim_index() and write_root_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().

abstractmethod write_root_velocity_to_sim_index(*, root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: 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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_velocity_to_sim_mask(*, root_velocity: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → 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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

cfg: RigidObjectCfg#: Configuration instance for the rigid object.

class isaaclab.assets.RigidObjectData[source]#

Bases: FactoryBase

Factory for creating rigid object data instances.

Methods:

`__new__`(cls, args, *kwargs)	Create a new instance of a rigid object data based on the backend.
`get_registry_keys`()	Returns a list of registered backend names.
`register`(name, sub_class)	Register a new implementation class.
`resolve_class`(args, *kwargs)	Resolve the concrete backend implementation class without instantiating it.

static __new__(cls, *args, **kwargs) → BaseRigidObjectData | PhysXRigidObjectData[source]#: Create a new instance of a rigid object data based on the backend.

classmethod get_registry_keys() → list[str]#: Returns a list of registered backend names.

classmethod register(name: str, sub_class) → None#: Register a new implementation class.

classmethod resolve_class(*args, **kwargs) → type#

Resolve the concrete backend implementation class without instantiating it.

Selects the backend via _get_backend(), lazily importing and registering the implementation class on first use, and returns it. Takes the same arguments as the constructor (the backend selector reads from them). Useful for querying class-level behavior (e.g. capability classmethods) before a sim/instance exists.

class isaaclab.assets.RigidObjectCfg[source]#

Bases: AssetBaseCfg

Configuration parameters for a rigid object.

Classes:

InitialStateCfg

Initial state of the rigid body.

Attributes:

`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.
`disable_shape_checks`	Disable shape/dtype validation in setter and writer methods.
`init_state`	Initial state of the rigid object.

class InitialStateCfg[source]#

Bases: InitialStateCfg

Initial state of the rigid body.

Attributes:

`lin_vel`	Linear velocity of the root in simulation world frame.
`ang_vel`	Angular velocity of the root in simulation world frame.
`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: tuple[float, float, float]#: Linear velocity of the root in simulation world frame. Defaults to (0.0, 0.0, 0.0).

ang_vel: tuple[float, float, float]#: Angular velocity of the root in simulation world frame. Defaults to (0.0, 0.0, 0.0).

pos: tuple[float, float, float]#: Position of the root in simulation world frame. Defaults to (0.0, 0.0, 0.0).

rot: tuple[float, float, float, float]#: Quaternion rotation (x, y, z, w) of the root in simulation world frame. Defaults to (0.0, 0.0, 0.0, 1.0).

prim_path: str#: Prim path (or expression) to the asset.

Note

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

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

spawn: SpawnerCfg | None#

Spawn configuration for the asset. Defaults to None.

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

collision_group: Literal[0, -1]#

Collision group of the asset. Defaults to 0.

-1: global collision group (collides with all assets in the scene).
0: local collision group (collides with other assets in the same environment).

debug_vis: bool#: Whether to enable debug visualization for the asset. Defaults to False.

disable_shape_checks: bool | None#

Disable shape/dtype validation in setter and writer methods.

When True, assert_shape_and_dtype() and assert_shape_and_dtype_mask() become no-ops, eliminating per-call assertion overhead.

When False, shape checks are always enabled, even under python -O.

When None (the default), shape checks follow Python’s __debug__ flag — enabled in normal mode, disabled with python -O.

init_state: InitialStateCfg#: Initial state of the rigid object. Defaults to identity pose with zero velocity.

Rigid Object Collection#

class isaaclab.assets.RigidObjectCollection[source]#

Bases: FactoryBase, BaseRigidObjectCollection

Factory for creating rigid object collection instances.

Attributes:

`data`	Data related to the asset.
`body_names`	Ordered names of bodies in the rigid object collection.
`device`	Memory device for computation.
`has_debug_vis_implementation`	Whether the asset has a debug visualization implemented.
`instantaneous_wrench_composer`	Instantaneous wrench composer.
`is_initialized`	Whether the asset is initialized.
`num_bodies`	Number of bodies in the rigid object collection.
`num_instances`	Number of instances of the asset.
`num_objects`	Deprecated property.
`object_names`	Deprecated property.
`permanent_wrench_composer`	Permanent wrench composer.
`root_view`	Root view for the rigid object collection.
`cfg`	Configuration instance for the rigid object.

Methods:

`__new__`(cls, args, *kwargs)	Create a new instance of a rigid object collection based on the backend.
`__init__`(cfg)	Initialize the rigid object.
`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 rigid body collection based on the name keys.
`find_objects`(name_keys[, preserve_order])	Deprecated method.
`get_registry_keys`()	Returns a list of registered backend names.
`register`(name, sub_class)	Register a new implementation class.
`reset`([env_ids, object_ids, env_mask])	Resets all internal buffers of selected environments and objects.
`resolve_class`(args, *kwargs)	Resolve the concrete backend implementation class without instantiating it.
`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 positions of all bodies.
`set_coms_mask`(*, coms[, body_mask, env_mask])	Set center of mass positions of all bodies.
`set_debug_vis`(debug_vis)	Sets whether to visualize the asset data.
`set_external_force_and_torque`(forces, torques)	Deprecated.
`set_inertias`(inertias[, body_ids, env_ids])	Deprecated, same as `set_inertias_index()`.
`set_inertias_index`(*, inertias[, body_ids, ...])	Set inertias of all bodies.
`set_inertias_mask`(*, inertias[, body_mask, ...])	Set inertias of all bodies.
`set_masses`(masses[, body_ids, env_ids])	Deprecated, same as `set_masses_index()`.
`set_masses_index`(*, masses[, body_ids, env_ids])	Set masses of all bodies.
`set_masses_mask`(*, masses[, body_mask, env_mask])	Set masses of all bodies.
`set_visibility`(visible[, env_ids])	Set the visibility of the prims corresponding to the asset.
`update`(dt)	Updates the simulation data.
`write_body_com_pose_to_sim`(body_poses[, ...])	Deprecated, same as `write_body_com_pose_to_sim_index()`.
`write_body_com_pose_to_sim_index`(*, body_poses)	Set the body center of mass pose over selected environment and body indices into the simulation.
`write_body_com_pose_to_sim_mask`(*, body_poses)	Set the body center of mass pose over selected environment and body mask into the simulation.
`write_body_com_state_to_sim`(body_states[, ...])	Deprecated, same as `write_body_com_pose_to_sim_index()` and `write_body_com_velocity_to_sim_index()`.
`write_body_com_velocity_to_sim`(body_velocities)	Deprecated, same as `write_body_com_velocity_to_sim_index()`.
`write_body_com_velocity_to_sim_index`(*, ...)	Set the body center of mass velocity over selected environment and body indices into the simulation.
`write_body_com_velocity_to_sim_mask`(*, ...)	Set the body center of mass velocity over selected environment and body mask into the simulation.
`write_body_link_pose_to_sim`(body_poses[, ...])	Deprecated, same as `write_body_link_pose_to_sim_index()`.
`write_body_link_pose_to_sim_index`(*, body_poses)	Set the body link pose over selected environment and body indices into the simulation.
`write_body_link_pose_to_sim_mask`(*, body_poses)	Set the body link pose over selected environment and body mask into the simulation.
`write_body_link_state_to_sim`(body_states[, ...])	Deprecated, same as `write_body_link_pose_to_sim_index()` and `write_body_link_velocity_to_sim_index()`.
`write_body_link_velocity_to_sim`(body_velocities)	Deprecated, same as `write_body_link_velocity_to_sim_index()`.
`write_body_link_velocity_to_sim_index`(*, ...)	Set the body link velocity over selected environment and body indices into the simulation.
`write_body_link_velocity_to_sim_mask`(*, ...)	Set the body link velocity over selected environment and body mask into the simulation.
`write_body_pose_to_sim`(body_poses[, ...])	Deprecated, same as `write_body_pose_to_sim_index()`.
`write_body_pose_to_sim_index`(*, body_poses)	Set the body poses over selected environment and body indices into the simulation.
`write_body_pose_to_sim_mask`(*, body_poses[, ...])	Set the body poses over selected environment and body mask into the simulation.
`write_body_state_to_sim`(body_states[, ...])	Deprecated, same as `write_body_link_pose_to_sim_index()` and `write_body_com_velocity_to_sim_index()`.
`write_body_velocity_to_sim`(body_velocities)	Deprecated, same as `write_body_velocity_to_sim_index()`.
`write_body_velocity_to_sim_index`(*, ...[, ...])	Set the body velocity over selected environment and body indices into the simulation.
`write_body_velocity_to_sim_mask`(*, ...[, ...])	Set the body velocity over selected environment and body mask into the simulation.
`write_data_to_sim`()	Write external wrench to the simulation.
`write_object_com_pose_to_sim`(object_pose[, ...])	Deprecated method.
`write_object_com_state_to_sim`(object_state)	Deprecated method.
`write_object_com_velocity_to_sim`(object_velocity)	Deprecated method.
`write_object_link_pose_to_sim`(object_pose[, ...])	Deprecated method.
`write_object_link_state_to_sim`(object_state)	Deprecated method.
`write_object_link_velocity_to_sim`(...[, ...])	Deprecated method.
`write_object_pose_to_sim`(object_pose[, ...])	Deprecated method.
`write_object_state_to_sim`(object_state[, ...])	Deprecated method.
`write_object_velocity_to_sim`(object_velocity)	Deprecated method.

abstract property data: RigidObjectCollectionData#: Data related to the asset.

static __new__(cls, *args, **kwargs) → BaseRigidObjectCollection | PhysXRigidObjectCollection[source]#: Create a new instance of a rigid object collection based on the backend.

__init__(cfg: RigidObjectCollectionCfg)#

Initialize the rigid object.

Parameters:: cfg¶ – A configuration instance.

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.

Controlled by AssetBaseCfg.disable_shape_checks. When checks are disabled this method is a no-op.

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

Controlled by AssetBaseCfg.disable_shape_checks. When checks are disabled this method is a no-op.

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

abstract property body_names: list[str]#: Ordered names of bodies in the rigid object collection.

property device: str#: Memory device for computation.

abstractmethod find_bodies(name_keys: str | Sequence[str], preserve_order: bool = False) → tuple[torch.Tensor, list[str]]#

Find bodies in the rigid body collection 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_objects(name_keys: str | Sequence[str], preserve_order: bool = False) → tuple[torch.Tensor, list[str]]#: Deprecated method. Please use find_bodies() instead.

classmethod get_registry_keys() → list[str]#: Returns a list of registered backend names.

property has_debug_vis_implementation: bool#: Whether the asset has a debug visualization implemented.

abstract 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_initialized: bool#

Whether the asset is initialized.

Returns True if the asset is initialized, False otherwise.

abstract property num_bodies: int#: Number of bodies in the rigid object collection.

abstract 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_objects: int#: Deprecated property. Please use num_bodies instead.

property object_names: list[str]#: Deprecated property. Please use body_names instead.

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

classmethod register(name: str, sub_class) → None#: Register a new implementation class.

Resets all internal buffers of selected environments and objects.

Caution

If both env_ids and env_mask are provided, then env_mask takes precedence over env_ids.

Parameters:

env_ids¶ – Environment indices. If None, then all indices are used.
object_ids¶ – Object indices. If None, then all indices are used.
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

classmethod resolve_class(*args, **kwargs) → type#

Resolve the concrete backend implementation class without instantiating it.

Selects the backend via _get_backend(), lazily importing and registering the implementation class on first use, and returns it. Takes the same arguments as the constructor (the backend selector reads from them). Useful for querying class-level behavior (e.g. capability classmethods) before a sim/instance exists.

abstract property root_view#: Root view for the rigid object collection.

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 positions of all bodies.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

coms¶ – Center of mass positions of all bodies. Shape is (len(env_ids), len(body_ids), 3).
body_ids¶ – The body indices to set the center of mass positions for. Defaults to None (all bodies).
env_ids¶ – The environment indices to set the center of mass positions for. Defaults to None (all environments).

abstractmethod 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 positions of all bodies.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

coms¶ – Center of mass positions of all bodies. Shape is (num_instances, num_bodies, 3) or (num_instances, num_bodies) with dtype wp.vec3f.
body_mask¶ – Body mask. If None, then all bodies are used. Shape is (num_bodies,).
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. Resets target environments, then adds forces and torques via the permanent wrench composer.

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.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

inertias¶ – Inertias of all bodies. Shape is (len(env_ids), len(body_ids), 9).
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).

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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. Shape is (num_bodies,).
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] | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated, same as set_masses_index().

Set masses of all bodies.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

masses¶ – Masses of all bodies. Shape is (len(env_ids), len(body_ids)).
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).

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

masses¶ – Masses of all bodies. Shape is (num_instances, num_bodies).
body_mask¶ – Body mask. If None, then all bodies are used. Shape is (num_bodies,).
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).

abstractmethod update(dt: float) → None#

Updates the simulation data.

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

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

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

The body center of mass 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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

body_poses¶ – Body center of mass poses in simulation frame. Shape is (len(env_ids), len(body_ids), 7) or (len(env_ids), len(body_ids)) with dtype wp.transformf.
body_ids¶ – Body indices. If None, then all indices are used.
env_ids¶ – Environment indices. If None, then all indices are used.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_body_com_pose_to_sim_mask(*, body_poses: torch.Tensor | wp.array, body_mask: wp.array | None = None, env_mask: wp.array | None = None, skip_forward: bool = False) → None#

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

The body center of mass 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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

body_poses¶ – Body center of mass poses in simulation frame. 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. Shape is (num_bodies,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_body_com_state_to_sim(body_states: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, body_ids: slice | torch.Tensor | None = None) → None#: Deprecated, same as write_body_com_pose_to_sim_index() and write_body_com_velocity_to_sim_index().

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

Set the body center of mass velocity over selected environment and body 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 body’s center of mass rather than the body’s frame.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

body_velocities¶ – Body center of mass velocities in simulation frame. Shape is (len(env_ids), len(body_ids), 6) or (len(env_ids), len(body_ids)) with dtype wp.spatial_vectorf.
body_ids¶ – Body indices. If None, then all indices are used.
env_ids¶ – Environment indices. If None, then all indices are used.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_body_com_velocity_to_sim_mask(*, body_velocities: torch.Tensor | wp.array, body_mask: wp.array | None = None, env_mask: wp.array | None = None, skip_forward: bool = False) → None#

Set the body center of mass velocity over selected environment and body 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 body’s center of mass rather than the body’s frame.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

body_velocities¶ – Body center of mass velocities in simulation frame. Shape is (num_instances, num_bodies, 6) or (num_instances, num_bodies) with dtype wp.spatial_vectorf.
body_mask¶ – Body mask. If None, then all bodies are used. Shape is (num_bodies,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

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

Set the body link pose over selected environment and body indices into the simulation.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

body_poses¶ – Body link poses in simulation frame. Shape is (len(env_ids), len(body_ids), 7) or (len(env_ids), len(body_ids)) with dtype wp.transformf.
body_ids¶ – Body indices. If None, then all indices are used.
env_ids¶ – Environment indices. If None, then all indices are used.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_body_link_pose_to_sim_mask(*, body_poses: torch.Tensor | wp.array, body_mask: wp.array | None = None, env_mask: wp.array | None = None, skip_forward: bool = False) → None#

Set the body link pose over selected environment and body mask into the simulation.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

body_poses¶ – Body link poses in simulation frame. 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. Shape is (num_bodies,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_body_link_state_to_sim(body_states: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, body_ids: slice | torch.Tensor | None = None) → None#: Deprecated, same as write_body_link_pose_to_sim_index() and write_body_link_velocity_to_sim_index().

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

Set the body link velocity over selected environment and body 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 body’s frame rather than the body’s center of mass.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

body_velocities¶ – Body link velocities in simulation frame. Shape is (len(env_ids), len(body_ids), 6) or (len(env_ids), len(body_ids)) with dtype wp.spatial_vectorf.
body_ids¶ – Body indices. If None, then all indices are used.
env_ids¶ – Environment indices. If None, then all indices are used.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_body_link_velocity_to_sim_mask(*, body_velocities: torch.Tensor | wp.array, body_mask: wp.array | None = None, env_mask: wp.array | None = None, skip_forward: bool = False) → None#

Set the body link velocity over selected environment and body 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 body’s frame rather than the body’s center of mass.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

body_velocities¶ – Body link velocities in simulation frame. Shape is (num_instances, num_bodies, 6) or (num_instances, num_bodies) with dtype wp.spatial_vectorf.
body_mask¶ – Body mask. If None, then all bodies are used. Shape is (num_bodies,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

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

Set the body poses over selected environment and body indices into the simulation.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

body_poses¶ – Body poses in simulation frame. Shape is (len(env_ids), len(body_ids), 7) or (len(env_ids), len(body_ids)) with dtype wp.transformf.
body_ids¶ – Body indices. If None, then all indices are used.
env_ids¶ – Environment indices. If None, then all indices are used.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_body_pose_to_sim_mask(*, body_poses: torch.Tensor | wp.array, body_mask: wp.array | None = None, env_mask: wp.array | None = None, skip_forward: bool = False) → None#

Set the body poses over selected environment and body mask into the simulation.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

body_poses¶ – Body poses in simulation frame. 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. Shape is (num_bodies,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_body_state_to_sim(body_states: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, body_ids: slice | torch.Tensor | None = None) → None#: Deprecated, same as write_body_link_pose_to_sim_index() and write_body_com_velocity_to_sim_index().

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

Set the body velocity over selected environment and body 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 body’s center of mass rather than the body’s frame.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

body_velocities¶ – Body velocities in simulation frame. Shape is (len(env_ids), len(body_ids), 6) or (len(env_ids), len(body_ids)) with dtype wp.spatial_vectorf.
body_ids¶ – Body indices. If None, then all indices are used.
env_ids¶ – Environment indices. If None, then all indices are used.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_body_velocity_to_sim_mask(*, body_velocities: torch.Tensor | wp.array, body_mask: wp.array | None = None, env_mask: wp.array | None = None, skip_forward: bool = False) → None#

Set the body velocity over selected environment and body 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 body’s center of mass rather than the body’s frame.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

body_velocities¶ – Body velocities in simulation frame. Shape is (num_instances, num_bodies, 6) or (num_instances, num_bodies) with dtype wp.spatial_vectorf.
body_mask¶ – Body mask. If None, then all bodies are used. Shape is (num_bodies,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_data_to_sim() → None#: Write external wrench to the simulation.

Note

We write external wrench to the simulation here since this function is called before the simulation step. This ensures that the external wrench is applied at every simulation step.

write_object_com_pose_to_sim(object_pose: torch.Tensor, env_ids: torch.Tensor | None = None, object_ids: slice | torch.Tensor | None = None) → None#: Deprecated method. Please use write_body_com_pose_to_sim_index() instead.

write_object_com_state_to_sim(object_state: torch.Tensor, env_ids: torch.Tensor | None = None, object_ids: slice | torch.Tensor | None = None) → None#: Deprecated method. Please use write_body_com_pose_to_sim_index() and write_body_velocity_to_sim_index() instead.

write_object_com_velocity_to_sim(object_velocity: torch.Tensor, env_ids: torch.Tensor | None = None, object_ids: slice | torch.Tensor | None = None) → None#: Deprecated method. Please use write_body_com_velocity_to_sim_index() instead.

write_object_link_pose_to_sim(object_pose: torch.Tensor, env_ids: torch.Tensor | None = None, object_ids: slice | torch.Tensor | None = None) → None#: Deprecated method. Please use write_body_link_pose_to_sim_index() instead.

write_object_link_state_to_sim(object_state: torch.Tensor, env_ids: torch.Tensor | None = None, object_ids: slice | torch.Tensor | None = None) → None#: Deprecated method. Please use write_body_pose_to_sim_index() and write_body_link_velocity_to_sim_index() instead.

write_object_link_velocity_to_sim(object_velocity: torch.Tensor, env_ids: torch.Tensor | None = None, object_ids: slice | torch.Tensor | None = None) → None#: Deprecated method. Please use write_body_link_velocity_to_sim_index() instead.

write_object_pose_to_sim(object_pose: torch.Tensor, env_ids: torch.Tensor | None = None, object_ids: slice | torch.Tensor | None = None) → None#: Deprecated method. Please use write_body_pose_to_sim_index() instead.

write_object_state_to_sim(object_state: torch.Tensor, env_ids: torch.Tensor | None = None, object_ids: slice | torch.Tensor | None = None) → None#: Deprecated method. Please use write_body_pose_to_sim_index() and write_body_link_velocity_to_sim_index() instead.

write_object_velocity_to_sim(object_velocity: torch.Tensor, env_ids: torch.Tensor | None = None, object_ids: slice | torch.Tensor | None = None) → None#: Deprecated method. Please use write_body_com_velocity_to_sim_index() instead.

cfg: RigidObjectCollectionCfg#: Configuration instance for the rigid object.

class isaaclab.assets.RigidObjectCollectionData[source]#

Bases: FactoryBase

Factory for creating rigid object collection data instances.

Methods:

`__new__`(cls, args, *kwargs)	Create a new instance of a rigid object collection data based on the backend.
`get_registry_keys`()	Returns a list of registered backend names.
`register`(name, sub_class)	Register a new implementation class.
`resolve_class`(args, *kwargs)	Resolve the concrete backend implementation class without instantiating it.

static __new__(cls, *args, **kwargs) → BaseRigidObjectCollectionData | PhysXRigidObjectCollectionData[source]#: Create a new instance of a rigid object collection data based on the backend.

classmethod get_registry_keys() → list[str]#: Returns a list of registered backend names.

classmethod register(name: str, sub_class) → None#: Register a new implementation class.

classmethod resolve_class(*args, **kwargs) → type#

Resolve the concrete backend implementation class without instantiating it.

Selects the backend via _get_backend(), lazily importing and registering the implementation class on first use, and returns it. Takes the same arguments as the constructor (the backend selector reads from them). Useful for querying class-level behavior (e.g. capability classmethods) before a sim/instance exists.

class isaaclab.assets.RigidObjectCollectionCfg[source]#

Bases: object

Configuration parameters for a rigid object collection.

Attributes:

rigid_objects

Dictionary of rigid object configurations to spawn.

rigid_objects: dict[str, RigidObjectCfg]#

Dictionary of rigid object configurations to spawn.

The keys are the names for the objects, which are used as unique identifiers throughout the code.

Deformable Object#

class isaaclab.assets.DeformableObject[source]#

Bases: FactoryBase, BaseDeformableObject

Factory for creating deformable object instances.

Attributes:

`data`	Data container for the deformable object.
`device`	Memory device for computation.
`has_debug_vis_implementation`	Whether the asset has a debug visualization implemented.
`is_initialized`	Whether the asset is initialized.
`max_sim_vertices_per_body`	The maximum number of simulation mesh vertices per deformable body.
`num_bodies`	Number of bodies in the asset.
`num_instances`	Number of instances of the asset.
`cfg`	Configuration instance for the deformable object.

Methods:

`__new__`(cls, args, *kwargs)	Create a new instance of a deformable object based on the backend.
`__init__`(cfg)	Initialize the deformable object.
`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.
`get_registry_keys`()	Returns a list of registered backend names.
`register`(name, sub_class)	Register a new implementation class.
`reset`([env_ids, env_mask])	Reset the deformable object.
`resolve_class`(args, *kwargs)	Resolve the concrete backend implementation class without instantiating it.
`set_debug_vis`(debug_vis)	Sets whether to visualize the asset data.
`set_visibility`(visible[, env_ids])	Set the visibility of the prims corresponding to the asset.
`transform_nodal_pos`(nodal_pos[, pos, quat])	Transform the nodal positions based on the pose transformation.
`update`(dt)	Update the internal buffers.
`write_data_to_sim`()	Write data to the simulator.
`write_nodal_kinematic_target_to_sim`(targets)	Deprecated.
`write_nodal_kinematic_target_to_sim_index`(targets)	Set the kinematic targets of the simulation mesh for the deformable bodies using indices.
`write_nodal_kinematic_target_to_sim_mask`(targets)	Set the kinematic targets of the simulation mesh for the deformable bodies using mask.
`write_nodal_pos_to_sim`(nodal_pos[, env_ids])	Deprecated.
`write_nodal_pos_to_sim_index`(nodal_pos[, ...])	Set the nodal positions over selected environment indices into the simulation.
`write_nodal_pos_to_sim_mask`(nodal_pos[, ...])	Set the nodal positions over selected environment mask into the simulation.
`write_nodal_state_to_sim`(nodal_state[, env_ids])	Deprecated.
`write_nodal_state_to_sim_index`(nodal_state)	Set the nodal state over selected environment indices into the simulation.
`write_nodal_state_to_sim_mask`(nodal_state[, ...])	Set the nodal state over selected environment mask into the simulation.
`write_nodal_velocity_to_sim`(nodal_vel[, env_ids])	Deprecated.
`write_nodal_velocity_to_sim_index`(nodal_vel)	Set the nodal velocity over selected environment indices into the simulation.
`write_nodal_velocity_to_sim_mask`(nodal_vel)	Set the nodal velocity over selected environment mask into the simulation.

abstract property data: BaseDeformableObjectData#: Data container for the deformable object.

static __new__(cls, *args, **kwargs) → BaseDeformableObject | PhysXDeformableObject[source]#: Create a new instance of a deformable object based on the backend.

__init__(cfg: DeformableObjectCfg)#

Initialize the deformable object.

Parameters:: cfg¶ – A configuration instance.

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.

Controlled by AssetBaseCfg.disable_shape_checks. When checks are disabled this method is a no-op.

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

Controlled by AssetBaseCfg.disable_shape_checks. When checks are disabled this method is a no-op.

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 device: str#: Memory device for computation.

classmethod get_registry_keys() → list[str]#: Returns a list of registered backend names.

property has_debug_vis_implementation: bool#: Whether the asset has a debug visualization implemented.

property is_initialized: bool#

Whether the asset is initialized.

Returns True if the asset is initialized, False otherwise.

abstract property max_sim_vertices_per_body: int#: The maximum number of simulation mesh vertices per deformable body.

abstract property num_bodies: int#

Number of bodies in the asset.

This is always 1 since each object is a single deformable body.

abstract property num_instances: int#: Number of instances of the asset.

classmethod register(name: str, sub_class) → None#: Register a new implementation class.

abstractmethod reset(env_ids: Sequence[int] | None = None, env_mask: wp.array | None = None) → None#

Reset the deformable object.

Parameters:

env_ids¶ – Environment indices. If None, then all indices are used.
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

classmethod resolve_class(*args, **kwargs) → type#

Resolve the concrete backend implementation class without instantiating it.

Selects the backend via _get_backend(), lazily importing and registering the implementation class on first use, and returns it. Takes the same arguments as the constructor (the backend selector reads from them). Useful for querying class-level behavior (e.g. capability classmethods) before a sim/instance exists.

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_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).

transform_nodal_pos(nodal_pos: torch.Tensor, pos: torch.Tensor | None = None, quat: torch.Tensor | None = None) → torch.Tensor#

Transform the nodal positions based on the pose transformation.

This function computes the transformation of the nodal positions based on the pose transformation. It multiplies the nodal positions with the rotation matrix of the pose and adds the translation. Internally, it calls the isaaclab.utils.math.transform_points() function.

Parameters:

nodal_pos¶ – The nodal positions in the simulation frame [m]. Shape is (N, max_sim_vertices_per_body, 3).
pos¶ – The position transformation [m]. Shape is (N, 3). Defaults to None, in which case the position is assumed to be zero.
quat¶ – The orientation transformation as quaternion (x, y, z, w). Shape is (N, 4). Defaults to None, in which case the orientation is assumed to be identity.

Returns:

The transformed nodal positions [m]. Shape is (N, max_sim_vertices_per_body, 3).

abstractmethod update(dt: float)#

Update the internal buffers.

Parameters:: dt¶ – The amount of time passed from last update() call [s].

abstractmethod write_data_to_sim()#: Write data to the simulator.

write_nodal_kinematic_target_to_sim(targets: torch.Tensor | wp.array | ProxyArray, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated. Please use write_nodal_kinematic_target_to_sim_index() instead.

Set the kinematic targets of the simulation mesh for the deformable bodies using indices.

The kinematic targets comprise of individual nodal positions of the simulation mesh for the deformable body and a flag indicating whether the node is kinematically driven or not. The positions are in the simulation frame.

Note

The flag is set to 0.0 for kinematically driven nodes and 1.0 for free nodes.

Parameters:

targets¶ – The kinematic targets comprising of nodal positions and flags [m]. Shape is (len(env_ids), max_sim_vertices_per_body, 4) or (num_instances, max_sim_vertices_per_body, 4).
env_ids¶ – Environment indices. If None, then all indices are used.
full_data¶ – Whether to expect full data. Defaults to False.

write_nodal_kinematic_target_to_sim_mask(targets: torch.Tensor | wp.array | ProxyArray, env_mask: wp.array | None = None) → None#

Set the kinematic targets of the simulation mesh for the deformable bodies using mask.

Parameters:

targets¶ – The kinematic targets comprising of nodal positions and flags [m]. Shape is (num_instances, max_sim_vertices_per_body, 4).
env_mask¶ – Environment mask. If None, then all indices are used.

write_nodal_pos_to_sim(nodal_pos: torch.Tensor | wp.array | ProxyArray, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated. Please use write_nodal_pos_to_sim_index() instead.

Set the nodal positions over selected environment indices into the simulation.

Parameters:

nodal_pos¶ – Nodal positions in simulation frame [m]. Shape is (len(env_ids), max_sim_vertices_per_body, 3) or (num_instances, max_sim_vertices_per_body, 3).
env_ids¶ – Environment indices. If None, then all indices are used.
full_data¶ – Whether to expect full data. Defaults to False.

write_nodal_pos_to_sim_mask(nodal_pos: torch.Tensor | wp.array | ProxyArray, env_mask: wp.array | None = None) → None#

Set the nodal positions over selected environment mask into the simulation.

Parameters:

nodal_pos¶ – Nodal positions in simulation frame [m]. Shape is (num_instances, max_sim_vertices_per_body, 3).
env_mask¶ – Environment mask. If None, then all indices are used.

write_nodal_state_to_sim(nodal_state: torch.Tensor | wp.array | ProxyArray, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated. Please use write_nodal_state_to_sim_index() instead.

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

The nodal state comprises of the nodal positions and velocities. Since these are nodes, the velocity only has a translational component. All the quantities are in the simulation frame.

Parameters:

nodal_state¶ – Nodal state in simulation frame [m, m/s]. Shape is (len(env_ids), max_sim_vertices_per_body, 6) or (num_instances, max_sim_vertices_per_body, 6).
env_ids¶ – Environment indices. If None, then all indices are used.
full_data¶ – Whether to expect full data. Defaults to False.

write_nodal_state_to_sim_mask(nodal_state: torch.Tensor | wp.array | ProxyArray, env_mask: wp.array | None = None) → None#

Set the nodal state over selected environment mask into the simulation.

Parameters:

nodal_state¶ – Nodal state in simulation frame [m, m/s]. Shape is (num_instances, max_sim_vertices_per_body, 6).
env_mask¶ – Environment mask. If None, then all indices are used.

write_nodal_velocity_to_sim(nodal_vel: torch.Tensor | wp.array | ProxyArray, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None#: Deprecated. Please use write_nodal_velocity_to_sim_index() instead.

Set the nodal velocity over selected environment indices into the simulation.

Parameters:

nodal_vel¶ – Nodal velocities in simulation frame [m/s]. Shape is (len(env_ids), max_sim_vertices_per_body, 3) or (num_instances, max_sim_vertices_per_body, 3).
env_ids¶ – Environment indices. If None, then all indices are used.
full_data¶ – Whether to expect full data. Defaults to False.

write_nodal_velocity_to_sim_mask(nodal_vel: torch.Tensor | wp.array | ProxyArray, env_mask: wp.array | None = None) → None#

Set the nodal velocity over selected environment mask into the simulation.

Parameters:

nodal_vel¶ – Nodal velocities in simulation frame [m/s]. Shape is (num_instances, max_sim_vertices_per_body, 3).
env_mask¶ – Environment mask. If None, then all indices are used.

cfg: DeformableObjectCfg#: Configuration instance for the deformable object.

class isaaclab.assets.BaseDeformableObject[source]#

Bases: AssetBase

Abstract base class for deformable object assets.

Deformable objects are assets that can be deformed in the simulation. They are typically used for soft bodies, such as stuffed animals, food items, and cloth.

Unlike rigid object assets, deformable objects have a more complex structure and require additional handling for simulation. The state of a deformable object comprises of its nodal positions and velocities, and not the object’s root position and orientation. The nodal positions and velocities are in the simulation frame.

Soft bodies can be partially kinematic, where some nodes are driven by kinematic targets, and the rest are simulated. The kinematic targets are the desired positions of the nodes, and the simulation drives the nodes towards these targets.

Attributes:

`cfg`	Configuration instance for the deformable object.
`data`	Data container for the deformable object.
`num_instances`	Number of instances of the asset.
`num_bodies`	Number of bodies in the asset.
`max_sim_vertices_per_body`	The maximum number of simulation mesh vertices per deformable body.
`device`	Memory device for computation.
`has_debug_vis_implementation`	Whether the asset has a debug visualization implemented.
`is_initialized`	Whether the asset is initialized.

Methods:

`__init__`(cfg)	Initialize the deformable object.
`reset`([env_ids, env_mask])	Reset the deformable object.
`write_data_to_sim`()	Write data to the simulator.
`update`(dt)	Update the internal buffers.
`write_nodal_state_to_sim_index`(nodal_state)	Set the nodal state over selected environment indices into the simulation.
`write_nodal_pos_to_sim_index`(nodal_pos[, ...])	Set the nodal positions over selected environment indices into the simulation.
`write_nodal_velocity_to_sim_index`(nodal_vel)	Set the nodal velocity over selected environment indices into the simulation.
`write_nodal_kinematic_target_to_sim_index`(targets)	Set the kinematic targets of the simulation mesh for the deformable bodies using indices.
`write_nodal_state_to_sim_mask`(nodal_state[, ...])	Set the nodal state over selected environment mask into the simulation.
`write_nodal_pos_to_sim_mask`(nodal_pos[, ...])	Set the nodal positions over selected environment mask into the simulation.
`write_nodal_velocity_to_sim_mask`(nodal_vel)	Set the nodal velocity over selected environment mask into the simulation.
`write_nodal_kinematic_target_to_sim_mask`(targets)	Set the kinematic targets of the simulation mesh for the deformable bodies using mask.
`write_nodal_state_to_sim`(nodal_state[, env_ids])	Deprecated.
`write_nodal_kinematic_target_to_sim`(targets)	Deprecated.
`write_nodal_pos_to_sim`(nodal_pos[, env_ids])	Deprecated.
`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.
`set_debug_vis`(debug_vis)	Sets whether to visualize the asset data.
`set_visibility`(visible[, env_ids])	Set the visibility of the prims corresponding to the asset.
`write_nodal_velocity_to_sim`(nodal_vel[, env_ids])	Deprecated.
`transform_nodal_pos`(nodal_pos[, pos, quat])	Transform the nodal positions based on the pose transformation.

cfg: DeformableObjectCfg#: Configuration instance for the deformable object.

__init__(cfg: DeformableObjectCfg)[source]#

Initialize the deformable object.

Parameters:: cfg¶ – A configuration instance.

abstract property data: BaseDeformableObjectData#: Data container for the deformable object.

abstract property num_instances: int#: Number of instances of the asset.

abstract property num_bodies: int#

Number of bodies in the asset.

This is always 1 since each object is a single deformable body.

abstract property max_sim_vertices_per_body: int#: The maximum number of simulation mesh vertices per deformable body.

abstractmethod reset(env_ids: Sequence[int] | None = None, env_mask: wp.array | None = None) → None[source]#

Reset the deformable object.

Parameters:

env_ids¶ – Environment indices. If None, then all indices are used.
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

abstractmethod write_data_to_sim()[source]#: Write data to the simulator.

abstractmethod update(dt: float)[source]#

Update the internal buffers.

Parameters:: dt¶ – The amount of time passed from last update() call [s].

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

The nodal state comprises of the nodal positions and velocities. Since these are nodes, the velocity only has a translational component. All the quantities are in the simulation frame.

Parameters:

nodal_state¶ – Nodal state in simulation frame [m, m/s]. Shape is (len(env_ids), max_sim_vertices_per_body, 6) or (num_instances, max_sim_vertices_per_body, 6).
env_ids¶ – Environment indices. If None, then all indices are used.
full_data¶ – Whether to expect full data. Defaults to False.

Set the nodal positions over selected environment indices into the simulation.

Parameters:

nodal_pos¶ – Nodal positions in simulation frame [m]. Shape is (len(env_ids), max_sim_vertices_per_body, 3) or (num_instances, max_sim_vertices_per_body, 3).
env_ids¶ – Environment indices. If None, then all indices are used.
full_data¶ – Whether to expect full data. Defaults to False.

Set the nodal velocity over selected environment indices into the simulation.

Parameters:

nodal_vel¶ – Nodal velocities in simulation frame [m/s]. Shape is (len(env_ids), max_sim_vertices_per_body, 3) or (num_instances, max_sim_vertices_per_body, 3).
env_ids¶ – Environment indices. If None, then all indices are used.
full_data¶ – Whether to expect full data. Defaults to False.

Set the kinematic targets of the simulation mesh for the deformable bodies using indices.

The kinematic targets comprise of individual nodal positions of the simulation mesh for the deformable body and a flag indicating whether the node is kinematically driven or not. The positions are in the simulation frame.

Note

The flag is set to 0.0 for kinematically driven nodes and 1.0 for free nodes.

Parameters:

targets¶ – The kinematic targets comprising of nodal positions and flags [m]. Shape is (len(env_ids), max_sim_vertices_per_body, 4) or (num_instances, max_sim_vertices_per_body, 4).
env_ids¶ – Environment indices. If None, then all indices are used.
full_data¶ – Whether to expect full data. Defaults to False.

write_nodal_state_to_sim_mask(nodal_state: torch.Tensor | wp.array | ProxyArray, env_mask: wp.array | None = None) → None[source]#

Set the nodal state over selected environment mask into the simulation.

Parameters:

nodal_state¶ – Nodal state in simulation frame [m, m/s]. Shape is (num_instances, max_sim_vertices_per_body, 6).
env_mask¶ – Environment mask. If None, then all indices are used.

write_nodal_pos_to_sim_mask(nodal_pos: torch.Tensor | wp.array | ProxyArray, env_mask: wp.array | None = None) → None[source]#

Set the nodal positions over selected environment mask into the simulation.

Parameters:

nodal_pos¶ – Nodal positions in simulation frame [m]. Shape is (num_instances, max_sim_vertices_per_body, 3).
env_mask¶ – Environment mask. If None, then all indices are used.

write_nodal_velocity_to_sim_mask(nodal_vel: torch.Tensor | wp.array | ProxyArray, env_mask: wp.array | None = None) → None[source]#

Set the nodal velocity over selected environment mask into the simulation.

Parameters:

nodal_vel¶ – Nodal velocities in simulation frame [m/s]. Shape is (num_instances, max_sim_vertices_per_body, 3).
env_mask¶ – Environment mask. If None, then all indices are used.

write_nodal_kinematic_target_to_sim_mask(targets: torch.Tensor | wp.array | ProxyArray, env_mask: wp.array | None = None) → None[source]#

Set the kinematic targets of the simulation mesh for the deformable bodies using mask.

Parameters:

targets¶ – The kinematic targets comprising of nodal positions and flags [m]. Shape is (num_instances, max_sim_vertices_per_body, 4).
env_mask¶ – Environment mask. If None, then all indices are used.

write_nodal_state_to_sim(nodal_state: torch.Tensor | wp.array | ProxyArray, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None[source]#: Deprecated. Please use write_nodal_state_to_sim_index() instead.

write_nodal_kinematic_target_to_sim(targets: torch.Tensor | wp.array | ProxyArray, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None[source]#: Deprecated. Please use write_nodal_kinematic_target_to_sim_index() instead.

write_nodal_pos_to_sim(nodal_pos: torch.Tensor | wp.array | ProxyArray, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None[source]#: Deprecated. Please use write_nodal_pos_to_sim_index() instead.

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.

Controlled by AssetBaseCfg.disable_shape_checks. When checks are disabled this method is a no-op.

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

Controlled by AssetBaseCfg.disable_shape_checks. When checks are disabled this method is a no-op.

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 device: str#: Memory device for computation.

property has_debug_vis_implementation: bool#: Whether the asset has a debug visualization implemented.

property is_initialized: bool#

Whether the asset is initialized.

Returns True if the asset is initialized, False otherwise.

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_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).

write_nodal_velocity_to_sim(nodal_vel: torch.Tensor | wp.array | ProxyArray, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None[source]#: Deprecated. Please use write_nodal_velocity_to_sim_index() instead.

transform_nodal_pos(nodal_pos: torch.Tensor, pos: torch.Tensor | None = None, quat: torch.Tensor | None = None) → torch.Tensor[source]#

Transform the nodal positions based on the pose transformation.

This function computes the transformation of the nodal positions based on the pose transformation. It multiplies the nodal positions with the rotation matrix of the pose and adds the translation. Internally, it calls the isaaclab.utils.math.transform_points() function.

Parameters:

nodal_pos¶ – The nodal positions in the simulation frame [m]. Shape is (N, max_sim_vertices_per_body, 3).
pos¶ – The position transformation [m]. Shape is (N, 3). Defaults to None, in which case the position is assumed to be zero.
quat¶ – The orientation transformation as quaternion (x, y, z, w). Shape is (N, 4). Defaults to None, in which case the orientation is assumed to be identity.

Returns:

The transformed nodal positions [m]. Shape is (N, max_sim_vertices_per_body, 3).

class isaaclab.assets.DeformableObjectData[source]#

Bases: FactoryBase

Factory for creating deformable object data instances.

Methods:

`__new__`(cls, args, *kwargs)	Create a new instance of a deformable object data based on the backend.
`get_registry_keys`()	Returns a list of registered backend names.
`register`(name, sub_class)	Register a new implementation class.
`resolve_class`(args, *kwargs)	Resolve the concrete backend implementation class without instantiating it.

static __new__(cls, *args, **kwargs) → BaseDeformableObjectData | PhysXDeformableObjectData[source]#: Create a new instance of a deformable object data based on the backend.

classmethod get_registry_keys() → list[str]#: Returns a list of registered backend names.

classmethod register(name: str, sub_class) → None#: Register a new implementation class.

classmethod resolve_class(*args, **kwargs) → type#

Resolve the concrete backend implementation class without instantiating it.

Selects the backend via _get_backend(), lazily importing and registering the implementation class on first use, and returns it. Takes the same arguments as the constructor (the backend selector reads from them). Useful for querying class-level behavior (e.g. capability classmethods) before a sim/instance exists.

class isaaclab.assets.BaseDeformableObjectData[source]#

Bases: ABC

Abstract data container for a deformable object.

This class defines the interface for deformable object data in the simulation. The data includes the nodal states of the root deformable body in the object. The data is stored in the simulation world frame unless otherwise specified.

The data is lazily updated, meaning that the data is only updated when it is accessed. This is useful when the data is expensive to compute or retrieve. The data is updated when the timestamp of the buffer is older than the current simulation timestamp.

Methods:

update(dt)

Update the data for the deformable object.

Attributes:

`default_nodal_state_w`	Default nodal state `[nodal_pos, nodal_vel]` in simulation world frame.
`nodal_kinematic_target`	Simulation mesh kinematic targets for the deformable bodies.
`nodal_pos_w`	Nodal positions in simulation world frame [m].
`nodal_vel_w`	Nodal velocities in simulation world frame [m/s].
`nodal_state_w`	Nodal state `[nodal_pos, nodal_vel]` in simulation world frame [m, m/s].
`root_pos_w`	Root position from nodal positions of the simulation mesh for the deformable bodies in simulation world frame [m].
`root_vel_w`	Root velocity from vertex velocities for the deformable bodies in simulation world frame [m/s].

update(dt: float)[source]#

Update the data for the deformable object.

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

default_nodal_state_w: ProxyArray | None = None#

Default nodal state [nodal_pos, nodal_vel] in simulation world frame.

Shape is (num_instances, max_sim_vertices_per_body), dtype vec6f. Use ProxyArray.warp for the underlying warp.array or ProxyArray.torch for a cached zero-copy torch.Tensor view.

nodal_kinematic_target: ProxyArray | None = None#

Simulation mesh kinematic targets for the deformable bodies.

Shape is (num_instances, max_sim_vertices_per_body), dtype wp.vec4f. Use ProxyArray.warp for the underlying warp.array or ProxyArray.torch for a cached zero-copy torch.Tensor view.

The kinematic targets are used to drive the simulation mesh vertices to the target positions. The targets are stored as (x, y, z, is_not_kinematic) where “is_not_kinematic” is a binary flag indicating whether the vertex is kinematic or not. The flag is set to 0 for kinematic vertices and 1 for non-kinematic vertices.

abstract property nodal_pos_w: ProxyArray#

Nodal positions in simulation world frame [m].

Shape is (num_instances, max_sim_vertices_per_body), dtype wp.vec3f. Use ProxyArray.warp for the underlying warp.array or ProxyArray.torch for a cached zero-copy torch.Tensor view.

abstract property nodal_vel_w: ProxyArray#

Nodal velocities in simulation world frame [m/s].

Shape is (num_instances, max_sim_vertices_per_body), dtype wp.vec3f. Use ProxyArray.warp for the underlying warp.array or ProxyArray.torch for a cached zero-copy torch.Tensor view.

abstract property nodal_state_w: ProxyArray#

Nodal state [nodal_pos, nodal_vel] in simulation world frame [m, m/s].

Shape is (num_instances, max_sim_vertices_per_body), dtype vec6f. Use ProxyArray.warp for the underlying warp.array or ProxyArray.torch for a cached zero-copy torch.Tensor view.

abstract property root_pos_w: ProxyArray#

Root position from nodal positions of the simulation mesh for the deformable bodies in simulation world frame [m]. Shape is (num_instances,) vec3f.

This quantity is computed as the mean of the nodal positions. Use ProxyArray.warp for the underlying warp.array or ProxyArray.torch for a cached zero-copy torch.Tensor view.

abstract property root_vel_w: ProxyArray#

Root velocity from vertex velocities for the deformable bodies in simulation world frame [m/s]. Shape is (num_instances,) vec3f.

This quantity is computed as the mean of the nodal velocities. Use ProxyArray.warp for the underlying warp.array or ProxyArray.torch for a cached zero-copy torch.Tensor view.

class isaaclab.assets.DeformableObjectCfg[source]#

Bases: AssetBaseCfg

Configuration parameters for a deformable object.

Attributes:

`prim_path`	Prim path (or expression) to the asset.
`spawn`	Spawn configuration for the asset.
`init_state`	Initial state of the rigid object.
`collision_group`	Collision group of the asset.
`debug_vis`	Whether to enable debug visualization for the asset.
`disable_shape_checks`	Disable shape/dtype validation in setter and writer methods.
`visualizer_cfg`	The configuration object for the visualization markers.

prim_path: str#: Prim path (or expression) to the asset.

Note

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

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

spawn: SpawnerCfg | None#

Spawn configuration for the asset. Defaults to None.

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

init_state: InitialStateCfg#: Initial state of the rigid object. Defaults to identity pose.

collision_group: Literal[0, -1]#

Collision group of the asset. Defaults to 0.

-1: global collision group (collides with all assets in the scene).
0: local collision group (collides with other assets in the same environment).

debug_vis: bool#: Whether to enable debug visualization for the asset. Defaults to False.

disable_shape_checks: bool | None#

Disable shape/dtype validation in setter and writer methods.

When True, assert_shape_and_dtype() and assert_shape_and_dtype_mask() become no-ops, eliminating per-call assertion overhead.

When False, shape checks are always enabled, even under python -O.

When None (the default), shape checks follow Python’s __debug__ flag — enabled in normal mode, disabled with python -O.

visualizer_cfg: VisualizationMarkersCfg#: The configuration object for the visualization markers. Defaults to DEFORMABLE_TARGET_MARKER_CFG.

Note

This attribute is only used when debug visualization is enabled.

Articulation#

class isaaclab.assets.Articulation[source]#

Bases: FactoryBase, BaseArticulation

Factory for creating articulation instances.

Attributes:

`data`	Data related to the asset.
`backend_body_names`	Body names in active backend solver-view order.
`backend_joint_names`	Joint names in active backend solver-view order.
`body_names`	Body names in public API order.
`body_ordering`	Bidirectional map between backend and public body order.
`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`	Joint names in public API order.
`joint_ordering`	Bidirectional map between backend and public joint order.
`num_base_dofs`	Number of free DoFs of the floating base.
`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_view`	Root articulation view in active backend order.
`spatial_tendon_names`	Ordered names of spatial tendons in articulation.
`cfg`	Configuration instance for the articulations.
`actuators`	Dictionary of actuator instances for the articulation.

Methods:

`__new__`(cls, args, *kwargs)	Create a new instance of an articulation based on the backend.
`__init__`(cfg)	Initialize the articulation.
`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.
`get_registry_keys`()	Returns a list of registered backend names.
`map_body_ids_to_backend`(body_ids)	Translate public body indices to active-backend body indices.
`map_joint_ids_to_backend`(joint_ids)	Translate public joint indices to active-backend joint indices.
`register`(name, sub_class)	Register a new implementation class.
`reset`([env_ids, env_mask])	Reset the articulation.
`resolve_class`(args, *kwargs)	Resolve the concrete backend implementation class without instantiating it.
`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 in their respective body link frames.
`set_coms_mask`(*, coms[, body_mask, env_mask])	Set center of mass pose of all bodies in their respective body link frames.
`set_debug_vis`(debug_vis)	Sets whether to visualize the asset data.
`set_external_force_and_torque`(forces, torques)	Deprecated.
`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.
`set_fixed_tendon_damping_mask`(*, damping[, ...])	Set fixed tendon damping into internal buffers.
`set_fixed_tendon_limit`(limit[, ...])	Set fixed tendon position limits into internal buffers.
`set_fixed_tendon_limit_stiffness`(limit_stiffness)	Deprecated, same as `set_fixed_tendon_limit_stiffness_index()`.
`set_fixed_tendon_limit_stiffness_index`(*, ...)	Set fixed tendon limit stiffness into internal buffers.
`set_fixed_tendon_limit_stiffness_mask`(*, ...)	Set fixed tendon limit stiffness into internal buffers.
`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.
`set_fixed_tendon_offset_mask`(*, offset[, ...])	Set fixed tendon offset into internal buffers.
`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 limits into internal buffers.
`set_fixed_tendon_position_limit_mask`(*, limit)	Set fixed tendon position limits into internal buffers.
`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.
`set_fixed_tendon_rest_length_mask`(*, rest_length)	Set fixed tendon rest length into internal buffers.
`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.
`set_fixed_tendon_stiffness_mask`(*, stiffness)	Set fixed tendon stiffness into internal buffers.
`set_inertias`(inertias[, body_ids, env_ids])	Deprecated, same as `set_inertias_index()`.
`set_inertias_index`(*, inertias[, body_ids, ...])	Set inertias of all bodies in the simulation world frame.
`set_inertias_mask`(*, inertias[, body_mask, ...])	Set inertias of all bodies in the simulation world frame.
`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.
`set_joint_effort_target_mask`(*, target[, ...])	Set joint efforts into internal buffers.
`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.
`set_joint_position_target_mask`(*, target[, ...])	Set joint position targets into internal buffers.
`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.
`set_joint_velocity_target_mask`(*, target[, ...])	Set joint velocity targets into internal buffers.
`set_masses`(masses[, body_ids, env_ids])	Deprecated, same as `set_masses_index()`.
`set_masses_index`(*, masses[, body_ids, env_ids])	Set masses of all bodies in the simulation world frame.
`set_masses_mask`(*, masses[, body_mask, env_mask])	Set masses of all bodies in the simulation world frame.
`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.
`set_spatial_tendon_damping_mask`(*, damping)	Set spatial tendon damping into internal buffers.
`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.
`set_spatial_tendon_limit_stiffness_mask`(*, ...)	Set spatial tendon limit stiffness into internal buffers.
`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.
`set_spatial_tendon_offset_mask`(*, offset[, ...])	Set spatial tendon offset into internal buffers.
`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.
`set_spatial_tendon_stiffness_mask`(*, stiffness)	Set spatial tendon stiffness into internal buffers.
`set_visibility`(visible[, env_ids])	Set the visibility of the prims corresponding to the asset.
`update`(dt)	Updates the simulation data.
`write_data_to_sim`()	Write external wrenches and joint commands to the simulation.
`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.
`write_fixed_tendon_properties_to_sim_mask`(*)	Write fixed tendon properties into the simulation.
`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 into the simulation.
`write_joint_armature_to_sim_mask`(*, armature)	Write joint armature 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 into the simulation.
`write_joint_damping_to_sim_mask`(*, damping)	Write joint damping 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 into the simulation.
`write_joint_effort_limit_to_sim_mask`(*, limits)	Write joint effort limits 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 backend-specific joint friction values into the simulation.
`write_joint_friction_coefficient_to_sim_mask`(*, ...)	Write backend-specific joint friction values 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 into the simulation.
`write_joint_position_limit_to_sim_mask`(*, limits)	Write joint position limits 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 to the simulation.
`write_joint_position_to_sim_mask`(*, position)	Write joint positions to 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_stiffness_to_sim`(stiffness[, ...])	Deprecated, same as `write_joint_stiffness_to_sim_index()`.
`write_joint_stiffness_to_sim_index`(*, stiffness)	Write joint stiffness into the simulation.
`write_joint_stiffness_to_sim_mask`(*, stiffness)	Write joint stiffness 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 to the simulation.
`write_joint_velocity_limit_to_sim_mask`(*, limits)	Write joint max velocity to 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 to 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_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_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_pose_to_sim_index()` and `write_root_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.
`write_spatial_tendon_properties_to_sim_mask`(*)	Write spatial tendon properties into the simulation.

abstract property data: BaseArticulationData#: Data related to the asset.

static __new__(cls, *args, **kwargs) → BaseArticulation | PhysXArticulation[source]#: Create a new instance of an articulation based on the backend.

__init__(cfg: ArticulationCfg)#

Initialize the articulation.

Parameters:: cfg¶ – A configuration instance.

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.

Controlled by AssetBaseCfg.disable_shape_checks. When checks are disabled this method is a no-op.

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

Controlled by AssetBaseCfg.disable_shape_checks. When checks are disabled this method is a no-op.

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 backend_body_names: list[str]#

Body names in active backend solver-view order.

Concrete backends must override this property so its order matches root_view metadata and body-indexed solver arrays even when body_names uses another public order.

The inherited compatibility fallback emits DeprecationWarning and returns body_names. A subclass relying on that fallback therefore receives public order and cannot expose a distinct solver order.

Raises:: NotImplementedError – If the subclass overrides neither body_names nor this property, since the two inherited fallbacks delegate to each other and cannot produce names.

property backend_joint_names: list[str]#

Joint names in active backend solver-view order.

Concrete backends must override this property so its order matches root_view metadata and joint-indexed solver arrays even when joint_names uses another public order.

The inherited compatibility fallback emits DeprecationWarning and returns joint_names. A subclass relying on that fallback therefore receives public order and cannot expose a distinct solver order.

Raises:: NotImplementedError – If the subclass overrides neither joint_names nor this property, since the two inherited fallbacks delegate to each other and cannot produce names.

property body_names: list[str]#

Body names in public API order.

The order follows ArticulationCfg.body_ordering when configured and otherwise matches backend_body_names. Once the articulation installs its resolved names on data, those are returned directly; before that, the property falls back to backend_body_names.

property body_ordering: ArticulationNameMap | None#

Bidirectional map between backend and public body order.

The map is None whenever the public and backend orders coincide: either no ordering is configured, or the configured ordering resolved to the backend’s native order. A non-None map always denotes an actual permutation.

property device: str#: Memory device for computation.

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

abstractmethod 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, names.

abstractmethod 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, names.

abstractmethod 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, names.

abstract property fixed_tendon_names: list[str]#: Ordered names of fixed tendons in articulation.

classmethod get_registry_keys() → list[str]#: Returns a list of registered backend names.

property has_debug_vis_implementation: bool#: Whether the asset has a debug visualization implemented.

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

abstract 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]#

Joint names in public API order.

The order follows ArticulationCfg.joint_ordering when configured and otherwise matches backend_joint_names. Once the articulation installs its resolved names on data, those are returned directly; before that, the property falls back to backend_joint_names.

property joint_ordering: ArticulationNameMap | None#

Bidirectional map between backend and public joint order.

The map is None whenever the public and backend orders coincide: either no ordering is configured, or the configured ordering resolved to the backend’s native order. A non-None map always denotes an actual permutation.

map_body_ids_to_backend(body_ids: Sequence[int] | slice) → Sequence[int] | slice#

Translate public body indices to active-backend body indices.

Backend solver views expose body metadata and body-indexed arrays in backend_body_names order, which can differ from the public body_names order selected by body_ordering. Consumers that pick bodies with public indices (for example event terms) must convert those indices before addressing backend arrays.

When body_ordering is None the public and backend orders coincide and body_ids is returned unchanged without any per-index lookup.

Parameters:: body_ids¶ – Body indices in public body_names order, or a slice selecting them.
Returns:: The selected body indices expressed in backend_body_names order, or body_ids unchanged when the orders coincide. A slice is expanded to its backend indices under a permutation.

map_joint_ids_to_backend(joint_ids: Sequence[int] | slice) → Sequence[int] | slice#

Translate public joint indices to active-backend joint indices.

Backend solver views expose joint metadata and joint-indexed arrays in backend_joint_names order, which can differ from the public joint_names order selected by joint_ordering. Consumers that pick joints with public indices (for example event terms) must convert those indices before addressing backend arrays.

When joint_ordering is None the public and backend orders coincide and joint_ids is returned unchanged without any per-index lookup.

Parameters:: joint_ids¶ – Joint indices in public joint_names order, or a slice selecting them.
Returns:: The selected joint indices expressed in backend_joint_names order, or joint_ids unchanged when the orders coincide. A slice is expanded to its backend indices under a permutation.

property num_base_dofs: int#

Number of free DoFs of the floating base.

A floating-base articulation can translate and rotate freely in space, so its base contributes 6 DoFs (3 linear, 3 angular). A fixed-base articulation is bolted to the world and contributes 0.

Use this to map an actuated-joint index j to its column in the Jacobian / mass matrix / gravity vector: column = j + num_base_dofs.

abstract property num_bodies: int#: Number of bodies in articulation.

abstract property num_fixed_tendons: int#: Number of fixed tendons in articulation.

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

abstract property num_joints: int#: Number of joints in articulation.

abstract property num_spatial_tendons: int#: Number of spatial tendons in articulation.

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

classmethod register(name: str, sub_class) → None#: Register a new implementation class.

abstractmethod reset(env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, env_mask: wp.array | None = None) → None#

Reset the articulation.

Caution

If both env_ids and env_mask are provided, then env_mask takes precedence over env_ids.

Parameters:

env_ids¶ – Environment indices. If None, then all indices are used.
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

classmethod resolve_class(*args, **kwargs) → type#

Resolve the concrete backend implementation class without instantiating it.

Selects the backend via _get_backend(), lazily importing and registering the implementation class on first use, and returns it. Takes the same arguments as the constructor (the backend selector reads from them). Useful for querying class-level behavior (e.g. capability classmethods) before a sim/instance exists.

abstract property root_view#

Root articulation view in active backend order.

Name metadata and joint- or body-indexed arrays exposed by this view always use backend solver-view order, regardless of the configured public order. Use joint_ordering or body_ordering when converting axes.

Note

Use this view with caution. It requires handling backend tensors in the backend-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 in their respective body link frames.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

coms¶ – Center of mass pose of all bodies. Shape is (len(env_ids), len(body_ids), 7) or (len(env_ids), len(body_ids)) 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 instances).

abstractmethod 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 in their respective body link frames.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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 the bodies are updated. Shape is (num_bodies,).
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. Resets target environments, then adds forces and torques via the permanent wrench composer.

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.

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.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

damping¶ – Fixed tendon damping. Shape is (len(env_ids), len(fixed_tendon_ids)).
fixed_tendon_ids¶ – The tendon indices to set the damping for. Defaults to None (all fixed tendons).
env_ids¶ – The environment indices to set the damping for. Defaults to None (all instances).

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

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

damping¶ – Fixed tendon damping. Shape is (num_instances, num_fixed_tendons).
fixed_tendon_mask¶ – Fixed tendon mask. If None, then all the fixed tendons are updated. Shape is (num_fixed_tendons,).
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.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limit_stiffness¶ – Fixed tendon limit stiffness. Shape is (len(env_ids), len(fixed_tendon_ids)).
fixed_tendon_ids¶ – The tendon indices to set the limit stiffness for. Defaults to None (all fixed tendons).
env_ids¶ – The environment indices to set the limit stiffness for. Defaults to None (all instances).

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

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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 the fixed tendons are updated. Shape is (num_fixed_tendons,).
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.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

offset¶ – Fixed tendon offset. Shape is (len(env_ids), len(fixed_tendon_ids)).
fixed_tendon_ids¶ – The tendon indices to set the offset for. Defaults to None (all fixed tendons).
env_ids¶ – The environment indices to set the offset for. Defaults to None (all instances).

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

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

offset¶ – Fixed tendon offset. Shape is (num_instances, num_fixed_tendons).
fixed_tendon_mask¶ – Fixed tendon mask. If None, then all the fixed tendons are updated. Shape is (num_fixed_tendons,).
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 limits into internal buffers.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

abstractmethod 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 limits into internal buffers.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limit¶ – Fixed tendon limit. Shape is (num_instances, num_fixed_tendons).
fixed_tendon_mask¶ – Fixed tendon mask. If None, then all the fixed tendons are updated. Shape is (num_fixed_tendons,).
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.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

rest_length¶ – Fixed tendon rest length. Shape is (len(env_ids), len(fixed_tendon_ids)).
fixed_tendon_ids¶ – The tendon indices to set the rest length for. Defaults to None (all fixed tendons).
env_ids¶ – The environment indices to set the rest length for. Defaults to None (all instances).

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

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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 the fixed tendons are updated. Shape is (num_fixed_tendons,).
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.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

stiffness¶ – Fixed tendon stiffness. Shape is (len(env_ids), len(fixed_tendon_ids)).
fixed_tendon_ids¶ – The tendon indices to set the stiffness for. Defaults to None (all fixed tendons).
env_ids¶ – The environment indices to set the stiffness for. Defaults to None (all instances).

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

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

stiffness¶ – Fixed tendon stiffness. Shape is (num_instances, num_fixed_tendons).
fixed_tendon_mask¶ – Fixed tendon mask. If None, then all the fixed tendons are updated. Shape is (num_fixed_tendons,).
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 in the simulation world frame.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

inertias¶ – Inertias of all bodies. Shape is (len(env_ids), len(body_ids), 9).
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 instances).

abstractmethod 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 in the simulation world frame.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

inertias¶ – Inertias of all bodies. Shape is (num_instances, num_bodies, 9).
body_mask¶ – Body mask. If None, then all the bodies are updated. Shape is (num_bodies,).
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.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.

Parameters:

target¶ – Joint effort targets. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the targets for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the targets for. Defaults to None (all instances).

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.

Parameters:

target¶ – Joint effort targets. Shape is (num_instances, num_joints).
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
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.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.

Parameters:

target¶ – Joint position targets. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the targets for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the targets for. Defaults to None (all instances).

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.

Parameters:

target¶ – Joint position targets. Shape is (num_instances, num_joints).
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
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.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.

Parameters:

target¶ – Joint velocity targets. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the targets for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the targets for. Defaults to None (all instances).

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.

Parameters:

target¶ – Joint velocity targets. Shape is (num_instances, num_joints).
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
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 in the simulation world frame.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

masses¶ – Masses of all bodies. Shape is (len(env_ids), len(body_ids)).
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 instances).

abstractmethod 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 in the simulation world frame.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

masses¶ – Masses of all bodies. Shape is (num_instances, num_bodies).
body_mask¶ – Body mask. If None, then all the bodies are updated. Shape is (num_bodies,).
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.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

damping¶ – Spatial tendon damping. Shape is (len(env_ids), len(spatial_tendon_ids)).
spatial_tendon_ids¶ – The tendon indices to set the damping for. Defaults to None (all spatial tendons).
env_ids¶ – The environment indices to set the damping for. Defaults to None (all instances).

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

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

damping¶ – Spatial tendon damping. Shape is (num_instances, num_spatial_tendons).
spatial_tendon_mask¶ – Spatial tendon mask. If None, then all the spatial tendons are updated. Shape is (num_spatial_tendons,).
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.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limit_stiffness¶ – Spatial tendon limit stiffness. Shape is (len(env_ids), len(spatial_tendon_ids)).
spatial_tendon_ids¶ – The tendon indices to set the limit stiffness for. Defaults to None (all spatial tendons).
env_ids¶ – The environment indices to set the limit stiffness for. Defaults to None (all instances).

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

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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 the spatial tendons are updated. Shape is (num_spatial_tendons,).
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.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

offset¶ – Spatial tendon offset. Shape is (len(env_ids), len(spatial_tendon_ids)).
spatial_tendon_ids¶ – The tendon indices to set the offset for. Defaults to None (all spatial tendons).
env_ids¶ – The environment indices to set the offset for. Defaults to None (all instances).

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

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

offset¶ – Spatial tendon offset. Shape is (num_instances, num_spatial_tendons).
spatial_tendon_mask¶ – Spatial tendon mask. If None, then all the spatial tendons are updated. Shape is (num_spatial_tendons,).
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.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

stiffness¶ – Spatial tendon stiffness. Shape is (len(env_ids), len(spatial_tendon_ids)).
spatial_tendon_ids¶ – The tendon indices to set the stiffness for. Defaults to None (all spatial tendons).
env_ids¶ – The environment indices to set the stiffness for. Defaults to None (all instances).

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

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

stiffness¶ – Spatial tendon stiffness. Shape is (num_instances, num_spatial_tendons).
spatial_tendon_mask¶ – Spatial tendon mask. If None, then all the spatial tendons are updated. Shape is (num_spatial_tendons,).
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).

abstract property spatial_tendon_names: list[str]#: Ordered names of spatial tendons in articulation.

abstractmethod update(dt: float) → None#

Updates the simulation data.

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

abstractmethod write_data_to_sim() → None#

Write external wrenches and joint commands to the simulation.

If any explicit actuators are present, then the actuator models are used to compute the joint commands. Otherwise, the joint commands are directly set into the simulation.

Note

We write external wrench to the simulation here since this function is called before the simulation step. This ensures that the external wrench is applied at every simulation step.

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 into the simulation.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

fixed_tendon_ids¶ – The fixed tendon indices to set the limits for. Defaults to None (all fixed tendons).
env_ids¶ – The environment indices to set the limits for. Defaults to None (all instances).

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

Write fixed tendon properties into the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

fixed_tendon_mask¶ – Fixed tendon mask. If None, then all the fixed tendons are updated. Shape is (num_fixed_tendons,).
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 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.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

armature¶ – Joint armature. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the joint torque limits for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the joint torque limits for. Defaults to None (all instances).

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

Write joint armature into the simulation.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

armature¶ – Joint armature. Shape is (num_instances, num_joints).
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
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 into the simulation.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

damping¶ – Joint damping. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the damping for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the damping for. Defaults to None (all instances).

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

Write joint damping into the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

damping¶ – Joint damping. Shape is (num_instances, num_joints).
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
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 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.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limits¶ – Joint torque limits. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the joint torque limits for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the joint torque limits for. Defaults to None (all instances).

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

Write joint effort limits into the simulation.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limits¶ – Joint torque limits. Shape is (num_instances, num_joints).
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
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 | 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_friction_coefficient_to_sim_index().

Write backend-specific joint friction values into the simulation.

Warning

The physical meaning and units of joint friction depend on the concrete backend and solver. Do not assume values are comparable across backends; check the backend-specific implementation before interpreting or reusing them.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

joint_friction_coeff¶ – Backend-specific joint friction values. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the joint torque limits for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the joint torque limits for. Defaults to None (all instances).

abstractmethod write_joint_friction_coefficient_to_sim_mask(*, joint_friction_coeff: torch.Tensor | float | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None) → None#

Write backend-specific joint friction values into the simulation.

Warning

The physical meaning and units of joint friction depend on the concrete backend and solver. Do not assume values are comparable across backends; check the backend-specific implementation before interpreting or reusing them.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

joint_friction_coeff¶ – Backend-specific joint friction values. Shape is (num_instances, num_joints).
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
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 into the simulation.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limits¶ – Joint limits. Shape is (len(env_ids), len(joint_ids), 2) or (len(env_ids), len(joint_ids)) with dtype wp.vec2f.
joint_ids¶ – The joint indices to set the limits for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the limits for. Defaults to None (all instances).
warn_limit_violation¶ – Whether to use warning or info level logging when default joint positions exceed the new limits. Defaults to True.

abstractmethod write_joint_position_limit_to_sim_mask(*, limits: torch.Tensor | float | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None, warn_limit_violation: bool = True) → None#

Write joint position limits into the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limits¶ – Joint limits. Shape is (num_instances, num_joints, 2) or (num_instances, num_joints) with dtype wp.vec2f.
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
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 to the simulation.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

position¶ – Joint positions. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the targets for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the targets for. Defaults to None (all instances).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_joint_position_to_sim_mask(*, position: torch.Tensor | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None, skip_forward: bool = False) → None#

Write joint positions to the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

position¶ – Joint positions. Shape is (num_instances, num_joints).
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_joint_state_to_sim(position: torch.Tensor | wp.array, 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_position_to_sim_index() and write_joint_velocity_to_sim_index().

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 into the simulation.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

stiffness¶ – Joint stiffness. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the stiffness for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the stiffness for. Defaults to None (all instances).

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

Write joint stiffness into the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

stiffness¶ – Joint stiffness. Shape is (num_instances, num_joints).
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
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 to the simulation.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limits¶ – Joint max velocity. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the max velocity for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the max velocity for. Defaults to None (all instances).

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

Write joint max velocity to the simulation.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limits¶ – Joint max velocity. Shape is (num_instances, num_joints).
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

velocity¶ – Joint velocities. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the targets for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the targets for. Defaults to None (all instances).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_joint_velocity_to_sim_mask(*, velocity: torch.Tensor | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None, skip_forward: bool = False) → None#

Write joint velocities to the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

velocity¶ – Joint velocities. Shape is (num_instances, num_joints).
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

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

abstractmethod write_root_com_pose_to_sim_index(*, root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: 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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

root_pose¶ – Root center of mass 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_com_pose_to_sim_mask(*, root_pose: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → 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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod 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_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().

abstractmethod write_root_com_velocity_to_sim_index(*, root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: 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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_com_velocity_to_sim_mask(*, root_velocity: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → 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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

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

abstractmethod write_root_link_pose_to_sim_index(*, root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: 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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_link_pose_to_sim_mask(*, root_pose: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → 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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod 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_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().

abstractmethod write_root_link_velocity_to_sim_index(*, root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: 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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

root_velocity¶ – Root frame 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_link_velocity_to_sim_mask(*, root_velocity: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → 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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

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

abstractmethod write_root_pose_to_sim_index(*, root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: bool = False) → 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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_pose_to_sim_mask(*, root_pose: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → 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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod 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_pose_to_sim_index() and write_root_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().

abstractmethod write_root_velocity_to_sim_index(*, root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: 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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_velocity_to_sim_mask(*, root_velocity: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → 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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

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 into the simulation.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

spatial_tendon_ids¶ – The spatial tendon indices to set the properties for. Defaults to None (all spatial tendons).
env_ids¶ – The environment indices to set the properties for. Defaults to None (all instances).

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

cfg: ArticulationCfg#: Configuration instance for the articulations.

actuators: dict#

Dictionary of actuator instances for the articulation.

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 ArticulationCfg.actuators attribute. They are used to compute the joint commands during the write_data_to_sim() function.

class isaaclab.assets.BaseArticulation[source]#

Bases: AssetBase

An articulation asset class.

An articulation is a collection of rigid bodies connected by joints. The joints can be either fixed or actuated. The joints can be of different types, such as revolute, prismatic, D-6, etc. However, the articulation class has currently been tested with revolute and prismatic joints. The class supports both floating-base and fixed-base articulations. The type of articulation is determined based on the root joint of the articulation. If the root joint is fixed, then the articulation is considered a fixed-base system. Otherwise, it is considered a floating-base system. This can be checked using the Articulation.is_fixed_base attribute.

For an asset to be considered an articulation, the root prim of the asset must have the USD ArticulationRootAPI. This API is used to define the sub-tree of the articulation using the reduced coordinate formulation. On playing the simulation, the physics engine parses the articulation root prim and creates the corresponding articulation in the physics engine. The articulation root prim can be specified using the AssetBaseCfg.prim_path attribute.

The articulation class also provides the functionality to augment the simulation of an articulated system with custom actuator models. These models can either be explicit or implicit, as detailed in the isaaclab.actuators module. The actuator models are specified using the ArticulationCfg.actuators attribute. These are then parsed and used to initialize the corresponding actuator models, when the simulation is played.

During the simulation step, the articulation class first applies the actuator models to compute the joint commands based on the user-specified targets. These joint commands are then applied into the simulation. The joint commands can be either position, velocity, or effort commands. As an example, the following snippet shows how this can be used for position commands:

# an example instance of the articulation class
my_articulation = Articulation(cfg)

# set joint position targets
my_articulation.set_joint_position_target(position)
# propagate the actuator models and apply the computed commands into the simulation
my_articulation.write_data_to_sim()

# step the simulation using the simulation context
sim_context.step()

# update the articulation state, where dt is the simulation time step
my_articulation.update(dt)

Note

Index-based writer selectors must contain unique environment, joint, and body indices. Repeated selector entries issue concurrent writes to the same simulation cell, so the winning value is undefined. Use a mask when a selection may contain duplicates.

Attributes:

`cfg`	Configuration instance for the articulations.
`actuators`	Dictionary of actuator instances for the articulation.
`data`	Data related to the asset.
`num_instances`	Number of instances of the asset.
`is_fixed_base`	Whether the articulation is a fixed-base or floating-base system.
`num_joints`	Number of joints in articulation.
`num_fixed_tendons`	Number of fixed tendons in articulation.
`num_spatial_tendons`	Number of spatial tendons in articulation.
`num_bodies`	Number of bodies in articulation.
`joint_names`	Joint names in public API order.
`fixed_tendon_names`	Ordered names of fixed tendons in articulation.
`spatial_tendon_names`	Ordered names of spatial tendons in articulation.
`body_names`	Body names in public API order.
`backend_joint_names`	Joint names in active backend solver-view order.
`backend_body_names`	Body names in active backend solver-view order.
`joint_ordering`	Bidirectional map between backend and public joint order.
`body_ordering`	Bidirectional map between backend and public body order.
`root_view`	Root articulation view in active backend order.
`num_base_dofs`	Number of free DoFs of the floating base.
`instantaneous_wrench_composer`	Instantaneous wrench composer.
`permanent_wrench_composer`	Permanent wrench composer.
`device`	Memory device for computation.
`has_debug_vis_implementation`	Whether the asset has a debug visualization implemented.
`is_initialized`	Whether the asset is initialized.

Methods:

`__init__`(cfg)	Initialize the articulation.
`map_joint_ids_to_backend`(joint_ids)	Translate public joint indices to active-backend joint indices.
`map_body_ids_to_backend`(body_ids)	Translate public body indices to active-backend body indices.
`reset`([env_ids, env_mask])	Reset the articulation.
`write_data_to_sim`()	Write external wrenches and joint commands to the simulation.
`update`(dt)	Updates the simulation data.
`find_bodies`(name_keys[, preserve_order])	Find bodies 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_fixed_tendons`(name_keys[, ...])	Find fixed tendons in the articulation based on the name keys.
`find_spatial_tendons`(name_keys[, ...])	Find spatial tendons in the articulation based on the name keys.
`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_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_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_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_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_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_joint_position_to_sim_index`(*, position)	Write joint positions to the simulation.
`write_joint_position_to_sim_mask`(*, position)	Write joint positions to the simulation.
`write_joint_velocity_to_sim_index`(*, velocity)	Write joint velocities to the simulation.
`write_joint_velocity_to_sim_mask`(*, velocity)	Write joint velocities to the simulation.
`write_joint_stiffness_to_sim_index`(*, stiffness)	Write joint stiffness into the simulation.
`write_joint_stiffness_to_sim_mask`(*, stiffness)	Write joint stiffness into the simulation.
`write_joint_damping_to_sim_index`(*, damping)	Write joint damping into the simulation.
`write_joint_damping_to_sim_mask`(*, damping)	Write joint damping into the simulation.
`write_joint_position_limit_to_sim_index`(*, ...)	Write joint position limits into the simulation.
`write_joint_position_limit_to_sim_mask`(*, limits)	Write joint position limits into the simulation.
`write_joint_velocity_limit_to_sim_index`(*, ...)	Write joint max velocity to the simulation.
`write_joint_velocity_limit_to_sim_mask`(*, limits)	Write joint max velocity to the simulation.
`write_joint_effort_limit_to_sim_index`(*, limits)	Write joint effort limits into the simulation.
`write_joint_effort_limit_to_sim_mask`(*, limits)	Write joint effort limits into the simulation.
`write_joint_armature_to_sim_index`(*, armature)	Write joint armature into the simulation.
`write_joint_armature_to_sim_mask`(*, armature)	Write joint armature into the simulation.
`write_joint_friction_coefficient_to_sim_index`(*, ...)	Write backend-specific joint friction values into the simulation.
`write_joint_friction_coefficient_to_sim_mask`(*, ...)	Write backend-specific joint friction values into the simulation.
`set_masses_index`(*, masses[, body_ids, env_ids])	Set masses of all bodies in the simulation world frame.
`set_masses_mask`(*, masses[, body_mask, env_mask])	Set masses of all bodies in the simulation world frame.
`set_coms_index`(*, coms[, body_ids, env_ids])	Set center of mass pose of all bodies in their respective body link frames.
`set_coms_mask`(*, coms[, body_mask, env_mask])	Set center of mass pose of all bodies in their respective body link frames.
`set_inertias_index`(*, inertias[, body_ids, ...])	Set inertias of all bodies in the simulation world frame.
`set_inertias_mask`(*, inertias[, body_mask, ...])	Set inertias of all bodies in the simulation world frame.
`set_joint_position_target_index`(*, target[, ...])	Set joint position targets into internal buffers.
`set_joint_position_target_mask`(*, target[, ...])	Set joint position targets into internal buffers.
`set_joint_velocity_target_index`(*, target[, ...])	Set joint velocity targets into internal buffers.
`set_joint_velocity_target_mask`(*, target[, ...])	Set joint velocity targets into internal buffers.
`set_joint_effort_target_index`(*, target[, ...])	Set joint efforts into internal buffers.
`set_joint_effort_target_mask`(*, target[, ...])	Set joint efforts into internal buffers.
`set_fixed_tendon_stiffness_index`(*, stiffness)	Set fixed tendon stiffness into internal buffers.
`set_fixed_tendon_stiffness_mask`(*, stiffness)	Set fixed tendon stiffness into internal buffers.
`set_fixed_tendon_damping_index`(*, damping[, ...])	Set fixed tendon damping into internal buffers.
`set_fixed_tendon_damping_mask`(*, damping[, ...])	Set fixed tendon damping into internal buffers.
`set_fixed_tendon_limit_stiffness_index`(*, ...)	Set fixed tendon limit stiffness into internal buffers.
`set_fixed_tendon_limit_stiffness_mask`(*, ...)	Set fixed tendon limit stiffness into internal buffers.
`set_fixed_tendon_position_limit_index`(*, limit)	Set fixed tendon position limits into internal buffers.
`set_fixed_tendon_position_limit_mask`(*, limit)	Set fixed tendon position limits into internal buffers.
`set_fixed_tendon_rest_length_index`(*, ...[, ...])	Set fixed tendon rest length into internal buffers.
`set_fixed_tendon_rest_length_mask`(*, rest_length)	Set fixed tendon rest length into internal buffers.
`set_fixed_tendon_offset_index`(*, offset[, ...])	Set fixed tendon offset into internal buffers.
`set_fixed_tendon_offset_mask`(*, offset[, ...])	Set fixed tendon offset into internal buffers.
`write_fixed_tendon_properties_to_sim_index`(*)	Write fixed tendon properties into the simulation.
`write_fixed_tendon_properties_to_sim_mask`(*)	Write fixed tendon properties into the simulation.
`set_spatial_tendon_stiffness_index`(*, stiffness)	Set spatial tendon stiffness into internal buffers.
`set_spatial_tendon_stiffness_mask`(*, stiffness)	Set spatial tendon stiffness into internal buffers.
`set_spatial_tendon_damping_index`(*, damping)	Set spatial tendon damping into internal buffers.
`set_spatial_tendon_damping_mask`(*, damping)	Set spatial tendon damping into internal buffers.
`set_spatial_tendon_limit_stiffness_index`(*, ...)	Set spatial tendon limit stiffness into internal buffers.
`set_spatial_tendon_limit_stiffness_mask`(*, ...)	Set spatial tendon limit stiffness into internal buffers.
`set_spatial_tendon_offset_index`(*, offset[, ...])	Set spatial tendon offset into internal buffers.
`set_spatial_tendon_offset_mask`(*, offset[, ...])	Set spatial tendon offset into internal buffers.
`write_spatial_tendon_properties_to_sim_index`(*)	Write spatial tendon properties into the simulation.
`write_spatial_tendon_properties_to_sim_mask`(*)	Write spatial tendon properties 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.
`set_fixed_tendon_limit`(limit[, ...])	Set fixed tendon position limits into internal buffers.
`write_root_state_to_sim`(root_state[, env_ids])	Deprecated, same as `write_root_pose_to_sim_index()` and `write_root_velocity_to_sim_index()`.
`write_root_com_state_to_sim`(root_state[, ...])	Deprecated, same as `write_root_com_pose_to_sim_index()` and `write_root_velocity_to_sim_index()`.
`write_root_link_state_to_sim`(root_state[, ...])	Deprecated, same as `write_root_pose_to_sim_index()` and `write_root_link_velocity_to_sim_index()`.
`write_root_pose_to_sim`(root_pose[, env_ids])	Deprecated, same as `write_root_pose_to_sim_index()`.
`write_root_link_pose_to_sim`(root_pose[, env_ids])	Deprecated, same as `write_root_link_pose_to_sim_index()`.
`write_root_com_pose_to_sim`(root_pose[, env_ids])	Deprecated, same as `write_root_com_pose_to_sim_index()`.
`write_root_velocity_to_sim`(root_velocity[, ...])	Deprecated, same as `write_root_velocity_to_sim_index()`.
`write_root_com_velocity_to_sim`(root_velocity)	Deprecated, same as `write_root_com_velocity_to_sim_index()`.
`write_root_link_velocity_to_sim`(root_velocity)	Deprecated, same as `write_root_link_velocity_to_sim_index()`.
`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_position_to_sim`(position[, ...])	Deprecated, same as `write_joint_position_to_sim_index()`.
`write_joint_velocity_to_sim`(velocity[, ...])	Deprecated, same as `write_joint_velocity_to_sim_index()`.
`write_joint_stiffness_to_sim`(stiffness[, ...])	Deprecated, same as `write_joint_stiffness_to_sim_index()`.
`write_joint_damping_to_sim`(damping[, ...])	Deprecated, same as `write_joint_damping_to_sim_index()`.
`write_joint_position_limit_to_sim`(limits[, ...])	Deprecated, same as `write_joint_position_limit_to_sim_index()`.
`write_joint_velocity_limit_to_sim`(limits[, ...])	Deprecated, same as `write_joint_velocity_limit_to_sim_index()`.
`write_joint_effort_limit_to_sim`(limits[, ...])	Deprecated, same as `write_joint_effort_limit_to_sim_index()`.
`write_joint_armature_to_sim`(armature[, ...])	Deprecated, same as `write_joint_armature_to_sim_index()`.
`write_joint_friction_coefficient_to_sim`(...)	Deprecated, same as `write_joint_friction_coefficient_to_sim_index()`.
`set_masses`(masses[, body_ids, env_ids])	Deprecated, same as `set_masses_index()`.
`set_coms`(coms[, body_ids, env_ids])	Deprecated, same as `set_coms_index()`.
`set_inertias`(inertias[, body_ids, env_ids])	Deprecated, same as `set_inertias_index()`.
`set_external_force_and_torque`(forces, torques)	Deprecated.
`set_joint_position_target`(target[, ...])	Deprecated, same as `set_joint_position_target_index()`.
`set_joint_velocity_target`(target[, ...])	Deprecated, same as `set_joint_velocity_target_index()`.
`set_joint_effort_target`(target[, joint_ids, ...])	Deprecated, same as `set_joint_effort_target_index()`.
`set_fixed_tendon_stiffness`(stiffness[, ...])	Deprecated, same as `set_fixed_tendon_stiffness_index()`.
`set_fixed_tendon_damping`(damping[, ...])	Deprecated, same as `set_fixed_tendon_damping_index()`.
`set_fixed_tendon_limit_stiffness`(limit_stiffness)	Deprecated, same as `set_fixed_tendon_limit_stiffness_index()`.
`set_fixed_tendon_position_limit`(limit[, ...])	Deprecated, same as `set_fixed_tendon_position_limit_index()`.
`set_fixed_tendon_rest_length`(rest_length[, ...])	Deprecated, same as `set_fixed_tendon_rest_length_index()`.
`set_fixed_tendon_offset`(offset[, ...])	Deprecated, same as `set_fixed_tendon_offset_index()`.
`write_fixed_tendon_properties_to_sim`([...])	Deprecated, same as `write_fixed_tendon_properties_to_sim_index()`.
`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.
`set_debug_vis`(debug_vis)	Sets whether to visualize the asset data.
`set_spatial_tendon_stiffness`(stiffness[, ...])	Deprecated, same as `set_spatial_tendon_stiffness_index()`.
`set_visibility`(visible[, env_ids])	Set the visibility of the prims corresponding to the asset.
`set_spatial_tendon_damping`(damping[, ...])	Deprecated, same as `set_spatial_tendon_damping_index()`.
`set_spatial_tendon_limit_stiffness`(...[, ...])	Deprecated, same as `set_spatial_tendon_limit_stiffness_index()`.
`set_spatial_tendon_offset`(offset[, ...])	Deprecated, same as `set_spatial_tendon_offset_index()`.
`write_spatial_tendon_properties_to_sim`([...])	Deprecated, same as `write_spatial_tendon_properties_to_sim_index()`.

cfg: ArticulationCfg#: Configuration instance for the articulations.

actuators: dict#

Dictionary of actuator instances for the articulation.

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 ArticulationCfg.actuators attribute. They are used to compute the joint commands during the write_data_to_sim() function.

__init__(cfg: ArticulationCfg)[source]#

Initialize the articulation.

Parameters:: cfg¶ – A configuration instance.

abstract property data: BaseArticulationData#: Data related to the asset.

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

abstract property is_fixed_base: bool#: Whether the articulation is a fixed-base or floating-base system.

abstract property num_joints: int#: Number of joints in articulation.

abstract property num_fixed_tendons: int#: Number of fixed tendons in articulation.

abstract property num_spatial_tendons: int#: Number of spatial tendons in articulation.

abstract property num_bodies: int#: Number of bodies in articulation.

property joint_names: list[str]#

Joint names in public API order.

The order follows ArticulationCfg.joint_ordering when configured and otherwise matches backend_joint_names. Once the articulation installs its resolved names on data, those are returned directly; before that, the property falls back to backend_joint_names.

abstract property fixed_tendon_names: list[str]#: Ordered names of fixed tendons in articulation.

abstract property spatial_tendon_names: list[str]#: Ordered names of spatial tendons in articulation.

property body_names: list[str]#

Body names in public API order.

The order follows ArticulationCfg.body_ordering when configured and otherwise matches backend_body_names. Once the articulation installs its resolved names on data, those are returned directly; before that, the property falls back to backend_body_names.

property backend_joint_names: list[str]#

Joint names in active backend solver-view order.

Concrete backends must override this property so its order matches root_view metadata and joint-indexed solver arrays even when joint_names uses another public order.

The inherited compatibility fallback emits DeprecationWarning and returns joint_names. A subclass relying on that fallback therefore receives public order and cannot expose a distinct solver order.

Raises:: NotImplementedError – If the subclass overrides neither joint_names nor this property, since the two inherited fallbacks delegate to each other and cannot produce names.

property backend_body_names: list[str]#

Body names in active backend solver-view order.

Concrete backends must override this property so its order matches root_view metadata and body-indexed solver arrays even when body_names uses another public order.

The inherited compatibility fallback emits DeprecationWarning and returns body_names. A subclass relying on that fallback therefore receives public order and cannot expose a distinct solver order.

Raises:: NotImplementedError – If the subclass overrides neither body_names nor this property, since the two inherited fallbacks delegate to each other and cannot produce names.

property joint_ordering: ArticulationNameMap | None#

Bidirectional map between backend and public joint order.

The map is None whenever the public and backend orders coincide: either no ordering is configured, or the configured ordering resolved to the backend’s native order. A non-None map always denotes an actual permutation.

property body_ordering: ArticulationNameMap | None#

Bidirectional map between backend and public body order.

The map is None whenever the public and backend orders coincide: either no ordering is configured, or the configured ordering resolved to the backend’s native order. A non-None map always denotes an actual permutation.

map_joint_ids_to_backend(joint_ids: Sequence[int] | slice) → Sequence[int] | slice[source]#

Translate public joint indices to active-backend joint indices.

Backend solver views expose joint metadata and joint-indexed arrays in backend_joint_names order, which can differ from the public joint_names order selected by joint_ordering. Consumers that pick joints with public indices (for example event terms) must convert those indices before addressing backend arrays.

When joint_ordering is None the public and backend orders coincide and joint_ids is returned unchanged without any per-index lookup.

Parameters:: joint_ids¶ – Joint indices in public joint_names order, or a slice selecting them.
Returns:: The selected joint indices expressed in backend_joint_names order, or joint_ids unchanged when the orders coincide. A slice is expanded to its backend indices under a permutation.

map_body_ids_to_backend(body_ids: Sequence[int] | slice) → Sequence[int] | slice[source]#

Translate public body indices to active-backend body indices.

Backend solver views expose body metadata and body-indexed arrays in backend_body_names order, which can differ from the public body_names order selected by body_ordering. Consumers that pick bodies with public indices (for example event terms) must convert those indices before addressing backend arrays.

When body_ordering is None the public and backend orders coincide and body_ids is returned unchanged without any per-index lookup.

Parameters:: body_ids¶ – Body indices in public body_names order, or a slice selecting them.
Returns:: The selected body indices expressed in backend_body_names order, or body_ids unchanged when the orders coincide. A slice is expanded to its backend indices under a permutation.

abstract property root_view#

Root articulation view in active backend order.

Name metadata and joint- or body-indexed arrays exposed by this view always use backend solver-view order, regardless of the configured public order. Use joint_ordering or body_ordering when converting axes.

Note

Use this view with caution. It requires handling backend tensors in the backend-specific way.

property num_base_dofs: int#

Number of free DoFs of the floating base.

A floating-base articulation can translate and rotate freely in space, so its base contributes 6 DoFs (3 linear, 3 angular). A fixed-base articulation is bolted to the world and contributes 0.

Use this to map an actuated-joint index j to its column in the Jacobian / mass matrix / gravity vector: column = j + num_base_dofs.

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

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

abstractmethod reset(env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, env_mask: wp.array | None = None) → None[source]#

Reset the articulation.

Caution

If both env_ids and env_mask are provided, then env_mask takes precedence over env_ids.

Parameters:

env_ids¶ – Environment indices. If None, then all indices are used.
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

abstractmethod write_data_to_sim() → None[source]#

Write external wrenches and joint commands to the simulation.

If any explicit actuators are present, then the actuator models are used to compute the joint commands. Otherwise, the joint commands are directly set into the simulation.

Note

We write external wrench to the simulation here since this function is called before the simulation step. This ensures that the external wrench is applied at every simulation step.

abstractmethod update(dt: float) → None[source]#

Updates the simulation data.

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

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

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.

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

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, names.

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

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, names.

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

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, names.

abstractmethod write_root_pose_to_sim_index(*, root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: bool = False) → None[source]#

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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_pose_to_sim_mask(*, root_pose: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → None[source]#

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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_link_pose_to_sim_index(*, root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: bool = False) → None[source]#

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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_link_pose_to_sim_mask(*, root_pose: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → None[source]#

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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_com_pose_to_sim_index(*, root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: bool = False) → None[source]#

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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

root_pose¶ – Root center of mass 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_com_pose_to_sim_mask(*, root_pose: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → None[source]#

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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_velocity_to_sim_index(*, root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: bool = False) → None[source]#

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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_velocity_to_sim_mask(*, root_velocity: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → None[source]#

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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_com_velocity_to_sim_index(*, root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: bool = False) → None[source]#

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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_com_velocity_to_sim_mask(*, root_velocity: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → None[source]#

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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_link_velocity_to_sim_index(*, root_velocity: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None, skip_forward: bool = False) → None[source]#

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 expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

root_velocity¶ – Root frame 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.
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_root_link_velocity_to_sim_mask(*, root_velocity: torch.Tensor | wp.array, env_mask: wp.array | None = None, skip_forward: bool = False) → None[source]#

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 expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

Write joint positions to the simulation.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

position¶ – Joint positions. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the targets for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the targets for. Defaults to None (all instances).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_joint_position_to_sim_mask(*, position: torch.Tensor | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None, skip_forward: bool = False) → None[source]#

Write joint positions to the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

position¶ – Joint positions. Shape is (num_instances, num_joints).
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

Write joint velocities to the simulation.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

velocity¶ – Joint velocities. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the targets for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the targets for. Defaults to None (all instances).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

abstractmethod write_joint_velocity_to_sim_mask(*, velocity: torch.Tensor | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None, skip_forward: bool = False) → None[source]#

Write joint velocities to the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

velocity¶ – Joint velocities. Shape is (num_instances, num_joints).
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).
skip_forward¶ – Whether to skip invalidating cached data after the write. When True, the caller must invalidate stale cached data before reading it back. Defaults to False.

Write joint stiffness into the simulation.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

stiffness¶ – Joint stiffness. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the stiffness for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the stiffness for. Defaults to None (all instances).

abstractmethod write_joint_stiffness_to_sim_mask(*, stiffness: torch.Tensor | float | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None) → None[source]#

Write joint stiffness into the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Write joint damping into the simulation.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

damping¶ – Joint damping. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the damping for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the damping for. Defaults to None (all instances).

abstractmethod write_joint_damping_to_sim_mask(*, damping: torch.Tensor | float | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None) → None[source]#

Write joint damping into the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Write joint position limits into the simulation.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limits¶ – Joint limits. Shape is (len(env_ids), len(joint_ids), 2) or (len(env_ids), len(joint_ids)) with dtype wp.vec2f.
joint_ids¶ – The joint indices to set the limits for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the limits for. Defaults to None (all instances).
warn_limit_violation¶ – Whether to use warning or info level logging when default joint positions exceed the new limits. Defaults to True.

abstractmethod write_joint_position_limit_to_sim_mask(*, limits: torch.Tensor | float | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None, warn_limit_violation: bool = True) → None[source]#

Write joint position limits into the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limits¶ – Joint limits. Shape is (num_instances, num_joints, 2) or (num_instances, num_joints) with dtype wp.vec2f.
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
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 max velocity to the simulation.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limits¶ – Joint max velocity. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the max velocity for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the max velocity for. Defaults to None (all instances).

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

Write joint max velocity to the simulation.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Write joint effort limits into the simulation.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limits¶ – Joint torque limits. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the joint torque limits for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the joint torque limits for. Defaults to None (all instances).

abstractmethod write_joint_effort_limit_to_sim_mask(*, limits: torch.Tensor | float | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None) → None[source]#

Write joint effort limits into the simulation.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Write joint armature into the simulation.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

armature¶ – Joint armature. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the joint torque limits for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the joint torque limits for. Defaults to None (all instances).

abstractmethod write_joint_armature_to_sim_mask(*, armature: torch.Tensor | float | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None) → None[source]#

Write joint armature into the simulation.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Write backend-specific joint friction values into the simulation.

Warning

The physical meaning and units of joint friction depend on the concrete backend and solver. Do not assume values are comparable across backends; check the backend-specific implementation before interpreting or reusing them.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

joint_friction_coeff¶ – Backend-specific joint friction values. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the joint torque limits for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the joint torque limits for. Defaults to None (all instances).

abstractmethod write_joint_friction_coefficient_to_sim_mask(*, joint_friction_coeff: torch.Tensor | float | wp.array, joint_mask: wp.array | None = None, env_mask: wp.array | None = None) → None[source]#

Write backend-specific joint friction values into the simulation.

Warning

The physical meaning and units of joint friction depend on the concrete backend and solver. Do not assume values are comparable across backends; check the backend-specific implementation before interpreting or reusing them.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

joint_friction_coeff¶ – Backend-specific joint friction values. Shape is (num_instances, num_joints).
joint_mask¶ – Joint mask. If None, then all the joints are updated. Shape is (num_joints,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

Set masses of all bodies in the simulation world frame.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

masses¶ – Masses of all bodies. Shape is (len(env_ids), len(body_ids)).
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 instances).

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

Set masses of all bodies in the simulation world frame.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Set center of mass pose of all bodies in their respective body link frames.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

coms¶ – Center of mass pose of all bodies. Shape is (len(env_ids), len(body_ids), 7) or (len(env_ids), len(body_ids)) 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 instances).

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

Set center of mass pose of all bodies in their respective body link frames.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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 the bodies are updated. Shape is (num_bodies,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

Set inertias of all bodies in the simulation world frame.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

inertias¶ – Inertias of all bodies. Shape is (len(env_ids), len(body_ids), 9).
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 instances).

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

Set inertias of all bodies in the simulation world frame.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Set joint position targets into internal buffers.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.

Parameters:

target¶ – Joint position targets. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the targets for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the targets for. Defaults to None (all instances).

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

Set joint position targets into internal buffers.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.

Parameters:

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

Set joint velocity targets into internal buffers.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.

Parameters:

target¶ – Joint velocity targets. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the targets for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the targets for. Defaults to None (all instances).

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

Set joint velocity targets into internal buffers.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.

Parameters:

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

Set joint efforts into internal buffers.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.

Parameters:

target¶ – Joint effort targets. Shape is (len(env_ids), len(joint_ids)).
joint_ids¶ – The joint indices to set the targets for. Defaults to None (all joints).
env_ids¶ – The environment indices to set the targets for. Defaults to None (all instances).

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

Set joint efforts into internal buffers.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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.

Parameters:

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

Set fixed tendon stiffness into internal buffers.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

stiffness¶ – Fixed tendon stiffness. Shape is (len(env_ids), len(fixed_tendon_ids)).
fixed_tendon_ids¶ – The tendon indices to set the stiffness for. Defaults to None (all fixed tendons).
env_ids¶ – The environment indices to set the stiffness for. Defaults to None (all instances).

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

Set fixed tendon stiffness into internal buffers.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Set fixed tendon damping into internal buffers.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

damping¶ – Fixed tendon damping. Shape is (len(env_ids), len(fixed_tendon_ids)).
fixed_tendon_ids¶ – The tendon indices to set the damping for. Defaults to None (all fixed tendons).
env_ids¶ – The environment indices to set the damping for. Defaults to None (all instances).

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

Set fixed tendon damping into internal buffers.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Set fixed tendon limit stiffness into internal buffers.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limit_stiffness¶ – Fixed tendon limit stiffness. Shape is (len(env_ids), len(fixed_tendon_ids)).
fixed_tendon_ids¶ – The tendon indices to set the limit stiffness for. Defaults to None (all fixed tendons).
env_ids¶ – The environment indices to set the limit stiffness for. Defaults to None (all instances).

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

Set fixed tendon limit stiffness into internal buffers.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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 the fixed tendons are updated. Shape is (num_fixed_tendons,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

Set fixed tendon position limits into internal buffers.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

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

Set fixed tendon position limits into internal buffers.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Set fixed tendon rest length into internal buffers.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

rest_length¶ – Fixed tendon rest length. Shape is (len(env_ids), len(fixed_tendon_ids)).
fixed_tendon_ids¶ – The tendon indices to set the rest length for. Defaults to None (all fixed tendons).
env_ids¶ – The environment indices to set the rest length for. Defaults to None (all instances).

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

Set fixed tendon rest length into internal buffers.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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 the fixed tendons are updated. Shape is (num_fixed_tendons,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

Set fixed tendon offset into internal buffers.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

offset¶ – Fixed tendon offset. Shape is (len(env_ids), len(fixed_tendon_ids)).
fixed_tendon_ids¶ – The tendon indices to set the offset for. Defaults to None (all fixed tendons).
env_ids¶ – The environment indices to set the offset for. Defaults to None (all instances).

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

Set fixed tendon offset into internal buffers.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Write fixed tendon properties into the simulation.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

fixed_tendon_ids¶ – The fixed tendon indices to set the limits for. Defaults to None (all fixed tendons).
env_ids¶ – The environment indices to set the limits for. Defaults to None (all instances).

abstractmethod write_fixed_tendon_properties_to_sim_mask(*, fixed_tendon_mask: wp.array | None = None, env_mask: wp.array | None = None) → None[source]#

Write fixed tendon properties into the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Set spatial tendon stiffness into internal buffers.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

stiffness¶ – Spatial tendon stiffness. Shape is (len(env_ids), len(spatial_tendon_ids)).
spatial_tendon_ids¶ – The tendon indices to set the stiffness for. Defaults to None (all spatial tendons).
env_ids¶ – The environment indices to set the stiffness for. Defaults to None (all instances).

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

Set spatial tendon stiffness into internal buffers.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Set spatial tendon damping into internal buffers.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

damping¶ – Spatial tendon damping. Shape is (len(env_ids), len(spatial_tendon_ids)).
spatial_tendon_ids¶ – The tendon indices to set the damping for. Defaults to None (all spatial tendons).
env_ids¶ – The environment indices to set the damping for. Defaults to None (all instances).

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

Set spatial tendon damping into internal buffers.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Set spatial tendon limit stiffness into internal buffers.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

limit_stiffness¶ – Spatial tendon limit stiffness. Shape is (len(env_ids), len(spatial_tendon_ids)).
spatial_tendon_ids¶ – The tendon indices to set the limit stiffness for. Defaults to None (all spatial tendons).
env_ids¶ – The environment indices to set the limit stiffness for. Defaults to None (all instances).

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

Set spatial tendon limit stiffness into internal buffers.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / 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 the spatial tendons are updated. Shape is (num_spatial_tendons,).
env_mask¶ – Environment mask. If None, then all the instances are updated. Shape is (num_instances,).

Set spatial tendon offset into internal buffers.

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

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

offset¶ – Spatial tendon offset. Shape is (len(env_ids), len(spatial_tendon_ids)).
spatial_tendon_ids¶ – The tendon indices to set the offset for. Defaults to None (all spatial tendons).
env_ids¶ – The environment indices to set the offset for. Defaults to None (all instances).

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

Set spatial tendon offset into internal buffers.

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

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

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

Write spatial tendon properties into the simulation.

Note

This method expects partial data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

spatial_tendon_ids¶ – The spatial tendon indices to set the properties for. Defaults to None (all spatial tendons).
env_ids¶ – The environment indices to set the properties for. Defaults to None (all instances).

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

Write spatial tendon properties into the simulation.

Note

This method expects full data.

Tip

For maximum performance we recommend looking at the actual implementation of the method in the backend. Some backends may provide optimized implementations for masks / indices.

Parameters:

spatial_tendon_mask¶ – Spatial tendon mask. If None, then all the spatial tendons are updated. Shape is (num_spatial_tendons,).
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[source]#: 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[source]#: Write joint limits into the simulation.

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

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[source]#: Set fixed tendon position limits into internal buffers.

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

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

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

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

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

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

write_root_com_pose_to_sim(root_pose: torch.Tensor | wp.array, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None[source]#: Deprecated, same as write_root_com_pose_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[source]#: Deprecated, same as write_root_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[source]#: Deprecated, same as write_root_com_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[source]#: Deprecated, same as write_root_link_velocity_to_sim_index().

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

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[source]#: Deprecated, same as write_joint_position_to_sim_index().

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[source]#: Deprecated, same as write_joint_velocity_to_sim_index().

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[source]#: Deprecated, same as write_joint_stiffness_to_sim_index().

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[source]#: Deprecated, same as write_joint_damping_to_sim_index().

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[source]#: Deprecated, same as write_joint_position_limit_to_sim_index().

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[source]#: Deprecated, same as write_joint_velocity_limit_to_sim_index().

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[source]#: Deprecated, same as write_joint_effort_limit_to_sim_index().

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[source]#: Deprecated, same as write_joint_armature_to_sim_index().

write_joint_friction_coefficient_to_sim(joint_friction_coeff: torch.Tensor | float | wp.array, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | torch.Tensor | wp.array | None = None) → None[source]#: Deprecated, same as write_joint_friction_coefficient_to_sim_index().

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[source]#: Deprecated, same as set_masses_index().

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

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

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[source]#: Deprecated. Resets target environments, then adds forces and torques via the permanent wrench composer.

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[source]#: Deprecated, same as set_joint_position_target_index().

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[source]#: Deprecated, same as set_joint_velocity_target_index().

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[source]#: Deprecated, same as set_joint_effort_target_index().

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[source]#: Deprecated, same as set_fixed_tendon_stiffness_index().

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[source]#: Deprecated, same as set_fixed_tendon_damping_index().

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[source]#: Deprecated, same as set_fixed_tendon_limit_stiffness_index().

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[source]#: Deprecated, same as set_fixed_tendon_position_limit_index().

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[source]#: Deprecated, same as set_fixed_tendon_rest_length_index().

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[source]#: Deprecated, same as set_fixed_tendon_offset_index().

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[source]#: Deprecated, same as write_fixed_tendon_properties_to_sim_index().

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.

Controlled by AssetBaseCfg.disable_shape_checks. When checks are disabled this method is a no-op.

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

Controlled by AssetBaseCfg.disable_shape_checks. When checks are disabled this method is a no-op.

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 device: str#: Memory device for computation.

property has_debug_vis_implementation: bool#: Whether the asset has a debug visualization implemented.

property is_initialized: bool#

Whether the asset is initialized.

Returns True if the asset is initialized, False otherwise.

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_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[source]#: Deprecated, same as set_spatial_tendon_stiffness_index().

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

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[source]#: Deprecated, same as set_spatial_tendon_damping_index().

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[source]#: Deprecated, same as set_spatial_tendon_limit_stiffness_index().

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[source]#: Deprecated, same as set_spatial_tendon_offset_index().

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[source]#: Deprecated, same as write_spatial_tendon_properties_to_sim_index().

class isaaclab.assets.ArticulationData[source]#

Bases: FactoryBase

Factory for creating articulation data instances.

Methods:

`__new__`(cls, args, *kwargs)	Create a new instance of an articulation data based on the backend.
`get_registry_keys`()	Returns a list of registered backend names.
`register`(name, sub_class)	Register a new implementation class.
`resolve_class`(args, *kwargs)	Resolve the concrete backend implementation class without instantiating it.

static __new__(cls, *args, **kwargs) → BaseArticulationData | PhysXArticulationData[source]#: Create a new instance of an articulation data based on the backend.

classmethod get_registry_keys() → list[str]#: Returns a list of registered backend names.

classmethod register(name: str, sub_class) → None#: Register a new implementation class.

classmethod resolve_class(*args, **kwargs) → type#

Resolve the concrete backend implementation class without instantiating it.

Selects the backend via _get_backend(), lazily importing and registering the implementation class on first use, and returns it. Takes the same arguments as the constructor (the backend selector reads from them). Useful for querying class-level behavior (e.g. capability classmethods) before a sim/instance exists.

class isaaclab.assets.BaseArticulationData[source]#

Bases: ABC

Data container for an articulation.

This class contains the data for an articulation in the simulation. The data includes the state of the root rigid body, the state of all the bodies in the articulation, and the joint state. The data is stored in the simulation world frame unless otherwise specified.

An articulation is comprised of multiple rigid bodies or links. For a rigid body, there are two frames of reference that are used:

Actor frame: The frame of reference of the rigid body prim. This typically corresponds to the Xform prim with the rigid body schema.
Center of mass frame: The frame of reference of the center of mass of the rigid body.

Depending on the settings, the two frames may not coincide with each other. In the robotics sense, the actor frame can be interpreted as the link frame.

Attributes:

`body_names`	Body names in public API order.
`joint_names`	Joint names in public API order.
`joint_ordering`	Bidirectional map between backend and public joint order.
`body_ordering`	Bidirectional map between backend and public body order.
`fixed_tendon_names`	Fixed tendon names in active backend solver-view order.
`spatial_tendon_names`	Spatial tendon names in active backend solver-view order.
`has_joint_ordering`	Whether a nonidentity joint ordering is active.
`has_body_ordering`	Whether a nonidentity body ordering is active.
`default_root_pose`	Default root pose `[pos, quat]` in the local environment frame.
`default_root_vel`	Default root velocity `[lin_vel, ang_vel]` in the local environment frame.
`default_root_state`	Deprecated, same as `default_root_pose` and `default_root_vel`.
`default_joint_pos`	Default joint positions of all joints.
`default_joint_vel`	Default joint velocities of all joints.
`joint_pos_target`	Joint position targets commanded by the user.
`joint_vel_target`	Joint velocity targets commanded by the user.
`joint_effort_target`	Joint effort targets commanded by the user.
`computed_torque`	Joint torques computed from the actuator model (before clipping).
`applied_torque`	Joint torques applied from the actuator model (after clipping).
`joint_stiffness`	Joint stiffness provided to the simulation.
`joint_damping`	Joint damping provided to the simulation.
`joint_armature`	Joint armature provided to the simulation.
`joint_friction_coeff`	Backend-specific joint friction values provided to the simulation.
`joint_pos_limits`	Joint position limits provided to the simulation.
`joint_vel_limits`	Joint maximum velocity provided to the simulation.
`joint_effort_limits`	Joint maximum effort provided to the simulation.
`soft_joint_pos_limits`	Soft joint positions limits for all joints.
`soft_joint_vel_limits`	Soft joint velocity limits for all joints.
`gear_ratio`	Gear ratio for relating motor torques to applied Joint torques.
`fixed_tendon_stiffness`	Fixed tendon stiffness provided to the simulation.
`fixed_tendon_damping`	Fixed tendon damping provided to the simulation.
`fixed_tendon_limit_stiffness`	Fixed tendon limit stiffness provided to the simulation.
`fixed_tendon_rest_length`	Fixed tendon rest length provided to the simulation.
`fixed_tendon_offset`	Fixed tendon offset provided to the simulation.
`fixed_tendon_pos_limits`	Fixed tendon position limits provided to the simulation.
`spatial_tendon_stiffness`	Spatial tendon stiffness provided to the simulation.
`spatial_tendon_damping`	Spatial tendon damping provided to the simulation.
`spatial_tendon_limit_stiffness`	Spatial tendon limit stiffness provided to the simulation.
`spatial_tendon_offset`	Spatial tendon offset provided to the simulation.
`root_link_pose_w`	Root link pose `[pos, quat]` in simulation world frame.
`root_link_vel_w`	Root link velocity `[lin_vel, ang_vel]` in simulation world frame.
`root_com_pose_w`	Root center of mass pose `[pos, quat]` in simulation world frame.
`root_com_vel_w`	Root center of mass velocity `[lin_vel, ang_vel]` in simulation world frame.
`root_state_w`	Deprecated, same as `root_link_pose_w` and `root_com_vel_w`.
`root_link_state_w`	Deprecated, same as `root_link_pose_w` and `root_link_vel_w`.
`root_com_state_w`	Deprecated, same as `root_com_pose_w` and `root_com_vel_w`.
`body_mass`	Body mass `wp.float32` in the world frame.
`body_inertia`	Flattened body inertia in the world frame.
`body_link_pose_w`	Body link pose `[pos, quat]` in simulation world frame.
`body_link_vel_w`	Body link velocity `[lin_vel, ang_vel]` in simulation world frame.
`body_com_pose_w`	Body center of mass pose `[pos, quat]` in simulation world frame.
`body_com_vel_w`	Body center of mass velocity `[lin_vel, ang_vel]` in simulation world frame.
`body_state_w`	Deprecated, same as `body_link_pose_w` and `body_com_vel_w`.
`body_link_state_w`	Deprecated, same as `body_link_pose_w` and `body_link_vel_w`.
`body_com_state_w`	Deprecated, same as `body_com_pose_w` and `body_com_vel_w`.
`body_com_acc_w`	Acceleration of all bodies center of mass `[lin_acc, ang_acc]`.
`body_com_pose_b`	Center of mass pose `[pos, quat]` of all bodies in their respective body's link frames.
`body_link_jacobian_w`	Per-body geometric Jacobian referenced at each body's link origin in world frame.
`body_com_jacobian_w`	Per-body geometric Jacobian referenced at each body's center of mass in world frame.
`mass_matrix`	Per-env generalized mass matrix `M(q)` in joint space.
`gravity_compensation_forces`	Per-env gravity compensation torques `g(q)` in joint space.
`joint_pos`	Joint positions of all joints.
`joint_vel`	Joint velocities of all joints.
`joint_acc`	Joint acceleration of all joints.
`projected_gravity_b`	Projection of the gravity direction on base frame.
`heading_w`	Yaw heading of the base frame (in radians).
`root_link_lin_vel_b`	Root link linear velocity in base frame.
`root_link_ang_vel_b`	Root link angular velocity in base frame.
`root_com_lin_vel_b`	Root center of mass linear velocity in base frame.
`root_com_ang_vel_b`	Root center of mass angular velocity in base frame.
`root_link_pos_w`	Root link position in simulation world frame.
`root_link_quat_w`	Root link orientation (x, y, z, w) in simulation world frame.
`root_link_lin_vel_w`	Root linear velocity in simulation world frame.
`root_link_ang_vel_w`	Root link angular velocity in simulation world frame.
`root_com_pos_w`	Root center of mass position in simulation world frame.
`root_com_quat_w`	Root center of mass orientation (x, y, z, w) in simulation world frame.
`root_com_lin_vel_w`	Root center of mass linear velocity in simulation world frame.
`root_com_ang_vel_w`	Root center of mass angular velocity in simulation world frame.
`body_link_pos_w`	Positions of all bodies in simulation world frame.
`body_link_quat_w`	Orientation (x, y, z, w) of all bodies in simulation world frame.
`body_link_lin_vel_w`	Linear velocity of all bodies in simulation world frame.
`body_link_ang_vel_w`	Angular velocity of all bodies in simulation world frame.
`body_com_pos_w`	Positions of all bodies in simulation world frame.
`body_com_quat_w`	Orientation (x, y, z, w) of the principal axes of inertia of all bodies in simulation world frame.
`body_com_lin_vel_w`	Linear velocity 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_ang_acc_w`	Angular acceleration 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_quat_b`	Orientation (x, y, z, w) of the principal axes of inertia of all of the bodies in their respective link frames.
`root_pose_w`	Shorthand for `root_link_pose_w`.
`root_pos_w`	Shorthand for `root_link_pos_w`.
`root_quat_w`	Shorthand for `root_link_quat_w`.
`root_vel_w`	Shorthand for `root_com_vel_w`.
`root_lin_vel_w`	Shorthand for `root_com_lin_vel_w`.
`root_ang_vel_w`	Shorthand for `root_com_ang_vel_w`.
`root_lin_vel_b`	Shorthand for `root_com_lin_vel_b`.
`root_ang_vel_b`	Shorthand for `root_com_ang_vel_b`.
`body_pose_w`	Shorthand for `body_link_pose_w`.
`body_pos_w`	Shorthand for `body_link_pos_w`.
`body_quat_w`	Shorthand for `body_link_quat_w`.
`body_vel_w`	Shorthand for `body_com_vel_w`.
`body_lin_vel_w`	Shorthand for `body_com_lin_vel_w`.
`body_ang_vel_w`	Shorthand for `body_com_ang_vel_w`.
`body_acc_w`	Shorthand for `body_com_acc_w`.
`body_lin_acc_w`	Shorthand for `body_com_lin_acc_w`.
`body_ang_acc_w`	Shorthand for `body_com_ang_acc_w`.
`com_pos_b`	Shorthand for `body_com_pos_b`.
`com_quat_b`	Shorthand for `body_com_quat_b`.
`joint_limits`	Shorthand for `joint_pos_limits`.
`default_joint_limits`	Shorthand for `default_joint_pos_limits`.
`joint_velocity_limits`	Shorthand for `joint_vel_limits`.
`joint_friction`	Shorthand for `joint_friction_coeff`.
`fixed_tendon_limit`	Shorthand for `fixed_tendon_pos_limits`.
`default_mass`	Deprecated property.
`default_inertia`	Deprecated property.
`default_joint_stiffness`	Deprecated property.
`default_joint_damping`	Deprecated property.
`default_joint_armature`	Deprecated property.
`default_joint_friction_coeff`	Deprecated property.
`default_joint_viscous_friction_coeff`	Deprecated property.
`default_joint_pos_limits`	Deprecated property.
`default_fixed_tendon_stiffness`	Deprecated property.
`default_fixed_tendon_damping`	Deprecated property.
`default_fixed_tendon_limit_stiffness`	Deprecated property.
`default_fixed_tendon_rest_length`	Deprecated property.
`default_fixed_tendon_offset`	Deprecated property.
`default_fixed_tendon_pos_limits`	Deprecated property.
`default_spatial_tendon_stiffness`	Deprecated property.
`default_spatial_tendon_damping`	Deprecated property.
`default_spatial_tendon_limit_stiffness`	Deprecated property.
`default_spatial_tendon_offset`	Deprecated property.
`default_fixed_tendon_limit`	Deprecated property.
`default_joint_friction`	Deprecated property.

body_names: list[str] | None = None#

Body names in public API order.

Configured order is used when present; otherwise this is active backend solver-view order.

joint_names: list[str] | None = None#

Joint names in public API order.

Configured order is used when present; otherwise this is active backend solver-view order.

joint_ordering: ArticulationNameMap | None = None#

Bidirectional map between backend and public joint order.

This is None whenever public and backend orders coincide (default ordering, or a configured ordering that resolved to backend order); a non-None map always denotes an actual permutation.

body_ordering: ArticulationNameMap | None = None#

Bidirectional map between backend and public body order.

This is None whenever public and backend orders coincide (default ordering, or a configured ordering that resolved to backend order); a non-None map always denotes an actual permutation.

fixed_tendon_names: list[str] | None = None#: Fixed tendon names in active backend solver-view order.

spatial_tendon_names: list[str] | None = None#: Spatial tendon names in active backend solver-view order.

property has_joint_ordering: bool#

Whether a nonidentity joint ordering is active.

Derived from joint_ordering; a non-None map always denotes an actual permutation between backend and public joint order.

property has_body_ordering: bool#

Whether a nonidentity body ordering is active.

Derived from body_ordering; a non-None map always denotes an actual permutation between backend and public body order.

abstract property default_root_pose: ProxyArray#

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

abstract property default_root_vel: ProxyArray#

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

abstract property default_root_state: ProxyArray#: Deprecated, same as default_root_pose and default_root_vel.

abstract property default_joint_pos: ProxyArray#

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.

abstract property default_joint_vel: ProxyArray#

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.

abstract property joint_pos_target: ProxyArray#

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.

abstract property joint_vel_target: ProxyArray#

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.

abstract property joint_effort_target: ProxyArray#

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.

abstract property computed_torque: ProxyArray#

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.

abstract property applied_torque: ProxyArray#

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.

abstract property joint_stiffness: ProxyArray#

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.

abstract property joint_damping: ProxyArray#

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.

abstract property joint_armature: ProxyArray#

Joint armature provided to the simulation.

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

abstract property joint_friction_coeff: ProxyArray#

Backend-specific joint friction values provided to the simulation.

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

Warning

The physical meaning and units of this value depend on the concrete backend and solver. Do not assume values are comparable across backends; check the backend-specific ArticulationData implementation before interpreting or reusing them.

abstract property joint_pos_limits: ProxyArray#

Joint position limits provided to the simulation.

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

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

abstract property joint_vel_limits: ProxyArray#

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

abstract property joint_effort_limits: ProxyArray#

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

abstract property soft_joint_pos_limits: ProxyArray#

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.

abstract property soft_joint_vel_limits: ProxyArray#

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.

abstract property gear_ratio: ProxyArray#

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

abstract property fixed_tendon_stiffness: ProxyArray#

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

abstract property fixed_tendon_damping: ProxyArray#

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

abstract property fixed_tendon_limit_stiffness: ProxyArray#

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

abstract property fixed_tendon_rest_length: ProxyArray#

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

abstract property fixed_tendon_offset: ProxyArray#

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

abstract property fixed_tendon_pos_limits: ProxyArray#

Fixed tendon position limits provided to the simulation.

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

abstract property spatial_tendon_stiffness: ProxyArray#

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

abstract property spatial_tendon_damping: ProxyArray#

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

abstract property spatial_tendon_limit_stiffness: ProxyArray#

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

abstract property spatial_tendon_offset: ProxyArray#

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

abstract property root_link_pose_w: ProxyArray#

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.

abstract property root_link_vel_w: ProxyArray#

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.

abstract property root_com_pose_w: ProxyArray#

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.

abstract property root_com_vel_w: ProxyArray#

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.

abstract property root_state_w: ProxyArray#: Deprecated, same as root_link_pose_w and root_com_vel_w.

abstract property root_link_state_w: ProxyArray#: Deprecated, same as root_link_pose_w and root_link_vel_w.

abstract property root_com_state_w: ProxyArray#: Deprecated, same as root_com_pose_w and root_com_vel_w.

abstract property body_mass: ProxyArray#

Body mass wp.float32 in the world frame.

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

abstract property body_inertia: ProxyArray#

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

abstract property body_link_pose_w: ProxyArray#

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.

abstract property body_link_vel_w: ProxyArray#

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.

abstract property body_com_pose_w: ProxyArray#

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.

abstract property body_com_vel_w: ProxyArray#

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.

abstract property body_state_w: ProxyArray#: Deprecated, same as body_link_pose_w and body_com_vel_w.

abstract property body_link_state_w: ProxyArray#: Deprecated, same as body_link_pose_w and body_link_vel_w.

abstract property body_com_state_w: ProxyArray#: Deprecated, same as body_com_pose_w and body_com_vel_w.

abstract property body_com_acc_w: ProxyArray#

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.

abstract property body_com_pose_b: ProxyArray#

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_link_jacobian_w: ProxyArray#

Per-body geometric Jacobian referenced at each body’s link origin in world frame.

Shape: (num_instances, num_jacobi_bodies, 6, num_joints + num_base_dofs), dtype wp.float32. Linear rows [0:3] [m/s per unit DoF velocity]; angular rows [3:6] [rad/s per unit DoF velocity].

Contract: for any generalized velocity v of length num_joints + num_base_dofs,

J[:, jacobi_body_idx, 0:3, :] @ v == body_link_lin_vel_w[:, body_idx]
J[:, jacobi_body_idx, 3:6, :] @ v == body_link_ang_vel_w[:, body_idx]

Conventions:

Body axis: jacobi_body_idx == body_idx - 1 for fixed-base (fixed-root row excluded); jacobi_body_idx == body_idx for floating-base. With custom body ordering, fixed-base Jacobian rows follow user body order with the fixed root omitted.
DoF axis: leading num_base_dofs floating-base columns (world-frame [lin_x, lin_y, lin_z, ang_x, ang_y, ang_z]), then actuated-joint columns in joint_names order.

property body_com_jacobian_w: ProxyArray#

Per-body geometric Jacobian referenced at each body’s center of mass in world frame.

Same shape and indexing conventions as body_link_jacobian_w. Linear rows [0:3] give the velocity at the body’s center of mass; angular rows [3:6] are reference-point invariant (identical to body_link_jacobian_w).

Contract: for any generalized velocity v,

J[:, jacobi_body_idx, 0:3, :] @ v == body_com_lin_vel_w[:, body_idx]
J[:, jacobi_body_idx, 3:6, :] @ v == body_com_ang_vel_w[:, body_idx]

property mass_matrix: ProxyArray#

Per-env generalized mass matrix M(q) in joint space.

Shape: (num_instances, num_joints + num_base_dofs, num_joints + num_base_dofs), dtype wp.float32 [kg·m² or kg, per DoF type]. DoF-axis convention matches body_link_jacobian_w.

M(q) is symmetric positive-definite. M[i, j] is the coefficient relating DoF j’s acceleration to the inertial torque on DoF i in M(q) q_ddot + C(q, q_dot) q_dot + g(q) = tau.

property gravity_compensation_forces: ProxyArray#

Per-env gravity compensation torques g(q) in joint space.

Shape: (num_instances, num_joints + num_base_dofs), dtype wp.float32 [N·m or N, per DoF type]. DoF-axis convention matches body_link_jacobian_w.

g(q) is the gravity-loading term in M(q) q_ddot + C(q, q_dot) q_dot + g(q) = tau. Applying tau = g(q) at q_dot = 0 with no external load yields q_ddot = 0 (static equilibrium under gravity).

abstract property joint_pos: ProxyArray#

Joint positions of all joints.

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

abstract property joint_vel: ProxyArray#

Joint velocities of all joints.

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

abstract property joint_acc: ProxyArray#

Joint acceleration of all joints.

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

abstract property projected_gravity_b: ProxyArray#

Projection of the gravity direction on base frame.

Shape is (num_instances), dtype = wp.vec3f. In torch this resolves to (num_instances, 3).

abstract property heading_w: ProxyArray#

Yaw heading of the base frame (in radians).

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

Note

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

abstract property root_link_lin_vel_b: ProxyArray#

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.

abstract property root_link_ang_vel_b: ProxyArray#

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.

abstract property root_com_lin_vel_b: ProxyArray#

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.

abstract property root_com_ang_vel_b: ProxyArray#

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.

abstract property root_link_pos_w: ProxyArray#

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.

abstract property root_link_quat_w: ProxyArray#

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.

abstract property root_link_lin_vel_w: ProxyArray#

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.

abstract property root_link_ang_vel_w: ProxyArray#

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.

abstract property root_com_pos_w: ProxyArray#

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.

abstract property root_com_quat_w: ProxyArray#

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.

abstract property root_com_lin_vel_w: ProxyArray#

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.

abstract property root_com_ang_vel_w: ProxyArray#

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.

abstract property body_link_pos_w: ProxyArray#

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.

abstract property body_link_quat_w: ProxyArray#

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.

abstract property body_link_lin_vel_w: ProxyArray#

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.

abstract property body_link_ang_vel_w: ProxyArray#

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.

abstract property body_com_pos_w: ProxyArray#

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’ center of mass frame.

abstract property body_com_quat_w: ProxyArray#

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 principal axes of inertia of the articulation bodies.

abstract property body_com_lin_vel_w: ProxyArray#

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.

abstract property body_com_ang_vel_w: ProxyArray#

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.

abstract property body_com_lin_acc_w: ProxyArray#

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.

abstract property body_com_ang_acc_w: ProxyArray#

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.

abstract property body_com_pos_b: ProxyArray#

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.

abstract property body_com_quat_b: ProxyArray#

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 root_pose_w: ProxyArray#: Shorthand for root_link_pose_w.

property root_pos_w: ProxyArray#: Shorthand for root_link_pos_w.

property root_quat_w: ProxyArray#: Shorthand for root_link_quat_w.

property root_vel_w: ProxyArray#: Shorthand for root_com_vel_w.

property root_lin_vel_w: ProxyArray#: Shorthand for root_com_lin_vel_w.

property root_ang_vel_w: ProxyArray#: Shorthand for root_com_ang_vel_w.

property root_lin_vel_b: ProxyArray#: Shorthand for root_com_lin_vel_b.

property root_ang_vel_b: ProxyArray#: Shorthand for root_com_ang_vel_b.

property body_pose_w: ProxyArray#: Shorthand for body_link_pose_w.

property body_pos_w: ProxyArray#: Shorthand for body_link_pos_w.

property body_quat_w: ProxyArray#: Shorthand for body_link_quat_w.

property body_vel_w: ProxyArray#: Shorthand for body_com_vel_w.

property body_lin_vel_w: ProxyArray#: Shorthand for body_com_lin_vel_w.

property body_ang_vel_w: ProxyArray#: Shorthand for body_com_ang_vel_w.

property body_acc_w: ProxyArray#: Shorthand for body_com_acc_w.

property body_lin_acc_w: ProxyArray#: Shorthand for body_com_lin_acc_w.

property body_ang_acc_w: ProxyArray#: Shorthand for body_com_ang_acc_w.

property com_pos_b: ProxyArray#: Shorthand for body_com_pos_b.

property com_quat_b: ProxyArray#: Shorthand for body_com_quat_b.

property joint_limits: ProxyArray#: Shorthand for joint_pos_limits.

property default_joint_limits: ProxyArray#: Shorthand for default_joint_pos_limits.

property joint_velocity_limits: ProxyArray#: Shorthand for joint_vel_limits.

property joint_friction: ProxyArray#: Shorthand for joint_friction_coeff.

property fixed_tendon_limit: ProxyArray#: Shorthand for fixed_tendon_pos_limits.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

property default_fixed_tendon_limit: ProxyArray#: Deprecated property. Please use default_fixed_tendon_pos_limits instead.

property default_joint_friction: ProxyArray#: Deprecated property. Please use default_joint_friction_coeff instead.

class isaaclab.assets.ArticulationCfg[source]#

Bases: AssetBaseCfg

Configuration parameters for an articulation.

Classes:

InitialStateCfg

Initial state of the articulation.

Attributes:

`articulation_root_prim_path`	Path to the articulation root prim under the `prim_path`.
`init_state`	Initial state of the articulated object.
`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.
`disable_shape_checks`	Disable shape/dtype validation in setter and writer methods.
`soft_joint_pos_limit_factor`	Fraction specifying the range of joint position limits (parsed from the asset) to use.
`joint_ordering`	Public joint-name ordering convention or complete explicit permutation.
`body_ordering`	Public body-name ordering convention or complete explicit permutation.
`actuators`	Actuators for the robot with corresponding joint names.
`actuator_value_resolution_debug_print`	Print the resolution of actuator final value when input cfg is different from USD value, Defaults to False

class InitialStateCfg[source]#

Bases: InitialStateCfg

Initial state of the articulation.

Attributes:

`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.
`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: tuple[float, float, float]#: Linear velocity of the root in simulation world frame. Defaults to (0.0, 0.0, 0.0).

ang_vel: tuple[float, float, float]#: Angular velocity of the root in simulation world frame. Defaults to (0.0, 0.0, 0.0).

joint_pos: dict[str, float]#: Joint positions of the joints. Defaults to 0.0 for all joints.

joint_vel: dict[str, float]#: Joint velocities of the joints. Defaults to 0.0 for all joints.

pos: tuple[float, float, float]#: Position of the root in simulation world frame. Defaults to (0.0, 0.0, 0.0).

rot: tuple[float, float, float, float]#: Quaternion rotation (x, y, z, w) of the root in simulation world frame. Defaults to (0.0, 0.0, 0.0, 1.0).

articulation_root_prim_path: str | None#

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

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

The path must start with a slash (/).

init_state: InitialStateCfg#: Initial state of the articulated object. Defaults to identity pose with zero velocity and zero joint state.

prim_path: str#: Prim path (or expression) to the asset.

Note

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

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

spawn: SpawnerCfg | None#

Spawn configuration for the asset. Defaults to None.

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

collision_group: Literal[0, -1]#

Collision group of the asset. Defaults to 0.

-1: global collision group (collides with all assets in the scene).
0: local collision group (collides with other assets in the same environment).

debug_vis: bool#: Whether to enable debug visualization for the asset. Defaults to False.

disable_shape_checks: bool | None#

Disable shape/dtype validation in setter and writer methods.

When True, assert_shape_and_dtype() and assert_shape_and_dtype_mask() become no-ops, eliminating per-call assertion overhead.

When False, shape checks are always enabled, even under python -O.

When None (the default), shape checks follow Python’s __debug__ flag — enabled in normal mode, disabled with python -O.

soft_joint_pos_limit_factor: float#

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

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

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

joint_ordering: list[str] | tuple[str, ...] | str | ArticulationOrderingConvention | None#

Public joint-name ordering convention or complete explicit permutation.

Accepts "physx", "mjwarp", and "robot_schema" aliases, the corresponding ArticulationOrderingConvention members, or a list or tuple (normalized to a tuple at initialization) containing every backend joint name exactly once.

None is the default: public joint order follows active backend solver-view order and no ordering map is installed. An order that resolves to backend order is normalized to None as well, so an installed map always denotes an actual permutation. Symbolic resolution and map construction occur during articulation initialization only, not each step.

body_ordering: list[str] | tuple[str, ...] | str | ArticulationOrderingConvention | None#

Public body-name ordering convention or complete explicit permutation.

Accepts "physx", "mjwarp", and "robot_schema" aliases, the corresponding ArticulationOrderingConvention members, or a list or tuple (normalized to a tuple at initialization) containing every backend body name exactly once.

None is the default: public body order follows active backend solver-view order and no ordering map is installed. An order that resolves to backend order is normalized to None as well, so an installed map always denotes an actual permutation. Symbolic resolution and map construction occur during articulation initialization only, not each step.

For fixed-base articulations, the backend root body must remain at public index zero; all remaining bodies may be permuted. Floating-base orders may relocate the root body.

actuators: dict[str, ActuatorBaseCfg]#: Actuators for the robot with corresponding joint names.

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

Articulation Ordering#

class isaaclab.assets.ArticulationOrderingConvention[source]#

Built-in non-default public articulation name-ordering conventions.

PHYSX#: Active PhysX or OVPhysX tensor-view order.

MJWARP#: Newton or MJWarp articulation-view order.

ROBOT_SCHEMA#: Authored target order of the isaac:physics:robotJoints and isaac:physics:robotLinks relationships.

None selects the active backend order by default and is not a member of this enum.

Methods:

__new__(value)

__new__(value)#

class isaaclab.assets.ArticulationNameMap[source]#

Frozen permutation between backend and public articulation order.

user in the field names means the order exposed by the public API. user_to_backend maps a public index to its backend index, while backend_to_user maps a backend index to its public index. The CPU tuples and device arrays are complete inverse permutations of the same length; both device maps are one-dimensional wp.int32 arrays on the articulation’s device. The frozen dataclass prevents field reassignment, but the Warp arrays remain mutable objects and callers must treat both device maps as read-only.

Instances are built by the owning articulation during initialization via build_articulation_name_map(); the class is not intended for direct construction. Identity orderings are represented as None rather than a map — the joint_ordering and body_ordering properties are None whenever public and backend orders coincide, so a non-None map always denotes an actual permutation.

Attributes:

`user_to_backend_indices`	One-dimensional CPU map from public index to backend index.
`backend_to_user_indices`	One-dimensional CPU map from backend index to public index.
`user_to_backend`	Read-only public-to-backend device map, shape `(num_names,)`, dtype `wp.int32`.
`backend_to_user`	Read-only backend-to-public device map, shape `(num_names,)`, dtype `wp.int32`.

Methods:

__init__(user_to_backend_indices, ...)

user_to_backend_indices: tuple[int, ...]#: One-dimensional CPU map from public index to backend index.

backend_to_user_indices: tuple[int, ...]#: One-dimensional CPU map from backend index to public index.

user_to_backend: warp.array#: Read-only public-to-backend device map, shape (num_names,), dtype wp.int32.

__init__(user_to_backend_indices: tuple[int, ...], backend_to_user_indices: tuple[int, ...], user_to_backend: warp.array, backend_to_user: warp.array) → None#

backend_to_user: warp.array#: Read-only backend-to-public device map, shape (num_names,), dtype wp.int32.

isaaclab.assets.apply_articulation_ordering_preset(cfg: ArticulationCfg, ordering: str | ArticulationOrderingConvention | None) → ArticulationCfg[source]#

Apply one public ordering preset to both joints and bodies.

Parameters:

cfg¶ – Articulation configuration to copy when a preset is requested.
ordering¶ – Convention alias, ArticulationOrderingConvention member, or None.

Returns:

A copy of cfg whose ArticulationCfg.joint_ordering and ArticulationCfg.body_ordering use the parsed convention. When ordering is None, returns the original cfg object unchanged.

Raises:

TypeError – If ordering is not a supported type.
ValueError – If ordering is an unsupported string alias.

isaaclab.assets.parse_articulation_ordering_convention(ordering: str | ArticulationOrderingConvention | None) → ArticulationOrderingConvention | None[source]#

Parse a symbolic public articulation ordering convention.

Accepted aliases are "physx", "mjwarp", and "robot_schema". String aliases are matched case-insensitively. None keeps the active backend’s default order and is not an enum member.

Parameters:

ordering¶ – Convention alias, ArticulationOrderingConvention member, or None.

Returns:

The matching ArticulationOrderingConvention member, or None when no non-default convention is requested.

Raises:

TypeError – If ordering is not a supported type.
ValueError – If ordering is an unsupported string alias.

isaaclab.assets.get_articulation_name_ordering(articulation: BaseArticulation, convention: str | ArticulationOrderingConvention, kind: Literal['joint', 'body']) → tuple[str, ...][source]#

Return articulation names in the order defined by a naming convention.

The supported conventions are:

"physx" – PhysX or OVPhysX articulation-view order. PhysX and OVPhysX articulations return active-backend names without discovery; other backends discover the order from a temporary Newton USD view using breadth-first joint ordering.
"mjwarp" – Newton or MJWarp articulation-view order. Newton articulations return active-backend names without discovery; other backends discover the order from a temporary Newton USD view using depth-first joint ordering.
"robot_schema" – authored robot-schema order. The source asset prim or configured articulation-root prim must author isaac:physics:robotJoints for joints or isaac:physics:robotLinks for bodies. Nested robot targets are expanded, name overrides are honored, unresolvable targets are logged and skipped, and the remaining names must be a complete unique permutation of active-backend names.

Cross-backend discovery through the temporary Newton USD view requires a source USD readable by the optional Newton and PXR dependencies, and a complete joint-and-body result is cached per articulation.

The result defines the public axis only; backend views remain in native order.

Parameters:

articulation¶ – Articulation whose names are resolved.
convention¶ – Convention alias ("physx", "mjwarp", or "robot_schema", matched case-insensitively) or ArticulationOrderingConvention member.
kind¶ – Element kind, either joint or body.

Returns:

Names in the requested convention’s order.

Raises:

TypeError – If backend or discovered names are malformed.
ValueError – If kind or convention is invalid, the builder or USD resolution rejects the source metadata, or an authored robot-schema relationship targets the same prim more than once.
NotImplementedError – If the source USD, builder dependencies, authored relationships, or a complete name permutation is unavailable. The message identifies the corresponding configuration field, the explicit-name fallback, and a short reason resolution did not produce a complete ordering.

isaaclab.assets

Contents

isaaclab.assets#

Asset Base#

Rigid Object#

Rigid Object Collection#

Deformable Object#

Articulation#

Articulation Ordering#