warp-lang 1.7.2__py3-none-win_amd64.whl → 1.8.0__py3-none-win_amd64.whl

warp/fem/domain.py

@@ -13,6 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from functools import cached_property
 from typing import Any, Optional, Set, Union
 
 import warp as wp
@@ -27,7 +28,7 @@ from warp.fem.geometry import (
     WholeGeometryPartition,
 )
 from warp.fem.operator import Operator
-from warp.fem.types import ElementKind
+from warp.fem.types import NULL_ELEMENT_INDEX, ElementKind
 
 GeometryOrPartition = Union[Geometry, GeometryPartition]
 
@@ -89,6 +90,9 @@ class GeometryDomain:
     element_index: wp.Function
     """Device function for retrieving an ElementIndex from a linearized index"""
 
+    element_partition_index: wp.Function
+    """Device function for retrieving linearized index in the domain's partition from an ElementIndex"""
+
     ElementArg: warp.codegen.Struct
     """Structure containing arguments to be passed to device functions computing element geometry"""
 
@@ -107,13 +111,34 @@ class GeometryDomain:
     element_normal: wp.Function
     """Device function returning the element normal at a sample point"""
 
+    element_closest_point: wp.Function
+    """Device function returning the coordinates of the closest point in a given element to a world position"""
+
+    element_coordinates: wp.Function
+    """Device function returning the coordinates corresponding to a world position in a given element reference system"""
+
     element_lookup: wp.Function
-    """Device function returning the sample point corresponding to a world position"""
+    """Device function returning the sample point in the domain's geometry corresponding to a world position"""
+
+    element_partition_lookup: wp.Function
+    """Device function returning the sample point in the domain's geometry partition corresponding to a world position"""
 
     def notify_operator_usage(self, ops: Set[Operator]):
         """Makes the Domain aware that the operators `ops` will be applied"""
         pass
 
+    @cached_property
+    def DomainArg(self):
+        return self._make_domain_arg()
+
+    def _make_domain_arg(self):
+        @cache.dynamic_struct(suffix=self.name)
+        class DomainArg:
+            geo: self.ElementArg
+            index: self.ElementIndexArg
+
+        return DomainArg
+
 
 class Cells(GeometryDomain):
     """A Domain containing all cells of the geometry or geometry partition"""
@@ -145,13 +170,23 @@ class Cells(GeometryDomain):
     def element_index_arg_value(self, device: warp.context.Devicelike) -> warp.codegen.StructInstance:
         return self.geometry_partition.cell_arg_value(device)
 
+    def fill_element_index_arg(self, arg: ElementIndexArg, device: warp.context.Devicelike):
+        self.geometry_partition.fill_cell_arg(arg, device)
+
     @property
     def element_index(self) -> wp.Function:
         return self.geometry_partition.cell_index
 
+    @property
+    def element_partition_index(self) -> wp.Function:
+        return self.geometry_partition.partition_cell_index
+
     def element_arg_value(self, device: warp.context.Devicelike) -> warp.codegen.StructInstance:
         return self.geometry.cell_arg_value(device)
 
+    def fill_element_arg(self, arg: "ElementArg", device: warp.context.Devicelike):
+        self.geometry.fill_cell_arg(arg, device)
+
     @property
     def ElementArg(self) -> warp.codegen.Struct:
         return self.geometry.CellArg
@@ -176,10 +211,46 @@ class Cells(GeometryDomain):
     def element_normal(self) -> wp.Function:
         return self.geometry.cell_normal
 
+    @property
+    def element_closest_point(self) -> wp.Function:
+        return self.geometry.cell_closest_point
+
+    @property
+    def element_coordinates(self) -> wp.Function:
+        return self.geometry.cell_coordinates
+
     @property
     def element_lookup(self) -> wp.Function:
         return self.geometry.cell_lookup
 
+    @property
+    def element_partition_lookup(self) -> wp.Function:
+        pos_type = cache.cached_vec_type(self.geometry.dimension, dtype=float)
+
+        @cache.dynamic_func(suffix=self.geometry_partition.name)
+        def is_in_partition(args: self.ElementIndexArg, cell_index: int):
+            return self.geometry_partition.partition_cell_index(args, cell_index) != NULL_ELEMENT_INDEX
+
+        filtered_cell_lookup = self.geometry.make_filtered_cell_lookup(filter_func=is_in_partition)
+
+        # overloads
+        filter_target = True
+        pos_type = cache.cached_vec_type(self.geometry.dimension, dtype=float)
+
+        @cache.dynamic_func(suffix=self.name)
+        def cell_partition_lookup(args: self.DomainArg, pos: pos_type, max_dist: float):
+            return filtered_cell_lookup(args.geo, pos, max_dist, args.index, filter_target)
+
+        @cache.dynamic_func(suffix=self.name)
+        def cell_partition_lookup(args: self.DomainArg, pos: pos_type):
+            max_dist = 0.0
+            return filtered_cell_lookup(args.geo, pos, max_dist, args.index, filter_target)
+
+        return cell_partition_lookup
+
+    def supports_lookup(self, device):
+        return self.geometry.supports_cell_lookup(device)
+
     @property
     def domain_cell_arg(self) -> wp.Function:
         return Cells._identity_fn
@@ -200,6 +271,11 @@ class Sides(GeometryDomain):
         super().__init__(geometry)
 
         self.element_lookup = None
+        self.element_partition_lookup = None
+        self.element_filtered_lookup = None
+
+    def supports_lookup(self, device):
+        return False
 
     @property
     def element_kind(self) -> ElementKind:
@@ -225,6 +301,9 @@ class Sides(GeometryDomain):
     def element_index_arg_value(self, device: warp.context.Devicelike) -> warp.codegen.StructInstance:
         return self.geometry_partition.side_arg_value(device)
 
+    def fill_element_index_arg(self, arg: "ElementIndexArg", device: warp.context.Devicelike):
+        self.geometry_partition.fill_side_arg(arg, device)
+
     @property
     def element_index(self) -> wp.Function:
         return self.geometry_partition.side_index
@@ -236,6 +315,9 @@ class Sides(GeometryDomain):
     def element_arg_value(self, device: warp.context.Devicelike) -> warp.codegen.StructInstance:
         return self.geometry.side_arg_value(device)
 
+    def fill_element_arg(self, arg: "ElementArg", device: warp.context.Devicelike):
+        self.geometry.fill_side_arg(arg, device)
+
     @property
     def element_position(self) -> wp.Function:
         return self.geometry.side_position
@@ -256,6 +338,14 @@ class Sides(GeometryDomain):
     def element_normal(self) -> wp.Function:
         return self.geometry.side_normal
 
+    @property
+    def element_closest_point(self) -> wp.Function:
+        return self.geometry.side_closest_point
+
+    @property
+    def element_coordinates(self) -> wp.Function:
+        return self.geometry.side_coordinates
+
     @property
     def element_inner_cell_index(self) -> wp.Function:
         return self.geometry.side_inner_cell_index
@@ -276,9 +366,18 @@ class Sides(GeometryDomain):
     def cell_to_element_coords(self) -> wp.Function:
         return self.geometry.side_from_cell_coords
 
-    @property
+    @cached_property
     def domain_cell_arg(self) -> wp.Function:
-        return self.geometry.side_to_cell_arg
+        CellDomainArg = self.cell_domain().DomainArg
+
+        @cache.dynamic_func(suffix=self.name)
+        def domain_cell_arg(x: self.DomainArg):
+            return CellDomainArg(
+                self.geometry.side_to_cell_arg(x.geo),
+                self.geometry_partition.side_to_cell_arg(x.index),
+            )
+
+        return domain_cell_arg
 
     def cell_domain(self):
         return Cells(self.geometry_partition)
@@ -359,11 +458,13 @@ class Subdomain(GeometryDomain):
         self.geometry_element_count = self._domain.geometry_element_count
         self.reference_element = self._domain.reference_element
         self.element_arg_value = self._domain.element_arg_value
+        self.fill_element_arg = self._domain.fill_element_arg
         self.element_measure = self._domain.element_measure
         self.element_measure_ratio = self._domain.element_measure_ratio
         self.element_position = self._domain.element_position
         self.element_deformation_gradient = self._domain.element_deformation_gradient
         self.element_lookup = self._domain.element_lookup
+        self.element_partition_lookup = self._domain.element_partition_lookup
         self.element_normal = self._domain.element_normal
 
     @property
@@ -399,13 +500,42 @@ class Subdomain(GeometryDomain):
     @cache.cached_arg_value
     def element_index_arg_value(self, device: warp.context.Devicelike):
         arg = self.ElementIndexArg()
-        arg.domain_arg = self._domain.element_index_arg_value(device)
-        arg.element_indices = self._element_indices.to(device)
+        self.fill_element_index_arg(arg, device)
         return arg
 
+    def fill_element_index_arg(self, arg: "GeometryDomain.ElementIndexArg", device: warp.context.Devicelike):
+        self._domain.fill_element_index_arg(arg.domain_arg, device)
+        arg.element_indices = self._element_indices.to(device)
+
     def _make_element_index(self) -> wp.Function:
         @cache.dynamic_func(suffix=self.name)
         def element_index(arg: self.ElementIndexArg, index: int):
             return self._domain.element_index(arg.domain_arg, arg.element_indices[index])
 
         return element_index
+
+    def _make_element_partition_index(self) -> wp.Function:
+        @cache.dynamic_func(suffix=self.name)
+        def element_partition_index(arg: self.ElementIndexArg, element_index: int):
+            return self._domain.element_partition_index(arg.domain_arg, element_index)
+
+        return element_partition_index
+
+    def supports_lookup(self, device):
+        return self._domain.supports_lokup(device)
+
+    def cell_domain(self):
+        return self._domain.cell_domain()
+
+    @cached_property
+    def domain_cell_arg(self) -> wp.Function:
+        CellDomainArg = self.cell_domain().DomainArg
+
+        @cache.dynamic_func(suffix=self.name)
+        def domain_cell_arg(x: self.DomainArg):
+            return CellDomainArg(
+                self.geometry.side_to_cell_arg(x.geo),
+                self.geometry_partition.side_to_cell_arg(x.index.domain_arg),
+            )
+
+        return domain_cell_arg

warp/fem/field/field.py

@@ -13,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Optional, Set
+from typing import Any, ClassVar, Dict, Optional, Set
 
 import warp as wp
 from warp.fem import cache
@@ -22,6 +22,7 @@ from warp.fem.geometry import DeformedGeometry, Geometry
 from warp.fem.operator import Operator, integrand
 from warp.fem.space import FunctionSpace, SpacePartition
 from warp.fem.types import NULL_ELEMENT_INDEX, ElementKind, Sample
+from warp.fem.utils import type_zero_element
 
 
 class FieldLike:
@@ -37,6 +38,10 @@ class FieldLike:
         """Value of the field-level arguments to be passed to device functions"""
         raise NotImplementedError
 
+    def fill_eval_arg(self, arg: "FieldLike.EvalArg", device):
+        """Fill the field-level arguments to be passed to device functions"""
+        raise NotImplementedError
+
     @property
     def degree(self) -> int:
         """Polynomial degree of the field, used to estimate necessary quadrature order"""
@@ -50,10 +55,6 @@ class FieldLike:
     def __str__(self) -> str:
         return self.name
 
-    def eval_arg_value(self, device):
-        """Value of arguments to be passed to device functions"""
-        raise NotImplementedError
-
     def gradient_valid(self) -> bool:
         """Whether the gradient operator is implemented for this field."""
         return False
@@ -139,6 +140,51 @@ class GeometryField(FieldLike):
         """
         return DeformedGeometry(self, relative=relative)
 
+    @property
+    def gradient_dtype(self):
+        """Return type of the (world space) gradient operator. Assumes self.gradient_valid()"""
+        if wp.types.type_is_matrix(self.dtype):
+            return None
+
+        if wp.types.type_is_vector(self.dtype):
+            return cache.cached_mat_type(
+                shape=(wp.types.type_size(self.dtype), self.geometry.dimension),
+                dtype=wp.types.type_scalar_type(self.dtype),
+            )
+        if wp.types.type_is_quaternion(self.dtype):
+            return cache.cached_mat_type(
+                shape=(4, self.geometry.dimension),
+                dtype=wp.types.type_scalar_type(self.dtype),
+            )
+        return cache.cached_vec_type(length=self.geometry.dimension, dtype=wp.types.type_scalar_type(self.dtype))
+
+    @property
+    def reference_gradient_dtype(self):
+        """Return type of the reference space gradient operator. Assumes self.gradient_valid()"""
+        if wp.types.type_is_matrix(self.dtype):
+            return None
+
+        if wp.types.type_is_vector(self.dtype):
+            return cache.cached_mat_type(
+                shape=(wp.types.type_size(self.dtype), self.geometry.cell_dimension),
+                dtype=wp.types.type_scalar_type(self.dtype),
+            )
+        if wp.types.type_is_quaternion(self.dtype):
+            return cache.cached_mat_type(
+                shape=(4, self.geometry.cell_dimension),
+                dtype=wp.types.type_scalar_type(self.dtype),
+            )
+        return cache.cached_vec_type(length=self.geometry.cell_dimension, dtype=wp.types.type_scalar_type(self.dtype))
+
+    @property
+    def divergence_dtype(self):
+        """Return type of the divergence operator. Assumes self.divergence_valid()"""
+        if wp.types.type_is_vector(self.dtype):
+            return wp.types.type_scalar_type(self.dtype)
+        if wp.types.type_is_matrix(self.dtype):
+            return cache.cached_vec_type(length=self.dtype._shape_[1], dtype=wp.types.type_scalar_type(self.dtype))
+        return None
+
 
 class SpaceField(GeometryField):
     """Base class for fields defined over a function space"""
@@ -178,33 +224,6 @@ class SpaceField(GeometryField):
     def dof_dtype(self) -> type:
         return self.space.dof_dtype
 
-    @property
-    def gradient_dtype(self):
-        """Return type of the (world space) gradient operator. Assumes self.gradient_valid()"""
-        if wp.types.type_is_vector(self.dtype):
-            return cache.cached_mat_type(
-                shape=(wp.types.type_length(self.dtype), self.geometry.dimension),
-                dtype=wp.types.type_scalar_type(self.dtype),
-            )
-        return cache.cached_vec_type(length=self.geometry.dimension, dtype=wp.types.type_scalar_type(self.dtype))
-
-    @property
-    def reference_gradient_dtype(self):
-        """Return type of the reference space gradient operator. Assumes self.gradient_valid()"""
-        if wp.types.type_is_vector(self.dtype):
-            return cache.cached_mat_type(
-                shape=(wp.types.type_length(self.dtype), self.geometry.cell_dimension),
-                dtype=wp.types.type_scalar_type(self.dtype),
-            )
-        return cache.cached_vec_type(length=self.geometry.cell_dimension, dtype=wp.types.type_scalar_type(self.dtype))
-
-    @property
-    def divergence_dtype(self):
-        """Return type of the divergence operator. Assumes self.gradient_valid()"""
-        if wp.types.type_is_vector(self.dtype):
-            return wp.types.type_scalar_type(self.dtype)
-        return cache.cached_vec_type(length=self.dtype._shape_[1], dtype=wp.types.type_scalar_type(self.dtype))
-
     def _make_eval_degree(self):
         ORDER = self.space.ORDER
 
@@ -251,6 +270,19 @@ class ImplicitField(GeometryField):
         degree: Optional hint for automatic determination of quadrature orders when integrating this field
     """
 
+    _dynamic_attribute_constructors: ClassVar = {
+        "ElementEvalArg": lambda obj: obj._make_element_eval_arg(),
+        "eval_degree": lambda obj: obj._make_eval_degree(),
+        "eval_inner": lambda obj: obj._make_eval_func(obj._func),
+        "eval_grad_inner": lambda obj: obj._make_eval_func(obj._grad_func),
+        "eval_div_inner": lambda obj: obj._make_eval_func(obj._div_func),
+        "eval_reference_grad_inner": lambda obj: obj._make_eval_reference_grad(),
+        "eval_outer": lambda obj: obj.eval_inner,
+        "eval_grad_outer": lambda obj: obj.eval_grad_inner,
+        "eval_div_outer": lambda obj: obj.eval_div_inner,
+        "eval_reference_grad_outer": lambda obj: obj.eval_reference_grad_inner,
+    }
+
     def __init__(
         self,
         domain: GeometryDomain,
@@ -284,18 +316,7 @@ class ImplicitField(GeometryField):
         self.EvalArg = cache.get_argument_struct(arg_types)
         self.values = values
 
-        self.ElementEvalArg = self._make_element_eval_arg()
-        self.eval_degree = self._make_eval_degree()
-
-        self.eval_inner = self._make_eval_func(func)
-        self.eval_grad_inner = self._make_eval_func(grad_func)
-        self.eval_div_inner = self._make_eval_func(div_func)
-        self.eval_reference_grad_inner = self._make_eval_reference_grad()
-
-        self.eval_outer = self.eval_inner
-        self.eval_grad_outer = self.eval_grad_inner
-        self.eval_div_outer = self.eval_div_inner
-        self.eval_reference_grad_outer = self.eval_reference_grad_inner
+        cache.setup_dynamic_attributes(self)
 
     @property
     def values(self):
@@ -303,6 +324,7 @@ class ImplicitField(GeometryField):
 
     @values.setter
     def values(self, v):
+        self._values = v
         self._func_arg = cache.populate_argument_struct(self.EvalArg, v, self._func.func.__name__)
 
     @property
@@ -316,6 +338,9 @@ class ImplicitField(GeometryField):
     def eval_arg_value(self, device):
         return self._func_arg
 
+    def fill_eval_arg(self, arg, device):
+        cache.populate_argument_struct(self.EvalArg, self._values, self._func.func.__name__, arg)
+
     @property
     def degree(self) -> int:
         return self._degree
@@ -324,6 +349,12 @@ class ImplicitField(GeometryField):
     def name(self) -> str:
         return f"Implicit_{self.domain.name}_{self.degree}_{self.EvalArg.key}"
 
+    def gradient_valid(self) -> bool:
+        return self._grad_func is not None
+
+    def divergence_valid(self) -> bool:
+        return self._div_func is not None
+
     def _make_eval_func(self, func):
         if func is None:
             return None
@@ -387,6 +418,20 @@ class UniformField(GeometryField):
         value: Uniform value over the domain
     """
 
+    _dynamic_attribute_constructors: ClassVar = {
+        "EvalArg": lambda obj: obj._make_eval_arg(),
+        "ElementEvalArg": lambda obj: obj._make_element_eval_arg(),
+        "eval_degree": lambda obj: obj._make_eval_degree(),
+        "eval_inner": lambda obj: obj._make_eval_inner(),
+        "eval_grad_inner": lambda obj: obj._make_eval_zero(obj.gradient_dtype),
+        "eval_div_inner": lambda obj: obj._make_eval_zero(obj.divergence_dtype),
+        "eval_reference_grad_inner": lambda obj: obj._make_eval_zero(obj.reference_gradient_dtype),
+        "eval_outer": lambda obj: obj.eval_inner,
+        "eval_grad_outer": lambda obj: obj.eval_grad_inner,
+        "eval_div_outer": lambda obj: obj.eval_div_inner,
+        "eval_reference_grad_outer": lambda obj: obj.eval_reference_grad_inner,
+    }
+
     def __init__(self, domain: GeometryDomain, value: Any):
         self.domain = domain
 
@@ -396,30 +441,7 @@ class UniformField(GeometryField):
         self.dtype = wp.types.type_to_warp(type(value))
         self._value = self.dtype(value)
 
-        scalar_type = wp.types.type_scalar_type(self.dtype)
-        if wp.types.type_is_vector(self.dtype):
-            grad_type = wp.mat(shape=(wp.types.type_length(self.dtype), self.geometry.dimension), dtype=scalar_type)
-            div_type = scalar_type
-        elif wp.types.type_is_matrix(self.dtype):
-            grad_type = None
-            div_type = wp.vec(length=(wp.types.type_length(self.dtype) // self.geometry.dimension), dtype=scalar_type)
-        else:
-            div_type = None
-            grad_type = wp.vec(length=self.geometry.dimension, dtype=scalar_type)
-
-        self.EvalArg = self._make_eval_arg()
-        self.ElementEvalArg = self._make_element_eval_arg()
-        self.eval_degree = self._make_eval_degree()
-
-        self.eval_inner = self._make_eval_inner()
-        self.eval_grad_inner = self._make_eval_zero(grad_type)
-        self.eval_div_inner = self._make_eval_zero(div_type)
-        self.eval_reference_grad_inner = self.eval_grad_inner
-
-        self.eval_outer = self.eval_inner
-        self.eval_grad_outer = self.eval_grad_inner
-        self.eval_div_outer = self.eval_div_inner
-        self.eval_reference_grad_outer = self.eval_reference_grad_inner
+        cache.setup_dynamic_attributes(self)
 
     @property
     def value(self):
@@ -444,10 +466,19 @@ class UniformField(GeometryField):
         arg.value = self.value
         return arg
 
+    def fill_eval_arg(self, arg, device):
+        arg.value = self.value
+
     @property
     def degree(self) -> int:
         return 0
 
+    def gradient_valid(self) -> bool:
+        return self.gradient_dtype is not None
+
+    def divergence_valid(self) -> bool:
+        return self.divergence_dtype is not None
+
     @property
     def name(self) -> str:
         return f"Uniform{self.domain.name}_{wp.types.get_type_code(self.dtype)}"
@@ -463,11 +494,11 @@ class UniformField(GeometryField):
         if dtype is None:
             return None
 
-        scalar_type = wp.types.type_scalar_type(dtype)
+        zero_element = type_zero_element(dtype)
 
         @cache.dynamic_func(suffix=f"{self.name}_{wp.types.get_type_code(dtype)}")
         def eval_zero(args: self.ElementEvalArg, s: Sample):
-            return dtype(scalar_type(0.0))
+            return zero_element()
 
         return eval_zero
 
@@ -511,6 +542,20 @@ class NonconformingField(GeometryField):
 
     _LOOKUP_EPS = wp.constant(1.0e-6)
 
+    _dynamic_attribute_constructors: ClassVar = {
+        "EvalArg": lambda obj: obj._make_eval_arg(),
+        "ElementEvalArg": lambda obj: obj._make_element_eval_arg(),
+        "eval_degree": lambda obj: obj._make_eval_degree(),
+        "eval_inner": lambda obj: obj._make_nonconforming_eval("eval_inner"),
+        "eval_grad_inner": lambda obj: obj._make_nonconforming_eval("eval_grad_inner"),
+        "eval_div_inner": lambda obj: obj._make_nonconforming_eval("eval_div_inner"),
+        "eval_reference_grad_inner": lambda obj: obj._make_eval_reference_grad(),
+        "eval_outer": lambda obj: obj.eval_inner,
+        "eval_grad_outer": lambda obj: obj.eval_grad_inner,
+        "eval_div_outer": lambda obj: obj.eval_div_inner,
+        "eval_reference_grad_outer": lambda obj: obj.eval_reference_grad_inner,
+    }
+
     def __init__(self, domain: GeometryDomain, field: DiscreteField, background: Any = 0.0):
         self.domain = domain
 
@@ -523,20 +568,7 @@ class NonconformingField(GeometryField):
             raise ValueError("Background field must be conforming to the domain")
         self.background = background
 
-        self.EvalArg = self._make_eval_arg()
-        self.ElementEvalArg = self._make_element_eval_arg()
-        self.eval_degree = self._make_eval_degree()
-
-        self.eval_inner = self._make_nonconforming_eval("eval_inner")
-        self.eval_grad_inner = self._make_nonconforming_eval("eval_grad_inner")
-        self.eval_div_inner = self._make_nonconforming_eval("eval_div_inner")
-        self.eval_reference_grad_inner = self._make_eval_reference_grad()
-
-        # Nonconforming evaluation is position based, does not handle discontinuous fields
-        self.eval_outer = self.eval_inner
-        self.eval_grad_outer = self.eval_grad_inner
-        self.eval_div_outer = self.eval_div_inner
-        self.eval_reference_grad_outer = self.eval_reference_grad_inner
+        cache.setup_dynamic_attributes(self)
 
     @property
     def geometry(self) -> Geometry:
@@ -546,19 +578,26 @@ class NonconformingField(GeometryField):
     def element_kind(self) -> ElementKind:
         return self.domain.element_kind
 
-    @cache.cached_arg_value
     def eval_arg_value(self, device):
         arg = self.EvalArg()
-        arg.field_cell_eval_arg = self.field.ElementEvalArg()
-        arg.field_cell_eval_arg.elt_arg = self.field.geometry.cell_arg_value(device)
-        arg.field_cell_eval_arg.eval_arg = self.field.eval_arg_value(device)
-        arg.background_arg = self.background.eval_arg_value(device)
+        self.fill_eval_arg(arg, device)
         return arg
 
+    def fill_eval_arg(self, arg, device):
+        self.field.fill_eval_arg(arg.field_cell_eval_arg.eval_arg, device)
+        self.field.geometry.fill_cell_arg(arg.field_cell_eval_arg.elt_arg, device)
+        self.background.fill_eval_arg(arg.background_arg, device)
+
     @property
     def degree(self) -> int:
         return self.field.degree
 
+    def gradient_valid(self) -> bool:
+        return self.field.gradient_valid() and self.background.gradient_valid()
+
+    def divergence_valid(self) -> bool:
+        return self.field.divergence_valid() and self.background.divergence_valid()
+
     @property
     def name(self) -> str:
         return f"{self.domain.name}_{self.field.name}_{self.background.name}"
@@ -570,20 +609,23 @@ class NonconformingField(GeometryField):
         if field_eval is None or bg_eval is None:
             return None
 
+        cell_lookup = self.field.geometry.cell_lookup
+
         @cache.dynamic_func(suffix=f"{eval_func_name}_{self.name}")
         def eval_nc(args: self.ElementEvalArg, s: Sample):
             pos = self.domain.element_position(args.elt_arg, s)
             cell_arg = args.eval_arg.field_cell_eval_arg.elt_arg
-            nonconforming_s = self.field.geometry.cell_lookup(cell_arg, pos)
-            if (
-                nonconforming_s.element_index == NULL_ELEMENT_INDEX
-                or wp.length_sq(pos - self.field.geometry.cell_position(cell_arg, nonconforming_s))
-                > NonconformingField._LOOKUP_EPS
-            ):
-                return bg_eval(self.background.ElementEvalArg(args.elt_arg, args.eval_arg.background_arg), s)
-            return field_eval(
-                self.field.ElementEvalArg(cell_arg, args.eval_arg.field_cell_eval_arg.eval_arg), nonconforming_s
-            )
+            nonconforming_s = cell_lookup(cell_arg, pos, NonconformingField._LOOKUP_EPS)
+            if nonconforming_s.element_index != NULL_ELEMENT_INDEX:
+                if (
+                    wp.length_sq(pos - self.field.geometry.cell_position(cell_arg, nonconforming_s))
+                    <= NonconformingField._LOOKUP_EPS
+                ):
+                    return field_eval(
+                        self.field.ElementEvalArg(cell_arg, args.eval_arg.field_cell_eval_arg.eval_arg), nonconforming_s
+                    )
+
+            return bg_eval(self.background.ElementEvalArg(args.elt_arg, args.eval_arg.background_arg), s)
 
         return eval_nc