isaaclab_contrib.assets

isaaclab_contrib.assets#

Sub-package for different Isaac Lab external contributions.

Classes

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

Multirotor Asset#

class isaaclab_contrib.assets.Multirotor[source]#

Bases: Articulation

A multirotor articulation asset class.

This class extends the base articulation class to support multirotor vehicles with thruster actuators that can be applied at specific body locations.

Attributes:

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

Methods:

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

cfg: MultirotorCfg#: Configuration instance for the multirotor.

actuators: dict[str, Thruster]#

Dictionary of thruster actuator instances for the multirotor.

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

__init__(cfg: MultirotorCfg)[source]#

Initialize the multirotor articulation.

Parameters:: cfg – A configuration instance.

property thruster_names: list[str]#: Ordered names of thrusters in the multirotor.

property num_thrusters: int#: Number of thrusters in the multirotor.

property allocation_matrix: torch.Tensor#: Allocation matrix for control allocation.

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

Set target thrust values for thrusters.

Parameters:

target – Target thrust values. Shape is (num_envs, num_thrusters) or (num_envs,).
thruster_ids – Indices of thrusters to set. Defaults to None (all thrusters).
env_ids – Environment indices to set. Defaults to None (all environments).

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

Reset the multirotor to default state.

Parameters:: env_ids – Environment indices to reset. Defaults to None (all environments).

write_data_to_sim()[source]#: Write thrust and torque commands to the simulation.

property body_names: list[str]#: Ordered names of bodies in articulation.

property data: ArticulationData#: Data related to the asset.

property device: str#: Memory device for computation.

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

Find bodies in the articulation based on the name keys.

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

Parameters:

name_keys – A regular expression or a list of regular expressions to match the body names.
preserve_order – Whether to preserve the order of the name keys in the output. Defaults to False.

Returns:

A tuple of lists containing the body indices and names.

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

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

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

Parameters:

name_keys – A regular expression or a list of regular expressions to match the joint names with fixed tendons.
tendon_subsets – A subset of joints with fixed tendons to search for. Defaults to None, which means all joints in the articulation are searched.
preserve_order – Whether to preserve the order of the name keys in the output. Defaults to False.

Returns:

A tuple of lists containing the tendon indices and names.

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

Find joints in the articulation based on the name keys.

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

Parameters:

name_keys – A regular expression or a list of regular expressions to match the joint names.
joint_subset – A subset of joints to search for. Defaults to None, which means all joints in the articulation are searched.
preserve_order – Whether to preserve the order of the name keys in the output. Defaults to False.

Returns:

A tuple of lists containing the joint indices and names.

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

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

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

Parameters:

name_keys – A regular expression or a list of regular expressions to match the tendon names.
tendon_subsets – A subset of tendons to search for. Defaults to None, which means all tendons in the articulation are searched.
preserve_order – Whether to preserve the order of the name keys in the output. Defaults to False.

Returns:

A tuple of lists containing the tendon indices and names.

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

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

property instantaneous_wrench_composer: WrenchComposer#

Instantaneous wrench composer.

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

Note

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

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

property is_initialized: bool#

Whether the asset is initialized.

Returns True if the asset is initialized, False otherwise.

property joint_names: list[str]#: Ordered names of joints in articulation.

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

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

property num_instances: int#

Number of instances of the asset.

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

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

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

property permanent_wrench_composer: WrenchComposer#

Permanent wrench composer.

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

Note

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

property root_physx_view: omni.physics.tensors.impl.api.ArticulationView#: Articulation view for the asset (PhysX).

Note

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

set_debug_vis(debug_vis: bool) → bool#

Sets whether to visualize the asset data.

Parameters:: debug_vis – Whether to visualize the asset data.
Returns:: Whether the debug visualization was successfully set. False if the asset does not support debug visualization.

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

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

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

Caution

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

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

Note

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

Parameters:

forces – External forces in bodies’ local frame. Shape is (len(env_ids), len(body_ids), 3).
torques – External torques in bodies’ local frame. Shape is (len(env_ids), len(body_ids), 3).
positions – Positions to apply external wrench. Shape is (len(env_ids), len(body_ids), 3). Defaults to None.
body_ids – Body indices to apply external wrench to. Defaults to None (all bodies).
env_ids – Environment indices to apply external wrench to. Defaults to None (all instances).
is_global – Whether to apply the external wrench in the global frame. Defaults to False. If set to False, the external wrench is applied in the link frame of the articulations’ bodies.

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

Set fixed tendon damping into internal buffers.

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

Parameters:

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

set_fixed_tendon_limit(limit: torch.Tensor, fixed_tendon_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)#: Set fixed tendon position limits into internal buffers.

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

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

Set fixed tendon limit stiffness efforts into internal buffers.

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

Parameters:

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

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

Set fixed tendon offset efforts into internal buffers.

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

Parameters:

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

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

Set fixed tendon limit efforts into internal buffers.

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

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

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

Set fixed tendon rest length efforts into internal buffers.

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

Parameters:

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

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

Set fixed tendon stiffness into internal buffers.

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

Parameters:

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

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

Set joint efforts into internal buffers.

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

Parameters:

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

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

Set joint position targets into internal buffers.

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

Parameters:

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

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

Set joint velocity targets into internal buffers.

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

Parameters:

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

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

Set spatial tendon damping into internal buffers.

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

Parameters:

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

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

Set spatial tendon limit stiffness into internal buffers.

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

Parameters:

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

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

Set spatial tendon offset efforts into internal buffers.

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

Parameters:

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

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

Set spatial tendon stiffness into internal buffers.

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

Parameters:

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

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

Set the visibility of the prims corresponding to the asset.

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

Note

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

Parameters:

visible – Whether to make the prims visible or not.
env_ids – The indices of the object to set visibility. Defaults to None (all instances).

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

update(dt: float)#

Update the internal buffers.

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

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

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

Write fixed tendon properties into the simulation.

Parameters:

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

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

Write joint armature into the simulation.

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

Parameters:

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

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

Write joint damping into the simulation.

Parameters:

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

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

Write joint effort limits into the simulation.

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

Parameters:

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

Write joint friction coefficients into the simulation.

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

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

Static friction \(\mu_s\) defines the maximum effort that prevents motion at rest.
Dynamic friction \(\mu_d\) applies once motion begins and remains constant during motion.
Viscous friction \(c_v\) is a velocity-proportional resistive term.

Parameters:

joint_friction_coeff – Static friction coefficient \(\mu_s\). Shape is (len(env_ids), len(joint_ids)). Scalars are broadcast to all selections.
joint_dynamic_friction_coeff – Dynamic (Coulomb) friction coefficient \(\mu_d\). Same shape as above. If None, the dynamic coefficient is not updated.
joint_viscous_friction_coeff – Viscous friction coefficient \(c_v\). Same shape as above. If None, the viscous coefficient is not updated.
joint_ids – The joint indices to set the friction coefficients for. Defaults to None (all joints).
env_ids – The environment indices to set the friction coefficients for. Defaults to None (all environments).

write_joint_friction_to_sim(joint_friction: torch.Tensor | float, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None)#: Write joint friction coefficients into the simulation.

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

write_joint_limits_to_sim(limits: torch.Tensor | float, joint_ids: Sequence[int] | slice | None = None, env_ids: Sequence[int] | None = None, warn_limit_violation: bool = True)#: Write joint limits into the simulation.

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

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

Write joint position limits into the simulation.

Parameters:

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

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

Write joint positions to the simulation.

Parameters:

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

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

Write joint positions and velocities to the simulation.

Parameters:

position – Joint positions. Shape is (len(env_ids), len(joint_ids)).
velocity – Joint velocities. Shape is (len(env_ids), len(joint_ids)).
joint_ids – The joint indices to set the targets for. Defaults to None (all joints).
env_ids – The environment indices to set the targets for. Defaults to None (all environments).

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

Write joint stiffness into the simulation.

Parameters:

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

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

Write joint max velocity to the simulation.

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

Parameters:

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

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

Write joint velocities to the simulation.

Parameters:

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

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

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

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

Parameters:

root_pose – Root center of mass poses in simulation frame. Shape is (len(env_ids), 7).
env_ids – Environment indices. If None, then all indices are used.

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

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

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

Parameters:

root_state – Root state in simulation frame. Shape is (len(env_ids), 13).
env_ids – Environment indices. If None, then all indices are used.

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

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

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

Parameters:

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

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

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

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

Parameters:

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

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

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

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

Parameters:

root_state – Root state in simulation frame. Shape is (len(env_ids), 13).
env_ids – Environment indices. If None, then all indices are used.

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

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

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

Parameters:

root_velocity – Root frame velocities in simulation world frame. Shape is (len(env_ids), 6).
env_ids – Environment indices. If None, then all indices are used.

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

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

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

Parameters:

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

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

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

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

Parameters:

root_state – Root state in simulation frame. Shape is (len(env_ids), 13).
env_ids – Environment indices. If None, then all indices are used.

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

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

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

Parameters:

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

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

Write spatial tendon properties into the simulation.

Parameters:

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

class isaaclab_contrib.assets.MultirotorCfg[source]#

Bases: ArticulationCfg

Configuration parameters for a multirotor articulation.

This extends the base articulation configuration to support multirotor-specific settings.

Classes:

InitialStateCfg

Initial state of the multirotor articulation.

Attributes:

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

class InitialStateCfg[source]#

Bases: InitialStateCfg

Initial state of the multirotor articulation.

Attributes:

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

rps: dict[str, float]#: Revolutions per second in [1/s] of the thrusters. Defaults to 100.0 for all thrusters.

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

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

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

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

joint_pos: dict[str, float]#: Joint positions of the joints. Defaults to 0.0 for all joints.

joint_vel: dict[str, float]#: Joint velocities of the joints. Defaults to 0.0 for all joints.

init_state: InitialStateCfg#: Initial state of the multirotor object.

actuators: dict[str, isaaclab_contrib.actuators.thruster_cfg.ThrusterCfg]#: Thruster actuators for the multirotor with corresponding thruster names.

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

Note

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

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

spawn: SpawnerCfg | None#

Spawn configuration for the asset. Defaults to None.

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

collision_group: Literal[0, -1]#

Collision group of the asset. Defaults to 0.

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

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

articulation_root_prim_path: str | None#

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

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

The path must start with a slash (/).

soft_joint_pos_limit_factor: float#

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

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

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

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

thruster_force_direction: tuple[float, float, float]#: Default force direction in body-local frame for thrusters. Defaults to Z-axis (upward).

allocation_matrix: Sequence[Sequence[float]] | None#: allocation matrix for control allocation

rotor_directions: Sequence[int] | None#: Sequence of rotor directions, -1 for clockwise, 1 for counter-clockwise.

class isaaclab_contrib.assets.MultirotorData[source]#

Bases: ArticulationData

Data container for a multirotor articulation.

This class extends the base articulation data container to include multirotor-specific data such as thruster states and forces.

Attributes:

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

Methods:

__init__(root_physx_view, device)

Initializes the articulation data.

thruster_names: list[str] = None#: List of thruster names in the multirotor.

default_thruster_rps: torch.Tensor = None#

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

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

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

Initializes the articulation data.

Parameters:

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

applied_torque: torch.Tensor = None#

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

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

property body_acc_w: torch.Tensor#: Same as body_com_acc_w.

property body_ang_acc_w: torch.Tensor#: Same as body_com_ang_acc_w.

property body_ang_vel_w: torch.Tensor#: Same as body_com_ang_vel_w.

property body_com_acc_w#

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

All values are relative to the world.

property body_com_ang_acc_w: torch.Tensor#

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

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

property body_com_ang_vel_w: torch.Tensor#

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

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

property body_com_lin_acc_w: torch.Tensor#

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

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

property body_com_lin_vel_w: torch.Tensor#

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

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

property body_com_pos_b: torch.Tensor#

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

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

property body_com_pos_w: torch.Tensor#

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

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

property body_com_pose_b: torch.Tensor#

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

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

property body_com_pose_w: torch.Tensor#

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

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

property body_com_quat_b: torch.Tensor#

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

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

property body_com_quat_w: torch.Tensor#

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

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

property body_com_state_w#

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

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

property body_com_vel_w: torch.Tensor#

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

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

property body_incoming_joint_wrench_b: torch.Tensor#

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

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

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

property body_lin_acc_w: torch.Tensor#: Same as body_com_lin_acc_w.

property body_lin_vel_w: torch.Tensor#: Same as body_com_lin_vel_w.

property body_link_ang_vel_w: torch.Tensor#

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

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

property body_link_lin_vel_w: torch.Tensor#

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

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

property body_link_pos_w: torch.Tensor#

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

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

property body_link_pose_w: torch.Tensor#

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

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

property body_link_quat_w: torch.Tensor#

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

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

property body_link_state_w#

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

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

property body_link_vel_w: torch.Tensor#

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

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

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

property body_pos_w: torch.Tensor#: Same as body_link_pos_w.

property body_pose_w: torch.Tensor#: Same as body_link_pose_w.

property body_quat_w: torch.Tensor#: Same as body_link_quat_w.

property body_state_w#

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

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

property body_vel_w: torch.Tensor#: Same as body_com_vel_w.

property com_pos_b: torch.Tensor#: Same as body_com_pos_b.

property com_quat_b: torch.Tensor#: Same as body_com_quat_b.

computed_torque: torch.Tensor = None#

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

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

default_fixed_tendon_damping: torch.Tensor = None#

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

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

property default_fixed_tendon_limit: torch.Tensor#: Deprecated property. Please use default_fixed_tendon_pos_limits instead.

default_fixed_tendon_limit_stiffness: torch.Tensor = None#

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

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

default_fixed_tendon_offset: torch.Tensor = None#

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

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

default_fixed_tendon_pos_limits: torch.Tensor = None#

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

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

default_fixed_tendon_rest_length: torch.Tensor = None#

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

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

default_fixed_tendon_stiffness: torch.Tensor = None#

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

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

default_inertia: torch.Tensor = None#

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

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

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

default_joint_armature: torch.Tensor = None#

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

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

default_joint_damping: torch.Tensor = None#

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

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

Attention

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

default_joint_dynamic_friction_coeff: torch.Tensor = None#

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

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

Note

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

property default_joint_friction: torch.Tensor#: Deprecated property. Please use default_joint_friction_coeff instead.

default_joint_friction_coeff: torch.Tensor = None#

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

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

Note

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

property default_joint_limits: torch.Tensor#: Deprecated property. Please use default_joint_pos_limits instead.

default_joint_pos: torch.Tensor = None#

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

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

default_joint_pos_limits: torch.Tensor = None#

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

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

default_joint_stiffness: torch.Tensor = None#

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

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

Attention

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

default_joint_vel: torch.Tensor = None#

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

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

default_joint_viscous_friction_coeff: torch.Tensor = None#

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

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

default_mass: torch.Tensor = None#

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

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

default_root_state: torch.Tensor = None#

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

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

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

default_spatial_tendon_damping: torch.Tensor = None#

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

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

default_spatial_tendon_limit_stiffness: torch.Tensor = None#

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

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

default_spatial_tendon_offset: torch.Tensor = None#

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

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

default_spatial_tendon_stiffness: torch.Tensor = None#

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

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

fixed_tendon_damping: torch.Tensor = None#: Fixed tendon damping provided to the simulation. Shape is (num_instances, num_fixed_tendons).

property fixed_tendon_limit: torch.Tensor#: Deprecated property. Please use fixed_tendon_pos_limits instead.

fixed_tendon_limit_stiffness: torch.Tensor = None#: Fixed tendon limit stiffness provided to the simulation. Shape is (num_instances, num_fixed_tendons).

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

fixed_tendon_offset: torch.Tensor = None#: Fixed tendon offset provided to the simulation. Shape is (num_instances, num_fixed_tendons).

fixed_tendon_pos_limits: torch.Tensor = None#: Fixed tendon position limits provided to the simulation. Shape is (num_instances, num_fixed_tendons, 2).

fixed_tendon_rest_length: torch.Tensor = None#: Fixed tendon rest length provided to the simulation. Shape is (num_instances, num_fixed_tendons).

fixed_tendon_stiffness: torch.Tensor = None#: Fixed tendon stiffness provided to the simulation. Shape is (num_instances, num_fixed_tendons).

gear_ratio: torch.Tensor = None#: Gear ratio for relating motor torques to applied Joint torques. Shape is (num_instances, num_joints).

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

Note

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

property joint_acc#: Joint acceleration of all joints. Shape is (num_instances, num_joints).

joint_armature: torch.Tensor = None#: Joint armature provided to the simulation. Shape is (num_instances, num_joints).

joint_damping: torch.Tensor = None#

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

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

joint_dynamic_friction_coeff: torch.Tensor = None#

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

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

joint_effort_limits: torch.Tensor = None#: Joint maximum effort provided to the simulation. Shape is (num_instances, num_joints).

joint_effort_target: torch.Tensor = None#

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

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

property joint_friction: torch.Tensor#: Deprecated property. Please use joint_friction_coeff instead.

joint_friction_coeff: torch.Tensor = None#

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

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

property joint_limits: torch.Tensor#: Deprecated property. Please use joint_pos_limits instead.

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

property joint_pos#: Joint positions of all joints. Shape is (num_instances, num_joints).

joint_pos_limits: torch.Tensor = None#

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

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

joint_pos_target: torch.Tensor = None#

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

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

joint_stiffness: torch.Tensor = None#

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

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

property joint_vel#: Joint velocities of all joints. Shape is (num_instances, num_joints).

joint_vel_limits: torch.Tensor = None#: Joint maximum velocity provided to the simulation. Shape is (num_instances, num_joints).

joint_vel_target: torch.Tensor = None#

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

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

property joint_velocity_limits: torch.Tensor#: Deprecated property. Please use joint_vel_limits instead.

joint_viscous_friction_coeff: torch.Tensor = None#: Joint viscous friction coefficient provided to the simulation. Shape is (num_instances, num_joints).

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

property root_ang_vel_b: torch.Tensor#: Same as root_com_ang_vel_b.

property root_ang_vel_w: torch.Tensor#: Same as root_com_ang_vel_w.

property root_com_ang_vel_b: torch.Tensor#

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

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

property root_com_ang_vel_w: torch.Tensor#

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

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

property root_com_lin_vel_b: torch.Tensor#

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

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

property root_com_lin_vel_w: torch.Tensor#

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

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

property root_com_pos_w: torch.Tensor#

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

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

property root_com_pose_w: torch.Tensor#

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

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

property root_com_quat_w: torch.Tensor#

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

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

property root_com_state_w#

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

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

property root_com_vel_w: torch.Tensor#

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

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

property root_lin_vel_b: torch.Tensor#: Same as root_com_lin_vel_b.

property root_lin_vel_w: torch.Tensor#: Same as root_com_lin_vel_w.

property root_link_ang_vel_b: torch.Tensor#

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

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

property root_link_ang_vel_w: torch.Tensor#

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

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

property root_link_lin_vel_b: torch.Tensor#

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

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

property root_link_lin_vel_w: torch.Tensor#

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

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

property root_link_pos_w: torch.Tensor#

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

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

property root_link_pose_w: torch.Tensor#

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

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

property root_link_quat_w: torch.Tensor#

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

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

property root_link_state_w#

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

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

property root_link_vel_w: torch.Tensor#

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

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

property root_pos_w: torch.Tensor#: Same as root_link_pos_w.

property root_pose_w: torch.Tensor#: Same as root_link_pose_w.

property root_quat_w: torch.Tensor#: Same as root_link_quat_w.

property root_state_w#

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

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

property root_vel_w: torch.Tensor#: Same as root_com_vel_w.

soft_joint_pos_limits: torch.Tensor = None#

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

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

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

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

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

soft_joint_vel_limits: torch.Tensor = None#

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

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

spatial_tendon_damping: torch.Tensor = None#: Spatial tendon damping provided to the simulation. Shape is (num_instances, num_spatial_tendons).

spatial_tendon_limit_stiffness: torch.Tensor = None#: Spatial tendon limit stiffness provided to the simulation. Shape is (num_instances, num_spatial_tendons).

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

spatial_tendon_offset: torch.Tensor = None#: Spatial tendon offset provided to the simulation. Shape is (num_instances, num_spatial_tendons).

spatial_tendon_stiffness: torch.Tensor = None#: Spatial tendon stiffness provided to the simulation. Shape is (num_instances, num_spatial_tendons).

thrust_target: torch.Tensor = None#

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

This quantity contains the target thrust values set by the user through the isaaclab.assets.Multirotor.set_thrust_target() method.

computed_thrust: torch.Tensor = None#

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

This quantity contains the thrust values computed by the thruster actuator models before any clipping or saturation is applied.

applied_thrust: torch.Tensor = None#

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

This quantity contains the final thrust values that are applied to the simulation after all actuator model processing, including clipping and saturation.

isaaclab_contrib.assets

Contents

isaaclab_contrib.assets#

Multirotor Asset#