def test_empty_rank_mesh():
"""Construction of mesh where some ranks are empty"""
comm = MPI.COMM_WORLD
cell_type = CellType.triangle
tdim = 2
domain = ufl.Mesh(
ufl.VectorElement("Lagrange", ufl.Cell(cell_type.name), 1))
def partitioner(comm, nparts, local_graph, num_ghost_nodes, ghosting):
"""Leave cells on the curent rank"""
dest = np.full(len(cells), comm.rank, dtype=np.int32)
return graph.create_adjacencylist(dest)
if comm.rank == 0:
cells = np.array([[0, 1, 2], [0, 2, 3]], dtype=np.int64)
cells = graph.create_adjacencylist(cells)
x = np.array([[0., 0.], [1., 0.], [1., 1.], [0., 1.]])
else:
cells = graph.create_adjacencylist(np.empty((0, 3), dtype=np.int64))
x = np.empty((0, 2), dtype=np.float64)
mesh = _mesh.create_mesh(comm, cells, x, domain, GhostMode.none,
partitioner)
topology = mesh.topology
# Check number of vertices
vmap = topology.index_map(0)
assert vmap.size_local == x.shape[0]
assert vmap.num_ghosts == 0
# Check number of cells
cmap = topology.index_map(tdim)
assert cmap.size_local == cells.num_nodes
assert cmap.num_ghosts == 0
# Check number of edges
topology.create_entities(1)
emap = topology.index_map(1)
e_to_v = topology.connectivity(1, 0)
assert emap.num_ghosts == 0
if comm.rank == 0:
assert emap.size_local == 5
assert e_to_v.num_nodes == 5
assert len(e_to_v.array) == 10
else:
assert emap.size_local == 0
assert len(e_to_v.array) == 0
assert e_to_v.num_nodes == 0
# Test creating and getting permutations doesn't throw an error
mesh.topology.create_entity_permutations()
mesh.topology.get_cell_permutation_info()
mesh.topology.get_facet_permutations()
def test_assemble_empty_rank_mesh():
"""Assembly on mesh where some ranks are empty"""
comm = MPI.COMM_WORLD
cell_type = CellType.triangle
domain = ufl.Mesh(
ufl.VectorElement("Lagrange", ufl.Cell(cell_type.name), 1))
def partitioner(comm, nparts, local_graph, num_ghost_nodes, ghosting):
"""Leave cells on the curent rank"""
dest = np.full(len(cells), comm.rank, dtype=np.int32)
return graph.create_adjacencylist(dest)
if comm.rank == 0:
# Put cells on rank 0
cells = np.array([[0, 1, 2], [0, 2, 3]], dtype=np.int64)
cells = graph.create_adjacencylist(cells)
x = np.array([[0., 0.], [1., 0.], [1., 1.], [0., 1.]])
else:
# No cells onm other ranks
cells = graph.create_adjacencylist(np.empty((0, 3), dtype=np.int64))
x = np.empty((0, 2), dtype=np.float64)
mesh = create_mesh(comm, cells, x, domain, GhostMode.none, partitioner)
V = FunctionSpace(mesh, ("Lagrange", 2))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
f, k, zero = Function(V), Function(V), Function(V)
f.x.array[:] = 10.0
k.x.array[:] = 1.0
zero.x.array[:] = 0.0
a = form(inner(k * u, v) * dx + inner(zero * u, v) * ds)
L = form(inner(f, v) * dx + inner(zero, v) * ds)
M = form(2 * k * dx + k * ds)
sum = comm.allreduce(assemble_scalar(M), op=MPI.SUM)
assert sum == pytest.approx(6.0)
# Assemble
A = assemble_matrix(a)
A.assemble()
b = assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
# Solve
ksp = PETSc.KSP()
ksp.create(mesh.comm)
ksp.setOperators(A)
ksp.setTolerances(rtol=1.0e-9, max_it=50)
ksp.setFromOptions()
x = b.copy()
ksp.solve(b, x)
assert np.allclose(x.array, 10.0)
def test_create_adj2d(dtype):
data = np.zeros([2, 4], dtype=dtype)
adj = create_adjacencylist(data)
num_nodes, num_links = data.shape[0], data.shape[1]
assert np.array_equal(
adj.offsets,
np.arange(0,
num_nodes * num_links + num_links,
num_links,
dtype=np.int32))
def test_create(cell_type):
comm = MPI.COMM_WORLD
mesh = create_unit_cube(comm, 6, 6, 6, cell_type)
marked_lines = locate_entities(mesh, 1, lambda x: np.isclose(x[1], 0.5))
f_v = mesh.topology.connectivity(1, 0).array.reshape(-1, 2)
entities = create_adjacencylist(f_v[marked_lines])
values = np.full(marked_lines.shape[0], 2, dtype=np.int32)
mt = create_meshtags(mesh, 1, entities, values)
assert mt.indices.shape == marked_lines.shape
def test_ufl_id():
"""Test that UFL can process MeshTags (tests ufl_id attribute)"""
comm = MPI.COMM_WORLD
mesh = create_unit_cube(comm, 6, 6, 6)
tdim = mesh.topology.dim
marked_facets = locate_entities(mesh, tdim - 1,
lambda x: np.isclose(x[1], 1))
f_v = mesh.topology.connectivity(tdim - 1, 0).array.reshape(-1, 3)
entities = create_adjacencylist(f_v[marked_facets])
values = np.full(marked_facets.shape[0], 2, dtype=np.int32)
ft = meshtags_from_entities(mesh, tdim - 1, entities, values)
ds = Measure("ds", domain=mesh, subdomain_data=ft, subdomain_id=(2, 3))
a = 1 * ds
assert isinstance(a.subdomain_data(), dict)
def test_transpose_dofmap():
dofmap = create_adjacencylist(
np.array([[0, 2, 1], [3, 2, 1], [4, 3, 1]], dtype=np.int32))
transpose = dolfinx.fem.transpose_dofmap(dofmap, 3)
assert np.array_equal(transpose.array, [0, 2, 5, 8, 1, 4, 3, 7, 6])
marked_facets = topologies[gmsh_facet_id]["topology"].astype(np.int64)
facet_values = topologies[gmsh_facet_id]["cell_data"].astype(np.int32)
else:
gmsh_cell_id = MPI.COMM_WORLD.bcast(None, root=0)
num_nodes = MPI.COMM_WORLD.bcast(None, root=0)
cells, x = np.empty([0, num_nodes]), np.empty([0, 3])
marked_facets, facet_values = np.empty((0, 3), dtype=np.int64), np.empty(
(0, ), dtype=np.int32)
mesh = create_mesh(MPI.COMM_WORLD, cells, x,
ufl_mesh_from_gmsh(gmsh_cell_id, 3))
mesh.name = "ball_d1"
entities, values = distribute_entity_data(mesh, 2, marked_facets, facet_values)
mesh.topology.create_connectivity(2, 0)
mt = create_meshtags(mesh, 2, create_adjacencylist(entities), np.int32(values))
mt.name = "ball_d1_surface"
with XDMFFile(MPI.COMM_WORLD, "mesh.xdmf", "w") as file:
file.write_mesh(mesh)
mesh.topology.create_connectivity(2, 3)
file.write_meshtags(
mt, geometry_xpath="/Xdmf/Domain/Grid[@Name='ball_d1']/Geometry")
# Create a distributed (parallel) mesh with quadratic geometry. Generate
# mesh on rank 0, then build a distributed mesh. ::
if MPI.COMM_WORLD.rank == 0:
# Using model.setCurrent(model_name) lets you change between models
model.setCurrent("Sphere minus box")
def partitioner(comm, nparts, local_graph, num_ghost_nodes, ghosting):
"""Leave cells on the curent rank"""
dest = np.full(len(cells), comm.rank, dtype=np.int32)
return graph.create_adjacencylist(dest)
marked_facets = topologies[gmsh_facet_id]["topology"].astype(np.int64)
facet_values = topologies[gmsh_facet_id]["cell_data"].astype(np.int32)
else:
gmsh_cell_id = MPI.COMM_WORLD.bcast(None, root=0)
num_nodes = MPI.COMM_WORLD.bcast(None, root=0)
cells, x = np.empty([0, num_nodes]), np.empty([0, 3])
marked_facets, facet_values = np.empty((0, 3), dtype=np.int64), np.empty(
(0, ), dtype=np.int32)
msh = create_mesh(MPI.COMM_WORLD, cells, x,
ufl_mesh_from_gmsh(gmsh_cell_id, 3))
msh.name = "ball_d1"
entities, values = distribute_entity_data(msh, 2, marked_facets, facet_values)
msh.topology.create_connectivity(2, 0)
mt = meshtags_from_entities(msh, 2, create_adjacencylist(entities),
np.int32(values))
mt.name = "ball_d1_surface"
with XDMFFile(MPI.COMM_WORLD, "mesh.xdmf", "w") as file:
file.write_mesh(msh)
msh.topology.create_connectivity(2, 3)
file.write_meshtags(
mt, geometry_xpath="/Xdmf/Domain/Grid[@Name='ball_d1']/Geometry")
# -
# Create a distributed (parallel) mesh with quadratic geometry. Generate
# mesh on rank 0, then build a distributed mesh.
# +
if MPI.COMM_WORLD.rank == 0:
