Test FIAT empty permutations

.github/workflows/core.yml

@@ -205,6 +205,7 @@ jobs:
             --extra-index-url https://download.pytorch.org/whl/cpu \
             "$(echo ./firedrake-repo/dist/firedrake-*.tar.gz)[ci,docs]"
 
+          pip install -I "firedrake-fiat @ git+https://github.com/firedrakeproject/fiat.git@pbrubeck/fix/permutations"
           firedrake-clean
           pip list
 

tests/firedrake/regression/test_facet_orientation.py

@@ -3,36 +3,39 @@
 """
 
 from os.path import abspath, dirname, join
+from functools import partial
 import pytest
 import numpy as np
 from firedrake import *
 
 cwd = abspath(dirname(__file__))
 
+meshes = [
+    partial(UnitSquareMesh, 5, 5, quadrilateral=False),
+    partial(UnitSquareMesh, 5, 5, quadrilateral=True),
+    partial(UnitIcosahedralSphereMesh, 2),
+    partial(UnitCubedSphereMesh, 3),
+    partial(Mesh, join(cwd, "..", "meshes", "unitsquare_unstructured_quadrilaterals.msh")),
+]
 
-@pytest.mark.parametrize('mesh_thunk',
-                         [lambda: UnitSquareMesh(5, 5, quadrilateral=False),
-                          lambda: UnitSquareMesh(5, 5, quadrilateral=True),
-                          lambda: UnitIcosahedralSphereMesh(2),
-                          lambda: UnitCubedSphereMesh(3),
-                          lambda: Mesh(join(cwd, "..", "meshes",
-                                            "unitsquare_unstructured_quadrilaterals.msh"))])
-def test_consistent_facet_orientation(mesh_thunk):
-    mesh = mesh_thunk()
+
+def run_consistent_facet_orientation(mesh_thunk, variant="equispaced", **kwargs):
+    mesh = mesh_thunk(**kwargs)
     x = SpatialCoordinate(mesh)
     degree = 3
-    fe_cg = FiniteElement("CG", mesh.ufl_cell(), degree, variant="equispaced")
-    V = FunctionSpace(mesh, fe_cg)  # continuous space
-    fe_dg = FiniteElement("DG", mesh.ufl_cell(), degree, variant="equispaced")
-    W = FunctionSpace(mesh, fe_dg)  # discontinuous space
+    V = FunctionSpace(mesh, "CG", degree, variant=variant)  # continuous space
+    if variant == "equispaced":
+        W = FunctionSpace(mesh, "DG", degree, variant=variant)  # discontinuous space
+    else:
+        W = FunctionSpace(mesh, BrokenElement(V.ufl_element()))  # discontinuous space
 
     Q = FunctionSpace(mesh, "DG", 0)  # result space
 
     expression = x[0]*(x[0] + sqrt(2.0)) + x[1]
     f = Function(V).interpolate(expression)
     g = Function(W).interpolate(expression)
 
-    q = Function(Q).interpolate(Constant(0.0))
+    q = Function(Q)
 
     domain = "{[i]: 0 <= i < C.dofs}"
     instructions = """
@@ -43,3 +46,16 @@ def test_consistent_facet_orientation(mesh_thunk):
     par_loop((domain, instructions), dx, {'C': (f, READ), 'D': (g, READ), 'R': (q, RW)})
 
     assert np.allclose(q.dat.data, 0.0)
+
+
+@pytest.mark.parametrize('mesh_thunk', meshes)
+def test_consistent_facet_orientation(mesh_thunk):
+    run_consistent_facet_orientation(mesh_thunk)
+
+
+@pytest.mark.parallel(nprocs=2)
+@pytest.mark.parametrize('variant', ("equispaced", "integral"))
+@pytest.mark.parametrize('mesh_thunk', meshes)
+def test_consistent_facet_orientation_parallel(mesh_thunk, variant):
+    dp = {"overlap_type": (DistributedMeshOverlapType.NONE, 0)}
+    run_consistent_facet_orientation(mesh_thunk, variant=variant, distribution_parameters=dp)