warp-lang 1.8.0__py3-none-manylinux_2_34_aarch64.whl → 1.8.1__py3-none-manylinux_2_34_aarch64.whl

warp/sparse.py

@@ -483,7 +483,7 @@ def bsr_set_from_triplets(
 
     device = dest.values.device
     scalar_type = dest.scalar_type
-    zero_value_mask = _zero_value_masks.get(scalar_type, 0)
+    zero_value_mask = _zero_value_masks.get(scalar_type, 0) if prune_numerical_zeros else 0
 
     # compute the BSR topology
 

warp/tape.py

@@ -251,6 +251,8 @@ class Tape:
                     else:
                         grad = None
                     setattr(adj, name, grad)
+                elif isinstance(a._cls.vars[name].type, wp.codegen.Struct):
+                    setattr(adj, name, self.get_adjoint(getattr(a, name)))
                 else:
                     setattr(adj, name, getattr(a, name))
 

warp/tests/sim/test_cloth.py

@@ -25,6 +25,7 @@ import warp.sim.integrator_euler
 import warp.sim.integrator_vbd
 import warp.sim.integrator_xpbd
 import warp.sim.particles
+import warp.sim.render
 from warp.sim.model import PARTICLE_FLAG_ACTIVE
 from warp.tests.unittest_utils import *
 
@@ -299,14 +300,16 @@ CLOTH_FACES = [
 
 # fmt: on
 class ClothSim:
-    def __init__(self, device, solver, use_cuda_graph=False):
+    def __init__(self, device, solver, use_cuda_graph=False, do_rendering=False):
         self.frame_dt = 1 / 60
         self.num_test_frames = 50
         self.iterations = 5
+        self.do_rendering = do_rendering
         self.device = device
         self.use_cuda_graph = self.device.is_cuda and use_cuda_graph
         self.builder = wp.sim.ModelBuilder()
         self.solver = solver
+        self.renderer_scale_factor = 1.0
 
         if solver != "semi_implicit":
             self.num_substeps = 10
@@ -434,7 +437,7 @@ class ClothSim:
 
         self.finalize()
 
-    def set_collision_experiment(self):
+    def set_self_collision_experiment(self):
         elasticity_ke = 1e4
         elasticity_kd = 1e-6
 
@@ -487,6 +490,44 @@ class ClothSim:
         self.model.gravity = wp.vec3(0.0, -1000.0, 0)
         self.num_test_frames = 30
 
+    def set_body_collision_experiment(self, handle_self_contact=False):
+        self.renderer_scale_factor = 1.0
+        elasticity_ke = 1e4
+        elasticity_kd = 1e-6
+
+        vs1 = [wp.vec3(v) for v in [[0, 0, 0], [1, 0, 0], [1, 0, 1], [0, 0, 1]]]
+        fs1 = [0, 1, 2, 0, 2, 3]
+
+        self.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=vs1,
+            indices=fs1,
+            vel=wp.vec3(0.0, 0.0, 0.0),
+            density=0.02,
+            tri_ke=elasticity_ke,
+            tri_ka=elasticity_ke,
+            tri_kd=elasticity_kd,
+            add_springs=self.solver == "xpbd",
+            spring_ke=1.0e3,
+            spring_kd=0.0,
+            particle_radius=0.1,
+        )
+
+        self.builder.add_shape_box(-1, pos=wp.vec3(0, -3.3, 0), hx=3, hy=3, hz=3)
+
+        self.fixed_particles = []
+
+        self.finalize(handle_self_contact=handle_self_contact, ground=False)
+        self.model.soft_contact_radius = 0.1
+        self.model.soft_contact_margin = 0.1
+        self.model.soft_contact_ke = 1e4
+        self.model.soft_contact_kd = 1e-3
+        self.model.soft_contact_mu = 0.2
+        self.model.gravity = wp.vec3(0.0, -1000.0, 0)
+        self.num_test_frames = 30
+
     def set_up_non_zero_rest_angle_bending_experiment(self):
         # fmt: off
         vs =[
@@ -629,6 +670,9 @@ class ClothSim:
                 wp.load_module(warp.sim.integrator_euler, device=self.device)
             wp.load_module(warp.sim.particles, device=self.device)
             wp.load_module(warp.sim.integrator, device=self.device)
+            collide_module = importlib.import_module("warp.sim.collide")
+            wp.set_module_options({"block_dim": 256}, collide_module)
+            wp.load_module(collide_module, device=self.device)
             wp.load_module(device=self.device)
             with wp.ScopedCapture(device=self.device, force_module_load=False) as capture:
                 self.simulate()
@@ -637,17 +681,30 @@ class ClothSim:
     def simulate(self):
         for _step in range(self.num_substeps):
             self.state0.clear_forces()
+            wp.sim.collide(self.model, self.state0)
 
             self.integrator.simulate(self.model, self.state0, self.state1, self.dt, None)
             (self.state0, self.state1) = (self.state1, self.state0)
 
     def run(self):
         self.sim_time = 0.0
+
+        if self.do_rendering:
+            self.renderer = wp.sim.render.SimRendererOpenGL(self.model, "cloth_sim", scaling=self.renderer_scale_factor)
+        else:
+            self.renderer = None
+
         for _frame in range(self.num_test_frames):
             if self.graph:
                 wp.capture_launch(self.graph)
             else:
                 self.simulate()
+
+                if self.renderer is not None:
+                    self.renderer.begin_frame()
+                    self.renderer.render(self.state0)
+                    self.renderer.end_frame()
+
             self.sim_time = self.sim_time + self.frame_dt
 
     def set_points_fixed(self, model, fixed_particles):
@@ -702,16 +759,41 @@ def test_cloth_bending_non_zero_rest_angle_bending(test, device, solver):
     test.assertTrue((example.init_pos != final_pos).any())
 
 
-def test_cloth_collision(test, device, solver):
+def test_cloth_body_collision(test, device, solver):
+    example = ClothSim(device, solver, use_cuda_graph=True)
+    example.set_body_collision_experiment(handle_self_contact=False)
+
+    example.run()
+
+    # examine that the velocity has died out
+    final_vel = example.state0.particle_qd.numpy()
+    final_pos = example.state0.particle_q.numpy()
+    test.assertTrue((np.linalg.norm(final_vel, axis=1) < 1.0).all())
+    # examine that the simulation has moved
+    test.assertTrue((example.init_pos[:, 1] != final_pos[:, 1]).any())
+
+    # run again with handle_self_contact=True
+    example = ClothSim(device, solver, use_cuda_graph=True)
+    example.set_body_collision_experiment(handle_self_contact=True)
+    example.run()
+    # examine that the velocity has died out
+    final_vel = example.state0.particle_qd.numpy()
+    final_pos = example.state0.particle_q.numpy()
+    test.assertTrue((np.linalg.norm(final_vel, axis=1) < 1.0).all())
+    # examine that the simulation has moved
+    test.assertTrue((example.init_pos[:, 1] != final_pos[:, 1]).any())
+
+
+def test_cloth_self_collision(test, device, solver):
     example = ClothSim(device, solver, use_cuda_graph=True)
-    example.set_collision_experiment()
+    example.set_self_collision_experiment()
 
     example.run()
 
     # examine that the velocity has died out
     final_vel = example.state0.particle_qd.numpy()
     final_pos = example.state0.particle_q.numpy()
-    test.assertTrue((np.linalg.norm(final_vel, axis=0) < 1.0).all())
+    test.assertTrue((np.linalg.norm(final_vel, axis=1) < 1.0).all())
     # examine that the simulation has moved
     test.assertTrue((example.init_pos != final_pos).any())
 
@@ -763,7 +845,8 @@ tests_to_run = {
         test_cloth_free_fall,
         test_cloth_sagging,
         test_cloth_bending,
-        test_cloth_collision,
+        test_cloth_self_collision,
+        test_cloth_body_collision,
         test_cloth_bending_non_zero_rest_angle_bending,
     ],
 }

warp/tests/sim/test_coloring.py

@@ -13,6 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import itertools
+
 import numpy as np
 
 import warp as wp
@@ -48,6 +50,63 @@ def color_lattice_grid(num_x, num_y):
     return color_groups
 
 
+def create_lattice_grid(N):
+    size = 10
+    position = (0, 0)
+
+    X = np.linspace(-0.5 * size + position[0], 0.5 * size + position[0], N)
+    Y = np.linspace(-0.5 * size + position[1], 0.5 * size + position[1], N)
+
+    X, Y = np.meshgrid(X, Y)
+
+    Z = []
+    for _i in range(N):
+        Z.append(np.linspace(0, size, N))
+
+    Z = np.array(Z)
+
+    vs = []
+    for i, j in itertools.product(range(N), range(N)):
+        vs.append(wp.vec3((X[i, j], Y[i, j], Z[i, j])))
+
+    fs = []
+    for i, j in itertools.product(range(0, N - 1), range(0, N - 1)):
+        vId = j + i * N
+
+        if (j + i) % 2:
+            fs.extend(
+                [
+                    vId,
+                    vId + N + 1,
+                    vId + 1,
+                ]
+            )
+            fs.extend(
+                [
+                    vId,
+                    vId + N,
+                    vId + N + 1,
+                ]
+            )
+        else:
+            fs.extend(
+                [
+                    vId,
+                    vId + N,
+                    vId + 1,
+                ]
+            )
+            fs.extend(
+                [
+                    vId + N,
+                    vId + N + 1,
+                    vId + 1,
+                ]
+            )
+
+    return vs, fs
+
+
 def test_coloring_corner_case(test, device):
     builder_1 = wp.sim.ModelBuilder()
     builder_1.color()
@@ -164,6 +223,22 @@ def test_coloring_trimesh(test, device):
         color_sizes = np.array([c.shape[0] for c in color_categories_balanced], dtype=np.float32)
         test.assertTrue(np.max(color_sizes) / np.min(color_sizes) <= max_min_ratio)
 
+        # test if the color balance can quit from equilibrium
+        builder = wp.sim.ModelBuilder()
+
+        vs, fs = create_lattice_grid(100)
+        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=vs,
+            indices=fs,
+            vel=wp.vec3(0.0, 0.0, 0.0),
+            density=0.02,
+        )
+
+        builder.color(include_bending=True)
+
 
 @unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
 def test_combine_coloring(test, device):
@@ -263,7 +338,7 @@ class TestColoring(unittest.TestCase):
     pass
 
 
-add_function_test(TestColoring, "test_coloring_trimesh", test_coloring_trimesh, devices=devices)
+add_function_test(TestColoring, "test_coloring_trimesh", test_coloring_trimesh, devices=devices, check_output=False)
 add_function_test(TestColoring, "test_combine_coloring", test_combine_coloring, devices=devices)
 add_function_test(TestColoring, "test_coloring_corner_case", test_coloring_corner_case, devices=devices)
 

warp/tests/test_assert.py

@@ -245,6 +245,59 @@ class TestAssertDebug(unittest.TestCase):
                 self.assertRegex(output, r"Assertion failed: .*assert value == 1.*Array element must be 1")
 
 
+class TestAssertModeSwitch(unittest.TestCase):
+    """Test that switching from release mode to debug mode rebuilds the module with assertions enabled."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls._saved_mode = wp.config.mode
+        cls._saved_mode_module = wp.get_module_options()["mode"]
+        cls._saved_cache_kernels = wp.config.cache_kernels
+
+        # Don't set any mode initially - use whatever the default is
+        wp.config.cache_kernels = False
+
+    @classmethod
+    def tearDownClass(cls):
+        wp.config.mode = cls._saved_mode
+        wp.set_module_options({"mode": cls._saved_mode_module})
+        wp.config.cache_kernels = cls._saved_cache_kernels
+
+    def test_switch_to_debug_mode(self):
+        """Test that switching from release mode to debug mode rebuilds the module with assertions enabled."""
+        with wp.ScopedDevice("cpu"):
+            # Create an array that will trigger an assertion
+            input_array = wp.zeros(1, dtype=int)
+
+            # In default mode, this should not assert
+            capture = StdErrCapture()
+            capture.begin()
+            wp.launch(expect_ones, input_array.shape, inputs=[input_array])
+            output = capture.end()
+
+            # Should not have any assertion output in release mode
+            self.assertEqual(output, "", f"Kernel should not print anything to stderr in release mode, got {output}")
+
+            # Now switch to debug mode and have it compile a new kernel
+            wp.config.mode = "debug"
+
+            @wp.kernel
+            def expect_ones_debug(a: wp.array(dtype=int)):
+                i = wp.tid()
+                assert a[i] == 1
+
+            # In debug mode, this should assert
+            capture = StdErrCapture()
+            capture.begin()
+            wp.launch(expect_ones_debug, input_array.shape, inputs=[input_array])
+            output = capture.end()
+
+            # Should have assertion output in debug mode
+            # Older Windows C runtimes have a bug where stdout sometimes does not get properly flushed.
+            if output != "" or sys.platform != "win32":
+                self.assertRegex(output, r"Assertion failed: .*assert a\[i\] == 1")
+
+
 if __name__ == "__main__":
     wp.clear_kernel_cache()
     unittest.main(verbosity=2)