ASR Model APIs

The Affine-Soft-Robot (ASR) Model includes the states for * Affine bodies * Soft bodies * Robots, with vision-based tactile sensors as soft bodies

class warp_ipc.sim_model.ASRModel(num_envs: int = 1, viz_envs: list[int] = [], device='cuda:0')

Bases: Model

ABD-IPC-Robots Model

ABD_centers: <warp.types.array object at 0x7238da064ee0>

class KinematicConstraintHelper(model: ASRModel, initial_stiffness: float = 10000.0)

Bases: object

increase_stiffness(factor: float = 2.0)

init() → None

initialize_stiffness()

is_satisfied()

project_system(sm, sys_grad)

reset()

reset_dof_satisfied()

set_initial_stiffness(initial_stiffness: float = 10000.0)

update_satisfied(x, y, dt: float, tol: float)

class LinearConstraintHelper(model: ASRModel)

Bases: object

add_constraint(constraint_row: asarray)

add_constraints(constraint_rows: asarray)

finalize()

init()

project_system(hess: BsrMatrix, grad: array)

class SetStateHelper(model: ASRModel)

Bases: object

clear_mask()

init() → None

X: <warp.types.array object at 0x7238e92a9ed0>

a_y: <warp.types.array object at 0x7238da064a60>

add_affine_body(x, face, density, E, mu, mass_xi: None | float = None, env_id: int = 0, nu: float = 0.3) → TriMeshBodyHandle

add_garment_stitch(stitches)

add_plane(n, o, mu) → None

add_robot(urdf_path: str, env_id: int = 0, start_coll_layer: int = 2, coll_layers: list[int] = [], disable_coll_layers: list[int] = [], mu: float = 0.3, self_collision: bool = False, **kwargs)

add_soft_shell_body(mesh, edge_stretching_stiffness: float = 0, density: float = 1000, E: float = 0, nu: float = 0.3, compression_softening: float = 0, bending_stiffness: float = 0, mu: float = 0, xi: float = 0.001, mass_thickness: None | float = None, env_id: int = 0) → TriMeshBodyHandle

Constitutive model: Baraff-Witkin and dihedral angle bendings NOTE: Since this repository is only for POC, interfaces functionality will be limited. This function must be called after all affine bodies are added. add_soft_vol_body must be called after all soft shell bodies are added.

add_soft_vol_body(mesh: UnstructuredGrid, density: float, E: float, nu: float, mu: float, env_id: int = 0, coll_layer: int = 0, self_coll: bool = True) → TetMeshBodyHandle

Constitutive model: Neo-Hookean/StVK for now; TODO: Corotated Linear NOTE: Since this repository is only for POC, interfaces functionality will be limited. This function must be called after all affine bodies are added.

add_world_prismatic_joint(handle: TetMeshBodyHandle | TriMeshBodyHandle, axis: ndarray[tuple[int, ...], dtype[_ScalarType_co]]) → WorldJointHandle

add_world_revolute_joint(handle: TetMeshBodyHandle | TriMeshBodyHandle, local_axis_position: ndarray[tuple[int, ...], dtype[_ScalarType_co]], axis_direction: ndarray[tuple[int, ...], dtype[_ScalarType_co]]) → WorldJointHandle

property affine_body_num: int

affine_density: <warp.types.array object at 0x7238da0dc040>

affine_ext_force_field: <warp.types.array object at 0x7238da064e80>

affine_ext_y_force: <warp.types.array object at 0x7238da064eb0>

affine_flipped: <warp.types.array object at 0x7238da064610>

affine_is_closed: <warp.types.array object at 0x7238da064670>

affine_mass_matrix: <warp.types.array object at 0x7238da064640>

affine_mass_xi: <warp.types.array object at 0x7238da0646a0>

allocate_sim_cache()

append_sim_data(attr: str, values: asarray, type) → None

apply_set_state(x=None, y=None) → None

call apply set state manually mainly for initial scene visualization purpose

arap_compression_k: <warp.types.array object at 0x723a845564d0>

arap_stretch_k: <warp.types.array object at 0x723a84556530>

bending: <warp.types.array object at 0x7238da064fa0>

bending_e: <warp.types.array object at 0x7238da066200>

bending_h: <warp.types.array object at 0x7238da066230>

bending_rest_angle: <warp.types.array object at 0x7238da0661d0>

bending_stiffness: <warp.types.array object at 0x7238da066260>

body_collision_layer: <warp.types.array object at 0x7238da065390>

body_enable_self_collision: <warp.types.array object at 0x7238da0650f0>

body_env_id: <warp.types.array object at 0x7238da065120>

body_is_affine: <warp.types.array object at 0x7238da0650c0>

body_q: <warp.types.array object at 0x7238da0dc160>

body_qd: <warp.types.array object at 0x7238da0dc190>

check_initial_state_valid(exclude_self_collision: bool = False) → bool

clear_force()

clear_grad() → None

collision_layer_filter: <warp.types.array object at 0x7238da064760>

property collision_map

dhat

IPC barrier active distance (m)

dim: int

Dimension of the space, defualt to be 3 for 3D

disable_affine_kinematic_constraint(handle: TetMeshBodyHandle | TriMeshBodyHandle) → None

property dummy_robot: Robot | None

property dx_div_dv_scale

dx_div_dv_scale_list

for quasi-static, implicit Euler, BDF-2

edge: <warp.types.array object at 0x7238db112980>

edge2body: <warp.types.array object at 0x7238da065090>

edge2env: <warp.types.array object at 0x7238da064fd0>

edge_area: <warp.types.array object at 0x7238da066440>

edge_stretching_stiffness: <warp.types.array object at 0x7238da0653c0>

edge_xi: <warp.types.array object at 0x7238da0664a0>

enable_affine_kinematic_constraint(handle: TetMeshBodyHandle | TriMeshBodyHandle) → None

env_origins: <warp.types.array object at 0x7238da0dc130>

env_states: <warp.types.array object at 0x7238da064730>

epsv

Friction (m/s)

face: <warp.types.array object at 0x7238db112950>

face2body: <warp.types.array object at 0x7238da065060>

face2env: <warp.types.array object at 0x7238da065000>

face_xi: <warp.types.array object at 0x7238da0664d0>

finalize() → None

fn_x: <warp.types.array object at 0x7238da0663b0>

ft_x: <warp.types.array object at 0x7238da0663e0>

get_affine_body_mesh_from_handle(handle: TriMeshBodyHandle) → Trimesh

get_affine_body_meshes_from_handle(handles: List[TriMeshBodyHandle], concat=True) → list[Trimesh] | Trimesh

get_affine_body_state(body_handle: TetMeshBodyHandle | TriMeshBodyHandle, return_numpy: bool = True) → Tuple[ndarray[tuple[int, ...], dtype[_ScalarType_co]], ndarray[tuple[int, ...], dtype[_ScalarType_co]]]

get_affine_body_state_matrix(body_handle: TetMeshBodyHandle | TriMeshBodyHandle, return_numpy: bool = True) → ndarray[tuple[int, ...], dtype[_ScalarType_co]]

get_affine_body_velocity(body_handle: TetMeshBodyHandle | TriMeshBodyHandle, return_numpy: bool = True) → Tuple[ndarray[tuple[int, ...], dtype[_ScalarType_co]], ndarray[tuple[int, ...], dtype[_ScalarType_co]]]

get_affine_body_velocity_matrix(body_handle: TetMeshBodyHandle | TriMeshBodyHandle, return_numpy: bool = True) → ndarray[tuple[int, ...], dtype[_ScalarType_co]]

get_affine_body_wp_meshes_from_handle(handles: list[TriMeshBodyHandle]) → list[Mesh]

get_body_env_id(handle: TetMeshBodyHandle | TriMeshBodyHandle) → int

get_body_face(handle: TetMeshBodyHandle | TriMeshBodyHandle) → Tensor

get_body_mesh(handle: TetMeshBodyHandle | TriMeshBodyHandle)

get_body_nodal_collision_force(handle: TetMeshBodyHandle | TriMeshBodyHandle, dt: float) → Tensor

get_body_nodal_contact_force(handle: TetMeshBodyHandle | TriMeshBodyHandle, dt: float) → Tensor

get_body_nodal_friction_force(handle: TetMeshBodyHandle | TriMeshBodyHandle, dt: float) → Tensor

get_body_resultant_contact_force(handle: TetMeshBodyHandle | TriMeshBodyHandle, dt: float) → Tensor

get_body_target_mesh(handle: TetMeshBodyHandle | TriMeshBodyHandle)

get_body_x(handle: TetMeshBodyHandle | TriMeshBodyHandle) → Tensor

get_body_x_target(handle: TetMeshBodyHandle | TriMeshBodyHandle) → Tensor

get_element_by_handle(handle: TetMeshBodyHandle, return_numpy=True) → Tuple[ndarray[tuple[int, ...], dtype[_ScalarType_co]], ndarray[tuple[int, ...], dtype[_ScalarType_co]]]

static get_env_pos(num_envs: int, n_row: int, n_col: int, env_spacing: float, device: str = 'cuda:0') → tensor

get_environment_states()

get_joint_value(joint_handle: WorldJointHandle) → float

get_scene_mesh() → Trimesh

get_soft_body_from_handle(handle: TetMeshBodyHandle) → UnstructuredGrid

get_soft_body_mesh_from_handle(handle: TetMeshBodyHandle) → Trimesh

get_soft_body_meshes_from_handle(handles: List[TetMeshBodyHandle], concat=True) → list[Trimesh] | Trimesh

get_soft_body_pos(body_handle: TetMeshBodyHandle | TriMeshBodyHandle, return_numpy: bool = True) → ndarray[tuple[int, ...], dtype[_ScalarType_co]]

get_soft_body_velocity(body_handle: TetMeshBodyHandle | TriMeshBodyHandle, return_numpy: bool = True) → ndarray[tuple[int, ...], dtype[_ScalarType_co]]

get_soft_nodes_from_idxs(idxs: list[tuple[int, int]]) → ndarray[tuple[int, ...], dtype[_ScalarType_co]]

get_soft_surf_verts_from_handle(handle: TetMeshBodyHandle | TriMeshBodyHandle) → ndarray[tuple[int, ...], dtype[_ScalarType_co]]

get_soft_verts_from_handle(handle: TetMeshBodyHandle | TriMeshBodyHandle) → ndarray[tuple[int, ...], dtype[_ScalarType_co]]

get_target_scene_mesh() → Trimesh

gravity

Gravity vector (m/s^2)

half_space_mu: <warp.types.array object at 0x7238da0dc100>

half_space_n: <warp.types.array object at 0x7238da0dc0a0>

half_space_o: <warp.types.array object at 0x7238da0dc0d0>

handle_EE

Handling edge-edge interpenetration; disabling makes the simulation faster.

hat_x: <warp.types.array object at 0x7238da066320>

hat_y: <warp.types.array object at 0x7238da067d90>

hess_affine_diag: COOMatrix3x3

hess_barrier: COOMatrix3x3

hess_friction: COOMatrix3x3

hess_soft_bending_elastic: COOMatrix3x3

hess_soft_diag: COOMatrix3x3

hess_soft_shell_elastic: COOMatrix3x3

hess_soft_vol_elastic: COOMatrix3x3

hess_stitch: COOMatrix3x3

init() → None

initialize_hat_x_y() → None

initialize_tilde_x_y(dt: float) → None

initialize_tilde_x_y_adjoint(dt: float) → None

k_elasticity_damping

Elasticity damping coefficient (Pa.s/m)

kappa

IPC barrier stiffness (Pa)

mass_body: <warp.types.array object at 0x7238da066530>

merge_sys_grad() → None

property n_affine_dofs: int

property n_dofs: int

negate(gradient: array) → None

negate_vec12d(gradient: array) → None

negate_vec3d(gradient: array) → None

node2body: <warp.types.array object at 0x7238da065030>

node2env: <warp.types.array object at 0x7238da064f10>

node_area: <warp.types.array object at 0x7238da066410>

node_xi: <warp.types.array object at 0x7238da066470>

property num_HS

property num_body

property num_cloth_edges

property num_edge

property num_face

property num_surf_verts

property num_x

particle_q: <warp.types.array object at 0x7238e92a9f00>

Node positions

particle_qd: <warp.types.array object at 0x7238da066350>

Node velocities

particle_qdd: <warp.types.array object at 0x7238da066380>

Node accelerations

particle_radius

Ground plane parameters for warp.sim visualization

requires_grad(flag=True) → None

reset_environement(env_id)

safeguard_direction_x(direction_x: array) → None

save_sim_x_to_xt() → None

set_affine_external_force_field(handle: TetMeshBodyHandle | TriMeshBodyHandle, target_force_acceleration: ndarray[tuple[int, ...], dtype[_ScalarType_co]] | Tensor) → None

set_affine_external_torque(handle: TetMeshBodyHandle | TriMeshBodyHandle, torque: ndarray[tuple[int, ...], dtype[_ScalarType_co]] | Tensor = tensor([0., 0., 0.], dtype=torch.float64)) → None

set_affine_external_wrench(handle: TetMeshBodyHandle | TriMeshBodyHandle, target_force_acceleration: ndarray[tuple[int, ...], dtype[_ScalarType_co]] | Tensor, torque: ndarray[tuple[int, ...], dtype[_ScalarType_co]] | Tensor = tensor([0., 0., 0.], dtype=torch.float64)) → None

set_affine_kinematic_target(handle: TetMeshBodyHandle | TriMeshBodyHandle, target_rot_mat: ndarray[tuple[int, ...], dtype[_ScalarType_co]] | Tensor, target_translation: ndarray[tuple[int, ...], dtype[_ScalarType_co]] | Tensor) → None

set_affine_state(handle: TetMeshBodyHandle | TriMeshBodyHandle, rotation: ndarray[tuple[int, ...], dtype[_ScalarType_co]] | Tensor, translation: ndarray[tuple[int, ...], dtype[_ScalarType_co]] | Tensor) → None

set_body_collision_layer(handle: TetMeshBodyHandle | TriMeshBodyHandle, layer_index: int) → None

set_body_env_id(handle: TetMeshBodyHandle | TriMeshBodyHandle, env_id: int) → None

set_body_self_collision(handle: TetMeshBodyHandle | TriMeshBodyHandle, to_enable: bool) → None

set_collision_layer_filter(layer_i: int, layer_j: int, to_enable_collision: bool) → None

set_kinematic_stiffness(weight) → None

set_robot_state(joint_params: dict[str, float], root_tf: ndarray[tuple[int, ...], dtype[_ScalarType_co]] = array([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.], [0., 0., 0., 1.]]), env_ids: list[int] = [])

set_soft_kinematic_constraint(handle: TetMeshBodyHandle | TriMeshBodyHandle, verts_mask: ndarray[tuple[int, ...], dtype[_ScalarType_co]] | Tensor) → None

set_soft_kinematic_target(handle: TetMeshBodyHandle | TriMeshBodyHandle, target_verts: ndarray[tuple[int, ...], dtype[_ScalarType_co]] | Tensor) → None

set_soft_state(handle: TetMeshBodyHandle | TriMeshBodyHandle, positions: ndarray[tuple[int, ...], dtype[_ScalarType_co]] | Tensor) → None

property shape_count_sim: int

property soft_bending_connectivity_num: int

property soft_kinematic_constraint: Tensor

property soft_kinematic_target: Tensor

soft_shell_E: <warp.types.array object at 0x7238ddf76e30>

soft_shell_IB: <warp.types.array object at 0x7238ddf77f10>

property soft_shell_elastic_connectivity_num: int

property soft_shell_elastic_connectivity_offset: int

soft_shell_elem_vol: <warp.types.array object at 0x7238ddf77c10>

soft_shell_nu: <warp.types.array object at 0x7238ddf77dc0>

property soft_shell_tris_num

soft_tet_E: <warp.types.array object at 0x723a84556470>

soft_tet_IB: <warp.types.array object at 0x723a845564a0>

soft_tet_elem_vol: <warp.types.array object at 0x723a845562c0>

soft_tet_nu: <warp.types.array object at 0x723a845554e0>

soft_tilde_x: <warp.types.array object at 0x7238da066560>

soft_verts_mass: <warp.types.array object at 0x7238da0dc070>

property soft_verts_num

property soft_vol_body_offset: int

property soft_vol_elastic_connectivity_num: int

property soft_vol_tets_num

state(requires_grad=None) → State

Returns a state object for the model

The returned state will be initialized with the initial configuration given in the model description.

Parameters:

requires_grad (bool) – Manual overwrite whether the state variables should have requires_grad enabled (defaults to None to use the model’s setting requires_grad)

Returns:

The state object

Return type:

State

step(dt)

stitch: <warp.types.array object at 0x7238da066290>

stitch_map: <warp.types.array object at 0x7238da0662c0>

stitch_num_per_x: <warp.types.array object at 0x7238da0662f0>

surf_vi: <warp.types.array object at 0x7238da046620>

sys_to_x(sys_direction: array, direction_x: array) → None

property tac_handles: list[list[TetMeshBodyHandle]]

tet_envs: <warp.types.array object at 0x7238da064700>

tets: <warp.types.array object at 0x7238ddf75690>

tilde_y: <warp.types.array object at 0x7238da064d30>

update_contact_force(dt: float) → Tensor

v_y: <warp.types.array object at 0x7238da067f70>

vol_body: <warp.types.array object at 0x7238da066500>

write_scene(filename: str, divide: bool = False, double_face: bool = False) → None

write_target_scene(filename: str) → None

property x_target: Tensor

update rigid targets

Type:

TODO

xt: <warp.types.array object at 0x7238db112530>

y: <warp.types.array object at 0x7238da067dc0>

y_to_x(direction: array, direction_x: array) → None