def test_mesh_function_assign_2D_cells():
mesh = UnitSquareMesh(MPI.comm_world, 3, 3)
ncells = mesh.num_cells()
f = MeshFunction("int", mesh, mesh.topology.dim, 0)
for cell in Cells(mesh):
f[cell] = ncells - cell.index()
g = MeshValueCollection("int", mesh, 2)
g.assign(f)
assert ncells == f.size()
assert ncells == g.size()
f2 = MeshFunction("int", mesh, g, 0)
for cell in Cells(mesh):
value = ncells - cell.index()
assert value == g.get_value(cell.index(), 0)
assert f2[cell] == g.get_value(cell.index(), 0)
h = MeshValueCollection("int", mesh, 2)
global_indices = mesh.topology.global_indices(2)
ncells_global = mesh.num_entities_global(2)
for cell in Cells(mesh):
if global_indices[cell.index()] in [5, 8, 10]:
continue
value = ncells_global - global_indices[cell.index()]
h.set_value(cell.index(), int(value))
f3 = MeshFunction("int", mesh, h, 0)
values = f3.array()
values[values > ncells_global] = 0.
assert MPI.sum(mesh.mpi_comm(), values.sum() * 1.0) == 140.
def test_save_3D_cell_function(tempdir, encoding, data_type):
if invalid_config(encoding):
pytest.skip("XDMF unsupported in current configuration")
dtype_str, dtype = data_type
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4)
mf = MeshFunction(dtype_str, mesh, mesh.topology.dim, 0)
mf.rename("cells")
for cell in Cells(mesh):
mf[cell] = dtype(cell.index())
filename = os.path.join(tempdir, "mf_3D_%s.xdmf" % dtype_str)
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(mf)
# mf_in = MeshFunction(dtype_str, mesh, mesh.topology.dim, 0)
with XDMFFile(mesh.mpi_comm(), filename) as xdmf:
read_function = getattr(xdmf, "read_mf_" + dtype_str)
mf_in = read_function(mesh, "cells")
diff = 0
for cell in Cells(mesh):
diff += (mf_in[cell] - mf[cell])
assert diff == 0
def test_append_and_load_mesh_functions(tempdir, encoding, data_type):
if invalid_config(encoding):
pytest.skip("XDMF unsupported in current configuration")
dtype_str, dtype = data_type
meshes = [
UnitSquareMesh(MPI.comm_world, 12, 12),
UnitCubeMesh(MPI.comm_world, 2, 2, 2)
]
for mesh in meshes:
dim = mesh.topology.dim
vf = MeshFunction(dtype_str, mesh, 0, 0)
vf.rename("vertices")
ff = MeshFunction(dtype_str, mesh, mesh.topology.dim - 1, 0)
ff.rename("facets")
cf = MeshFunction(dtype_str, mesh, mesh.topology.dim, 0)
cf.rename("cells")
if (MPI.size(mesh.mpi_comm()) == 1):
for vertex in Vertices(mesh):
vf[vertex] = dtype(vertex.index())
for facet in Facets(mesh):
ff[facet] = dtype(facet.index())
for cell in Cells(mesh):
cf[cell] = dtype(cell.index())
else:
for vertex in Vertices(mesh):
vf[vertex] = dtype(vertex.global_index())
for facet in Facets(mesh):
ff[facet] = dtype(facet.global_index())
for cell in Cells(mesh):
cf[cell] = dtype(cell.global_index())
filename = os.path.join(tempdir, "appended_mf_%dD.xdmf" % dim)
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as xdmf:
xdmf.write(mesh)
xdmf.write(vf)
xdmf.write(ff)
xdmf.write(cf)
with XDMFFile(mesh.mpi_comm(), filename) as xdmf:
read_function = getattr(xdmf, "read_mf_" + dtype_str)
vf_in = read_function(mesh, "vertices")
ff_in = read_function(mesh, "facets")
cf_in = read_function(mesh, "cells")
diff = 0
for vertex in Vertices(mesh):
diff += (vf_in[vertex] - vf[vertex])
for facet in Facets(mesh):
diff += (ff_in[facet] - ff[facet])
for cell in Cells(mesh):
diff += (cf_in[cell] - cf[cell])
assert diff == 0
def test_tabulate_dofs(mesh_factory):
func, args = mesh_factory
mesh = func(*args)
W0 = FiniteElement("Lagrange", mesh.ufl_cell(), 1)
W1 = VectorElement("Lagrange", mesh.ufl_cell(), 1)
W = FunctionSpace(mesh, W0 * W1)
L0 = W.sub(0)
L1 = W.sub(1)
L01 = L1.sub(0)
L11 = L1.sub(1)
for i, cell in enumerate(Cells(mesh)):
dofs0 = L0.dofmap().cell_dofs(cell.index())
dofs1 = L01.dofmap().cell_dofs(cell.index())
dofs2 = L11.dofmap().cell_dofs(cell.index())
dofs3 = L1.dofmap().cell_dofs(cell.index())
assert np.array_equal(dofs0, L0.dofmap().cell_dofs(i))
assert np.array_equal(dofs1, L01.dofmap().cell_dofs(i))
assert np.array_equal(dofs2, L11.dofmap().cell_dofs(i))
assert np.array_equal(dofs3, L1.dofmap().cell_dofs(i))
assert len(np.intersect1d(dofs0, dofs1)) == 0
assert len(np.intersect1d(dofs0, dofs2)) == 0
assert len(np.intersect1d(dofs1, dofs2)) == 0
assert np.array_equal(np.append(dofs1, dofs2), dofs3)
def test_p4_parallel_3d():
mesh = UnitCubeMesh(MPI.comm_world, 3, 5, 8)
Q = FunctionSpace(mesh, ("CG", 5))
F = Function(Q)
@function.expression.numba_eval
def x0(values, x, cell_idx):
values[:, 0] = x[:, 0]
F.interpolate(Expression(x0))
# Generate random points in this mesh partition (one per cell)
x = numpy.zeros(4)
tree = cpp.geometry.BoundingBoxTree(mesh, mesh.geometry.dim)
for c in Cells(mesh):
x[0] = random()
x[1] = random() * (1 - x[0])
x[2] = random() * (1 - x[0] - x[1])
x[3] = 1 - x[0] - x[1] - x[2]
p = Point(0.0, 0.0, 0.0)
for i, v in enumerate(VertexRange(c)):
p += v.point() * x[i]
p = p.array()
assert numpy.isclose(F(p, tree)[0], p[0])
def test_cell_iterators():
"Iterate over cells"
mesh = UnitCubeMesh(MPI.comm_world, 5, 5, 5)
for i in range(4):
mesh.init(3, i)
# Test connectivity
cons = [(i, mesh.topology.connectivity(3, i)) for i in range(4)]
# Test writability
for i, con in cons:
def assign(con, i):
con(i)[0] = 1
with pytest.raises(Exception):
assign(con, i)
n = 0
for i, c in enumerate(Cells(mesh)):
n += 1
for j, con in cons:
assert numpy.all(con(i) == c.entities(j))
assert n == mesh.num_cells()
def test_radius_ratio_tetrahedron():
# Create mesh and compute ratios
mesh = UnitCubeMesh(MPI.comm_world, 14, 14, 14)
ratios = MeshQuality.radius_ratios(mesh)
for c in Cells(mesh):
assert round(ratios[c] - 0.717438935214, 7) == 0
def test_mixed_parallel():
mesh = UnitSquareMesh(MPI.comm_world, 5, 8)
V = VectorElement("Lagrange", triangle, 4)
Q = FiniteElement("Lagrange", triangle, 5)
W = FunctionSpace(mesh, Q * V)
F = Function(W)
@function.expression.numba_eval
def expr_eval(values, x, cell_idx):
values[:, 0] = x[:, 0]
values[:, 1] = x[:, 1]
values[:, 2] = numpy.sin(x[:, 0] + x[:, 1])
F.interpolate(Expression(expr_eval, shape=(3, )))
# Generate random points in this mesh partition (one per cell)
x = numpy.zeros(3)
for c in Cells(mesh):
x[0] = random()
x[1] = random() * (1 - x[0])
x[2] = (1 - x[0] - x[1])
p = Point(0.0, 0.0)
for i, v in enumerate(VertexRange(c)):
p += v.point() * x[i]
p = p.array()[:2]
val = F(p)
assert numpy.allclose(val[0], p[0])
assert numpy.isclose(val[1], p[1])
assert numpy.isclose(val[2], numpy.sin(p[0] + p[1]))
def test_mesh_topology_against_fiat(mesh_factory, ghost_mode):
"""Test that mesh cells have topology matching to FIAT reference
cell they were created from.
"""
func, args = mesh_factory
xfail_ghosted_quads_hexes(func, ghost_mode)
mesh = func(*args)
# Create FIAT cell
cell_name = CellType.type2string(mesh.type().cell_type())
fiat_cell = FIAT.ufc_cell(cell_name)
# Initialize all mesh entities and connectivities
mesh.init()
for cell in Cells(mesh):
# Get mesh-global (MPI-local) indices of cell vertices
vertex_global_indices = cell.entities(0)
# Loop over all dimensions of reference cell topology
for d, d_topology in fiat_cell.get_topology().items():
# Get entities of dimension d on the cell
entities = cell.entities(d)
if len(entities) == 0: # Fixup for highest dimension
entities = (cell.index(), )
# Loop over all entities of fixed dimension d
for entity_index, entity_topology in d_topology.items():
# Check that entity vertices map to cell vertices in right order
entity = MeshEntity(mesh, d, entities[entity_index])
entity_vertices = entity.entities(0)
assert all(vertex_global_indices[numpy.array(entity_topology)]
== entity_vertices)
def test_radius_ratio_triangle():
# Create mesh and compute rations
mesh = UnitSquareMesh(MPI.comm_world, 12, 12)
ratios = MeshQuality.radius_ratios(mesh)
for c in Cells(mesh):
assert round(ratios[c] - 0.828427124746, 7) == 0
def test_save_mesh_value_collection(tempdir, encoding, data_type):
dtype_str, dtype = data_type
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4)
tdim = mesh.topology.dim
meshfn = MeshFunction(dtype_str, mesh, mesh.topology.dim, False)
meshfn.rename("volume_marker")
for c in Cells(mesh):
if c.midpoint()[1] > 0.1:
meshfn[c] = dtype(1)
if c.midpoint()[1] > 0.9:
meshfn[c] = dtype(2)
for mvc_dim in range(0, tdim + 1):
mvc = MeshValueCollection(dtype_str, mesh, mvc_dim)
tag = "dim_%d_marker" % mvc_dim
mvc.rename(tag)
mesh.init(mvc_dim, tdim)
for e in MeshEntities(mesh, mvc_dim):
if (e.midpoint()[0] > 0.5):
mvc.set_value(e.index(), dtype(1))
filename = os.path.join(tempdir, "mvc_%d.xdmf" % mvc_dim)
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as xdmf:
xdmf.write(meshfn)
xdmf.write(mvc)
with XDMFFile(mesh.mpi_comm(), filename) as xdmf:
read_function = getattr(xdmf, "read_mvc_" + dtype_str)
mvc = read_function(mesh, tag)
def test_save_1d_mesh(tempdir, encoding):
filename = os.path.join(tempdir, "mf_1D.xdmf")
mesh = UnitIntervalMesh(MPI.comm_world, 32)
mf = MeshFunction("size_t", mesh, mesh.topology.dim, 0)
for cell in Cells(mesh):
mf[cell] = cell.index()
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(mf)
def test_mixed_iterators():
"Iterate over vertices of cells"
mesh = UnitCubeMesh(MPI.comm_world, 5, 5, 5)
n = 0
for c in Cells(mesh):
for v in VertexRange(c):
n += 1
assert n == 4 * mesh.num_cells()
def test_save_2D_cell_function(tempdir, encoding, data_type):
dtype_str, dtype = data_type
filename = os.path.join(tempdir, "mf_2D_%s.xdmf" % dtype_str)
mesh = UnitSquareMesh(MPI.comm_world, 32, 32)
mf = MeshFunction(dtype_str, mesh, mesh.topology.dim, 0)
mf.rename("cells")
for cell in Cells(mesh):
mf[cell] = dtype(cell.index())
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(mf)
with XDMFFile(mesh.mpi_comm(), filename) as xdmf:
read_function = getattr(xdmf, "read_mf_" + dtype_str)
mf_in = read_function(mesh, "cells")
diff = 0
for cell in Cells(mesh):
diff += (mf_in[cell] - mf[cell])
assert diff == 0
def test_save_1d_mesh(tempdir, encoding):
if invalid_config(encoding):
pytest.skip("XDMF unsupported in current configuration")
filename = os.path.join(tempdir, "mf_1D.xdmf")
mesh = UnitIntervalMesh(MPI.comm_world, 32)
mf = MeshFunction("size_t", mesh, mesh.topology.dim, 0)
for cell in Cells(mesh):
mf[cell] = cell.index()
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(mf)
def test_assign_2D_facets():
mesh = UnitSquareMesh(MPI.comm_world, 3, 3)
mesh.init(2, 1)
ncells = mesh.num_cells()
f = MeshValueCollection("int", mesh, 1)
all_new = True
for cell in Cells(mesh):
value = ncells - cell.index()
for i, facet in enumerate(FacetRange(cell)):
all_new = all_new and f.set_value(cell.index(), i, value + i)
g = MeshValueCollection("int", mesh, 1)
g.assign(f)
assert ncells * 3 == f.size()
assert ncells * 3 == g.size()
assert all_new
for cell in Cells(mesh):
value = ncells - cell.index()
for i, facet in enumerate(FacetRange(cell)):
assert value + i == g.get_value(cell.index(), i)
def test_assign_2D_vertices():
mesh = UnitSquareMesh(MPI.comm_world, 3, 3)
mesh.create_connectivity(2, 0)
ncells = mesh.num_cells()
f = MeshValueCollection("int", mesh, 0)
all_new = True
for cell in Cells(mesh):
value = ncells - cell.index()
for i, vert in enumerate(VertexRange(cell)):
all_new = all_new and f.set_value(cell.index(), i, value + i)
g = MeshValueCollection("int", mesh, 0)
g.assign(f)
assert ncells * 3 == f.size()
assert ncells * 3 == g.size()
assert all_new
for cell in Cells(mesh):
value = ncells - cell.index()
for i, vert in enumerate(VertexRange(cell)):
assert value + i == g.get_value(cell.index(), i)
def test_assign_2D_cells():
mesh = UnitSquareMesh(MPI.comm_world, 3, 3)
ncells = mesh.num_cells()
f = MeshValueCollection("int", mesh, 2)
all_new = True
for cell in Cells(mesh):
value = ncells - cell.index()
all_new = all_new and f.set_value(cell.index(), value)
g = MeshValueCollection("int", mesh, 2)
g.assign(f)
assert ncells == f.size()
assert ncells == g.size()
assert all_new
for cell in Cells(mesh):
value = ncells - cell.index()
assert value, g.get_value(cell.index() == 0)
old_value = g.get_value(0, 0)
g.set_value(0, 0, old_value + 1)
assert old_value + 1 == g.get_value(0, 0)
def test_mesh_function_assign_2D_facets():
mesh = UnitSquareMesh(MPI.comm_world, 3, 3)
mesh.init(1)
f = MeshFunction("int", mesh, mesh.topology.dim - 1, 25)
for cell in Cells(mesh):
for i, facet in enumerate(FacetRange(cell)):
assert 25 == f[facet]
g = MeshValueCollection("int", mesh, 1)
g.assign(f)
assert mesh.num_facets() == f.size()
assert mesh.num_cells() * 3 == g.size()
for cell in Cells(mesh):
for i, facet in enumerate(FacetRange(cell)):
assert 25 == g.get_value(cell.index(), i)
f2 = MeshFunction("int", mesh, g, 0)
for cell in Cells(mesh):
for i, facet in enumerate(FacetRange(cell)):
assert f2[facet] == g.get_value(cell.index(), i)
def test_tabulate_dofs_periodic(mesh_factory):
class PeriodicBoundary2(SubDomain):
def inside(self, x, on_boundary):
return x[0] < np.finfo(float).eps
def map(self, x, y):
y[0] = x[0] - 1.0
y[1] = x[1]
func, args = mesh_factory
mesh = func(*args)
# Create periodic boundary
periodic_boundary = PeriodicBoundary2()
V = FiniteElement("Lagrange", mesh.ufl_cell(), 2)
Q = VectorElement("Lagrange", mesh.ufl_cell(), 2)
W = V * Q
V = FunctionSpace(mesh, V, constrained_domain=periodic_boundary)
Q = FunctionSpace(mesh, Q, constrained_domain=periodic_boundary)
W = FunctionSpace(mesh, W, constrained_domain=periodic_boundary)
L0 = W.sub(0)
L1 = W.sub(1)
L01 = L1.sub(0)
L11 = L1.sub(1)
# Check dimensions
assert V.dim == 110
assert Q.dim == 220
assert L0.dim == V.dim
assert L1.dim == Q.dim
assert L01.dim == V.dim
assert L11.dim == V.dim
for i, cell in enumerate(Cells(mesh)):
dofs0 = L0.dofmap().cell_dofs(cell.index())
dofs1 = L01.dofmap().cell_dofs(cell.index())
dofs2 = L11.dofmap().cell_dofs(cell.index())
dofs3 = L1.dofmap().cell_dofs(cell.index())
assert np.array_equal(dofs0, L0.dofmap().cell_dofs(i))
assert np.array_equal(dofs1, L01.dofmap().cell_dofs(i))
assert np.array_equal(dofs2, L11.dofmap().cell_dofs(i))
assert np.array_equal(dofs3, L1.dofmap().cell_dofs(i))
assert len(np.intersect1d(dofs0, dofs1)) == 0
assert len(np.intersect1d(dofs0, dofs2)) == 0
assert len(np.intersect1d(dofs1, dofs2)) == 0
assert np.array_equal(np.append(dofs1, dofs2), dofs3)
def test_mesh_function_assign_2D_vertices():
mesh = UnitSquareMesh(MPI.comm_world, 3, 3)
mesh.create_entities(0)
f = MeshFunction("int", mesh, 0, 25)
g = MeshValueCollection("int", mesh, 0)
g.assign(f)
assert mesh.num_entities(0) == f.size()
assert mesh.num_cells() * 3 == g.size()
f2 = MeshFunction("int", mesh, g, 0)
for cell in Cells(mesh):
for i, vert in enumerate(VertexRange(cell)):
assert 25 == g.get_value(cell.index(), i)
assert f2[vert] == g.get_value(cell.index(), i)
def test_tabulate_coord_periodic(mesh_factory):
class PeriodicBoundary2(SubDomain):
def inside(self, x, on_boundary):
return x[0] < np.finfo(float).eps
def map(self, x, y):
y[0] = x[0] - 1.0
y[1] = x[1]
# Create periodic boundary condition
periodic_boundary = PeriodicBoundary2()
func, args = mesh_factory
mesh = func(*args)
V = FiniteElement("Lagrange", mesh.ufl_cell(), 1)
Q = VectorElement("Lagrange", mesh.ufl_cell(), 1)
W = V * Q
V = FunctionSpace(mesh, V, constrained_domain=periodic_boundary)
W = FunctionSpace(mesh, W, constrained_domain=periodic_boundary)
L0 = W.sub(0)
L1 = W.sub(1)
L01 = L1.sub(0)
L11 = L1.sub(1)
sdim = V.element().space_dimension()
coord0 = np.zeros((sdim, 2), dtype="d")
coord1 = np.zeros((sdim, 2), dtype="d")
coord2 = np.zeros((sdim, 2), dtype="d")
coord3 = np.zeros((sdim, 2), dtype="d")
for cell in Cells(mesh):
coord0 = V.element().tabulate_dof_coordinates(cell)
coord1 = L0.element().tabulate_dof_coordinates(cell)
coord2 = L01.element().tabulate_dof_coordinates(cell)
coord3 = L11.element().tabulate_dof_coordinates(cell)
coord4 = L1.element().tabulate_dof_coordinates(cell)
assert (coord0 == coord1).all()
assert (coord0 == coord2).all()
assert (coord0 == coord3).all()
assert (coord4[:sdim] == coord0).all()
assert (coord4[sdim:] == coord0).all()
def test_p4_parallel_2d():
mesh = UnitSquareMesh(MPI.comm_world, 5, 8)
Q = FunctionSpace(mesh, ("CG", 4))
F = Function(Q)
F.interpolate(Expression("x[0]", degree=4))
# Generate random points in this mesh partition (one per cell)
x = numpy.zeros(3)
for c in Cells(mesh):
x[0] = random()
x[1] = random() * (1 - x[0])
x[2] = 1 - x[0] - x[1]
p = Point(0.0, 0.0)
for i, v in enumerate(VertexRange(c)):
p += v.point() * x[i]
p = p.array()[:2]
assert numpy.isclose(F(p)[0], p[0])
def test_tabulate_all_coordinates(mesh_factory):
func, args = mesh_factory
mesh = func(*args)
V = FunctionSpace(mesh, ("Lagrange", 1))
W0 = FiniteElement("Lagrange", mesh.ufl_cell(), 1)
W1 = VectorElement("Lagrange", mesh.ufl_cell(), 1)
W = FunctionSpace(mesh, W0 * W1)
D = mesh.geometry.dim
V_dofmap = V.dofmap()
W_dofmap = W.dofmap()
all_coords_V = V.tabulate_dof_coordinates()
all_coords_W = W.tabulate_dof_coordinates()
local_size_V = V_dofmap().index_map.size_local * V_dofmap(
).index_map.block_size
local_size_W = W_dofmap().index_map.size_local * W_dofmap(
).index_map.block_size
all_coords_V = all_coords_V.reshape(local_size_V, D)
all_coords_W = all_coords_W.reshape(local_size_W, D)
checked_V = [False] * local_size_V
checked_W = [False] * local_size_W
# Check that all coordinates are within the cell it should be
for cell in Cells(mesh):
dofs_V = V_dofmap.cell_dofs(cell.index())
for di in dofs_V:
if di >= local_size_V:
continue
assert cell.contains(all_coords_V[di])
checked_V[di] = True
dofs_W = W_dofmap.cell_dofs(cell.index())
for di in dofs_W:
if di >= local_size_W:
continue
assert cell.contains(all_coords_W[di])
checked_W[di] = True
# Assert that all dofs have been checked by the above
assert all(checked_V)
assert all(checked_W)
def get_cell_at(mesh, x, y, z, eps=1e-3):
"""Return the cell with the given midpoint or None if not found. The
function also checks that the cell is found on one of the
processes when running in parallel to avoid that the above tests
always suceed if the cell is not found on any of the processes.
"""
found = None
for cell in Cells(mesh):
mp = cell.midpoint().array()
if abs(mp[0] - x) + abs(mp[1] - y) + abs(mp[2] - z) < eps:
found = cell
break
# Make sure this cell is on at least one of the parallel processes
marker = 1 if found is not None else 0
assert MPI.max(MPI.comm_world, marker) == 1
return found
def test_mixed_parallel():
mesh = UnitSquareMesh(MPI.comm_world, 5, 8)
V = VectorElement("Lagrange", triangle, 4)
Q = FiniteElement("Lagrange", triangle, 5)
W = FunctionSpace(mesh, Q * V)
F = Function(W)
F.interpolate(Expression(("x[0]", "x[1]", "sin(x[0] + x[1])"), degree=5))
# Generate random points in this mesh partition (one per cell)
x = numpy.zeros(3)
for c in Cells(mesh):
x[0] = random()
x[1] = random() * (1 - x[0])
x[2] = (1 - x[0] - x[1])
p = Point(0.0, 0.0)
for i, v in enumerate(VertexRange(c)):
p += v.point() * x[i]
p = p.array()[:2]
val = F(p)
assert numpy.allclose(val[0], p[0])
assert numpy.isclose(val[1], p[1])
assert numpy.isclose(val[2], numpy.sin(p[0] + p[1]))
def test_tabulate_coord_periodic(mesh_factory):
def periodic_boundary(x):
return x[0] < np.finfo(float).eps
func, args = mesh_factory
mesh = func(*args)
V = FiniteElement("Lagrange", mesh.ufl_cell(), 1)
Q = VectorElement("Lagrange", mesh.ufl_cell(), 1)
W = V * Q
V = FunctionSpace(mesh, V, constrained_domain=periodic_boundary)
W = FunctionSpace(mesh, W, constrained_domain=periodic_boundary)
L0 = W.sub(0)
L1 = W.sub(1)
L01 = L1.sub(0)
L11 = L1.sub(1)
sdim = V.element.space_dimension()
coord0 = np.zeros((sdim, 2), dtype="d")
coord1 = np.zeros((sdim, 2), dtype="d")
coord2 = np.zeros((sdim, 2), dtype="d")
coord3 = np.zeros((sdim, 2), dtype="d")
for cell in Cells(mesh):
coord0 = V.element.tabulate_dof_coordinates(cell)
coord1 = L0.element.tabulate_dof_coordinates(cell)
coord2 = L01.element.tabulate_dof_coordinates(cell)
coord3 = L11.element.tabulate_dof_coordinates(cell)
coord4 = L1.element.tabulate_dof_coordinates(cell)
assert (coord0 == coord1).all()
assert (coord0 == coord2).all()
assert (coord0 == coord3).all()
assert (coord4[:sdim] == coord0).all()
assert (coord4[sdim:] == coord0).all()
def test_ghost_connectivities(mode):
# Ghosted mesh
meshG = UnitSquareMesh(MPI.comm_world, 4, 4, ghost_mode=mode)
meshG.init(1, 2)
# Reference mesh, not ghosted, not parallel
meshR = UnitSquareMesh(MPI.comm_self,
4,
4,
ghost_mode=cpp.mesh.GhostMode.none)
meshR.init(1, 2)
# Create reference mapping from facet midpoint to cell midpoint
reference = {}
for facet in Facets(meshR):
fidx = facet.index()
facet_mp = tuple(facet.midpoint()[:])
reference[facet_mp] = []
for cidx in meshR.topology.connectivity(1, 2)(fidx):
cell = Cell(meshR, cidx)
cell_mp = tuple(cell.midpoint()[:])
reference[facet_mp].append(cell_mp)
# Loop through ghosted mesh and check connectivities
allowable_cell_indices = [
c.index() for c in Cells(meshG, cpp.mesh.MeshRangeType.ALL)
]
for facet in Facets(meshG, cpp.mesh.MeshRangeType.REGULAR):
fidx = facet.index()
facet_mp = tuple(facet.midpoint()[:])
assert facet_mp in reference
for cidx in meshG.topology.connectivity(1, 2)(fidx):
assert cidx in allowable_cell_indices
cell = Cell(meshG, cidx)
cell_mp = tuple(cell.midpoint()[:])
assert cell_mp in reference[facet_mp]
