warp-lang 1.6.2__py3-none-macosx_10_13_universal2.whl → 1.7.1__py3-none-macosx_10_13_universal2.whl

warp/fem/field/nodal_field.py

@@ -83,22 +83,15 @@ class NodalFieldBase(DiscreteField):
         @cache.dynamic_func(suffix=self.name)
         def eval_inner(args: self.ElementEvalArg, s: Sample):
             local_value_map = self.space.local_value_map_inner(args.elt_arg, s.element_index, s.element_coords)
-            res = self.space.space_value(
-                self._read_node_value(args, s.element_index, 0),
-                self.space.element_inner_weight(
-                    args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, 0
-                ),
-                local_value_map,
-            )
-
             node_count = self.space.topology.element_node_count(
                 args.elt_arg, args.eval_arg.topology_arg, s.element_index
             )
-            for k in range(1, node_count):
+            res = self.space.dtype(0.0)
+            for k in range(node_count):
                 res += self.space.space_value(
                     self._read_node_value(args, s.element_index, k),
                     self.space.element_inner_weight(
-                        args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k
+                        args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k, s.qp_index
                     ),
                     local_value_map,
                 )
@@ -110,44 +103,43 @@ class NodalFieldBase(DiscreteField):
         if not self.space.gradient_valid():
             return None
 
-        @cache.dynamic_func(suffix=self.name)
+        gradient_dtype = self.gradient_dtype if world_space else self.reference_gradient_dtype
+
+        @cache.dynamic_func(suffix=f"{self.name}{world_space}")
         def eval_grad_inner(args: self.ElementEvalArg, s: Sample, grad_transform: Any):
             local_value_map = self.space.local_value_map_inner(args.elt_arg, s.element_index, s.element_coords)
-
-            res = self.space.space_gradient(
-                self._read_node_value(args, s.element_index, 0),
-                self.space.element_inner_weight_gradient(
-                    args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, 0
-                ),
-                local_value_map,
-                grad_transform,
-            )
-
             node_count = self.space.topology.element_node_count(
                 args.elt_arg, args.eval_arg.topology_arg, s.element_index
             )
-            for k in range(1, node_count):
+
+            res = gradient_dtype(0.0)
+            for k in range(node_count):
                 res += self.space.space_gradient(
                     self._read_node_value(args, s.element_index, k),
                     self.space.element_inner_weight_gradient(
-                        args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k
+                        args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k, s.qp_index
                     ),
                     local_value_map,
                     grad_transform,
                 )
             return res
 
-        @cache.dynamic_func(suffix=self.name)
-        def eval_grad_inner_ref_space(args: self.ElementEvalArg, s: Sample):
-            grad_transform = 1.0
-            return eval_grad_inner(args, s, grad_transform)
+        if world_space:
 
-        @cache.dynamic_func(suffix=self.name)
-        def eval_grad_inner_world_space(args: self.ElementEvalArg, s: Sample):
-            grad_transform = self.space.element_inner_reference_gradient_transform(args.elt_arg, s)
-            return eval_grad_inner(args, s, grad_transform)
+            @cache.dynamic_func(suffix=self.name)
+            def eval_grad_inner_world_space(args: self.ElementEvalArg, s: Sample):
+                grad_transform = self.space.element_inner_reference_gradient_transform(args.elt_arg, s)
+                return eval_grad_inner(args, s, grad_transform)
+
+            return eval_grad_inner_world_space
+        else:
+
+            @cache.dynamic_func(suffix=self.name)
+            def eval_grad_inner_ref_space(args: self.ElementEvalArg, s: Sample):
+                grad_transform = 1.0
+                return eval_grad_inner(args, s, grad_transform)
 
-        return eval_grad_inner_world_space if world_space else eval_grad_inner_ref_space
+            return eval_grad_inner_ref_space
 
     def _make_eval_div_inner(self):
         if not self.divergence_valid():
@@ -157,24 +149,16 @@ class NodalFieldBase(DiscreteField):
         def eval_div_inner(args: self.ElementEvalArg, s: Sample):
             grad_transform = self.space.element_inner_reference_gradient_transform(args.elt_arg, s)
             local_value_map = self.space.local_value_map_inner(args.elt_arg, s.element_index, s.element_coords)
-
-            res = self.space.space_divergence(
-                self._read_node_value(args, s.element_index, 0),
-                self.space.element_inner_weight_gradient(
-                    args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, 0
-                ),
-                local_value_map,
-                grad_transform,
-            )
-
             node_count = self.space.topology.element_node_count(
                 args.elt_arg, args.eval_arg.topology_arg, s.element_index
             )
-            for k in range(1, node_count):
+
+            res = self.divergence_dtype(0.0)
+            for k in range(node_count):
                 res += self.space.space_divergence(
                     self._read_node_value(args, s.element_index, k),
                     self.space.element_inner_weight_gradient(
-                        args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k
+                        args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k, s.qp_index
                     ),
                     local_value_map,
                     grad_transform,
@@ -187,23 +171,16 @@ class NodalFieldBase(DiscreteField):
         @cache.dynamic_func(suffix=self.name)
         def eval_outer(args: self.ElementEvalArg, s: Sample):
             local_value_map = self.space.local_value_map_outer(args.elt_arg, s.element_index, s.element_coords)
-            res = self.space.space_value(
-                self._read_node_value(args, s.element_index, 0),
-                self.space.element_outer_weight(
-                    args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, 0
-                ),
-                local_value_map,
-            )
-
             node_count = self.space.topology.element_node_count(
                 args.elt_arg, args.eval_arg.topology_arg, s.element_index
             )
 
-            for k in range(1, node_count):
+            res = self.dtype(0.0)
+            for k in range(node_count):
                 res += self.space.space_value(
                     self._read_node_value(args, s.element_index, k),
                     self.space.element_outer_weight(
-                        args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k
+                        args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k, s.qp_index
                     ),
                     local_value_map,
                 )
@@ -215,44 +192,43 @@ class NodalFieldBase(DiscreteField):
         if not self.space.gradient_valid():
             return None
 
-        @cache.dynamic_func(suffix=self.name)
+        gradient_dtype = self.gradient_dtype if world_space else self.reference_gradient_dtype
+
+        @cache.dynamic_func(suffix=f"{self.name}{world_space}")
         def eval_grad_outer(args: self.ElementEvalArg, s: Sample, grad_transform: Any):
             local_value_map = self.space.local_value_map_outer(args.elt_arg, s.element_index, s.element_coords)
-
-            res = self.space.space_gradient(
-                self._read_node_value(args, s.element_index, 0),
-                self.space.element_outer_weight_gradient(
-                    args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, 0
-                ),
-                local_value_map,
-                grad_transform,
-            )
-
             node_count = self.space.topology.element_node_count(
                 args.elt_arg, args.eval_arg.topology_arg, s.element_index
             )
-            for k in range(1, node_count):
+
+            res = gradient_dtype(0.0)
+            for k in range(node_count):
                 res += self.space.space_gradient(
                     self._read_node_value(args, s.element_index, k),
                     self.space.element_outer_weight_gradient(
-                        args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k
+                        args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k, s.qp_index
                     ),
                     local_value_map,
                     grad_transform,
                 )
             return res
 
-        @cache.dynamic_func(suffix=self.name)
-        def eval_grad_outer_ref_space(args: self.ElementEvalArg, s: Sample):
-            grad_transform = 1.0
-            return eval_grad_outer_ref_space(args, s, grad_transform)
+        if world_space:
 
-        @cache.dynamic_func(suffix=self.name)
-        def eval_grad_outer_world_space(args: self.ElementEvalArg, s: Sample):
-            grad_transform = self.space.element_outer_reference_gradient_transform(args.elt_arg, s)
-            return eval_grad_outer_ref_space(args, s, grad_transform)
+            @cache.dynamic_func(suffix=self.name)
+            def eval_grad_outer_world_space(args: self.ElementEvalArg, s: Sample):
+                grad_transform = self.space.element_outer_reference_gradient_transform(args.elt_arg, s)
+                return eval_grad_outer_ref_space(args, s, grad_transform)
+
+            return eval_grad_outer_world_space
+        else:
+
+            @cache.dynamic_func(suffix=self.name)
+            def eval_grad_outer_ref_space(args: self.ElementEvalArg, s: Sample):
+                grad_transform = 1.0
+                return eval_grad_outer_ref_space(args, s, grad_transform)
 
-        return eval_grad_outer_world_space if world_space else eval_grad_outer_ref_space
+            return eval_grad_outer_ref_space
 
     def _make_eval_div_outer(self):
         if not self.divergence_valid():
@@ -262,24 +238,16 @@ class NodalFieldBase(DiscreteField):
         def eval_div_outer(args: self.ElementEvalArg, s: Sample):
             grad_transform = self.space.element_outer_reference_gradient_transform(args.elt_arg, s)
             local_value_map = self.space.local_value_map_outer(args.elt_arg, s.element_index, s.element_coords)
-
-            res = self.space.space_divergence(
-                self._read_node_value(args, s.element_index, 0),
-                self.space.element_outer_weight_gradient(
-                    args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, 0
-                ),
-                local_value_map,
-                grad_transform,
-            )
-
             node_count = self.space.topology.element_node_count(
                 args.elt_arg, args.eval_arg.topology_arg, s.element_index
             )
-            for k in range(1, node_count):
+
+            res = self.divergence_dtype(0.0)
+            for k in range(node_count):
                 res += self.space.space_divergence(
                     self._read_node_value(args, s.element_index, k),
                     self.space.element_outer_weight_gradient(
-                        args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k
+                        args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k, s.qp_index
                     ),
                     local_value_map,
                     grad_transform,

warp/fem/field/virtual.py

@@ -69,7 +69,12 @@ class AdjointField(SpaceField):
         def eval_test_inner(args: self.ElementEvalArg, s: Sample):
             dof = self._get_dof(s)
             node_weight = self.space.element_inner_weight(
-                args.elt_arg, args.eval_arg, s.element_index, s.element_coords, get_node_index_in_element(dof)
+                args.elt_arg,
+                args.eval_arg,
+                s.element_index,
+                s.element_coords,
+                get_node_index_in_element(dof),
+                s.qp_index,
             )
             local_value_map = self.space.local_value_map_inner(args.elt_arg, s.element_index, s.element_coords)
             dof_value = self.space.node_basis_element(get_node_coord(dof))
@@ -90,6 +95,7 @@ class AdjointField(SpaceField):
                 s.element_index,
                 s.element_coords,
                 get_node_index_in_element(dof),
+                s.qp_index,
             )
             grad_transform = self.space.element_inner_reference_gradient_transform(args.elt_arg, s)
             local_value_map = self.space.local_value_map_inner(args.elt_arg, s.element_index, s.element_coords)
@@ -111,6 +117,7 @@ class AdjointField(SpaceField):
                 s.element_index,
                 s.element_coords,
                 get_node_index_in_element(dof),
+                s.qp_index,
             )
             grad_transform = self.space.element_inner_reference_gradient_transform(args.elt_arg, s)
             local_value_map = self.space.local_value_map_inner(args.elt_arg, s.element_index, s.element_coords)
@@ -124,7 +131,12 @@ class AdjointField(SpaceField):
         def eval_test_outer(args: self.ElementEvalArg, s: Sample):
             dof = self._get_dof(s)
             node_weight = self.space.element_outer_weight(
-                args.elt_arg, args.eval_arg, s.element_index, s.element_coords, get_node_index_in_element(dof)
+                args.elt_arg,
+                args.eval_arg,
+                s.element_index,
+                s.element_coords,
+                get_node_index_in_element(dof),
+                s.qp_index,
             )
             local_value_map = self.space.local_value_map_outer(args.elt_arg, s.element_index, s.element_coords)
             dof_value = self.space.node_basis_element(get_node_coord(dof))
@@ -145,6 +157,7 @@ class AdjointField(SpaceField):
                 s.element_index,
                 s.element_coords,
                 get_node_index_in_element(dof),
+                s.qp_index,
             )
             grad_transform = self.space.element_outer_reference_gradient_transform(args.elt_arg, s)
             local_value_map = self.space.local_value_map_outer(args.elt_arg, s.element_index, s.element_coords)
@@ -166,6 +179,7 @@ class AdjointField(SpaceField):
                 s.element_index,
                 s.element_coords,
                 get_node_index_in_element(dof),
+                s.qp_index,
             )
             grad_transform = self.space.element_outer_reference_gradient_transform(args.elt_arg, s)
             local_value_map = self.space.local_value_map_outer(args.elt_arg, s.element_index, s.element_coords)
@@ -370,9 +384,8 @@ class LocalAdjointField(SpaceField):
 
         @cache.dynamic_func(suffix=str(TAYLOR_DOF_COUNT))
         def split_dof(dof_index: DofIndex, dof_begin: int):
-            dof = get_node_coord(dof_index)
-            value_dof = dof // TAYLOR_DOF_COUNT
-            taylor_dof = dof - value_dof * TAYLOR_DOF_COUNT - dof_begin
+            taylor_dof = get_node_index_in_element(dof_index) - dof_begin
+            value_dof = get_node_coord(dof_index)
             return value_dof, taylor_dof
 
         return split_dof
@@ -386,7 +399,7 @@ class LocalAdjointField(SpaceField):
 
             local_value_map = self.space.local_value_map_inner(args.elt_arg, s.element_index, s.element_coords)
             dof_value = self.space.value_basis_element(value_dof, local_value_map)
-            return wp.select(taylor_dof == 0, self.dtype(0.0), dof_value)
+            return wp.where(taylor_dof == 0, dof_value, self.dtype(0.0))
 
         return eval_test_inner
 
@@ -441,7 +454,7 @@ class LocalAdjointField(SpaceField):
 
             local_value_map = self.space.local_value_map_outer(args.elt_arg, s.element_index, s.element_coords)
             dof_value = self.space.value_basis_element(value_dof, local_value_map)
-            return wp.select(taylor_dof == 0, self.dtype(0.0), dof_value)
+            return wp.where(taylor_dof == 0, dof_value, self.dtype(0.0))
 
         return eval_test_outer
 
@@ -551,17 +564,25 @@ def make_linear_dispatch_kernel(test: LocalTestField, quadrature: Quadrature, ac
                 qp_index = quadrature.point_index(
                     domain_arg, qp_arg, test_element_index.domain_element_index, element_index, k
                 )
+                qp_eval_index = quadrature.point_evaluation_index(
+                    domain_arg, qp_arg, test_element_index.domain_element_index, element_index, k
+                )
                 coords = quadrature.point_coords(
                     domain_arg, qp_arg, test_element_index.domain_element_index, element_index, k
                 )
 
-                qp_result = local_result[qp_index]
+                qp_result = local_result[qp_eval_index]
 
                 qp_sum = float(0.0)
 
                 if wp.static(0 != TEST_INNER_COUNT):
                     w = test.space.element_inner_weight(
-                        domain_arg, test_space_arg, element_index, coords, test_element_index.node_index_in_element
+                        domain_arg,
+                        test_space_arg,
+                        element_index,
+                        coords,
+                        test_element_index.node_index_in_element,
+                        qp_index,
                     )
                     for val_dof in range(TEST_NODE_DOF_DIM):
                         test_dof = test_node_dof * TEST_NODE_DOF_DIM + val_dof
@@ -569,7 +590,12 @@ def make_linear_dispatch_kernel(test: LocalTestField, quadrature: Quadrature, ac
 
                 if wp.static(0 != TEST_OUTER_COUNT):
                     w = test.space.element_outer_weight(
-                        domain_arg, test_space_arg, element_index, coords, test_element_index.node_index_in_element
+                        domain_arg,
+                        test_space_arg,
+                        element_index,
+                        coords,
+                        test_element_index.node_index_in_element,
+                        qp_index,
                     )
                     for val_dof in range(TEST_NODE_DOF_DIM):
                         test_dof = test_node_dof * TEST_NODE_DOF_DIM + val_dof
@@ -577,7 +603,12 @@ def make_linear_dispatch_kernel(test: LocalTestField, quadrature: Quadrature, ac
 
                 if wp.static(0 != TEST_INNER_GRAD_COUNT):
                     w_grad = test.space.element_inner_weight_gradient(
-                        domain_arg, test_space_arg, element_index, coords, test_element_index.node_index_in_element
+                        domain_arg,
+                        test_space_arg,
+                        element_index,
+                        coords,
+                        test_element_index.node_index_in_element,
+                        qp_index,
                     )
                     for val_dof in range(TEST_NODE_DOF_DIM):
                         test_dof = test_node_dof * TEST_NODE_DOF_DIM + val_dof
@@ -589,7 +620,12 @@ def make_linear_dispatch_kernel(test: LocalTestField, quadrature: Quadrature, ac
 
                 if wp.static(0 != TEST_OUTER_GRAD_COUNT):
                     w_grad = test.space.element_outer_weight_gradient(
-                        domain_arg, test_space_arg, element_index, coords, test_element_index.node_index_in_element
+                        domain_arg,
+                        test_space_arg,
+                        element_index,
+                        coords,
+                        test_element_index.node_index_in_element,
+                        qp_index,
                     )
                     for val_dof in range(TEST_NODE_DOF_DIM):
                         test_dof = test_node_dof * TEST_NODE_DOF_DIM + val_dof
@@ -669,10 +705,10 @@ def make_bilinear_dispatch_kernel(
                 domain_arg, trial_topology_arg, element_index
             )
 
-            qp_point_count = wp.select(
+            qp_point_count = wp.where(
                 trial_node < element_trial_node_count,
-                0,
                 quadrature.point_count(domain_arg, qp_arg, test_element_index.domain_element_index, element_index),
+                0,
             )
 
             val_sum = accumulate_dtype(0.0)
@@ -681,51 +717,54 @@ def make_bilinear_dispatch_kernel(
                 qp_index = quadrature.point_index(
                     domain_arg, qp_arg, test_element_index.domain_element_index, element_index, k
                 )
+                qp_eval_index = quadrature.point_evaluation_index(
+                    domain_arg, qp_arg, test_element_index.domain_element_index, element_index, k
+                )
                 coords = quadrature.point_coords(
                     domain_arg, qp_arg, test_element_index.domain_element_index, element_index, k
                 )
 
-                qp_result = local_result[qp_index]
+                qp_result = local_result[qp_eval_index]
                 trial_result = float(0.0)
 
                 if wp.static(0 != TEST_INNER_COUNT):
                     w_test_inner = test.space.element_inner_weight(
-                        domain_arg, test_space_arg, element_index, coords, test_node
+                        domain_arg, test_space_arg, element_index, coords, test_node, qp_index
                     )
 
                 if wp.static(0 != TEST_OUTER_COUNT):
                     w_test_outer = test.space.element_outer_weight(
-                        domain_arg, test_space_arg, element_index, coords, test_node
+                        domain_arg, test_space_arg, element_index, coords, test_node, qp_index
                     )
 
                 if wp.static(0 != TEST_INNER_GRAD_COUNT):
                     w_test_grad_inner = test.space.element_inner_weight_gradient(
-                        domain_arg, test_space_arg, element_index, coords, test_node
+                        domain_arg, test_space_arg, element_index, coords, test_node, qp_index
                     )
 
                 if wp.static(0 != TEST_OUTER_GRAD_COUNT):
                     w_test_grad_outer = test.space.element_outer_weight_gradient(
-                        domain_arg, test_space_arg, element_index, coords, test_node
+                        domain_arg, test_space_arg, element_index, coords, test_node, qp_index
                     )
 
                 if wp.static(0 != TRIAL_INNER_COUNT):
                     w_trial_inner = trial.space.element_inner_weight(
-                        domain_arg, trial_space_arg, element_index, coords, trial_node
+                        domain_arg, trial_space_arg, element_index, coords, trial_node, qp_index
                     )
 
                 if wp.static(0 != TRIAL_OUTER_COUNT):
                     w_trial_outer = trial.space.element_outer_weight(
-                        domain_arg, trial_space_arg, element_index, coords, trial_node
+                        domain_arg, trial_space_arg, element_index, coords, trial_node, qp_index
                     )
 
                 if wp.static(0 != TRIAL_INNER_GRAD_COUNT):
                     w_trial_grad_inner = trial.space.element_inner_weight_gradient(
-                        domain_arg, trial_space_arg, element_index, coords, trial_node
+                        domain_arg, trial_space_arg, element_index, coords, trial_node, qp_index
                     )
 
                 if wp.static(0 != TRIAL_OUTER_GRAD_COUNT):
                     w_trial_grad_outer = trial.space.element_outer_weight_gradient(
-                        domain_arg, trial_space_arg, element_index, coords, trial_node
+                        domain_arg, trial_space_arg, element_index, coords, trial_node, qp_index
                     )
 
                 for trial_val_dof in range(TRIAL_NODE_DOF_DIM):

warp/fem/geometry/adaptive_nanogrid.py

@@ -30,7 +30,6 @@ from .nanogrid import (
     _extract_axis_flag,
     _get_boundary_mask,
     _make_face_flags,
-    _mat32,
 )
 
 _FACE_LEVEL_BIT = wp.constant(wp.uint8(4))  # follows nanogrid.FACE_OUTER_OFFSET_BIT
@@ -185,9 +184,13 @@ class AdaptiveNanogrid(Geometry):
 
     @wp.func
     def cell_position(args: CellArg, s: Sample):
-        scale = AdaptiveNanogrid._cell_scale(args, s.element_index)
-        uvw = wp.vec3(args.cell_ijk[s.element_index]) + s.element_coords * scale
-        return wp.volume_index_to_world(args.cell_grid, uvw - wp.vec3(0.5))
+        cell_idx = s.element_index
+        scale = AdaptiveNanogrid._cell_scale(args, cell_idx)
+        cell_coords = s.element_coords
+        cell_ijk = args.cell_ijk[cell_idx]
+        uvw = wp.vec3(cell_ijk) + cell_coords * scale
+        grid_id = args.cell_grid
+        return wp.volume_index_to_world(grid_id, uvw - wp.vec3(0.5))
 
     @wp.func
     def cell_deformation_gradient(args: CellArg, s: Sample):
@@ -214,9 +217,9 @@ class AdaptiveNanogrid(Geometry):
             coords = uvw - wp.vec3(ijk)
 
             if wp.min(coords) == 0.0 or wp.max(coords) == 1.0:
-                il = wp.select(coords[0] > 0.5, -1, 0)
-                jl = wp.select(coords[1] > 0.5, -1, 0)
-                kl = wp.select(coords[2] > 0.5, -1, 0)
+                il = wp.where(coords[0] > 0.5, 0, -1)
+                jl = wp.where(coords[1] > 0.5, 0, -1)
+                kl = wp.where(coords[2] > 0.5, 0, -1)
 
                 for n in range(8):
                     ni = n >> 2
@@ -331,7 +334,7 @@ class AdaptiveNanogrid(Geometry):
         flip = Nanogrid._get_face_inner_offset(flags)
         scale = AdaptiveNanogrid._get_face_scale(flags)
         v1, v2 = Nanogrid._face_tangent_vecs(args.cell_arg.cell_grid, axis, flip)
-        return _mat32(v1, v2) * scale
+        return wp.matrix_from_cols(v1, v2) * scale
 
     @wp.func
     def side_inner_inverse_deformation_gradient(args: SideArg, s: Sample):
@@ -447,10 +450,10 @@ class AdaptiveNanogrid(Geometry):
             and wp.max(same_level_cell_coords) <= 1.0
         )
 
-        return wp.select(
+        return wp.where(
             on_side,
-            Coords(OUTSIDE),
             Coords(same_level_cell_coords[(axis + 1) % 3], same_level_cell_coords[(axis + 2) % 3], 0.0),
+            Coords(OUTSIDE),
         )
 
     def _build_face_grid(self, temporary_store: Optional[cache.TemporaryStore] = None):
@@ -527,7 +530,7 @@ class AdaptiveNanogrid(Geometry):
         for ax in range(3):
             coord = ijk[ax]
             level_flag = ((level >> ax) & 1) << _GRID_LEVEL_BIT
-            ijk[ax] = wp.select(coord < 0, coord | level_flag, coord & ~level_flag)
+            ijk[ax] = wp.where(coord < 0, coord & ~level_flag, coord | level_flag)
 
         return _add_axis_flag(ijk, axis)
 
@@ -845,8 +848,8 @@ def _build_face_indices_and_flags(
 
     plus_cell_index, minus_cell_index = _find_face_neighbours(cell_grid, ijk, axis, level_count, cell_level)
 
-    inner_cell = wp.select(minus_cell_index == -1, minus_cell_index, plus_cell_index)
-    outer_cell = wp.select(plus_cell_index == -1, plus_cell_index, minus_cell_index)
+    inner_cell = wp.where(minus_cell_index == -1, plus_cell_index, minus_cell_index)
+    outer_cell = wp.where(plus_cell_index == -1, minus_cell_index, plus_cell_index)
 
     face_level = wp.min(cell_level[inner_cell], cell_level[outer_cell])
 

warp/fem/geometry/closest_point.py

@@ -59,7 +59,7 @@ def project_on_tri_at_origin(q: Any, e1: Any, e2: Any):
 
 @wp.func
 def project_on_tet_at_origin(q: wp.vec3, e1: wp.vec3, e2: wp.vec3, e3: wp.vec3):
-    mat = wp.inverse(wp.mat33(e1, e2, e3))
+    mat = wp.inverse(wp.matrix_from_cols(e1, e2, e3))
     coords = mat * q
 
     if wp.min(coords) >= 0.0 and coords[0] + coords[1] + coords[2] <= 1.0:

warp/fem/geometry/deformed_geometry.py

@@ -46,7 +46,6 @@ class DeformedGeometry(Geometry):
         self._relative = relative
 
         self.field: GeometryField = field
-        self.base = self.field.geometry
         self.dimension = self.base.dimension
 
         self.CellArg = self.field.ElementEvalArg
@@ -81,9 +80,13 @@ class DeformedGeometry(Geometry):
         self._make_default_dependent_implementations()
 
     @property
-    def name(self):
+    def name(self) -> str:
         return f"DefGeo_{self.field.name}_{'rel' if self._relative else 'abs'}"
 
+    @property
+    def base(self) -> Geometry:
+        return self.field.geometry.base
+
     # Geometry device interface
 
     @cache.cached_arg_value

warp/fem/geometry/geometry.py

@@ -58,6 +58,11 @@ class Geometry:
         """Manifold dimension of the geometry cells"""
         return self.reference_cell().dimension
 
+    @property
+    def base(self) -> "Geometry":
+        """Returns the base geometry from which this geometry derives its topology. Usually `self`"""
+        return self
+
     @property
     def name(self) -> str:
         return self.__class__.__name__