More extensive tests

Author: pbrubeck

firedrake/interpolation.py

@@ -1013,9 +1013,6 @@ def callable():
         # Make sure we have an expression of the right length i.e. a value for
         # each component in the value shape of each function space
         loops = []
-        if numpy.prod(expr.ufl_shape, dtype=int) != V.value_size:
-            raise RuntimeError('Expression of length %d required, got length %d'
-                               % (V.value_size, numpy.prod(expr.ufl_shape, dtype=int)))
 
         if len(V) == 1:
             loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))

tests/firedrake/meshes/test_meshes_volume.py

@@ -20,12 +20,3 @@ def test_meshes_volume_solidtorusmesh():
     vol = assemble(Constant(1., domain=mesh) * dx)
     exact = (pi * r * r) * (2 * pi * R)
     assert abs(vol - exact) / exact < .0005
-
-
-def test_meshes_cell_sizes():
-    msh = UnitDiskMesh(4)
-    msh.cell_sizes
-
-    V = msh.coordinates.function_space().reconstruct(degree=2)
-    msh = Mesh(Function(V).interpolate(msh.coordinates))
-    msh.cell_sizes

tests/firedrake/regression/test_interpolate_zany.py

@@ -75,13 +75,59 @@ def test_interpolate_zany_into_cg(V, mesh, which, expect, tolerance):
 
 @pytest.fixture
 def vom(mesh):
-    return VertexOnlyMesh(mesh, [(0.5, 0.5)])
+    return VertexOnlyMesh(mesh, [(0.5, 0.5), (0.31, 0.72)])
 
 
-def test_interpolate_zany_into_vom(V, vom):
+def test_interpolate_zany_into_vom(V, mesh, which, vom):
+    degree = V.ufl_element().degree()
+    x, y = SpatialCoordinate(mesh)
+    expr = (x + y)**degree
+
+    f = Function(V)
+    f.project(expr, solver_parameters={"ksp_type": "preonly",
+                                       "pc_type": "lu"})
+    fexpr = f
+    vexpr = TestFunction(V)
     P0 = FunctionSpace(vom, "DG", 0)
-    vvom = TestFunction(P0)
-    Fvom = inner(1, vvom) * dx
+    if which == "coefficient":
+        P0 = FunctionSpace(vom, "DG", 0)
+    elif which == "grad":
+        fexpr = grad(fexpr)
+        vexpr = grad(vexpr)
+        expr = ufl.algorithms.expand_derivatives(grad(expr))
+        P0 = VectorFunctionSpace(vom, "DG", 0)
+
+    expected = Function(P0)
+    point = Constant([0]*mesh.geometric_dimension())
+    expr_at_pt = ufl.replace(expr, {SpatialCoordinate(mesh): point})
+    for i, pt in enumerate(vom.coordinates.dat.data_ro):
+        point.assign(pt)
+        expected.dat.data[i] = numpy.asarray(expr_at_pt, dtype=float)
+
+    # Interpolate a Function into P0(vom)
+    f_at_vom = assemble(Interpolate(fexpr, P0))
+    assert numpy.allclose(f_at_vom.dat.data_ro, expected.dat.data_ro)
+
+    # Construct a Cofunction on P0(vom)*
+    Fvom = Cofunction(P0.dual()).assign(1)
+    expected = assemble(action(Fvom, expected))
+
+    # Interpolate a Function into Fvom
+    f_at_vom = assemble(Interpolate(fexpr, Fvom))
+    assert numpy.allclose(f_at_vom, expected)
+
+    # Interpolate a TestFunction into Fvom
+    expr_vom = assemble(Interpolate(vexpr, Fvom))
+    f_at_vom = assemble(action(expr_vom, f))
+    assert numpy.allclose(f_at_vom, expected)
+
+
+def test_high_order_mesh_cell_sizes():
+    msh1 = UnitSquareMesh(2, 2)
+    h1 = msh1.cell_sizes
+
+    P2 = msh1.coordinates.function_space().reconstruct(degree=2)
+    msh2 = Mesh(Function(P2).interpolate(msh1.coordinates))
+    h2 = msh2.cell_sizes
 
-    v = TestFunction(V)
-    assemble(Interpolate(v, Fvom))
+    assert numpy.allclose(h1.dat.data, h2.dat.data)