Fix tests

Author: pbrubeck

firedrake/preconditioners/pmg.py

@@ -8,7 +8,7 @@
 from firedrake.nullspace import VectorSpaceBasis, MixedVectorSpaceBasis
 from firedrake.solving_utils import _SNESContext
 from firedrake.tsfc_interface import extract_numbered_coefficients
-from firedrake.utils import ScalarType_c, IntType_c, cached_property
+from firedrake.utils import IntType_c, cached_property
 from finat.element_factory import create_element
 from tsfc import compile_expression_dual_evaluation
 from pyop2 import op2
@@ -1236,13 +1236,18 @@ def _weight(self):
 
     @cached_property
     def _kernels(self):
+        from firedrake.interpolation import interpolate, Interpolator
         try:
-            prolong = partial(firedrake.assemble, firedrake.interpolate(self.uc, self.Vf), tensor=self.uf)
-            prolong()
-            self.rf = firedrake.Function(self.Vf.dual(), val=self.uf.dat)
-            self.rc = firedrake.Function(self.Vc.dual(), val=self.uc.dat)
-            restrict = partial(firedrake.assemble, firedrake.interpolate(firedrake.TestFunction(self.Vc), self.rf), tensor=self.rc)
-        except NotImplementedError:
+            assert self.Vf.ufl_element().mapping() == self.Vc.ufl_element().mapping()
+            P = Interpolator(interpolate(self.uc, self.Vf), self.Vf)
+            prolong = partial(P.assemble, tensor=self.uf)
+
+            rf = firedrake.Function(self.Vf.dual(), val=self.uf.dat)
+            rc = firedrake.Function(self.Vc.dual(), val=self.uc.dat)
+            vc = firedrake.TestFunction(self.Vc)
+            R = Interpolator(interpolate(vc, rf), self.Vf)
+            restrict = partial(R.assemble, tensor=rc)
+        except (AttributeError, AssertionError, NotImplementedError):
             # We generate custom prolongation and restriction kernels because
             # dual evaluation of EnrichedElement is not yet implemented in FInAT
             uf_map = get_permuted_map(self.Vf)
@@ -1439,49 +1444,6 @@ def make_blas_kernels(self, Vf, Vc):
                                      ldargs=BLASLAPACK_LIB.split(), requires_zeroed_output_arguments=True)
         return cache.setdefault(key, (prolong_kernel, restrict_kernel, coefficients))
 
-    def make_kernels(self, Vf, Vc):
-        """
-        Interpolation and restriction kernels between arbitrary elements.
-
-        This is temporary while we wait for dual evaluation in FInAT.
-        """
-        cache = self._cache_kernels
-        key = (Vf.ufl_element(), Vc.ufl_element())
-        try:
-            return cache[key]
-        except KeyError:
-            pass
-        prolong_kernel, _ = prolongation_transfer_kernel_action(Vf, self.uc)
-        matrix_kernel, coefficients = prolongation_transfer_kernel_action(Vf, firedrake.TrialFunction(Vc))
-
-        # The way we transpose the prolongation kernel is suboptimal.
-        # A local matrix is generated each time the kernel is executed.
-        element_kernel = cache_generate_code(matrix_kernel, Vf._comm)
-        element_kernel = element_kernel.replace("void expression_kernel", "static void expression_kernel")
-        coef_args = "".join([", c%d" % i for i in range(len(coefficients))])
-        coef_decl = "".join([", const %s *restrict c%d" % (ScalarType_c, i) for i in range(len(coefficients))])
-        dimc = Vc.finat_element.space_dimension() * Vc.block_size
-        dimf = Vf.finat_element.space_dimension() * Vf.block_size
-        restrict_code = f"""
-        {element_kernel}
-
-        void restriction({ScalarType_c} *restrict Rc, const {ScalarType_c} *restrict Rf, const {ScalarType_c} *restrict w{coef_decl})
-        {{
-            {ScalarType_c} Afc[{dimf}*{dimc}] = {{0}};
-            expression_kernel(Afc{coef_args});
-            for ({IntType_c} i = 0; i < {dimf}; i++)
-               for ({IntType_c} j = 0; j < {dimc}; j++)
-                   Rc[j] += Afc[i*{dimc} + j] * Rf[i] * w[i];
-        }}
-        """
-        restrict_kernel = op2.Kernel(
-            restrict_code,
-            "restriction",
-            requires_zeroed_output_arguments=True,
-            events=matrix_kernel.events,
-        )
-        return cache.setdefault(key, (prolong_kernel, restrict_kernel, coefficients))
-
     def multTranspose(self, mat, rf, rc):
         """
         Implement restriction: restrict residual on fine grid rf to coarse grid rc.

tests/firedrake/multigrid/test_p_multigrid.py

@@ -208,7 +208,7 @@ def test_p_multigrid_scalar(mesh, mat_type, restrict):
     solver = NonlinearVariationalSolver(problem, solver_parameters=sp)
     solver.solve()
 
-    assert solver.snes.ksp.its <= 5
+    assert solver.snes.ksp.its <= 6
     ppc = solver.snes.ksp.pc.getPythonContext().ppc
     assert ppc.getMGLevels() == 3
     assert ppc.getMGCoarseSolve().pc.getMGLevels() == 2
@@ -345,7 +345,7 @@ def test_p_multigrid_mixed(mat_type):
     sp = {"snes_monitor": None,
           "snes_type": "ksponly",
           "ksp_type": "cg",
-          "ksp_rtol": 1E-12,
+          "ksp_rtol": 1E-11,
           "ksp_monitor_true_residual": None,
           "pc_type": "python",
           "pc_python_type": "firedrake.PMGPC",
@@ -369,9 +369,9 @@ def test_p_multigrid_mixed(mat_type):
     assert ppc.getMGLevels() == 3
 
     # test that nullspace component is zero
-    assert abs(assemble(z[1]*dx)) < 1E-12
+    assert abs(assemble(z[1]*dx)) < 1E-10
     # test that we converge to the exact solution
-    assert norm(z-z_exact, "H1") < 1E-12
+    assert norm(z-z_exact, "H1") < 1E-10
 
     # test that we have coarsened the nullspace correctly
     ctx_levels = 0