warp-lang 1.4.1__py3-none-win_amd64.whl → 1.5.0__py3-none-win_amd64.whl

warp/tests/test_collision.py

@@ -7,8 +7,11 @@
 
 import unittest
 
+import warp as wp
 import warp.examples
+import warp.sim
 from warp.sim.collide import *
+from warp.sim.integrator_euler import eval_triangles_contact
 from warp.tests.unittest_utils import *
 
 
@@ -474,12 +477,119 @@ def test_edge_edge_collision(test, device):
 devices = get_test_devices()
 
 
+def test_particle_collision(test, device):
+    with wp.ScopedDevice(device):
+        contact_radius = 1.23
+        builder1 = wp.sim.ModelBuilder()
+        builder1.add_cloth_grid(
+            pos=wp.vec3(0.0, 0.0, 0.0),
+            rot=wp.quat_identity(),
+            vel=wp.vec3(0.0, 0.0, 0.0),
+            dim_x=100,
+            dim_y=100,
+            cell_x=0.1,
+            cell_y=0.1,
+            mass=0.1,
+            particle_radius=contact_radius,
+        )
+
+    cloth_grid = builder1.finalize()
+    cloth_grid_particle_radius = cloth_grid.particle_radius.numpy()
+    assert_np_equal(cloth_grid_particle_radius, np.full(cloth_grid_particle_radius.shape, contact_radius), tol=1e-5)
+
+    vertices = [
+        [2.0, 0.0, 0.0],
+        [2.0, 2.0, 0.0],
+        [0.0, 0.0, 0.0],
+        [1.0, 0.0, 1.0],
+        [1.0, 1.0, 1.0],
+        [0.0, 0.0, 1.0],
+    ]
+    vertices = [wp.vec3(v) for v in vertices]
+    faces = [0, 1, 2, 3, 4, 5]
+
+    builder2 = wp.sim.ModelBuilder()
+    builder2.add_cloth_mesh(
+        pos=wp.vec3(0.0, 0.0, 0.0),
+        rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), 0.0),
+        scale=1.0,
+        vertices=vertices,
+        indices=faces,
+        tri_ke=1e4,
+        tri_ka=1e4,
+        tri_kd=1e-5,
+        edge_ke=10,
+        edge_kd=0.0,
+        vel=wp.vec3(0.0, 0.0, 0.0),
+        density=0.1,
+        particle_radius=contact_radius,
+    )
+    cloth_mesh = builder2.finalize()
+    cloth_mesh_particle_radius = cloth_mesh.particle_radius.numpy()
+    assert_np_equal(cloth_mesh_particle_radius, np.full(cloth_mesh_particle_radius.shape, contact_radius), tol=1e-5)
+
+    state = cloth_mesh.state()
+    particle_f = wp.zeros_like(state.particle_q)
+    wp.launch(
+        kernel=eval_triangles_contact,
+        dim=cloth_mesh.tri_count * cloth_mesh.particle_count,
+        inputs=[
+            cloth_mesh.particle_count,
+            state.particle_q,
+            state.particle_qd,
+            cloth_mesh.tri_indices,
+            cloth_mesh.tri_materials,
+            cloth_mesh.particle_radius,
+        ],
+        outputs=[particle_f],
+    )
+    test.assertTrue((np.linalg.norm(particle_f.numpy(), axis=1) != 0).all())
+
+    builder3 = wp.sim.ModelBuilder()
+    builder3.add_cloth_mesh(
+        pos=wp.vec3(0.0, 0.0, 0.0),
+        rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), 0.0),
+        scale=1.0,
+        vertices=vertices,
+        indices=faces,
+        tri_ke=1e4,
+        tri_ka=1e4,
+        tri_kd=1e-5,
+        edge_ke=10,
+        edge_kd=0.0,
+        vel=wp.vec3(0.0, 0.0, 0.0),
+        density=0.1,
+        particle_radius=0.5,
+    )
+    cloth_mesh_2 = builder3.finalize()
+    cloth_mesh_2_particle_radius = cloth_mesh_2.particle_radius.numpy()
+    assert_np_equal(cloth_mesh_2_particle_radius, np.full(cloth_mesh_2_particle_radius.shape, 0.5), tol=1e-5)
+
+    state_2 = cloth_mesh_2.state()
+    particle_f_2 = wp.zeros_like(cloth_mesh_2.particle_q)
+    wp.launch(
+        kernel=eval_triangles_contact,
+        dim=cloth_mesh_2.tri_count * cloth_mesh_2.particle_count,
+        inputs=[
+            cloth_mesh_2.particle_count,
+            state_2.particle_q,
+            state_2.particle_qd,
+            cloth_mesh_2.tri_indices,
+            cloth_mesh_2.tri_materials,
+            cloth_mesh_2.particle_radius,
+        ],
+        outputs=[particle_f_2],
+    )
+    test.assertTrue((np.linalg.norm(particle_f_2.numpy(), axis=1) == 0).all())
+
+
 class TestCollision(unittest.TestCase):
     pass
 
 
 add_function_test(TestCollision, "test_vertex_triangle_collision", test_vertex_triangle_collision, devices=devices)
 add_function_test(TestCollision, "test_edge_edge_collision", test_vertex_triangle_collision, devices=devices)
+add_function_test(TestCollision, "test_particle_collision", test_particle_collision, devices=devices)
 
 if __name__ == "__main__":
     wp.clear_kernel_cache()

warp/tests/test_coloring.py

@@ -0,0 +1,241 @@
+# 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.
+
+
+import numpy as np
+
+import warp as wp
+import warp.examples
+import warp.sim
+from warp.sim.graph_coloring import ColoringAlgorithm, construct_trimesh_graph_edges, validate_graph_coloring
+from warp.tests.unittest_utils import *
+
+
+def color_lattice_grid(num_x, num_y):
+    colors = []
+    for _ in range(4):
+        colors.append([])
+
+    for xi in range(num_x + 1):
+        for yi in range(num_y + 1):
+            node_dx = yi * (num_x + 1) + xi
+
+            a = 1 if xi % 2 else 0
+            b = 1 if yi % 2 else 0
+
+            c = b * 2 + a
+
+            colors[c].append(node_dx)
+
+    color_groups = [np.array(group) for group in colors]
+
+    return color_groups
+
+
+@unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
+def test_coloring_trimesh(test, device):
+    from pxr import Usd, UsdGeom
+
+    with wp.ScopedDevice(device):
+        usd_stage = Usd.Stage.Open(os.path.join(wp.examples.get_asset_directory(), "bunny.usd"))
+        usd_geom = UsdGeom.Mesh(usd_stage.GetPrimAtPath("/root/bunny"))
+
+        vertices = np.array(usd_geom.GetPointsAttr().Get())
+        faces = np.array(usd_geom.GetFaceVertexIndicesAttr().Get())
+
+        builder = wp.sim.ModelBuilder()
+
+        builder.add_cloth_mesh(
+            pos=wp.vec3(0.0, 0.0, 0.0),
+            rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), 0.0),
+            scale=1.0,
+            vertices=[wp.vec3(p) for p in vertices],
+            indices=faces.flatten(),
+            vel=wp.vec3(0.0, 0.0, 0.0),
+            density=0.02,
+        )
+
+        model = builder.finalize()
+
+        particle_colors = wp.empty(shape=(model.particle_count), dtype=int, device="cpu")
+
+        edge_indices_cpu = wp.array(model.edge_indices.numpy()[:, 2:], dtype=int, device="cpu")
+
+        # coloring without bending
+        num_colors_greedy = wp.context.runtime.core.graph_coloring(
+            model.particle_count,
+            edge_indices_cpu.__ctype__(),
+            ColoringAlgorithm.GREEDY.value,
+            particle_colors.__ctype__(),
+        )
+        wp.launch(
+            kernel=validate_graph_coloring,
+            inputs=[edge_indices_cpu, particle_colors],
+            dim=edge_indices_cpu.shape[0],
+            device="cpu",
+        )
+
+        num_colors_mcs = wp.context.runtime.core.graph_coloring(
+            model.particle_count,
+            edge_indices_cpu.__ctype__(),
+            ColoringAlgorithm.MCS.value,
+            particle_colors.__ctype__(),
+        )
+        wp.launch(
+            kernel=validate_graph_coloring,
+            inputs=[edge_indices_cpu, particle_colors],
+            dim=edge_indices_cpu.shape[0],
+            device="cpu",
+        )
+
+        # coloring with bending
+        edge_indices_cpu_with_bending = construct_trimesh_graph_edges(model.edge_indices, True)
+        num_colors_greedy = wp.context.runtime.core.graph_coloring(
+            model.particle_count,
+            edge_indices_cpu_with_bending.__ctype__(),
+            ColoringAlgorithm.GREEDY.value,
+            particle_colors.__ctype__(),
+        )
+        wp.context.runtime.core.balance_coloring(
+            model.particle_count,
+            edge_indices_cpu_with_bending.__ctype__(),
+            num_colors_greedy,
+            1.1,
+            particle_colors.__ctype__(),
+        )
+        wp.launch(
+            kernel=validate_graph_coloring,
+            inputs=[edge_indices_cpu_with_bending, particle_colors],
+            dim=edge_indices_cpu_with_bending.shape[0],
+            device="cpu",
+        )
+
+        num_colors_mcs = wp.context.runtime.core.graph_coloring(
+            model.particle_count,
+            edge_indices_cpu_with_bending.__ctype__(),
+            ColoringAlgorithm.MCS.value,
+            particle_colors.__ctype__(),
+        )
+        wp.context.runtime.core.balance_coloring(
+            model.particle_count,
+            edge_indices_cpu_with_bending.__ctype__(),
+            num_colors_mcs,
+            1.1,
+            particle_colors.__ctype__(),
+        )
+        wp.launch(
+            kernel=validate_graph_coloring,
+            inputs=[edge_indices_cpu_with_bending, particle_colors],
+            dim=edge_indices_cpu_with_bending.shape[0],
+            device="cpu",
+        )
+
+
+@unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
+def test_combine_coloring(test, device):
+    from pxr import Usd, UsdGeom
+
+    with wp.ScopedDevice(device):
+        builder1 = wp.sim.ModelBuilder()
+        usd_stage = Usd.Stage.Open(os.path.join(wp.examples.get_asset_directory(), "bunny.usd"))
+        usd_geom = UsdGeom.Mesh(usd_stage.GetPrimAtPath("/root/bunny"))
+
+        vertices = np.array(usd_geom.GetPointsAttr().Get())
+        faces = np.array(usd_geom.GetFaceVertexIndicesAttr().Get())
+
+        builder1.add_cloth_mesh(
+            pos=wp.vec3(0.0, 0.0, 0.0),
+            rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), 0.0),
+            scale=1.0,
+            vertices=[wp.vec3(p) for p in vertices],
+            indices=faces.flatten(),
+            vel=wp.vec3(0.0, 0.0, 0.0),
+            density=0.02,
+        )
+
+        builder1.add_cloth_grid(
+            pos=wp.vec3(0.0, 4.0, 0.0),
+            rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), 0.0),
+            vel=wp.vec3(0.0, 0.0, 0.0),
+            dim_x=50,
+            dim_y=100,
+            cell_x=0.1,
+            cell_y=0.1,
+            mass=0.1,
+            fix_left=True,
+        )
+        builder1.color()
+
+        builder2 = wp.sim.ModelBuilder()
+        builder2.add_cloth_grid(
+            pos=wp.vec3(0.0, 4.0, 0.0),
+            rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), 0.0),
+            vel=wp.vec3(0.0, 0.0, 0.0),
+            dim_x=50,
+            dim_y=100,
+            cell_x=0.1,
+            cell_y=0.1,
+            mass=0.1,
+            # to include bending in coloring
+            edge_ke=100000,
+            fix_left=True,
+        )
+        builder2.color()
+
+        builder3 = wp.sim.ModelBuilder()
+        builder3.add_cloth_grid(
+            pos=wp.vec3(0.0, 4.0, 0.0),
+            rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), 0.0),
+            vel=wp.vec3(0.0, 0.0, 0.0),
+            dim_x=50,
+            dim_y=100,
+            cell_x=0.1,
+            cell_y=0.1,
+            mass=0.1,
+            fix_left=True,
+        )
+
+        builder3.set_coloring(
+            color_lattice_grid(50, 100),
+        )
+
+        builder1.add_builder(builder2)
+        builder1.add_builder(builder3)
+
+        model = builder2.finalize()
+
+        particle_number_colored = np.full((model.particle_count), -1, dtype=int)
+        particle_colors = np.full((model.particle_count), -1, dtype=int)
+        for color, color_group in enumerate(model.particle_coloring):
+            particle_number_colored[color_group.numpy()] += 1
+            particle_colors[color_group.numpy()] = color
+
+        # all particles has been colored exactly once
+        assert_np_equal(particle_number_colored, 0)
+
+        edge_indices_cpu = wp.array(model.edge_indices.numpy()[:, 2:], dtype=int, device="cpu")
+        wp.launch(
+            kernel=validate_graph_coloring,
+            inputs=[edge_indices_cpu, wp.array(particle_colors, dtype=int, device="cpu")],
+            dim=edge_indices_cpu.shape[0],
+            device="cpu",
+        )
+
+
+devices = get_test_devices()
+
+
+class TestColoring(unittest.TestCase):
+    pass
+
+
+add_function_test(TestColoring, "test_coloring_trimesh", test_coloring_trimesh, devices=devices)
+add_function_test(TestColoring, "test_combine_coloring", test_combine_coloring, devices=devices)
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/test_context.py

@@ -0,0 +1,34 @@
+# 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.
+
+import unittest
+from typing import List, Tuple
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+
+def test_context_type_str(test, device):
+    assert wp.context.type_str(List[int]) == "List[int]"
+    assert wp.context.type_str(List[float]) == "List[float]"
+
+    assert wp.context.type_str(Tuple[int]) == "Tuple[int]"
+    assert wp.context.type_str(Tuple[float]) == "Tuple[float]"
+    assert wp.context.type_str(Tuple[int, float]) == "Tuple[int, float]"
+    assert wp.context.type_str(Tuple[int, ...]) == "Tuple[int, ...]"
+
+
+class TestContext(unittest.TestCase):
+    pass
+
+
+add_function_test(TestContext, "test_context_type_str", test_context_type_str)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/test_examples.py

@@ -316,7 +316,7 @@ add_example_test(
     name="sim.example_cloth",
     devices=test_devices,
     test_options={"usd_required": True},
-    test_options_cpu={"num_frames": 10},
+    test_options_cpu={"num_frames": 10, "test_timeout": 600},
 )
 add_example_test(
     TestSimExamples, name="sim.example_granular", devices=test_devices, test_options_cpu={"num_frames": 10}
@@ -365,9 +365,15 @@ if check_p2p():
 add_example_test(
     TestFemExamples,
     name="fem.example_apic_fluid",
-    devices=get_selected_cuda_test_devices(),
+    devices=get_selected_cuda_test_devices(mode="basic"),
     test_options={"num_frames": 5, "voxel_size": 2.0},
 )
+add_example_test(
+    TestFemExamples,
+    name="fem.example_adaptive_grid",
+    devices=get_selected_cuda_test_devices(mode="basic"),
+    test_options={"headless": True, "div_conforming": True},
+)
 
 # The following examples do not need CUDA
 add_example_test(
@@ -390,18 +396,20 @@ add_example_test(
     name="fem.example_convection_diffusion",
     devices=test_devices,
     test_options={"resolution": 20, "headless": True},
+    test_options_cpu={"test_timeout": 600},
 )
 add_example_test(
     TestFemExamples,
     name="fem.example_burgers",
     devices=test_devices,
     test_options={"resolution": 20, "num_frames": 25, "degree": 1, "headless": True},
+    test_options_cpu={"test_timeout": 600},
 )
 add_example_test(
     TestFemExamples,
     name="fem.example_convection_diffusion_dg",
     devices=test_devices,
-    test_options={"resolution": 20, "num_frames": 25, "mesh": "quad", "headless": True},
+    test_options={"resolution": 20, "num_frames": 25, "headless": True},
     test_options_cpu={"test_timeout": 600},
 )
 add_example_test(
@@ -429,9 +437,15 @@ add_example_test(
 add_example_test(
     TestFemExamples,
     name="fem.example_streamlines",
-    devices=test_devices,
+    devices=get_selected_cuda_test_devices(),
     test_options={"headless": True},
 )
+add_example_test(
+    TestFemExamples,
+    name="fem.example_distortion_energy",
+    devices=get_selected_cuda_test_devices(),
+    test_options={"headless": True, "resolution": 16},
+)
 add_example_test(
     TestFemExamples,
     name="fem.example_magnetostatics",

warp/tests/test_fabricarray.py

@@ -821,6 +821,38 @@ def test_fabricarray_fill_matrix(test, device):
             assert_np_equal(ifb.numpy(), np.zeros((*ifb.shape, *mat_shape), dtype=nptype))
 
 
+@wp.kernel
+def fa_kernel_indexing_types(
+    a: wp.fabricarray(dtype=wp.int32),
+):
+    x = a[wp.uint8(0)]
+    y = a[wp.int16(1)]
+    z = a[wp.uint32(2)]
+    w = a[wp.int64(3)]
+
+    a[wp.uint8(0)] = 123
+    a[wp.int16(1)] = 123
+    a[wp.uint32(2)] = 123
+    a[wp.int64(3)] = 123
+
+    wp.atomic_add(a, wp.uint8(0), 123)
+    wp.atomic_sub(a, wp.int16(1), 123)
+    # wp.atomic_min(a, wp.uint32(2), 123)
+    # wp.atomic_max(a, wp.int64(3), 123)
+
+
+def test_fabricarray_indexing_types(test, device):
+    data = wp.zeros(shape=(4,), dtype=wp.int32, device=device)
+    iface = _create_fabric_array_interface(data, "foo", copy=True)
+    fa = wp.fabricarray(data=iface, attrib="foo")
+    wp.launch(
+        kernel=fa_kernel_indexing_types,
+        dim=1,
+        inputs=(fa,),
+        device=device,
+    )
+
+
 @wp.kernel
 def fa_generic_sums_kernel(a: wp.fabricarrayarray(dtype=Any), sums: wp.array(dtype=Any)):
     i = wp.tid()
@@ -945,6 +977,7 @@ add_function_test(TestFabricArray, "test_fabricarray_generic_array", test_fabric
 add_function_test(TestFabricArray, "test_fabricarray_fill_scalar", test_fabricarray_fill_scalar, devices=devices)
 add_function_test(TestFabricArray, "test_fabricarray_fill_vector", test_fabricarray_fill_vector, devices=devices)
 add_function_test(TestFabricArray, "test_fabricarray_fill_matrix", test_fabricarray_fill_matrix, devices=devices)
+add_function_test(TestFabricArray, "test_fabricarray_indexing_types", test_fabricarray_indexing_types, devices=devices)
 
 # fabric arrays of arrays
 add_function_test(TestFabricArray, "test_fabricarrayarray", test_fabricarrayarray, devices=devices)