warp-lang 1.6.2__py3-none-macosx_10_13_universal2.whl → 1.7.0__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,
                 )
@@ -113,24 +106,16 @@ class NodalFieldBase(DiscreteField):
         @cache.dynamic_func(suffix=self.name)
         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 = self.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,
@@ -157,24 +142,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 +164,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,
                 )
@@ -218,24 +188,16 @@ class NodalFieldBase(DiscreteField):
         @cache.dynamic_func(suffix=self.name)
         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 = self.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,
@@ -262,24 +224,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
@@ -214,9 +213,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 +330,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 +446,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 +526,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 +844,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__

warp/fem/geometry/grid_2d.py

@@ -173,7 +173,7 @@ class Grid2D(Geometry):
             return Grid2D.Side(axis, origin)
 
         axis_side_index = side_index - 2 * arg.cell_count
-        axis = wp.select(axis_side_index < arg.axis_offsets[1], 1, 0)
+        axis = wp.where(axis_side_index < arg.axis_offsets[1], 0, 1)
 
         altitude = arg.cell_arg.res[Grid2D.ROTATION[axis, 0]]
         longitude = axis_side_index - arg.axis_offsets[axis]
@@ -273,7 +273,7 @@ class Grid2D(Geometry):
     def side_position(args: SideArg, s: Sample):
         side = Grid2D.get_side(args, s.element_index)
 
-        coord = wp.select((side.origin[0] == 0) == (side.axis == 0), 1.0 - s.element_coords[0], s.element_coords[0])
+        coord = wp.where((side.origin[0] == 0) == (side.axis == 0), s.element_coords[0], 1.0 - s.element_coords[0])
 
         local_pos = wp.vec2(
             float(side.origin[0]),
@@ -288,7 +288,7 @@ class Grid2D(Geometry):
     def side_deformation_gradient(args: SideArg, s: Sample):
         side = Grid2D.get_side(args, s.element_index)
 
-        sign = wp.select((side.origin[0] == 0) == (side.axis == 0), -1.0, 1.0)
+        sign = wp.where((side.origin[0] == 0) == (side.axis == 0), 1.0, -1.0)
 
         return wp.cw_mul(Grid2D._rotate(side.axis, wp.vec2(0.0, sign)), args.cell_arg.cell_size)
 
@@ -316,7 +316,7 @@ class Grid2D(Geometry):
     def side_normal(args: SideArg, s: Sample):
         side = Grid2D.get_side(args, s.element_index)
 
-        sign = wp.select(side.origin[0] == 0, 1.0, -1.0)
+        sign = wp.where(side.origin[0] == 0, -1.0, 1.0)
 
         local_n = wp.vec2(sign, 0.0)
         return Grid2D._rotate(side.axis, local_n)
@@ -325,7 +325,7 @@ class Grid2D(Geometry):
     def side_inner_cell_index(arg: SideArg, side_index: ElementIndex):
         side = Grid2D.get_side(arg, side_index)
 
-        inner_alt = wp.select(side.origin[0] == 0, side.origin[0] - 1, 0)
+        inner_alt = wp.where(side.origin[0] == 0, 0, side.origin[0] - 1)
 
         inner_origin = wp.vec2i(inner_alt, side.origin[1])
 
@@ -337,8 +337,8 @@ class Grid2D(Geometry):
         side = Grid2D.get_side(arg, side_index)
 
         alt_axis = Grid2D.ROTATION[side.axis, 0]
-        outer_alt = wp.select(
-            side.origin[0] == arg.cell_arg.res[alt_axis], side.origin[0], arg.cell_arg.res[alt_axis] - 1
+        outer_alt = wp.where(
+            side.origin[0] == arg.cell_arg.res[alt_axis], arg.cell_arg.res[alt_axis] - 1, side.origin[0]
         )
 
         outer_origin = wp.vec2i(outer_alt, side.origin[1])
@@ -350,9 +350,9 @@ class Grid2D(Geometry):
     def side_inner_cell_coords(args: SideArg, side_index: ElementIndex, side_coords: Coords):
         side = Grid2D.get_side(args, side_index)
 
-        inner_alt = wp.select(side.origin[0] == 0, 1.0, 0.0)
+        inner_alt = wp.where(side.origin[0] == 0, 0.0, 1.0)
 
-        side_coord = wp.select((side.origin[0] == 0) == (side.axis == 0), 1.0 - side_coords[0], side_coords[0])
+        side_coord = wp.where((side.origin[0] == 0) == (side.axis == 0), side_coords[0], 1.0 - side_coords[0])
 
         coords = Grid2D._rotate(side.axis, wp.vec2(inner_alt, side_coord))
         return Coords(coords[0], coords[1], 0.0)
@@ -362,9 +362,9 @@ class Grid2D(Geometry):
         side = Grid2D.get_side(args, side_index)
 
         alt_axis = Grid2D.ROTATION[side.axis, 0]
-        outer_alt = wp.select(side.origin[0] == args.cell_arg.res[alt_axis], 0.0, 1.0)
+        outer_alt = wp.where(side.origin[0] == args.cell_arg.res[alt_axis], 1.0, 0.0)
 
-        side_coord = wp.select((side.origin[0] == 0) == (side.axis == 0), 1.0 - side_coords[0], side_coords[0])
+        side_coord = wp.where((side.origin[0] == 0) == (side.axis == 0), side_coords[0], 1.0 - side_coords[0])
 
         coords = Grid2D._rotate(side.axis, wp.vec2(outer_alt, side_coord))
         return Coords(coords[0], coords[1], 0.0)
@@ -382,7 +382,7 @@ class Grid2D(Geometry):
         if float(side.origin[0] - cell[side.axis]) == element_coords[side.axis]:
             long_axis = Grid2D.ROTATION[side.axis, 1]
             axis_coord = element_coords[long_axis]
-            side_coord = wp.select((side.origin[0] == 0) == (side.axis == 0), 1.0 - axis_coord, axis_coord)
+            side_coord = wp.where((side.origin[0] == 0) == (side.axis == 0), axis_coord, 1.0 - axis_coord)
             return Coords(side_coord, 0.0, 0.0)
 
         return Coords(OUTSIDE)