warp-lang 1.0.0b2__py3-none-win_amd64.whl → 1.0.0b6__py3-none-win_amd64.whl

warp/fem/field/field.py

@@ -0,0 +1,149 @@
+from typing import Any
+
+import warp as wp
+
+from warp.fem.types import Sample
+from warp.fem.space import FunctionSpace, SpacePartition
+from warp.fem.geometry import Geometry, DeformedGeometry
+
+
+class FieldLike:
+    """Base class for integrable fields"""
+
+    EvalArg: wp.codegen.Struct
+    """Structure containing field-level arguments passed to device functions for field evaluation"""
+
+    ElementEvalArg: wp.codegen.Struct
+    """Structure combining geometry-level and field-level arguments passed to device functions for field evaluation"""
+
+    def eval_arg_value(self, device) -> "EvalArg":
+        """Value of 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"""
+        raise NotImplementedError
+
+    @property
+    def name(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def __str__(self) -> str:
+        return self.name
+
+    def eval_arg_value(self, device):
+        """Value of arguments to be passed to device functions"""
+        raise NotImplementedError
+
+    @staticmethod
+    def eval_inner(args: "ElementEvalArg", s: "Sample"):
+        """Device function evaluating the inner field value at a sample point"""
+        raise NotImplementedError
+
+    @staticmethod
+    def eval_grad_inner(args: "ElementEvalArg", s: "Sample"):
+        """Device function evaluating the inner field gradient at a sample point"""
+        raise NotImplementedError
+
+    @staticmethod
+    def eval_div_inner(args: "ElementEvalArg", s: "Sample"):
+        """Device function evaluating the inner field divergence at a sample point"""
+        raise NotImplementedError
+
+    @staticmethod
+    def eval_outer(args: "ElementEvalArg", s: "Sample"):
+        """Device function evaluating the outer field value at a sample point"""
+        raise NotImplementedError
+
+    @staticmethod
+    def eval_grad_outer(args: "ElementEvalArg", s: "Sample"):
+        """Device function evaluating the outer field gradient at a sample point"""
+        raise NotImplementedError
+
+    @staticmethod
+    def eval_div_outer(args: "ElementEvalArg", s: "Sample"):
+        """Device function evaluating the outer field divergence at a sample point"""
+        raise NotImplementedError
+
+
+class SpaceField(FieldLike):
+    """Base class for fields defined over a function space"""
+
+    def __init__(self, space: FunctionSpace, space_partition: SpacePartition):
+        self._space = space
+        self._space_partition = space_partition
+
+    @property
+    def space(self) -> FunctionSpace:
+        return self._space
+
+    @property
+    def space_partition(self) -> SpacePartition:
+        return self._space_partition
+
+    @property
+    def degree(self) -> int:
+        return self.space.degree
+
+    @property
+    def dtype(self) -> type:
+        return self.space.dtype
+
+    @property
+    def dof_dtype(self) -> type:
+        return self.space.dof_dtype
+
+    def gradient_valid(self) -> bool:
+        """Whether gradient operator can be computed. Only for scalar and vector fields as higher-order tensors are not support yet"""
+        return not wp.types.type_is_matrix(self.dtype)
+
+    def divergence_valid(self) -> bool:
+        """Whether divergence of this field can be computed. Only for vector and tensor fields with same dimension as embedding geometry"""
+        if wp.types.type_is_vector(self.dtype):
+            return wp.types.type_length(self.dtype) == self.space.geometry.dimension
+        if wp.types.type_is_matrix(self.dtype):
+            return self.dtype._shape_[0] == self.space.geometry.dimension
+        return False
+
+    def _make_eval_degree(self):
+        ORDER = self.space.ORDER
+        from warp.fem import cache
+
+        @cache.dynamic_func(suffix=self.name)
+        def degree(args: self.ElementEvalArg):
+            return ORDER
+
+        return degree
+
+
+class DiscreteField(SpaceField):
+    """Explicitly-valued field defined over a partition of a discrete function space"""
+
+    @property
+    def dof_values(self) -> wp.array:
+        """Array of degrees of freedom values"""
+        raise NotImplementedError
+
+    @dof_values.setter
+    def dof_values(self, values: wp.array):
+        """Sets degrees of freedom values from an array"""
+        raise NotImplementedError
+
+    def trace(self) -> "DiscreteField":
+        """Trace of this field over a lower-dimensional function space"""
+        raise NotImplementedError
+
+    @staticmethod
+    def set_node_value(args: "FieldLike.EvalArg", node_index: int, value: Any):
+        """Device function setting the value at given node"""
+        raise NotImplementedError
+
+    @property
+    def name(self) -> str:
+        return f"{self.__class__.__qualname__}_{self.space.name}_{self.space_partition.name}"
+
+    def make_deformed_geometry(self) -> Geometry:
+        """Returns a deformed version of the underlying geometry using this field's values as displacement"""
+        return DeformedGeometry(self)

warp/fem/field/nodal_field.py

@@ -1,193 +1,299 @@
 import warp as wp
 
-from warp.fem.space import NodalFunctionSpace, SpacePartition
+from warp.fem.space import CollocatedFunctionSpace, SpacePartition
 from warp.fem import cache, utils
 from warp.fem.types import Sample, ElementIndex, NULL_NODE_INDEX
 
-from .discrete_field import DiscreteField
+from .field import DiscreteField
 
 
-class NodalField(DiscreteField):
-    def __init__(self, space_partition: SpacePartition, space: NodalFunctionSpace = None):
-        if space is None:
-            space = space_partition.space
+class NodalFieldBase(DiscreteField):
+    """Base class for nodal field and nodal field traces. Does not hold values"""
 
+    def __init__(self, space: CollocatedFunctionSpace, space_partition: SpacePartition):
         super().__init__(space, space_partition)
 
-        self._dof_values = wp.zeros(n=self.space_partition.node_count(), dtype=self.dof_dtype)
-
-        self.EvalArg = NodalField._make_eval_arg(self.space, self.space_partition)
-        self.eval_degree = DiscreteField._make_eval_degree(self.EvalArg, self.space)
-        self.set_node_value = NodalField._make_set_node_value(self.EvalArg, self.space)
-
-        read_node_value = NodalField._make_read_node_value(self.EvalArg, self.space, self.space_partition)
+        self.EvalArg = self._make_eval_arg()
+        self.ElementEvalArg = self._make_element_eval_arg()
+        self.eval_degree = DiscreteField._make_eval_degree(self)
 
-        self.eval_inner = NodalField._make_eval_inner(self.EvalArg, self.space, read_node_value)
-        self.eval_outer = NodalField._make_eval_outer(self.EvalArg, self.space, read_node_value)
-        self.eval_grad_inner = NodalField._make_eval_grad_inner(self.EvalArg, self.space, read_node_value)
-        self.eval_grad_outer = NodalField._make_eval_grad_outer(self.EvalArg, self.space, read_node_value)
+        self._read_node_value = self._make_read_node_value()
 
-    def eval_arg_value(self, device):
-        arg = self.EvalArg()
-        arg.space_arg = self.space.space_arg_value(device)
-        arg.partition_arg = self.space_partition.partition_arg_value(device)
-        arg.dof_values = self._dof_values.to(device)
+        self.eval_inner = self._make_eval_inner()
+        self.eval_outer = self._make_eval_outer()
+        self.eval_grad_inner = self._make_eval_grad_inner(world_space=True)
+        self.eval_grad_outer = self._make_eval_grad_outer(world_space=True)
+        self.eval_reference_grad_inner = self._make_eval_grad_inner(world_space=False)
+        self.eval_reference_grad_outer = self._make_eval_grad_outer(world_space=False)
+        self.eval_div_inner = self._make_eval_div_inner()
+        self.eval_div_outer = self._make_eval_div_outer()
 
-        return arg
+        self.set_node_value = self._make_set_node_value()
 
-    @property
-    def dof_values(self):
-        return self._dof_values
+    def _make_eval_arg(self):
+        @cache.dynamic_struct(suffix=self.name)
+        class EvalArg:
+            dof_values: wp.array(dtype=self.space.dof_dtype)
+            space_arg: self.space.SpaceArg
+            topology_arg: self.space.topology.TopologyArg
+            partition_arg: self.space_partition.PartitionArg
+
+        return EvalArg
+
+    def _make_element_eval_arg(self):
+        @cache.dynamic_struct(suffix=self.name)
+        class ElementEvalArg:
+            elt_arg: self.space.topology.ElementArg
+            eval_arg: self.EvalArg
+
+        return ElementEvalArg
+
+    def _make_read_node_value(self):
+        @cache.dynamic_func(suffix=self.name)
+        def read_node_value(args: self.ElementEvalArg, geo_element_index: ElementIndex, node_index_in_elt: int):
+            nidx = self.space.topology.element_node_index(
+                args.elt_arg, args.eval_arg.topology_arg, geo_element_index, node_index_in_elt
+            )
+            pidx = self.space_partition.partition_node_index(args.eval_arg.partition_arg, nidx)
+            if pidx == NULL_NODE_INDEX:
+                return self.space.dtype(0.0)
 
-    @dof_values.setter
-    def dof_values(self, values):
-        if isinstance(values, wp.array):
-            self._dof_values = values
-        else:
-            self._dof_values = wp.array(values, dtype=self.dof_dtype)
+            return self.space.dof_mapper.dof_to_value(args.eval_arg.dof_values[pidx])
 
-    class Trace(DiscreteField):
-        def __init__(self, field):
-            self._field = field
-            super().__init__(field.space.trace(), field.space_partition)
+        return read_node_value
 
-            self.EvalArg = field.EvalArg
-            self.eval_degree = DiscreteField._make_eval_degree(self.EvalArg, self.space)
-            self.eval_arg_value = field.eval_arg_value
+    def _make_eval_inner(self):
+        NODES_PER_ELEMENT = self.space.topology.NODES_PER_ELEMENT
 
-            self.set_node_value = field.set_node_value
+        @cache.dynamic_func(suffix=self.name)
+        def eval_inner(args: self.ElementEvalArg, s: Sample):
+            res = self.space.element_inner_weight(
+                args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, 0
+            ) * self._read_node_value(args, s.element_index, 0)
+            for k in range(1, NODES_PER_ELEMENT):
+                res += self.space.element_inner_weight(
+                    args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k
+                ) * self._read_node_value(args, s.element_index, k)
+            return res
 
-            read_node_value = NodalField._make_read_node_value(self.EvalArg, self.space, self.space_partition)
+        return eval_inner
 
-            self.eval_inner = NodalField._make_eval_inner(self.EvalArg, self.space, read_node_value)
-            self.eval_outer = NodalField._make_eval_outer(self.EvalArg, self.space, read_node_value)
-            self.eval_grad_inner = NodalField._make_eval_grad_inner(self.EvalArg, self.space, read_node_value)
-            self.eval_grad_outer = NodalField._make_eval_grad_outer(self.EvalArg, self.space, read_node_value)
+    def _make_eval_grad_inner(self, world_space: bool):
+        NODES_PER_ELEMENT = self.space.topology.NODES_PER_ELEMENT
 
-    def trace(self) -> Trace:
-        trace_field = NodalField.Trace(self)
-        return trace_field
+        if not self.gradient_valid():
+            return None
 
-    @staticmethod
-    def _make_eval_arg(space: NodalFunctionSpace, space_partition: SpacePartition):
-        from warp.fem import cache
+        @cache.dynamic_func(suffix=self.name)
+        def eval_grad_inner_ref_space(args: self.ElementEvalArg, s: Sample):
+            res = utils.generalized_outer(
+                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
+                ),
+            )
+            for k in range(1, NODES_PER_ELEMENT):
+                res += utils.generalized_outer(
+                    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
+                    ),
+                )
+            return res
 
-        class EvalArg:
-            space_arg: space.SpaceArg
-            partition_arg: space_partition.PartitionArg
-            dof_values: wp.array(dtype=space.dof_dtype)
+        @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)
+            res = eval_grad_inner_ref_space(args, s)
+            return utils.apply_right(res, grad_transform)
 
-        EvalArg.__qualname__ = f"{space.name}_{space_partition.name}_FieldEvalArg"
-        return cache.get_struct(EvalArg)
+        return eval_grad_inner_world_space if world_space else eval_grad_inner_ref_space
 
-    @staticmethod
-    def _make_set_node_value(EvalArg, space: NodalFunctionSpace):
-        def set_node_value(args: EvalArg, partition_node_index: int, value: space.dtype):
-            args.dof_values[partition_node_index] = space.dof_mapper.value_to_dof(value)
+    def _make_eval_div_inner(self):
+        NODES_PER_ELEMENT = self.space.topology.NODES_PER_ELEMENT
 
-        return cache.get_func(set_node_value, space)
+        if not self.divergence_valid():
+            return None
 
-    @staticmethod
-    def _make_read_node_value(EvalArg, space: NodalFunctionSpace, space_partition: SpacePartition):
-        def read_node_value(args: EvalArg, geo_element_index: ElementIndex, node_index_in_elt: int):
-            nidx = space.element_node_index(args.space_arg, geo_element_index, node_index_in_elt)
-            pidx = space_partition.partition_node_index(args.partition_arg, nidx)
-            if pidx == NULL_NODE_INDEX:
-                return space.dtype(0.0)
+        @cache.dynamic_func(suffix=self.name)
+        def eval_div_inner(args: self.ElementEvalArg, s: Sample):
+            grad_transform = self.space.element_inner_reference_gradient_transform(args.elt_arg, s)
+
+            res = utils.generalized_inner(
+                self._read_node_value(args, s.element_index, 0),
+                utils.apply_right(
+                    self.space.element_inner_weight_gradient(
+                        args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, 0
+                    ),
+                    grad_transform,
+                ),
+            )
 
-            return space.dof_mapper.dof_to_value(args.dof_values[pidx])
+            for k in range(1, NODES_PER_ELEMENT):
+                res += utils.generalized_inner(
+                    self._read_node_value(args, s.element_index, k),
+                    utils.apply_right(
+                        self.space.element_inner_weight_gradient(
+                            args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k
+                        ),
+                        grad_transform,
+                    ),
+                )
+            return res
 
-        return cache.get_func(read_node_value, f"{space}_{space_partition}")
+        return eval_div_inner
 
-    @staticmethod
-    def _make_eval_inner(
-        EvalArg,
-        space: NodalFunctionSpace,
-        read_node_value: wp.Function,
-    ):
-        NODES_PER_ELEMENT = space.NODES_PER_ELEMENT
+    def _make_eval_outer(self):
+        NODES_PER_ELEMENT = self.space.topology.NODES_PER_ELEMENT
 
-        def eval_inner(args: EvalArg, s: Sample):
-            res = space.element_inner_weight(args.space_arg, s.element_index, s.element_coords, 0) * read_node_value(
-                args, s.element_index, 0
-            )
+        @cache.dynamic_func(suffix=self.name)
+        def eval_outer(args: self.ElementEvalArg, s: Sample):
+            res = self.space.element_outer_weight(
+                args.elt_arg,
+                args.eval_arg.space_arg,
+                s.element_index,
+                s.element_coords,
+                0,
+            ) * self._read_node_value(args, s.element_index, 0)
             for k in range(1, NODES_PER_ELEMENT):
-                res += space.element_inner_weight(
-                    args.space_arg, s.element_index, s.element_coords, k
-                ) * read_node_value(args, s.element_index, k)
+                res += self.space.element_outer_weight(
+                    args.elt_arg,
+                    args.eval_arg.space_arg,
+                    s.element_index,
+                    s.element_coords,
+                    k,
+                ) * self._read_node_value(args, s.element_index, k)
             return res
 
-        return cache.get_func(eval_inner, read_node_value.key)
+        return eval_outer
 
-    @staticmethod
-    def _make_eval_grad_inner(
-        EvalArg,
-        space: NodalFunctionSpace,
-        read_node_value: wp.Function,
-    ):
-        NODES_PER_ELEMENT = space.NODES_PER_ELEMENT
+    def _make_eval_grad_outer(self, world_space: bool):
+        NODES_PER_ELEMENT = self.space.topology.NODES_PER_ELEMENT
 
-        if wp.types.type_is_matrix(space.dtype):
-            # There is no Warp high-order tensor type to represent matrix gradients
+        if not self.gradient_valid():
             return None
 
-        def eval_grad_inner(args: EvalArg, s: Sample):
+        @cache.dynamic_func(suffix=self.name)
+        def eval_grad_outer_ref_space(args: self.ElementEvalArg, s: Sample):
             res = utils.generalized_outer(
-                space.element_inner_weight_gradient(args.space_arg, s.element_index, s.element_coords, 0),
-                read_node_value(args, s.element_index, 0),
+                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
+                ),
             )
-
             for k in range(1, NODES_PER_ELEMENT):
                 res += utils.generalized_outer(
-                    space.element_inner_weight_gradient(args.space_arg, s.element_index, s.element_coords, k),
-                    read_node_value(args, s.element_index, k),
+                    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
+                    ),
                 )
             return res
 
-        return cache.get_func(eval_grad_inner, read_node_value.key)
+        @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)
+            res = eval_grad_outer_ref_space(args, s)
+            return utils.apply_right(res, grad_transform)
 
-    @staticmethod
-    def _make_eval_outer(
-        EvalArg,
-        space: NodalFunctionSpace,
-        read_node_value: wp.Function,
-    ):
-        NODES_PER_ELEMENT = space.NODES_PER_ELEMENT
+        return eval_grad_outer_world_space if world_space else eval_grad_outer_ref_space
 
-        def eval_outer(args: EvalArg, s: Sample):
-            res = space.element_outer_weight(args.space_arg, s.element_index, s.element_coords, 0) * read_node_value(
-                args, s.element_index, 0
-            )
-            for k in range(1, NODES_PER_ELEMENT):
-                res += space.element_outer_weight(
-                    args.space_arg, s.element_index, s.element_coords, k
-                ) * read_node_value(args, s.element_index, k)
-            return res
-
-        return cache.get_func(eval_outer, read_node_value.key)
-
-    @staticmethod
-    def _make_eval_grad_outer(
-        EvalArg,
-        space: NodalFunctionSpace,
-        read_node_value: wp.Function,
-    ):
-        NODES_PER_ELEMENT = space.NODES_PER_ELEMENT
+    def _make_eval_div_outer(self):
+        NODES_PER_ELEMENT = self.space.topology.NODES_PER_ELEMENT
 
-        if wp.types.type_is_matrix(space.dtype):
-            # There is no Warp high-order tensor type to represent matrix gradients
+        if not self.divergence_valid():
             return None
 
-        def eval_grad_outer(args: EvalArg, s: Sample):
-            res = utils.generalized_outer(
-                space.element_outer_weight_gradient(args.space_arg, s.element_index, s.element_coords, 0),
-                read_node_value(args, s.element_index, 0),
+        @cache.dynamic_func(suffix=self.name)
+        def eval_div_outer(args: self.ElementEvalArg, s: Sample):
+            grad_transform = self.space.element_outer_reference_gradient_transform(args.elt_arg, s)
+
+            res = utils.generalized_inner(
+                self._read_node_value(args, s.element_index, 0),
+                utils.apply_right(
+                    self.space.element_outer_weight_gradient(
+                        args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, 0
+                    ),
+                    grad_transform,
+                ),
             )
             for k in range(1, NODES_PER_ELEMENT):
-                res += utils.generalized_outer(
-                    space.element_outer_weight_gradient(args.space_arg, s.element_index, s.element_coords, k),
-                    read_node_value(args, s.element_index, k),
+                res += utils.generalized_inner(
+                    self._read_node_value(args, s.element_index, k),
+                    utils.apply_right(
+                        self.space.element_outer_weight_gradient(
+                            args.elt_arg, args.eval_arg.space_arg, s.element_index, s.element_coords, k
+                        ),
+                        grad_transform,
+                    ),
                 )
             return res
 
-        return cache.get_func(eval_grad_outer, read_node_value.key)
+        return eval_div_outer
+
+    def _make_set_node_value(self):
+        @cache.dynamic_func(suffix=self.name)
+        def set_node_value(args: self.EvalArg, partition_node_index: int, value: self.space.dtype):
+            args.dof_values[partition_node_index] = self.space.dof_mapper.value_to_dof(value)
+
+        return set_node_value
+
+
+class NodalField(NodalFieldBase):
+    """A field holding values for all degrees of freedom at each node of the underlying function space partition
+
+    See also: warp.fem.space.CollocatedFunctionSpace.make_field
+    """
+
+    def __init__(self, space: CollocatedFunctionSpace, space_partition: SpacePartition):
+        if space.topology != space_partition.space_topology:
+            raise ValueError("Incompatible space and space partition topologies")
+
+        super().__init__(space, space_partition)
+
+        self._dof_values = wp.zeros(n=self.space_partition.node_count(), dtype=self.dof_dtype)
+
+    def eval_arg_value(self, device):
+        arg = self.EvalArg()
+        arg.dof_values = self._dof_values.to(device)
+        arg.space_arg = self.space.space_arg_value(device)
+        arg.partition_arg = self.space_partition.partition_arg_value(device)
+        arg.topology_arg = self.space.topology.topo_arg_value(device)
+
+        return arg
+
+    @property
+    def dof_values(self) -> wp.array:
+        """Returns a warp array containing the values at all degrees of freedom of the underlying space partition"""
+        return self._dof_values
+
+    @dof_values.setter
+    def dof_values(self, values):
+        """Sets the degrees-of-freedom values
+
+        Args:
+            values: Array that is convertible to a warp array of length ``self.space_partition.node_count()`` and data type ``self.space.dof_dtype``
+        """
+
+        if isinstance(values, wp.array):
+            self._dof_values = values
+        else:
+            self._dof_values = wp.array(values, dtype=self.dof_dtype)
+
+    class Trace(NodalFieldBase):
+        def __init__(self, field):
+            self._field = field
+            super().__init__(field.space.trace(), field.space_partition)
+
+        def eval_arg_value(self, device):
+            arg = self.EvalArg()
+            arg.dof_values = self._field.dof_values.to(device)
+            arg.space_arg = self.space.space_arg_value(device)
+            arg.partition_arg = self.space_partition.partition_arg_value(device)
+            arg.topology_arg = self.space.topology.topo_arg_value(device)
+
+            return arg
+
+    def trace(self) -> Trace:
+        trace_field = NodalField.Trace(self)
+        return trace_field

warp/fem/field/restriction.py

@@ -1,19 +1,21 @@
 from warp.fem.space import SpaceRestriction
-from .discrete_field import DiscreteField
+from .field import DiscreteField
 
 
 class FieldRestriction:
-    """Restriction of a space to a given GeometryDomain"""
+    """Restriction of a discrete field to a given GeometryDomain"""
 
     def __init__(self, space_restriction: SpaceRestriction, field: DiscreteField):
-
-        if field.space.DIMENSION - 1 == space_restriction.space.DIMENSION:
+        if field.space.dimension - 1 == space_restriction.space_topology.dimension:
             field = field.trace()
 
-        if field.space.DIMENSION != space_restriction.space.DIMENSION:
+        if field.space.dimension != space_restriction.space_topology.dimension:
             raise ValueError("Incompatible space and field dimensions")
 
+        if field.space.topology != space_restriction.space_topology:
+            raise ValueError("Incompatible field and space restriction topologies")
+
         self.space_restriction = space_restriction
-        self.space = self.space_restriction.space
         self.domain = self.space_restriction.domain
         self.field = field
+        self.space = self.field.space