cleanup

Author: pbrubeck

firedrake/bcs.py

@@ -741,8 +741,7 @@ def restricted_function_space(V, ids):
         return V
 
     assert len(ids) == len(V)
-    spaces = [V_ if len(boundary_set) == 0 else
-              firedrake.RestrictedFunctionSpace(V_, boundary_set=boundary_set, name=V_.name)
+    spaces = [V_.reconstruct(boundary_set=boundary_set, name=V_.name)
               for V_, boundary_set in zip(V, ids)]
 
     if len(spaces) == 1:

firedrake/functionspaceimpl.py

@@ -357,7 +357,7 @@ def collapse(self):
         return type(self).create(self.topological.collapse(), self.mesh())
 
     @classmethod
-    def make_function_space(cls, mesh, element, name=None, boundary_set=None):
+    def make_function_space(cls, mesh, element, name=None):
         r"""Factory method for :class:`.WithGeometryBase`."""
         mesh.init()
         topology = mesh.topology
@@ -376,25 +376,25 @@ def make_function_space(cls, mesh, element, name=None, boundary_set=None):
         if mesh is not topology:
             # Create a concrete WithGeometry or FiredrakeDualSpace on this mesh
             new = cls.create(new, mesh)
-
-        if boundary_set:
-            new = RestrictedFunctionSpace(new, boundary_set=boundary_set)
-            if mesh is not topology:
-                new = cls.create(new, mesh)
         return new
 
-    def reconstruct(self, mesh=None, element=None, name=None, **kwargs):
+    def reconstruct(self, mesh=None, element=None, boundary_set=None, name=None, **kwargs):
         r"""Reconstruct this :class:`.WithGeometryBase` .
 
         :kwarg mesh: the new :func:`~.Mesh` (defaults to same mesh)
         :kwarg element: the new :class:`finat.ufl.FiniteElement` (defaults to same element)
+        :kwarg boundary_set: the set boundary subdomain labels defining a new
+                             :func:`~.RestrictedFunctionSpace` (defaults to same boundary_set)
         :kwarg name: the new name (defaults to None)
         :returns: the new function space of the same class as ``self``.
 
         Any extra kwargs are used to reconstruct the finite element.
         For details see :meth:`finat.ufl.finiteelement.FiniteElement.reconstruct`.
         """
         V_parent = self
+        if boundary_set is None:
+            boundary_set = V_parent.boundary_set
+
         # Deal with ProxyFunctionSpace
         indices = []
         while True:
@@ -409,17 +409,19 @@ def reconstruct(self, mesh=None, element=None, name=None, **kwargs):
 
         if mesh is None:
             mesh = V_parent.mesh()
-
         if element is None:
             element = V_parent.ufl_element()
+
         cell = mesh.topology.ufl_cell()
         if len(kwargs) > 0 or element.cell != cell:
             element = element.reconstruct(cell=cell, **kwargs)
 
-        V = type(self).make_function_space(mesh, element, name=name,
-                                           boundary_set=V_parent.boundary_set)
+        V = type(self).make_function_space(mesh, element, name=name)
         for i in reversed(indices):
             V = V.sub(i)
+
+        if len(boundary_set) > 0:
+            V = RestrictedFunctionSpace(V, boundary_set=boundary_set)
         return V
 
 
@@ -884,6 +886,15 @@ class RestrictedFunctionSpace(FunctionSpace):
     If using this class to solve or similar, a list of DirichletBCs will still
     need to be specified on this space and passed into the function.
     """
+    def __new__(cls, function_space, boundary_set=frozenset(), name=None):
+        mesh = function_space.mesh()
+        if mesh is not mesh.topology:
+            # Restrict WithGeometry and return a WithGeometry
+            V = RestrictedFunctionSpace(function_space.topological,
+                                        boundary_set=boundary_set, name=name)
+            return type(function_space).create(V, mesh)
+        return FunctionSpace.__new__(cls)
+
     def __init__(self, function_space, boundary_set=frozenset(), name=None):
         label = ""
         boundary_set_ = []
@@ -1207,7 +1218,7 @@ class ProxyFunctionSpace(FunctionSpace):
     """
     def __new__(cls, mesh, element, name=None):
         topology = mesh.topology
-        self = super(ProxyFunctionSpace, cls).__new__(cls)
+        self = FunctionSpace.__new__(cls)
         if mesh is not topology:
             return WithGeometry.create(self, mesh)
         else:
@@ -1262,7 +1273,7 @@ class ProxyRestrictedFunctionSpace(RestrictedFunctionSpace):
     """
     def __new__(cls, function_space, boundary_set=frozenset(), name=None):
         topology = function_space._mesh.topology
-        self = super(ProxyRestrictedFunctionSpace, cls).__new__(cls)
+        self = FunctionSpace.__new__(cls)
         if function_space._mesh is not topology:
             return WithGeometry.create(self, function_space._mesh)
         else:

firedrake/mg/utils.py

@@ -140,7 +140,7 @@ def physical_node_locations(V):
     try:
         return cache[key]
     except KeyError:
-        Vc = V.reconstruct(element=finat.ufl.VectorElement(element, dim=mesh.geometric_dimension()))
+        Vc = V.collapse().reconstruct(element=finat.ufl.VectorElement(element, dim=mesh.geometric_dimension()))
 
         # FIXME: This is unsafe for DG coordinates and CG target spaces.
         locations = firedrake.assemble(firedrake.Interpolate(firedrake.SpatialCoordinate(mesh), Vc))