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

warp/fem/quadrature/quadrature.py

@@ -2,6 +2,7 @@ from typing import Any
 
 import warp as wp
 from warp.fem import cache, domain
+from warp.fem.geometry import Element
 from warp.fem.space import FunctionSpace
 from warp.fem.types import Coords, ElementIndex
 
@@ -77,6 +78,38 @@ class Quadrature:
 class RegularQuadrature(Quadrature):
     """Regular quadrature formula, using a constant set of quadrature points per element"""
 
+    @wp.struct
+    class Arg:
+        # Quadrature points and weights used to be passed as Warp constants,
+        # but this tended to incur register spilling for high point counts
+        points: wp.array(dtype=Coords)
+        weights: wp.array(dtype=float)
+
+    # Cache common formulas so we do dot have to do h2d transfer for each call
+    class CachedFormula:
+        _cache = {}
+
+        def __init__(self, element: Element, order: int, family: Polynomial):
+            self.points, self.weights = element.instantiate_quadrature(order, family)
+            self.count = wp.constant(len(self.points))
+
+        @cache.cached_arg_value
+        def arg_value(self, device):
+            arg = RegularQuadrature.Arg()
+            arg.points = wp.array(self.points, device=device, dtype=Coords)
+            arg.weights = wp.array(self.weights, device=device, dtype=float)
+            return arg
+
+        @staticmethod
+        def get(element: Element, order: int, family: Polynomial):
+            key = (element.__class__.__name__, order, family)
+            try:
+                return RegularQuadrature.CachedFormula._cache[key]
+            except KeyError:
+                quadrature = RegularQuadrature.CachedFormula(element, order, family)
+                RegularQuadrature.CachedFormula._cache[key] = quadrature
+                return quadrature
+
     def __init__(
         self,
         domain: domain.GeometryDomain,
@@ -88,15 +121,7 @@ class RegularQuadrature(Quadrature):
         self.family = family
         self.order = order
 
-        self._element_quadrature = domain.reference_element().instantiate_quadrature(order, family)
-
-        self._N = wp.constant(len(self.points))
-
-        WeightVec = wp.vec(length=self._N, dtype=wp.float32)
-        CoordMat = wp.mat(shape=(self._N, 3), dtype=wp.float32)
-
-        self._POINTS = wp.constant(CoordMat(self.points))
-        self._WEIGHTS = wp.constant(WeightVec(self.weights))
+        self._formula = RegularQuadrature.CachedFormula.get(domain.reference_element(), order, family)
 
         self.point_count = self._make_point_count()
         self.point_index = self._make_point_index()
@@ -108,21 +133,24 @@ class RegularQuadrature(Quadrature):
         return f"{self.__class__.__name__}_{self.domain.name}_{self.family}_{self.order}"
 
     def total_point_count(self):
-        return len(self.points) * self.domain.geometry_element_count()
+        return self._formula.count * self.domain.element_count()
 
     def max_points_per_element(self):
-        return self._N
+        return self._formula.count
 
     @property
     def points(self):
-        return self._element_quadrature[0]
+        return self._formula.points
 
     @property
     def weights(self):
-        return self._element_quadrature[1]
+        return self._formula.weights
+
+    def arg_value(self, device):
+        return self._formula.arg_value(device)
 
     def _make_point_count(self):
-        N = self._N
+        N = self._formula.count
 
         @cache.dynamic_func(suffix=self.name)
         def point_count(
@@ -136,8 +164,6 @@ class RegularQuadrature(Quadrature):
         return point_count
 
     def _make_point_coords(self):
-        POINTS = self._POINTS
-
         @cache.dynamic_func(suffix=self.name)
         def point_coords(
             elt_arg: self.domain.ElementArg,
@@ -146,13 +172,11 @@ class RegularQuadrature(Quadrature):
             element_index: ElementIndex,
             qp_index: int,
         ):
-            return Coords(POINTS[qp_index, 0], POINTS[qp_index, 1], POINTS[qp_index, 2])
+            return qp_arg.points[qp_index]
 
         return point_coords
 
     def _make_point_weight(self):
-        WEIGHTS = self._WEIGHTS
-
         @cache.dynamic_func(suffix=self.name)
         def point_weight(
             elt_arg: self.domain.ElementArg,
@@ -161,12 +185,12 @@ class RegularQuadrature(Quadrature):
             element_index: ElementIndex,
             qp_index: int,
         ):
-            return WEIGHTS[qp_index]
+            return qp_arg.weights[qp_index]
 
         return point_weight
 
     def _make_point_index(self):
-        N = self._N
+        N = self._formula.count
 
         @cache.dynamic_func(suffix=self.name)
         def point_index(

warp/fem/space/__init__.py

@@ -8,20 +8,20 @@ import warp.fem.geometry as _geometry
 import warp.fem.polynomial as _polynomial
 
 from .function_space import FunctionSpace
+from .basis_function_space import CollocatedFunctionSpace, ContravariantFunctionSpace, CovariantFunctionSpace
 from .topology import SpaceTopology
 from .basis_space import BasisSpace, PointBasisSpace, ShapeBasisSpace, make_discontinuous_basis_space
-from .collocated_function_space import CollocatedFunctionSpace
-from .shape import ElementBasis, get_shape_function
+from .shape import ElementBasis, get_shape_function, ShapeFunction
 
 from .grid_2d_function_space import make_grid_2d_space_topology
 
 from .grid_3d_function_space import make_grid_3d_space_topology
 
-from .trimesh_2d_function_space import make_trimesh_2d_space_topology
+from .trimesh_function_space import make_trimesh_space_topology
 
 from .tetmesh_function_space import make_tetmesh_space_topology
 
-from .quadmesh_2d_function_space import make_quadmesh_2d_space_topology
+from .quadmesh_function_space import make_quadmesh_space_topology
 
 from .hexmesh_function_space import make_hexmesh_space_topology
 
@@ -115,12 +115,12 @@ def make_polynomial_basis_space(
         topology = make_grid_2d_space_topology(geo, shape)
     elif isinstance(base_geo, _geometry.Grid3D):
         topology = make_grid_3d_space_topology(geo, shape)
-    elif isinstance(base_geo, _geometry.Trimesh2D):
-        topology = make_trimesh_2d_space_topology(geo, shape)
+    elif isinstance(base_geo, _geometry.Trimesh):
+        topology = make_trimesh_space_topology(geo, shape)
     elif isinstance(base_geo, _geometry.Tetmesh):
         topology = make_tetmesh_space_topology(geo, shape)
-    elif isinstance(base_geo, _geometry.Quadmesh2D):
-        topology = make_quadmesh_2d_space_topology(geo, shape)
+    elif isinstance(base_geo, _geometry.Quadmesh):
+        topology = make_quadmesh_space_topology(geo, shape)
     elif isinstance(base_geo, _geometry.Hexmesh):
         topology = make_hexmesh_space_topology(geo, shape)
     elif isinstance(base_geo, _geometry.Nanogrid) or isinstance(base_geo, _geometry.AdaptiveNanogrid):
@@ -136,7 +136,7 @@ def make_collocated_function_space(
     basis_space: BasisSpace, dtype: type = float, dof_mapper: Optional[DofMapper] = None
 ) -> CollocatedFunctionSpace:
     """
-    Constructs a function space from a basis space and a value type, such that all degrees of freedom of the value type are stored at each of the basis nodes.
+    Constructs a function space from a scalar-valued basis space and a value type, such that all degrees of freedom of the value type are stored at each of the basis nodes.
 
     Args:
         geo: the Geometry on which to build the space
@@ -146,9 +146,37 @@ def make_collocated_function_space(
     Returns:
         the constructed function space
     """
+
+    if basis_space.value != ShapeFunction.Value.Scalar:
+        raise ValueError("Collocated function spaces may only be constructed from scalar-valued basis")
+
     return CollocatedFunctionSpace(basis_space, dtype=dtype, dof_mapper=dof_mapper)
 
 
+def make_covariant_function_space(
+    basis_space: BasisSpace,
+) -> CovariantFunctionSpace:
+    """
+    Constructs a covariant function space from a vector-valued basis space
+    """
+
+    if basis_space.value != ShapeFunction.Value.CovariantVector:
+        raise ValueError("Covariant function spaces may only be constructed from covariant vector-valued basis")
+    return CovariantFunctionSpace(basis_space)
+
+
+def make_contravariant_function_space(
+    basis_space: BasisSpace,
+) -> ContravariantFunctionSpace:
+    """
+    Constructs a contravariant function space from a vector-valued basis space
+    """
+
+    if basis_space.value != ShapeFunction.Value.ContravariantVector:
+        raise ValueError("Contravariant function spaces may only be constructed from contravariant vector-valued basis")
+    return ContravariantFunctionSpace(basis_space)
+
+
 def make_polynomial_space(
     geo: _geometry.Geometry,
     dtype: type = float,
@@ -160,7 +188,7 @@ def make_polynomial_space(
 ) -> CollocatedFunctionSpace:
     """
     Equips a geometry with a collocated, polynomial function space.
-    Equivalent to successive calls to :func:`make_polynomial_basis_space` and `make_collocated_function_space`.
+    Equivalent to successive calls to :func:`make_polynomial_basis_space` then `make_collocated_function_space`, `make_covariant_function_space` or `make_contravariant_function_space`.
 
     Args:
         geo: the Geometry on which to build the space
@@ -176,4 +204,10 @@ def make_polynomial_space(
     """
 
     basis_space = make_polynomial_basis_space(geo, degree, element_basis, discontinuous, family)
-    return CollocatedFunctionSpace(basis_space, dtype=dtype, dof_mapper=dof_mapper)
+
+    if basis_space.value == ShapeFunction.Value.CovariantVector:
+        return make_covariant_function_space(basis_space)
+    if basis_space.value == ShapeFunction.Value.ContravariantVector:
+        return make_contravariant_function_space(basis_space)
+
+    return make_collocated_function_space(basis_space, dtype=dtype, dof_mapper=dof_mapper)

warp/fem/space/basis_function_space.py

@@ -0,0 +1,451 @@
+from typing import Any, Optional
+
+import warp as wp
+from warp.fem import cache
+from warp.fem.geometry import Geometry
+from warp.fem.linalg import basis_element, generalized_inner, generalized_outer
+from warp.fem.types import Coords, ElementIndex, make_free_sample
+
+from .basis_space import BasisSpace
+from .dof_mapper import DofMapper, IdentityMapper
+from .function_space import FunctionSpace
+from .partition import SpacePartition, make_space_partition
+
+
+class CollocatedFunctionSpace(FunctionSpace):
+    """Function space where values are collocated at nodes"""
+
+    @wp.struct
+    class LocalValueMap:
+        pass
+
+    def __init__(self, basis: BasisSpace, dtype: type = float, dof_mapper: DofMapper = None):
+        self.dof_mapper = IdentityMapper(dtype) if dof_mapper is None else dof_mapper
+        self._basis = basis
+
+        super().__init__(topology=basis.topology)
+
+        self.dtype = self.dof_mapper.value_dtype
+        self.dof_dtype = self.dof_mapper.dof_dtype
+        self.VALUE_DOF_COUNT = self.dof_mapper.DOF_SIZE
+        self.NODE_DOF_COUNT = self.dof_mapper.DOF_SIZE
+
+        self.SpaceArg = self._basis.BasisArg
+        self.space_arg_value = self._basis.basis_arg_value
+
+        self.ORDER = self._basis.ORDER
+
+        self.node_basis_element = self._make_node_basis_element()
+        self.value_basis_element = self._make_value_basis_element()
+
+        self.node_coords_in_element = self._basis.make_node_coords_in_element()
+        self.node_quadrature_weight = self._basis.make_node_quadrature_weight()
+        self.element_inner_weight = self._basis.make_element_inner_weight()
+        self.element_inner_weight_gradient = self._basis.make_element_inner_weight_gradient()
+        self.element_outer_weight = self._basis.make_element_outer_weight()
+        self.element_outer_weight_gradient = self._basis.make_element_outer_weight_gradient()
+
+        self.space_value = self._make_space_value()
+        self.space_gradient = self._make_space_gradient()
+        self.space_divergence = self._make_space_divergence()
+
+        self.node_dof_value = self._make_node_dof_value()
+
+        # For backward compatibility
+        if hasattr(basis, "node_grid"):
+            self.node_grid = basis.node_grid
+        if hasattr(basis, "node_triangulation"):
+            self.node_triangulation = basis.node_triangulation
+        if hasattr(basis, "node_tets"):
+            self.node_tets = basis.node_tets
+        if hasattr(basis, "node_hexes"):
+            self.node_hexes = basis.node_hexes
+        if hasattr(basis, "vtk_cells"):
+            self.vtk_cells = basis.vtk_cells
+
+    @property
+    def name(self):
+        return f"{self._basis.name}_{self.dof_mapper}".replace(".", "_")
+
+    def node_positions(self, out: Optional[wp.array] = None) -> wp.array:
+        return self._basis.node_positions(out=out)
+
+    def make_field(
+        self,
+        space_partition: Optional[SpacePartition] = None,
+    ) -> "wp.fem.field.NodalField":
+        from warp.fem.field import NodalField
+
+        if space_partition is None:
+            space_partition = make_space_partition(space_topology=self.topology)
+
+        return NodalField(space=self, space_partition=space_partition)
+
+    def trace(self) -> "CollocatedFunctionSpace":
+        return CollocatedFunctionSpaceTrace(self)
+
+    def _make_node_basis_element(self):
+        @cache.dynamic_func(suffix=self.name)
+        def node_basis_element(dof_coord: int):
+            return basis_element(self.dof_dtype(0.0), dof_coord)
+
+        return node_basis_element
+
+    def _make_value_basis_element(self):
+        @cache.dynamic_func(suffix=self.name)
+        def value_basis_element(dof_coord: int, value_map: CollocatedFunctionSpace.LocalValueMap):
+            return self.dof_mapper.dof_to_value(self.node_basis_element(dof_coord))
+
+        return value_basis_element
+
+    @wp.func
+    def local_value_map_inner(
+        elt_arg: Any,
+        element_index: ElementIndex,
+        element_coords: Coords,
+    ):
+        return CollocatedFunctionSpace.LocalValueMap()
+
+    @wp.func
+    def local_value_map_outer(
+        elt_arg: Any,
+        element_index: ElementIndex,
+        element_coords: Coords,
+    ):
+        return CollocatedFunctionSpace.LocalValueMap()
+
+    def _make_space_value(self):
+        @cache.dynamic_func(suffix=self.name)
+        def value_func(
+            dof_value: self.dof_dtype,
+            node_weight: self._basis.weight_type,
+            local_value_map: self.LocalValueMap,
+        ):
+            return node_weight * self.dof_mapper.dof_to_value(dof_value)
+
+        return value_func
+
+    def _make_space_gradient(self):
+        @cache.dynamic_func(suffix=self.name)
+        def gradient_func(
+            dof_value: self.dof_dtype,
+            node_weight_gradient: self._basis.weight_gradient_type,
+            local_value_map: self.LocalValueMap,
+            grad_transform: Any,
+        ):
+            return generalized_outer(self.dof_mapper.dof_to_value(dof_value), node_weight_gradient * grad_transform)
+
+        return gradient_func
+
+    def _make_space_divergence(self):
+        @cache.dynamic_func(suffix=self.name)
+        def divergence_func(
+            dof_value: self.dof_dtype,
+            node_weight_gradient: self._basis.weight_gradient_type,
+            local_value_map: self.LocalValueMap,
+            grad_transform: Any,
+        ):
+            return generalized_inner(self.dof_mapper.dof_to_value(dof_value), node_weight_gradient * grad_transform)
+
+        return divergence_func
+
+    def _make_node_dof_value(self):
+        @cache.dynamic_func(suffix=self.name)
+        def node_dof_value(
+            elt_arg: self.ElementArg,
+            space_arg: self.SpaceArg,
+            element_index: ElementIndex,
+            node_index_in_elt: int,
+            space_value: self.dtype,
+        ):
+            return self.dof_mapper.value_to_dof(space_value)
+
+        return node_dof_value
+
+
+class CollocatedFunctionSpaceTrace(CollocatedFunctionSpace):
+    """Trace of a :class:`CollocatedFunctionSpace`"""
+
+    def __init__(self, space: CollocatedFunctionSpace):
+        self._space = space
+        super().__init__(space._basis.trace(), space.dtype, space.dof_mapper)
+
+    @property
+    def name(self):
+        return f"{self._space.name}_Trace"
+
+    def __eq__(self, other: "CollocatedFunctionSpaceTrace") -> bool:
+        return self._space == other._space
+
+
+class VectorValuedFunctionSpace(FunctionSpace):
+    """Function space whose values are vectors"""
+
+    def __init__(self, basis: BasisSpace):
+        self._basis = basis
+
+        super().__init__(topology=basis.topology)
+
+        self.dtype = cache.cached_vec_type(self.geometry.dimension, dtype=float)
+        self.dof_dtype = float
+
+        self.VALUE_DOF_COUNT = self.geometry.dimension
+        self.NODE_DOF_COUNT = 1
+
+        self.SpaceArg = self._basis.BasisArg
+        self.space_arg_value = self._basis.basis_arg_value
+
+        self.ORDER = self._basis.ORDER
+
+        self.LocalValueMap = cache.cached_mat_type(
+            shape=(self.geometry.dimension, self.geometry.cell_dimension), dtype=float
+        )
+
+        self.value_basis_element = self._make_value_basis_element()
+
+        self.node_coords_in_element = self._basis.make_node_coords_in_element()
+        self.node_quadrature_weight = self._basis.make_node_quadrature_weight()
+        self.element_inner_weight = self._basis.make_element_inner_weight()
+        self.element_inner_weight_gradient = self._basis.make_element_inner_weight_gradient()
+        self.element_outer_weight = self._basis.make_element_outer_weight()
+        self.element_outer_weight_gradient = self._basis.make_element_outer_weight_gradient()
+
+        self.space_value = self._make_space_value()
+        self.space_gradient = self._make_space_gradient()
+        self.space_divergence = self._make_space_divergence()
+
+        self.node_dof_value = self._make_node_dof_value()
+
+    @property
+    def name(self):
+        return self._basis.name
+
+    def node_positions(self, out: Optional[wp.array] = None) -> wp.array:
+        return self._basis.node_positions(out=out)
+
+    def make_field(
+        self,
+        space_partition: Optional[SpacePartition] = None,
+    ) -> "wp.fem.field.NodalField":
+        from warp.fem.field import NodalField
+
+        if space_partition is None:
+            space_partition = make_space_partition(space_topology=self.topology)
+
+        return NodalField(space=self, space_partition=space_partition)
+
+    @wp.func
+    def node_basis_element(dof_coord: int):
+        return 1.0
+
+    def _make_value_basis_element(self):
+        @cache.dynamic_func(suffix=self.name)
+        def value_basis_element(dof_coord: int, value_map: Any):
+            return value_map * basis_element(self.dtype(0.0), dof_coord)
+
+        return value_basis_element
+
+    def _make_space_value(self):
+        @cache.dynamic_func(suffix=self.name)
+        def value_func(
+            dof_value: self.dof_dtype,
+            node_weight: self._basis.weight_type,
+            local_value_map: self.LocalValueMap,
+        ):
+            return local_value_map * (node_weight * dof_value)
+
+        return value_func
+
+    def _make_space_gradient(self):
+        @cache.dynamic_func(suffix=self.name)
+        def gradient_func(
+            dof_value: self.dof_dtype,
+            node_weight_gradient: self._basis.weight_gradient_type,
+            local_value_map: self.LocalValueMap,
+            grad_transform: Any,
+        ):
+            return dof_value * local_value_map * node_weight_gradient * grad_transform
+
+        return gradient_func
+
+    def _make_space_divergence(self):
+        @cache.dynamic_func(suffix=self.name)
+        def divergence_func(
+            dof_value: self.dof_dtype,
+            node_weight_gradient: self._basis.weight_gradient_type,
+            local_value_map: self.LocalValueMap,
+            grad_transform: Any,
+        ):
+            return dof_value * wp.trace(local_value_map * node_weight_gradient * grad_transform)
+
+        return divergence_func
+
+    def _make_node_dof_value(self):
+        @cache.dynamic_func(suffix=self.name)
+        def node_dof_value(
+            elt_arg: self.ElementArg,
+            space_arg: self.SpaceArg,
+            element_index: ElementIndex,
+            node_index_in_elt: int,
+            space_value: self.dtype,
+        ):
+            coords = self.node_coords_in_element(elt_arg, space_arg, element_index, node_index_in_elt)
+            weight = self.element_inner_weight(elt_arg, space_arg, element_index, coords, node_index_in_elt)
+            local_value_map = self.local_value_map_inner(elt_arg, element_index, coords)
+
+            unit_value = local_value_map * weight
+            return wp.dot(space_value, unit_value) / wp.length_sq(unit_value)
+
+        return node_dof_value
+
+
+class CovariantFunctionSpace(VectorValuedFunctionSpace):
+    """Function space whose values are covariant vectors"""
+
+    def __init__(self, basis: BasisSpace):
+        super().__init__(basis)
+
+        self.local_value_map_inner = self._make_local_value_map()
+        self.local_value_map_outer = self.local_value_map_inner
+
+    def trace(self) -> "CovariantFunctionSpaceTrace":
+        return CovariantFunctionSpaceTrace(self)
+
+    def _make_local_value_map(self):
+        @cache.dynamic_func(suffix=self.name)
+        def local_value_map(
+            elt_arg: self.ElementArg,
+            element_index: ElementIndex,
+            element_coords: Coords,
+        ):
+            J = wp.transpose(
+                self.geometry.cell_inverse_deformation_gradient(
+                    elt_arg, make_free_sample(element_index, element_coords)
+                )
+            )
+            return J
+
+        return local_value_map
+
+
+class CovariantFunctionSpaceTrace(VectorValuedFunctionSpace):
+    """Trace of a :class:`CovariantFunctionSpace`"""
+
+    def __init__(self, space: VectorValuedFunctionSpace):
+        self._space = space
+        super().__init__(space._basis.trace())
+
+        self.local_value_map_inner = self._make_local_value_map_inner()
+        self.local_value_map_outer = self._make_local_value_map_outer()
+
+    @property
+    def name(self):
+        return f"{self._space.name}_Trace"
+
+    def __eq__(self, other: "CovariantFunctionSpaceTrace") -> bool:
+        return self._space == other._space
+
+    def _make_local_value_map_inner(self):
+        @cache.dynamic_func(suffix=self.name)
+        def local_value_map_inner(
+            elt_arg: self.ElementArg,
+            element_index: ElementIndex,
+            element_coords: Coords,
+        ):
+            return wp.transpose(
+                self.geometry.side_inner_inverse_deformation_gradient(
+                    elt_arg, make_free_sample(element_index, element_coords)
+                )
+            )
+
+        return local_value_map_inner
+
+    def _make_local_value_map_outer(self):
+        @cache.dynamic_func(suffix=self.name)
+        def local_value_map_outer(
+            elt_arg: self.ElementArg,
+            element_index: ElementIndex,
+            element_coords: Coords,
+        ):
+            return wp.transpose(
+                self.geometry.side_outer_inverse_deformation_gradient(
+                    elt_arg, make_free_sample(element_index, element_coords)
+                )
+            )
+
+        return local_value_map_outer
+
+
+class ContravariantFunctionSpace(VectorValuedFunctionSpace):
+    """Function space whose values are contravariant vectors"""
+
+    def __init__(self, basis: BasisSpace):
+        super().__init__(basis)
+
+        self.local_value_map_inner = self._make_local_value_map()
+        self.local_value_map_outer = self.local_value_map_inner
+
+    def trace(self) -> "ContravariantFunctionSpaceTrace":
+        return ContravariantFunctionSpaceTrace(self)
+
+    def _make_local_value_map(self):
+        @cache.dynamic_func(suffix=self.name)
+        def local_value_map(
+            elt_arg: self.ElementArg,
+            element_index: ElementIndex,
+            element_coords: Coords,
+        ):
+            F = self.geometry.cell_deformation_gradient(elt_arg, make_free_sample(element_index, element_coords))
+            return F / Geometry._element_measure(F)
+
+        return local_value_map
+
+
+class ContravariantFunctionSpaceTrace(VectorValuedFunctionSpace):
+    """Trace of a :class:`ContravariantFunctionSpace`"""
+
+    def __init__(self, space: ContravariantFunctionSpace):
+        self._space = space
+        super().__init__(space._basis.trace())
+
+        self.local_value_map_inner = self._make_local_value_map_inner()
+        self.local_value_map_outer = self._make_local_value_map_outer()
+
+    @property
+    def name(self):
+        return f"{self._space.name}_Trace"
+
+    def __eq__(self, other: "ContravariantFunctionSpaceTrace") -> bool:
+        return self._space == other._space
+
+    def _make_local_value_map_inner(self):
+        @cache.dynamic_func(suffix=self.name)
+        def local_value_map_inner(
+            elt_arg: self.ElementArg,
+            element_index: ElementIndex,
+            element_coords: Coords,
+        ):
+            cell_index = self.geometry.side_inner_cell_index(elt_arg, element_index)
+            cell_coords = self.geometry.side_inner_cell_coords(elt_arg, element_index, element_coords)
+            cell_arg = self.geometry.side_to_cell_arg(elt_arg)
+
+            F = self.geometry.cell_deformation_gradient(cell_arg, make_free_sample(cell_index, cell_coords))
+            return F / Geometry._element_measure(F)
+
+        return local_value_map_inner
+
+    def _make_local_value_map_outer(self):
+        @cache.dynamic_func(suffix=self.name)
+        def local_value_map_outer(
+            elt_arg: self.ElementArg,
+            element_index: ElementIndex,
+            element_coords: Coords,
+        ):
+            cell_index = self.geometry.side_outer_cell_index(elt_arg, element_index)
+            cell_coords = self.geometry.side_outer_cell_coords(elt_arg, element_index, element_coords)
+            cell_arg = self.geometry.side_to_cell_arg(elt_arg)
+
+            F = self.geometry.cell_deformation_gradient(cell_arg, make_free_sample(cell_index, cell_coords))
+            return F / Geometry._element_measure(F)
+
+        return local_value_map_outer