warp-lang 1.7.0__py3-none-win_amd64.whl → 1.7.1__py3-none-win_amd64.whl

warp/tests/sim/test_xpbd.py

@@ -0,0 +1,399 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from warp.sim.model import PARTICLE_FLAG_ACTIVE
+from warp.tests.unittest_utils import *
+
+# fmt: off
+CLOTH_POINTS = [
+    (-50.0000000, 0.0000000, -50.0000000),
+    (-38.8888893, 11.1111107, -50.0000000),
+    (-27.7777786, 22.2222214, -50.0000000),
+    (-16.6666679, 33.3333321, -50.0000000),
+    (-5.5555558, 44.4444427, -50.0000000),
+    (5.5555558, 55.5555573, -50.0000000),
+    (16.6666679, 66.6666641, -50.0000000),
+    (27.7777786, 77.7777786, -50.0000000),
+    (38.8888893, 88.8888855, -50.0000000),
+    (50.0000000, 100.0000000, -50.0000000),
+    (-50.0000000, 0.0000000, -38.8888893),
+    (-38.8888893, 11.1111107, -38.8888893),
+    (-27.7777786, 22.2222214, -38.8888893),
+    (-16.6666679, 33.3333321, -38.8888893),
+    (-5.5555558, 44.4444427, -38.8888893),
+    (5.5555558, 55.5555573, -38.8888893),
+    (16.6666679, 66.6666641, -38.8888893),
+    (27.7777786, 77.7777786, -38.8888893),
+    (38.8888893, 88.8888855, -38.8888893),
+    (50.0000000, 100.0000000, -38.8888893),
+    (-50.0000000, 0.0000000, -27.7777786),
+    (-38.8888893, 11.1111107, -27.7777786),
+    (-27.7777786, 22.2222214, -27.7777786),
+    (-16.6666679, 33.3333321, -27.7777786),
+    (-5.5555558, 44.4444427, -27.7777786),
+    (5.5555558, 55.5555573, -27.7777786),
+    (16.6666679, 66.6666641, -27.7777786),
+    (27.7777786, 77.7777786, -27.7777786),
+    (38.8888893, 88.8888855, -27.7777786),
+    (50.0000000, 100.0000000, -27.7777786),
+    (-50.0000000, 0.0000000, -16.6666679),
+    (-38.8888893, 11.1111107, -16.6666679),
+    (-27.7777786, 22.2222214, -16.6666679),
+    (-16.6666679, 33.3333321, -16.6666679),
+    (-5.5555558, 44.4444427, -16.6666679),
+    (5.5555558, 55.5555573, -16.6666679),
+    (16.6666679, 66.6666641, -16.6666679),
+    (27.7777786, 77.7777786, -16.6666679),
+    (38.8888893, 88.8888855, -16.6666679),
+    (50.0000000, 100.0000000, -16.6666679),
+    (-50.0000000, 0.0000000, -5.5555558),
+    (-38.8888893, 11.1111107, -5.5555558),
+    (-27.7777786, 22.2222214, -5.5555558),
+    (-16.6666679, 33.3333321, -5.5555558),
+    (-5.5555558, 44.4444427, -5.5555558),
+    (5.5555558, 55.5555573, -5.5555558),
+    (16.6666679, 66.6666641, -5.5555558),
+    (27.7777786, 77.7777786, -5.5555558),
+    (38.8888893, 88.8888855, -5.5555558),
+    (50.0000000, 100.0000000, -5.5555558),
+    (-50.0000000, 0.0000000, 5.5555558),
+    (-38.8888893, 11.1111107, 5.5555558),
+    (-27.7777786, 22.2222214, 5.5555558),
+    (-16.6666679, 33.3333321, 5.5555558),
+    (-5.5555558, 44.4444427, 5.5555558),
+    (5.5555558, 55.5555573, 5.5555558),
+    (16.6666679, 66.6666641, 5.5555558),
+    (27.7777786, 77.7777786, 5.5555558),
+    (38.8888893, 88.8888855, 5.5555558),
+    (50.0000000, 100.0000000, 5.5555558),
+    (-50.0000000, 0.0000000, 16.6666679),
+    (-38.8888893, 11.1111107, 16.6666679),
+    (-27.7777786, 22.2222214, 16.6666679),
+    (-16.6666679, 33.3333321, 16.6666679),
+    (-5.5555558, 44.4444427, 16.6666679),
+    (5.5555558, 55.5555573, 16.6666679),
+    (16.6666679, 66.6666641, 16.6666679),
+    (27.7777786, 77.7777786, 16.6666679),
+    (38.8888893, 88.8888855, 16.6666679),
+    (50.0000000, 100.0000000, 16.6666679),
+    (-50.0000000, 0.0000000, 27.7777786),
+    (-38.8888893, 11.1111107, 27.7777786),
+    (-27.7777786, 22.2222214, 27.7777786),
+    (-16.6666679, 33.3333321, 27.7777786),
+    (-5.5555558, 44.4444427, 27.7777786),
+    (5.5555558, 55.5555573, 27.7777786),
+    (16.6666679, 66.6666641, 27.7777786),
+    (27.7777786, 77.7777786, 27.7777786),
+    (38.8888893, 88.8888855, 27.7777786),
+    (50.0000000, 100.0000000, 27.7777786),
+    (-50.0000000, 0.0000000, 38.8888893),
+    (-38.8888893, 11.1111107, 38.8888893),
+    (-27.7777786, 22.2222214, 38.8888893),
+    (-16.6666679, 33.3333321, 38.8888893),
+    (-5.5555558, 44.4444427, 38.8888893),
+    (5.5555558, 55.5555573, 38.8888893),
+    (16.6666679, 66.6666641, 38.8888893),
+    (27.7777786, 77.7777786, 38.8888893),
+    (38.8888893, 88.8888855, 38.8888893),
+    (50.0000000, 100.0000000, 38.8888893),
+    (-50.0000000, 0.0000000, 50.0000000),
+    (-38.8888893, 11.1111107, 50.0000000),
+    (-27.7777786, 22.2222214, 50.0000000),
+    (-16.6666679, 33.3333321, 50.0000000),
+    (-5.5555558, 44.4444427, 50.0000000),
+    (5.5555558, 55.5555573, 50.0000000),
+    (16.6666679, 66.6666641, 50.0000000),
+    (27.7777786, 77.7777786, 50.0000000),
+    (38.8888893, 88.8888855, 50.0000000),
+    (50.0000000, 100.0000000, 50.0000000),
+]
+
+CLOTH_FACES = [
+    1, 12, 2,
+    1, 11, 12,
+    2, 12, 3,
+    12, 13, 3,
+    3, 14, 4,
+    3, 13, 14,
+    4, 14, 5,
+    14, 15, 5,
+    5, 16, 6,
+    5, 15, 16,
+    6, 16, 7,
+    16, 17, 7,
+    7, 18, 8,
+    7, 17, 18,
+    8, 18, 9,
+    18, 19, 9,
+    9, 20, 10,
+    9, 19, 20,
+    11, 21, 12,
+    21, 22, 12,
+    12, 23, 13,
+    12, 22, 23,
+    13, 23, 14,
+    23, 24, 14,
+    14, 25, 15,
+    14, 24, 25,
+    15, 25, 16,
+    25, 26, 16,
+    16, 27, 17,
+    16, 26, 27,
+    17, 27, 18,
+    27, 28, 18,
+    18, 29, 19,
+    18, 28, 29,
+    19, 29, 20,
+    29, 30, 20,
+    21, 32, 22,
+    21, 31, 32,
+    22, 32, 23,
+    32, 33, 23,
+    23, 34, 24,
+    23, 33, 34,
+    24, 34, 25,
+    34, 35, 25,
+    25, 36, 26,
+    25, 35, 36,
+    26, 36, 27,
+    36, 37, 27,
+    27, 38, 28,
+    27, 37, 38,
+    28, 38, 29,
+    38, 39, 29,
+    29, 40, 30,
+    29, 39, 40,
+    31, 41, 32,
+    41, 42, 32,
+    32, 43, 33,
+    32, 42, 43,
+    33, 43, 34,
+    43, 44, 34,
+    34, 45, 35,
+    34, 44, 45,
+    35, 45, 36,
+    45, 46, 36,
+    36, 47, 37,
+    36, 46, 47,
+    37, 47, 38,
+    47, 48, 38,
+    38, 49, 39,
+    38, 48, 49,
+    39, 49, 40,
+    49, 50, 40,
+    41, 52, 42,
+    41, 51, 52,
+    42, 52, 43,
+    52, 53, 43,
+    43, 54, 44,
+    43, 53, 54,
+    44, 54, 45,
+    54, 55, 45,
+    45, 56, 46,
+    45, 55, 56,
+    46, 56, 47,
+    56, 57, 47,
+    47, 58, 48,
+    47, 57, 58,
+    48, 58, 49,
+    58, 59, 49,
+    49, 60, 50,
+    49, 59, 60,
+    51, 61, 52,
+    61, 62, 52,
+    52, 63, 53,
+    52, 62, 63,
+    53, 63, 54,
+    63, 64, 54,
+    54, 65, 55,
+    54, 64, 65,
+    55, 65, 56,
+    65, 66, 56,
+    56, 67, 57,
+    56, 66, 67,
+    57, 67, 58,
+    67, 68, 58,
+    58, 69, 59,
+    58, 68, 69,
+    59, 69, 60,
+    69, 70, 60,
+    61, 72, 62,
+    61, 71, 72,
+    62, 72, 63,
+    72, 73, 63,
+    63, 74, 64,
+    63, 73, 74,
+    64, 74, 65,
+    74, 75, 65,
+    65, 76, 66,
+    65, 75, 76,
+    66, 76, 67,
+    76, 77, 67,
+    67, 78, 68,
+    67, 77, 78,
+    68, 78, 69,
+    78, 79, 69,
+    69, 80, 70,
+    69, 79, 80,
+    71, 81, 72,
+    81, 82, 72,
+    72, 83, 73,
+    72, 82, 83,
+    73, 83, 74,
+    83, 84, 74,
+    74, 85, 75,
+    74, 84, 85,
+    75, 85, 76,
+    85, 86, 76,
+    76, 87, 77,
+    76, 86, 87,
+    77, 87, 78,
+    87, 88, 78,
+    78, 89, 79,
+    78, 88, 89,
+    79, 89, 80,
+    89, 90, 80,
+    81, 92, 82,
+    81, 91, 92,
+    82, 92, 83,
+    92, 93, 83,
+    83, 94, 84,
+    83, 93, 94,
+    84, 94, 85,
+    94, 95, 85,
+    85, 96, 86,
+    85, 95, 96,
+    86, 96, 87,
+    96, 97, 87,
+    87, 98, 88,
+    87, 97, 98,
+    88, 98, 89,
+    98, 99, 89,
+    89, 100, 90,
+    89, 99, 100
+]
+
+# fmt: on
+class XPBDClothSim:
+    def __init__(self, device, use_cuda_graph=False):
+        self.frame_dt = 1 / 60
+        self.num_test_frames = 100
+        self.num_substeps = 20
+        self.iterations = 2
+        self.dt = self.frame_dt / self.num_substeps
+        self.device = device
+        self.use_cuda_graph = self.device.is_cuda and use_cuda_graph
+        self.builder = wp.sim.ModelBuilder()
+
+    def set_free_falling_experiment(self):
+        self.input_scale_factor = 1.0
+        self.renderer_scale_factor = 0.01
+        vertices = [wp.vec3(v) * self.input_scale_factor for v in CLOTH_POINTS]
+        faces_flatten = [fv - 1 for fv in CLOTH_FACES]
+
+        self.builder.add_cloth_mesh(
+            vertices=vertices,
+            indices=faces_flatten,
+            scale=0.05,
+            density=10,
+            pos=wp.vec3(0.0, 4.0, 0.0),
+            rot=wp.quat_identity(),
+            vel=wp.vec3(0.0, 0.0, 0.0),
+            edge_ke=1.0e2,
+            add_springs=True,
+            spring_ke=1.0e3,
+            spring_kd=0.0,
+        )
+        self.fixed_particles = []
+        self.num_test_frames = 30
+
+    def finalize(self, ground=True):
+        self.model = self.builder.finalize(device=self.device)
+        self.model.ground = ground
+        self.model.gravity = wp.vec3(0, -10.0, 0)
+        self.model.soft_contact_ke = 1.0e4
+        self.model.soft_contact_kd = 1.0e2
+
+        self.set_points_fixed(self.model, self.fixed_particles)
+
+        self.integrator = wp.sim.XPBDIntegrator(self.iterations)
+        self.state0 = self.model.state()
+        self.state1 = self.model.state()
+
+        self.init_pos = np.array(self.state0.particle_q.numpy(), copy=True)
+
+        self.graph = None
+        if self.use_cuda_graph:
+            with wp.ScopedCapture(device=self.device, force_module_load=False) as capture:
+                self.simulate()
+            self.graph = capture.graph
+
+    def simulate(self):
+        for _step in range(self.num_substeps * self.num_test_frames):
+            self.integrator.simulate(self.model, self.state0, self.state1, self.dt, None)
+            (self.state0, self.state1) = (self.state1, self.state0)
+
+    def run(self):
+        if self.graph:
+            wp.capture_launch(self.graph)
+        else:
+            self.simulate()
+
+    def set_points_fixed(self, model, fixed_particles):
+        if len(fixed_particles):
+            flags = model.particle_flags.numpy()
+            for fixed_v_id in fixed_particles:
+                flags[fixed_v_id] = wp.uint32(int(flags[fixed_v_id]) & ~int(PARTICLE_FLAG_ACTIVE))
+
+            model.particle_flags = wp.array(flags, device=model.device)
+
+
+def test_xpbd_free_falling(test, device):
+    example = XPBDClothSim(device)
+    example.set_free_falling_experiment()
+    example.finalize(ground=False)
+    initial_pos = example.state0.particle_q.numpy().copy()
+
+    example.run()
+
+    # examine that the simulation does not explode
+    final_pos = example.state0.particle_q.numpy()
+    test.assertTrue((final_pos < 1e5).all())
+    # examine that the simulation have moved
+    test.assertTrue((example.init_pos != final_pos).any())
+
+    gravity = np.array(example.model.gravity)
+    diff = final_pos - initial_pos
+    vertical_translation_norm = diff @ gravity[..., None] / (np.linalg.norm(gravity) ** 2)
+    # ensure it's free-falling
+    test.assertTrue((np.abs(vertical_translation_norm - 0.5 * np.linalg.norm(gravity) * (example.dt**2)) < 2e-1).all())
+    horizontal_move = diff - (vertical_translation_norm * gravity)
+    # ensure its horizontal translation is minimal
+    test.assertTrue((np.abs(horizontal_move) < 1e-1).all())
+
+
+devices = get_test_devices(mode="basic")
+
+
+class TestXPBD(unittest.TestCase):
+    pass
+
+
+add_function_test(TestXPBD, "test_xpbd_free_falling", test_xpbd_free_falling, devices=devices)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/test_codegen.py

@@ -482,7 +482,7 @@ def test_error_unmatched_arguments(test, device):
     kernel = wp.Kernel(func=kernel_2_fn)
     with test.assertRaisesRegex(
         RuntimeError,
-        r"Input types must be exactly the same, got \[\"vector\(length=2, dtype=<class 'warp.types.float32'>\)\", \"vector\(length=2, dtype=<class 'warp.types.float16'>\)\"\]",
+        r"Input types must be exactly the same, got \['vec2f', 'vector\(length=2, dtype=float16\)'\]",
     ):
         wp.launch(kernel, dim=1, device=device)
 
@@ -672,6 +672,27 @@ def test_while_condition_eval():
         it.valid = False
 
 
+@wp.kernel
+def conditional_return_or_sum(result: wp.array(dtype=wp.int32)):
+    tid = wp.tid()
+
+    if tid < 256:
+        return
+
+    wp.atomic_add(result, 0, 1)
+
+
+def test_codegen_return_in_kernel(test, device):
+    result = wp.zeros(1, dtype=wp.int32, device=device)
+
+    grid_size = 1024
+
+    # On CUDA devices, this becomes a grid-stride loop
+    wp.launch(conditional_return_or_sum, dim=grid_size, inputs=[result], block_dim=256, max_blocks=1, device=device)
+
+    test.assertEqual(result.numpy()[0], grid_size - 256)
+
+
 class TestCodeGen(unittest.TestCase):
     pass
 
@@ -803,8 +824,8 @@ add_function_test(
 add_kernel_test(TestCodeGen, name="test_call_syntax", kernel=test_call_syntax, dim=1, devices=devices)
 add_kernel_test(TestCodeGen, name="test_shadow_builtin", kernel=test_shadow_builtin, dim=1, devices=devices)
 add_kernel_test(TestCodeGen, name="test_while_condition_eval", kernel=test_while_condition_eval, dim=1, devices=devices)
-
+add_function_test(TestCodeGen, "test_codegen_return_in_kernel", test_codegen_return_in_kernel, devices=devices)
 
 if __name__ == "__main__":
     wp.clear_kernel_cache()
-    unittest.main(verbosity=2, failfast=True)
+    unittest.main(verbosity=2)

warp/tests/test_examples.py

@@ -36,6 +36,7 @@ Use "test_timeout" to override the default test timeout threshold of 600 seconds
 """
 
 import os
+import platform
 import subprocess
 import sys
 import unittest
@@ -239,12 +240,21 @@ add_example_test(
     devices=test_devices,
     test_options={"usd_required": True, "headless": True},
 )
-add_example_test(
-    TestCoreExamples,
-    name="core.example_raymarch",
-    devices=test_devices,
-    test_options={"height": 512, "width": 1024, "headless": True},
-)
+if platform.system() == "Windows":
+    # Skip GPU testing because of obscure NVRTC bug with illegal memory access
+    add_example_test(
+        TestCoreExamples,
+        name="core.example_raymarch",
+        devices=[wp.get_device("cpu")],
+        test_options={"height": 512, "width": 1024, "headless": True},
+    )
+else:
+    add_example_test(
+        TestCoreExamples,
+        name="core.example_raymarch",
+        devices=test_devices,
+        test_options={"height": 512, "width": 1024, "headless": True},
+    )
 add_example_test(
     TestCoreExamples,
     name="core.example_sample_mesh",

warp/tests/test_fem.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 
 import math
+import platform
 import unittest
 from typing import Any
 
@@ -475,6 +476,22 @@ def _test_geo_cells(
     wp.atomic_add(cell_measures, s.element_index, fem.measure(domain, s) * s.qp_weight)
 
 
+@fem.integrand(kernel_options={"enable_backward": False})
+def _test_cell_lookup(
+    s: fem.Sample,
+    domain: fem.Domain,
+):
+    pos = domain(s)
+
+    s_guess = fem.lookup(domain, pos, s)
+    wp.expect_eq(s_guess.element_index, s.element_index)
+    wp.expect_near(domain(s_guess), pos, 0.001)
+
+    s_noguess = fem.lookup(domain, pos)
+    wp.expect_eq(s_noguess.element_index, s.element_index)
+    wp.expect_near(domain(s_noguess), pos, 0.001)
+
+
 @fem.integrand(kernel_options={"enable_backward": False, "max_unroll": 1})
 def _test_geo_sides(
     s: fem.Sample,
@@ -527,7 +544,7 @@ def _test_side_normals(
         wp.expect_near(F_cross[k], nor[k], 0.0001)
 
 
-def _launch_test_geometry_kernel(geo: fem.Geometry, device):
+def _launch_test_geometry_kernel(geo: fem.Geometry, device, test_cell_lookup: bool = True):
     cell_measures = wp.zeros(dtype=float, device=device, shape=geo.cell_count())
     cell_quadrature = fem.RegularQuadrature(fem.Cells(geo), order=2)
 
@@ -540,6 +557,12 @@ def _launch_test_geometry_kernel(geo: fem.Geometry, device):
             quadrature=cell_quadrature,
             values={"cell_measures": cell_measures},
         )
+        if test_cell_lookup:
+            fem.interpolate(
+                _test_cell_lookup,
+                quadrature=cell_quadrature,
+            )
+
         fem.interpolate(
             _test_geo_sides,
             quadrature=side_quadrature,
@@ -577,7 +600,7 @@ def test_triangle_mesh(test, device):
     with wp.ScopedDevice(device):
         positions, tri_vidx = _gen_trimesh(N, N)
 
-    geo = fem.Trimesh2D(tri_vertex_indices=tri_vidx, positions=positions)
+    geo = fem.Trimesh2D(tri_vertex_indices=tri_vidx, positions=positions, build_bvh=True)
 
     test.assertEqual(geo.cell_count(), 2 * (N) ** 2)
     test.assertEqual(geo.vertex_count(), (N + 1) ** 2)
@@ -595,7 +618,7 @@ def test_triangle_mesh(test, device):
     positions = np.hstack((positions, np.ones((positions.shape[0], 1))))
     positions = wp.array(positions, device=device, dtype=wp.vec3)
 
-    geo = fem.Trimesh3D(tri_vertex_indices=tri_vidx, positions=positions)
+    geo = fem.Trimesh3D(tri_vertex_indices=tri_vidx, positions=positions, build_bvh=True)
 
     test.assertEqual(geo.cell_count(), 2 * (N) ** 2)
     test.assertEqual(geo.vertex_count(), (N + 1) ** 2)
@@ -621,7 +644,7 @@ def test_quad_mesh(test, device):
     test.assertEqual(geo.side_count(), 2 * (N + 1) * N)
     test.assertEqual(geo.boundary_side_count(), 4 * N)
 
-    side_measures, cell_measures = _launch_test_geometry_kernel(geo, device)
+    side_measures, cell_measures = _launch_test_geometry_kernel(geo, device, test_cell_lookup=False)
 
     assert_np_equal(side_measures.numpy(), np.full(side_measures.shape, 1.0 / (N)), tol=1.0e-4)
     assert_np_equal(cell_measures.numpy(), np.full(cell_measures.shape, 1.0 / (N**2)), tol=1.0e-4)
@@ -639,7 +662,7 @@ def test_quad_mesh(test, device):
     test.assertEqual(geo.side_count(), 2 * (N + 1) * N)
     test.assertEqual(geo.boundary_side_count(), 4 * N)
 
-    side_measures, cell_measures = _launch_test_geometry_kernel(geo, device)
+    side_measures, cell_measures = _launch_test_geometry_kernel(geo, device, test_cell_lookup=False)
 
     assert_np_equal(side_measures.numpy(), np.full(side_measures.shape, 1.0 / (N)), tol=1.0e-4)
     assert_np_equal(cell_measures.numpy(), np.full(cell_measures.shape, 1.0 / (N**2)), tol=1.0e-4)
@@ -668,7 +691,7 @@ def test_tet_mesh(test, device):
     with wp.ScopedDevice(device):
         positions, tet_vidx = _gen_tetmesh(N, N, N)
 
-    geo = fem.Tetmesh(tet_vertex_indices=tet_vidx, positions=positions)
+    geo = fem.Tetmesh(tet_vertex_indices=tet_vidx, positions=positions, build_bvh=True)
 
     test.assertEqual(geo.cell_count(), 5 * (N) ** 3)
     test.assertEqual(geo.vertex_count(), (N + 1) ** 3)
@@ -696,7 +719,7 @@ def test_hex_mesh(test, device):
     test.assertEqual(geo.boundary_side_count(), 6 * N * N)
     test.assertEqual(geo.edge_count(), 3 * N * (N + 1) ** 2)
 
-    side_measures, cell_measures = _launch_test_geometry_kernel(geo, device)
+    side_measures, cell_measures = _launch_test_geometry_kernel(geo, device, test_cell_lookup=False)
 
     assert_np_equal(side_measures.numpy(), np.full(side_measures.shape, 1.0 / (N**2)), tol=1.0e-4)
     assert_np_equal(cell_measures.numpy(), np.full(cell_measures.shape, 1.0 / (N**3)), tol=1.0e-4)
@@ -732,6 +755,9 @@ def _refinement_field(x: wp.vec3):
 def test_adaptive_nanogrid(test, device):
     # 3 res-1 voxels, 8 res-0 voxels
 
+    if platform.system() == "Windows" or (device.is_cuda and wp.context.runtime.toolkit_version[0] == 11):
+        test.skipTest("Skipping test due to NVRTC bug on CUDA 11 and Windows")
+
     res0 = wp.array(
         [
             [2, 2, 0],
@@ -756,7 +782,6 @@ def test_adaptive_nanogrid(test, device):
         dtype=int,
         device=device,
     )
-
     grid0 = wp.Volume.allocate_by_voxels(res0, 0.5, device=device)
     grid1 = wp.Volume.allocate_by_voxels(res1, 1.0, device=device)
     geo = fem.adaptive_nanogrid_from_hierarchy([grid0, grid1])
@@ -819,7 +844,7 @@ def test_deformed_geometry(test, device):
         test.assertEqual(geo.side_count(), 6 * (N + 1) * N**2 + (N**3) * 4)
         test.assertEqual(geo.boundary_side_count(), 12 * N * N)
 
-        side_measures, cell_measures = _launch_test_geometry_kernel(deformed_geo, wp.get_device())
+        side_measures, cell_measures = _launch_test_geometry_kernel(deformed_geo, device, test_cell_lookup=False)
 
         test.assertAlmostEqual(
             np.sum(cell_measures.numpy()), scale**3, places=4, msg=f"cell_measures = {cell_measures.numpy()}"
@@ -853,6 +878,45 @@ def test_deformed_geometry(test, device):
             ],
         )
 
+        # Test with Trimesh3d (different space and cell dimensions)
+        positions, tri_vidx = _gen_trimesh(N, N)
+        positions = positions.numpy()
+        positions = np.hstack((positions, np.ones((positions.shape[0], 1))))
+        positions = wp.array(positions, device=device, dtype=wp.vec3)
+
+        geo = fem.Trimesh3D(tri_vertex_indices=tri_vidx, positions=positions)
+
+        vector_space = fem.make_polynomial_space(geo, dtype=wp.vec3, degree=1)
+        pos_field = vector_space.make_field()
+        fem.interpolate(
+            _rigid_deformation_field,
+            dest=pos_field,
+            values={"translation": translation, "rotation": rotation, "scale": scale},
+        )
+
+        deformed_geo = pos_field.make_deformed_geometry()
+
+        @wp.kernel
+        def _test_deformed_geometry_normal(geo_arg: geo.CellArg, def_arg: deformed_geo.CellArg, rotation: wp.vec3):
+            i = wp.tid()
+
+            s = make_free_sample(i, Coords(0.5, 0.5, 0.0))
+            geo_n = geo.cell_normal(geo_arg, s)
+            def_n = deformed_geo.cell_normal(def_arg, s)
+
+            q = wp.quat_from_axis_angle(wp.normalize(rotation), wp.length(rotation))
+            wp.expect_near(wp.quat_rotate(q, geo_n), def_n, 0.001)
+
+        wp.launch(
+            _test_deformed_geometry_normal,
+            dim=geo.cell_count(),
+            inputs=[
+                geo.cell_arg_value(wp.get_device()),
+                deformed_geo.cell_arg_value(wp.get_device()),
+                rotation,
+            ],
+        )
+
     wp.synchronize()
 
 
@@ -1847,7 +1911,7 @@ def test_vector_spaces(test, device):
 
 @wp.kernel
 def test_qr_eigenvalues():
-    tol = 1.0e-8
+    tol = 5.0e-7
 
     # zero
     Zero = wp.mat33(0.0)
@@ -1984,6 +2048,7 @@ class TestFemUtilities(unittest.TestCase):
 
 
 add_kernel_test(TestFemUtilities, test_qr_eigenvalues, dim=1, devices=devices)
+
 add_kernel_test(TestFemUtilities, test_qr_inverse, dim=100, devices=devices)
 add_function_test(TestFemUtilities, "test_array_axpy", test_array_axpy)