warp-lang 1.5.1__py3-none-manylinux2014_x86_64.whl → 1.6.1__py3-none-manylinux2014_x86_64.whl

warp/examples/sim/example_cloth_self_contact.py

@@ -0,0 +1,314 @@
+# Copyright (c) 2024 NVIDIA CORPORATION.  All rights reserved.
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+###########################################################################
+# Example Sim Cloth Self Contact
+#
+# This simulation demonstrates twisting an FEM cloth model using the VBD
+# integrator, showcasing its ability to handle complex self-contacts while
+# ensuring it remains intersection-free.
+#
+###########################################################################
+
+import math
+import os
+
+import numpy as np
+from pxr import Usd, UsdGeom
+
+import warp as wp
+import warp.examples
+import warp.sim
+import warp.sim.render
+from warp.sim.model import PARTICLE_FLAG_ACTIVE
+
+
+@wp.kernel
+def initialize_rotation(
+    # input
+    vertex_indices_to_rot: wp.array(dtype=wp.int32),
+    pos: wp.array(dtype=wp.vec3),
+    rot_centers: wp.array(dtype=wp.vec3),
+    rot_axes: wp.array(dtype=wp.vec3),
+    t: wp.array(dtype=float),
+    # output
+    roots: wp.array(dtype=wp.vec3),
+    roots_to_ps: wp.array(dtype=wp.vec3),
+):
+    tid = wp.tid()
+    v_index = vertex_indices_to_rot[wp.tid()]
+
+    p = pos[v_index]
+    rot_center = rot_centers[tid]
+    rot_axis = rot_axes[tid]
+    op = p - rot_center
+
+    root = wp.dot(op, rot_axis) * rot_axis
+
+    root_to_p = p - root
+
+    roots[tid] = root
+    roots_to_ps[tid] = root_to_p
+
+    if tid == 0:
+        t[0] = 0.0
+
+
+@wp.kernel
+def apply_rotation(
+    # input
+    vertex_indices_to_rot: wp.array(dtype=wp.int32),
+    rot_axes: wp.array(dtype=wp.vec3),
+    roots: wp.array(dtype=wp.vec3),
+    roots_to_ps: wp.array(dtype=wp.vec3),
+    t: wp.array(dtype=float),
+    angular_velocity: float,
+    dt: float,
+    end_time: float,
+    # output
+    pos_0: wp.array(dtype=wp.vec3),
+    pos_1: wp.array(dtype=wp.vec3),
+):
+    cur_t = t[0]
+    if cur_t > end_time:
+        return
+
+    tid = wp.tid()
+    v_index = vertex_indices_to_rot[wp.tid()]
+
+    rot_axis = rot_axes[tid]
+
+    ux = rot_axis[0]
+    uy = rot_axis[1]
+    uz = rot_axis[2]
+
+    theta = cur_t * angular_velocity
+
+    R = wp.mat33(
+        wp.cos(theta) + ux * ux * (1.0 - wp.cos(theta)),
+        ux * uy * (1.0 - wp.cos(theta)) - uz * wp.sin(theta),
+        ux * uz * (1.0 - wp.cos(theta)) + uy * wp.sin(theta),
+        uy * ux * (1.0 - wp.cos(theta)) + uz * wp.sin(theta),
+        wp.cos(theta) + uy * uy * (1.0 - wp.cos(theta)),
+        uy * uz * (1.0 - wp.cos(theta)) - ux * wp.sin(theta),
+        uz * ux * (1.0 - wp.cos(theta)) - uy * wp.sin(theta),
+        uz * uy * (1.0 - wp.cos(theta)) + ux * wp.sin(theta),
+        wp.cos(theta) + uz * uz * (1.0 - wp.cos(theta)),
+    )
+
+    root = roots[tid]
+    root_to_p = roots_to_ps[tid]
+    root_to_p_rot = R * root_to_p
+    p_rot = root + root_to_p_rot
+
+    pos_0[v_index] = p_rot
+    pos_1[v_index] = p_rot
+
+    if tid == 0:
+        t[0] = cur_t + dt
+
+
+class Example:
+    def __init__(self, stage_path="example_cloth_self_contact.usd", num_frames=600):
+        fps = 60
+        self.frame_dt = 1.0 / fps
+        # must be an even number when using CUDA Graph
+        self.num_substeps = 10
+        self.iterations = 4
+        self.dt = self.frame_dt / self.num_substeps
+
+        self.num_frames = num_frames
+        self.sim_time = 0.0
+        self.profiler = {}
+
+        self.rot_angular_velocity = math.pi / 3
+        self.rot_end_time = 10
+        self.use_cuda_graph = wp.get_device().is_cuda
+
+        usd_stage = Usd.Stage.Open(os.path.join(warp.examples.get_asset_directory(), "square_cloth.usd"))
+        usd_geom = UsdGeom.Mesh(usd_stage.GetPrimAtPath("/root/cloth/cloth"))
+
+        mesh_points = np.array(usd_geom.GetPointsAttr().Get())
+        mesh_indices = np.array(usd_geom.GetFaceVertexIndicesAttr().Get())
+
+        self.input_scale_factor = 1.0
+        self.renderer_scale_factor = 0.01
+
+        vertices = [wp.vec3(v) * self.input_scale_factor for v in mesh_points]
+        self.faces = mesh_indices.reshape(-1, 3)
+
+        builder = wp.sim.ModelBuilder()
+        builder.add_cloth_mesh(
+            pos=wp.vec3(0.0, 0.0, 0.0),
+            rot=wp.quat_identity(),
+            scale=1.0,
+            vertices=vertices,
+            indices=mesh_indices,
+            vel=wp.vec3(0.0, 0.0, 0.0),
+            density=0.02,
+            tri_ke=1.0e5,
+            tri_ka=1.0e5,
+            tri_kd=2.0e-6,
+            edge_ke=10,
+        )
+        builder.color()
+        self.model = builder.finalize()
+        self.model.ground = False
+        self.model.soft_contact_ke = 1.0e5
+        self.model.soft_contact_kd = 1.0e-6
+        self.model.soft_contact_mu = 0.2
+
+        # set up contact query and contact detection distances
+        self.model.soft_contact_radius = 0.2
+        self.model.soft_contact_margin = 0.35
+
+        cloth_size = 50
+        left_side = [cloth_size - 1 + i * cloth_size for i in range(cloth_size)]
+        right_side = [i * cloth_size for i in range(cloth_size)]
+        rot_point_indices = left_side + right_side
+
+        if len(rot_point_indices):
+            flags = self.model.particle_flags.numpy()
+            for fixed_vertex_id in rot_point_indices:
+                flags[fixed_vertex_id] = wp.uint32(int(flags[fixed_vertex_id]) & ~int(PARTICLE_FLAG_ACTIVE))
+
+            self.model.particle_flags = wp.array(flags)
+
+        self.integrator = wp.sim.VBDIntegrator(
+            self.model,
+            self.iterations,
+            handle_self_contact=True,
+        )
+        self.state0 = self.model.state()
+        self.state1 = self.model.state()
+
+        rot_axes = [[1, 0, 0]] * len(right_side) + [[-1, 0, 0]] * len(left_side)
+
+        self.rot_point_indices = wp.array(rot_point_indices, dtype=int)
+        self.t = wp.zeros((1,), dtype=float)
+        self.rot_centers = wp.zeros(len(rot_point_indices), dtype=wp.vec3)
+        self.rot_axes = wp.array(rot_axes, dtype=wp.vec3)
+
+        self.roots = wp.zeros_like(self.rot_centers)
+        self.roots_to_ps = wp.zeros_like(self.rot_centers)
+
+        wp.launch(
+            kernel=initialize_rotation,
+            dim=self.rot_point_indices.shape[0],
+            inputs=[
+                self.rot_point_indices,
+                self.state0.particle_q,
+                self.rot_centers,
+                self.rot_axes,
+                self.t,
+            ],
+            outputs=[
+                self.roots,
+                self.roots_to_ps,
+            ],
+        )
+
+        if stage_path:
+            self.renderer = wp.sim.render.SimRenderer(self.model, stage_path, scaling=1)
+        else:
+            self.renderer = None
+        self.cuda_graph = None
+        if self.use_cuda_graph:
+            with wp.ScopedCapture() as capture:
+                for _ in range(self.num_substeps):
+                    wp.launch(
+                        kernel=apply_rotation,
+                        dim=self.rot_point_indices.shape[0],
+                        inputs=[
+                            self.rot_point_indices,
+                            self.rot_axes,
+                            self.roots,
+                            self.roots_to_ps,
+                            self.t,
+                            self.rot_angular_velocity,
+                            self.dt,
+                            self.rot_end_time,
+                        ],
+                        outputs=[
+                            self.state0.particle_q,
+                            self.state1.particle_q,
+                        ],
+                    )
+
+                    self.integrator.simulate(self.model, self.state0, self.state1, self.dt, None)
+                    (self.state0, self.state1) = (self.state1, self.state0)
+
+            self.cuda_graph = capture.graph
+
+    def step(self):
+        with wp.ScopedTimer("step", print=False, dict=self.profiler):
+            if self.use_cuda_graph:
+                wp.capture_launch(self.cuda_graph)
+            else:
+                for _ in range(self.num_substeps):
+                    wp.launch(
+                        kernel=apply_rotation,
+                        dim=self.rot_point_indices.shape[0],
+                        inputs=[
+                            self.rot_point_indices,
+                            self.rot_axes,
+                            self.roots,
+                            self.roots_to_ps,
+                            self.t,
+                            self.rot_angular_velocity,
+                            self.dt,
+                            self.rot_end_time,
+                        ],
+                        outputs=[
+                            self.state0.particle_q,
+                            self.state1.particle_q,
+                        ],
+                    )
+                    self.integrator.simulate(self.model, self.state0, self.state1, self.dt)
+
+                    (self.state0, self.state1) = (self.state1, self.state0)
+
+            self.sim_time += self.dt
+
+    def render(self):
+        if self.renderer is None:
+            return
+
+        with wp.ScopedTimer("render", print=False):
+            self.renderer.begin_frame(self.sim_time)
+            self.renderer.render(self.state0)
+            self.renderer.end_frame()
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument("--device", type=str, default=None, help="Override the default Warp device.")
+    parser.add_argument(
+        "--stage_path",
+        type=lambda x: None if x == "None" else str(x),
+        default="example_cloth_self_contact.usd",
+        help="Path to the output USD file.",
+    )
+    parser.add_argument("--num_frames", type=int, default=300, help="Total number of frames.")
+
+    args = parser.parse_known_args()[0]
+
+    with wp.ScopedDevice(args.device):
+        example = Example(stage_path=args.stage_path, num_frames=args.num_frames)
+
+        for i in range(example.num_frames):
+            example.step()
+            example.render()
+            print(f"[{i:4d}/{example.num_frames}]")
+
+        frame_times = example.profiler["step"]
+        print("\nAverage frame sim time: {:.2f} ms".format(sum(frame_times) / len(frame_times)))
+
+        if example.renderer:
+            example.renderer.save()

warp/examples/sim/example_granular_collision_sdf.py

@@ -15,7 +15,6 @@
 # Note: requires a CUDA-capable device
 ###########################################################################
 
-import math
 import os
 
 import numpy as np
@@ -66,8 +65,8 @@ class Example:
             sdf=rock_sdf,
             body=-1,
             pos=wp.vec3(0.0, 0.0, 0.0),
-            rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), -0.5 * math.pi),
-            scale=wp.vec3(0.01, 0.01, 0.01),
+            rot=wp.quat(0.0, 0.0, 0.0, 1.0),
+            scale=wp.vec3(1.0, 1.0, 1.0),
         )
 
         mins = np.array([-3.0, -3.0, -3.0])
@@ -149,13 +148,13 @@ class Example:
         with wp.ScopedTimer("render"):
             self.renderer.begin_frame(self.sim_time)
 
-            # Note the extra wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), math.pi) is because .usd is oriented differently from .nvdb
             self.renderer.render_ref(
                 name="collision",
                 path=os.path.join(warp.examples.get_asset_directory(), "rocks.usd"),
                 pos=wp.vec3(0.0, 0.0, 0.0),
                 rot=wp.quat(0.0, 0.0, 0.0, 1.0),
-                scale=wp.vec3(0.01, 0.01, 0.01),
+                scale=wp.vec3(1.0, 1.0, 1.0),
+                color=(0.35, 0.55, 0.9),
             )
 
             self.renderer.render_sphere(

warp/examples/sim/example_jacobian_ik.py

@@ -43,8 +43,6 @@ class Example:
     def __init__(self, stage_path="example_jacobian_ik.usd", num_envs=10):
         rng = np.random.default_rng(42)
 
-        builder = wp.sim.ModelBuilder()
-
         self.num_envs = num_envs
 
         fps = 60

warp/examples/sim/example_quadruped.py

@@ -93,7 +93,7 @@ class Example:
         fps = 100
         self.frame_dt = 1.0 / fps
 
-        self.sim_substeps = 5
+        self.sim_substeps = 10
         self.sim_dt = self.frame_dt / self.sim_substeps
 
         self.num_envs = num_envs
@@ -116,10 +116,13 @@ class Example:
         self.model.joint_attach_ke = 16000.0
         self.model.joint_attach_kd = 200.0
         self.use_tile_gemm = False
+        self.fuse_cholesky = False
 
         # self.integrator = wp.sim.XPBDIntegrator()
         # self.integrator = wp.sim.SemiImplicitIntegrator()
-        self.integrator = wp.sim.FeatherstoneIntegrator(self.model, use_tile_gemm=self.use_tile_gemm)
+        self.integrator = wp.sim.FeatherstoneIntegrator(
+            self.model, use_tile_gemm=self.use_tile_gemm, fuse_cholesky=self.fuse_cholesky
+        )
 
         if stage_path:
             self.renderer = wp.sim.render.SimRenderer(self.model, stage_path)

warp/examples/tile/example_tile_cholesky.py

@@ -0,0 +1,79 @@
+# Copyright (c) 2025 NVIDIA CORPORATION.  All rights reserved.
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+###########################################################################
+# Example Tile Cholesky
+#
+# Shows how to write a simple kernel computing a Cholesky factorize and
+# triangular solve using Warp Cholesky Tile APIs.
+#
+###########################################################################
+
+import numpy as np
+
+import warp as wp
+
+wp.init()
+wp.set_module_options({"enable_backward": False})
+
+BLOCK_DIM = 128
+TILE = 32
+
+# Both should work
+np_type, wp_type = np.float64, wp.float64
+# np_type, wp_type = np.float32, wp.float32
+
+
+@wp.kernel
+def cholesky(
+    A: wp.array2d(dtype=wp_type),
+    L: wp.array2d(dtype=wp_type),
+    X: wp.array1d(dtype=wp_type),
+    Y: wp.array1d(dtype=wp_type),
+):
+    i, j, _ = wp.tid()
+
+    a = wp.tile_load(A, shape=(TILE, TILE))
+    l = wp.tile_cholesky(a)
+    wp.tile_store(L, l)
+
+    x = wp.tile_load(X, shape=TILE)
+    y = wp.tile_cholesky_solve(l, x)
+    wp.tile_store(Y, y)
+
+
+if __name__ == "__main__":
+    wp.set_device("cuda:0")
+
+    A_h = np.ones((TILE, TILE), dtype=np_type) + 5 * np.diag(np.ones(TILE), 0)
+    L_h = np.zeros_like(A_h)
+
+    A_wp = wp.array2d(A_h, dtype=wp_type)
+    L_wp = wp.array2d(L_h, dtype=wp_type)
+
+    X_h = np.arange(TILE, dtype=np_type)
+    Y_h = np.zeros_like(X_h)
+
+    X_wp = wp.array1d(X_h, dtype=wp_type)
+    Y_wp = wp.array1d(Y_h, dtype=wp_type)
+
+    wp.launch_tiled(cholesky, dim=[1, 1], inputs=[A_wp, L_wp, X_wp, Y_wp], block_dim=BLOCK_DIM)
+
+    L_np = np.linalg.cholesky(A_h)
+    Y_np = np.linalg.solve(A_h, X_h)
+
+    print("A:\n", A_h)
+    print("L (Warp):\n", L_wp)
+    print("L (Numpy):\n", L_np)
+
+    print("x:\n", X_h)
+    print("A\\n (Warp):\n", Y_wp.numpy())
+    print("A\\x (Numpy):\n", Y_np)
+
+    assert np.allclose(Y_wp.numpy(), Y_np) and np.allclose(L_wp.numpy(), L_np)
+
+    print("Example Tile Cholesky passed")

warp/examples/tile/example_tile_convolution.py

@@ -34,11 +34,11 @@ def filter(x: wp.vec2d):
 @wp.kernel
 def conv_tiled(x: wp.array2d(dtype=wp.vec2d), y: wp.array2d(dtype=wp.vec2d)):
     i, j, _ = wp.tid()
-    a = wp.tile_load(x, i, j, m=TILE_M, n=TILE_N)
+    a = wp.tile_load(x, shape=(TILE_M, TILE_N))
     wp.tile_fft(a)
     b = wp.tile_map(filter, a)
     wp.tile_ifft(b)
-    wp.tile_store(y, i, j, b)
+    wp.tile_store(y, b)
 
 
 if __name__ == "__main__":

warp/examples/tile/example_tile_fft.py

@@ -26,10 +26,10 @@ TILE_N = 32
 @wp.kernel
 def fft_tiled(x: wp.array2d(dtype=wp.vec2d), y: wp.array2d(dtype=wp.vec2d)):
     i, j, _ = wp.tid()
-    a = wp.tile_load(x, i, j, m=TILE_M, n=TILE_N)
+    a = wp.tile_load(x, shape=(TILE_M, TILE_N))
     wp.tile_fft(a)
     wp.tile_ifft(a)
-    wp.tile_store(y, i, j, a)
+    wp.tile_store(y, a)
 
 
 if __name__ == "__main__":

warp/examples/tile/example_tile_filtering.py

@@ -38,12 +38,12 @@ def cplx_prod(x: wp.vec2d, y: wp.vec2d):
 @wp.kernel
 def conv_tiled(x: wp.array2d(dtype=wp.vec2d), y: wp.array2d(dtype=wp.vec2d), z: wp.array2d(dtype=wp.vec2d)):
     i, j, _ = wp.tid()
-    a = wp.tile_load(x, i, j, m=TILE_M, n=TILE_N)
-    b = wp.tile_load(y, i, j, m=TILE_M, n=TILE_N)
+    a = wp.tile_load(x, shape=(TILE_M, TILE_N))
+    b = wp.tile_load(y, shape=(TILE_M, TILE_N))
     wp.tile_fft(a)
     c = wp.tile_map(cplx_prod, a, b)
     wp.tile_ifft(c)
-    wp.tile_store(z, i, j, c)
+    wp.tile_store(z, c)
 
 
 if __name__ == "__main__":

warp/examples/tile/example_tile_matmul.py

@@ -30,7 +30,7 @@ def tile_gemm(A: wp.array2d(dtype=wp.float32), B: wp.array2d(dtype=wp.float16),
     # output tile index
     i, j = wp.tid()
 
-    sum = wp.tile_zeros(m=TILE_M, n=TILE_N, dtype=wp.float64)
+    sum = wp.tile_zeros(shape=(TILE_M, TILE_N), dtype=wp.float64)
 
     _M = A.shape[0]
     _N = B.shape[1]
@@ -39,13 +39,13 @@ def tile_gemm(A: wp.array2d(dtype=wp.float32), B: wp.array2d(dtype=wp.float16),
     count = int(K / TILE_K)
 
     for k in range(0, count):
-        a = wp.tile_load(A, i, k, m=TILE_M, n=TILE_K)
-        b = wp.tile_load(B, k, j, m=TILE_K, n=TILE_N)
+        a = wp.tile_load(A, shape=(TILE_M, TILE_K), offset=(i * TILE_M, k * TILE_K))
+        b = wp.tile_load(B, shape=(TILE_K, TILE_N), offset=(k * TILE_K, j * TILE_N))
 
         # sum += a*b
         wp.tile_matmul(a, b, sum)
 
-    wp.tile_store(C, i, j, sum)
+    wp.tile_store(C, sum, offset=(i * TILE_M, j * TILE_N))
 
 
 if __name__ == "__main__":

warp/examples/tile/example_tile_mlp.py

@@ -117,23 +117,23 @@ def compute(
     f = wp.tile(local)
 
     # input layer
-    w0 = wp.tile_load(weights_0, 0, 0, m=DIM_HID, n=DIM_IN)
-    b0 = wp.tile_load(bias_0, 0, 0, m=DIM_HID, n=1)
-    z = wp.tile_map(relu, wp.tile_matmul(w0, f) + wp.tile_broadcast(b0, m=DIM_HID, n=NUM_THREADS))
+    w0 = wp.tile_load(weights_0, shape=(DIM_HID, DIM_IN))
+    b0 = wp.tile_load(bias_0, shape=(DIM_HID, 1))
+    z = wp.tile_map(relu, wp.tile_matmul(w0, f) + wp.tile_broadcast(b0, shape=(DIM_HID, NUM_THREADS)))
 
     # hidden layer
-    w1 = wp.tile_load(weights_1, 0, 0, m=DIM_HID, n=DIM_HID)
-    b1 = wp.tile_load(bias_1, 0, 0, m=DIM_HID, n=1)
-    z = wp.tile_map(relu, wp.tile_matmul(w1, z) + wp.tile_broadcast(b1, m=DIM_HID, n=NUM_THREADS))
+    w1 = wp.tile_load(weights_1, shape=(DIM_HID, DIM_HID))
+    b1 = wp.tile_load(bias_1, shape=(DIM_HID, 1))
+    z = wp.tile_map(relu, wp.tile_matmul(w1, z) + wp.tile_broadcast(b1, shape=(DIM_HID, NUM_THREADS)))
 
-    w2 = wp.tile_load(weights_2, 0, 0, m=DIM_HID, n=DIM_HID)
-    b2 = wp.tile_load(bias_2, 0, 0, m=DIM_HID, n=1)
-    z = wp.tile_map(relu, wp.tile_matmul(w2, z) + wp.tile_broadcast(b2, m=DIM_HID, n=NUM_THREADS))
+    w2 = wp.tile_load(weights_2, shape=(DIM_HID, DIM_HID))
+    b2 = wp.tile_load(bias_2, shape=(DIM_HID, 1))
+    z = wp.tile_map(relu, wp.tile_matmul(w2, z) + wp.tile_broadcast(b2, shape=(DIM_HID, NUM_THREADS)))
 
     # output layer
-    w3 = wp.tile_load(weights_3, 0, 0, m=DIM_OUT, n=DIM_HID)
-    b3 = wp.tile_load(bias_3, 0, 0, m=DIM_OUT, n=1)
-    o = wp.tile_map(relu, wp.tile_matmul(w3, z) + wp.tile_broadcast(b3, m=DIM_OUT, n=NUM_THREADS))
+    w3 = wp.tile_load(weights_3, shape=(DIM_OUT, DIM_HID))
+    b3 = wp.tile_load(bias_3, shape=(DIM_OUT, 1))
+    o = wp.tile_map(relu, wp.tile_matmul(w3, z) + wp.tile_broadcast(b3, shape=(DIM_OUT, NUM_THREADS)))
 
     # untile back to SIMT
     output = wp.untile(o)