def test_save_and_load_1d_mesh(tempdir, encoding):
filename = os.path.join(tempdir, "mesh.xdmf")
mesh = UnitIntervalMesh(MPI.COMM_WORLD, 32)
with XDMFFile(mesh.mpi_comm(), filename, "w", encoding=encoding) as file:
file.write_mesh(mesh)
with XDMFFile(MPI.COMM_WORLD, filename, "r", encoding=encoding) as file:
mesh2 = file.read_mesh()
assert mesh.topology.index_map(0).size_global == mesh2.topology.index_map(
0).size_global
assert mesh.topology.index_map(
mesh.topology.dim).size_global == mesh2.topology.index_map(
mesh.topology.dim).size_global
def test_save_points_3D(tempdir, encoding, cell_type):
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4, cell_type)
points = mesh.geometry.points
vals = np.linalg.norm(points, axis=1)
with XDMFFile(mesh.mpi_comm(),
os.path.join(tempdir, "points_3D.xdmf"),
encoding=encoding) as file:
file.write(points)
with XDMFFile(mesh.mpi_comm(),
os.path.join(tempdir, "points_values_3D.xdmf"),
encoding=encoding) as file:
file.write(points, vals)
def write_output(self, pb=None, writemesh=False, N=1, t=0):
if writemesh:
if self.write_results_every > 0:
self.resultsfiles = {}
for res in self.results_to_write:
outfile = XDMFFile(
self.comm, self.output_path + '/results_' +
pb.simname + '_' + res + '.xdmf', 'w')
outfile.write_mesh(self.mesh)
self.resultsfiles[res] = outfile
return
else:
# write results every write_results_every steps
if self.write_results_every > 0 and N % self.write_results_every == 0:
# save solution to XDMF format
for res in self.results_to_write:
if res == 'velocity':
self.resultsfiles[res].write_function(pb.v, t)
elif res == 'acceleration': # passed in a is not a function but form, so we have to project
a_proj = project(pb.acc,
pb.V_v,
pb.dx_,
nm="Acceleration")
self.resultsfiles[res].write_function(a_proj, t)
elif res == 'pressure':
self.resultsfiles[res].write_function(pb.p, t)
elif res == 'cauchystress':
stressfuncs = []
for n in range(pb.num_domains):
stressfuncs.append(pb.ma[n].sigma(pb.v, pb.p))
cauchystress = project(stressfuncs,
pb.Vd_tensor,
pb.dx_,
nm="CauchyStress")
self.resultsfiles[res].write_function(cauchystress, t)
elif res == 'reynolds':
reynolds = project(re,
pb.Vd_scalar,
pb.dx_,
nm="Reynolds")
self.resultsfiles[res].write_function(reynolds, t)
else:
raise NameError(
"Unknown output to write for fluid mechanics!")
def test_append_and_load_mesh_functions(tempdir, encoding, data_type):
dtype_str, dtype = data_type
meshes = [
UnitSquareMesh(MPI.comm_world, 12, 12),
UnitCubeMesh(MPI.comm_world, 2, 2, 2),
UnitSquareMesh(MPI.comm_world, 12, 12, CellType.quadrilateral),
UnitCubeMesh(MPI.comm_world, 2, 2, 2, CellType.hexahedron)
]
for mesh in meshes:
dim = mesh.topology.dim
vf = MeshFunction(dtype_str, mesh, 0, 0)
vf.name = "vertices"
ff = MeshFunction(dtype_str, mesh, mesh.topology.dim - 1, 0)
ff.name = "facets"
cf = MeshFunction(dtype_str, mesh, mesh.topology.dim, 0)
cf.name = "cells"
# vf.values[:] = mesh.topology.global_indices(0)[:]
map = mesh.topology.index_map(0)
vf.values[:] = map.global_indices(True)
map = mesh.topology.index_map(dim - 1)
ff.values[:] = map.global_indices(True)
map = mesh.topology.index_map(dim)
cf.values[:] = map.global_indices(True)
filename = os.path.join(
tempdir, "appended_mf_{0:d}_{1:s}.xdmf".format(
dim, str(mesh.topology.cell_type)))
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_vf = vf_in.values - vf.values
diff_ff = ff_in.values - ff.values
diff_cf = cf_in.values - cf.values
assert np.all(diff_vf == 0)
assert np.all(diff_ff == 0)
assert np.all(diff_cf == 0)
def test_read_write_p2_mesh(tempdir, encoding):
if MPI.COMM_WORLD.rank == 0:
gmsh = pytest.importorskip("gmsh")
gmsh.initialize()
gmsh.model.occ.addSphere(0, 0, 0, 1, tag=1)
gmsh.option.setNumber("Mesh.CharacteristicLengthMin", 0.3)
gmsh.option.setNumber("Mesh.CharacteristicLengthMax", 0.4)
gmsh.model.occ.synchronize()
gmsh.model.mesh.generate(3)
gmsh.model.mesh.setOrder(2)
idx, points, _ = gmsh.model.mesh.getNodes()
points = points.reshape(-1, 3)
idx -= 1
srt = np.argsort(idx)
assert np.all(idx[srt] == np.arange(len(idx)))
x = points[srt]
element_types, element_tags, node_tags = gmsh.model.mesh.getElements(
dim=3)
name, dim, order, num_nodes, local_coords, num_first_order_nodes = gmsh.model.mesh.getElementProperties(
element_types[0])
cells = node_tags[0].reshape(-1, num_nodes) - 1
num_nodes, gmsh_cell_id = MPI.COMM_WORLD.bcast(
[cells.shape[1],
gmsh.model.mesh.getElementType("tetrahedron", 2)],
root=0)
gmsh.finalize()
else:
num_nodes, gmsh_cell_id = MPI.COMM_WORLD.bcast([None, None], root=0)
cells, x = np.empty([0, num_nodes]), np.empty([0, 3])
domain = ufl_mesh_from_gmsh(gmsh_cell_id, 3)
cell_type = cpp.mesh.to_type(str(domain.ufl_cell()))
cells = cells[:, perm_gmsh(cell_type, cells.shape[1])]
mesh = create_mesh(MPI.COMM_WORLD, cells, x, domain)
filename = os.path.join(tempdir, "tet10_mesh.xdmf")
with XDMFFile(mesh.mpi_comm(), filename, "w", encoding=encoding) as xdmf:
xdmf.write_mesh(mesh)
with XDMFFile(mesh.mpi_comm(), filename, "r", encoding=encoding) as xdmf:
mesh2 = xdmf.read_mesh()
assert mesh.topology.index_map(0).size_global == mesh2.topology.index_map(
0).size_global
assert mesh.topology.index_map(
mesh.topology.dim).size_global == mesh2.topology.index_map(
mesh.topology.dim).size_global
def test_save_3d_vector_series(tempdir, encoding, cell_type):
filename = os.path.join(tempdir, "u_3D.xdmf")
mesh = UnitCubeMesh(MPI.COMM_WORLD, 2, 2, 2, cell_type)
u = Function(VectorFunctionSpace(mesh, ("Lagrange", 2)))
with XDMFFile(mesh.mpi_comm(), filename, "w", encoding=encoding) as file:
file.write_mesh(mesh)
u.vector.set(1.0 + (1j if has_petsc_complex else 0))
file.write_function(u, 0.1)
u.vector.set(2.0 + (2j if has_petsc_complex else 0))
file.write_function(u, 0.2)
with XDMFFile(mesh.mpi_comm(), filename, "a", encoding=encoding) as file:
u.vector.set(3.0 + (3j if has_petsc_complex else 0))
file.write_function(u, 0.3)
def test_save_and_load_3d_mesh(tempdir, encoding, cell_type):
filename = os.path.join(tempdir, "mesh.xdmf")
mesh = UnitCubeMesh(MPI.COMM_WORLD, 12, 12, 8, cell_type)
with XDMFFile(mesh.mpi_comm(), filename, "w", encoding=encoding) as file:
file.write_mesh(mesh)
with XDMFFile(MPI.COMM_WORLD, filename, "r", encoding=encoding) as file:
mesh2 = file.read_mesh()
assert mesh.topology.index_map(0).size_global == mesh2.topology.index_map(
0).size_global
dim = mesh.topology.dim
assert mesh.topology.index_map(
dim).size_global == mesh2.topology.index_map(dim).size_global
def test_append_and_load_mesh_value_collections(tempdir, encoding, data_type,
cell_type):
dtype_str, dtype = data_type
mesh = UnitCubeMesh(MPI.comm_world, 2, 2, 2, cell_type)
mesh.create_connectivity_all()
mvc_v = MeshValueCollection(dtype_str, mesh, 0)
mvc_v.name = "vertices"
mvc_e = MeshValueCollection(dtype_str, mesh, 1)
mvc_e.name = "edges"
mvc_f = MeshValueCollection(dtype_str, mesh, 2)
mvc_f.name = "facets"
mvc_c = MeshValueCollection(dtype_str, mesh, 3)
mvc_c.name = "cells"
mvcs = [mvc_v, mvc_e, mvc_f, mvc_c]
filename = os.path.join(tempdir, "appended_mvcs.xdmf")
with XDMFFile(mesh.mpi_comm(), filename) as xdmf:
for mvc in mvcs:
# global_indices = mesh.topology.global_indices(mvc.dim)
map = mesh.topology.index_map(mvc.dim)
global_indices = map.global_indices(True)
for ent in range(mesh.num_entities(mvc.dim)):
assert (mvc.set_value(ent, global_indices[ent]))
xdmf.write(mvc)
mvc_v_in = MeshValueCollection(dtype_str, mesh, 0)
mvc_e_in = MeshValueCollection(dtype_str, mesh, 1)
mvc_f_in = MeshValueCollection(dtype_str, mesh, 2)
mvc_c_in = MeshValueCollection(dtype_str, mesh, 3)
with XDMFFile(mesh.mpi_comm(), filename) as xdmf:
read_function = getattr(xdmf, "read_mvc_" + dtype_str)
mvc_v_in = read_function(mesh, "vertices")
mvc_e_in = read_function(mesh, "edges")
mvc_f_in = read_function(mesh, "facets")
mvc_c_in = read_function(mesh, "cells")
mvcs_in = [mvc_v_in, mvc_e_in, mvc_f_in, mvc_c_in]
for (mvc, mvc_in) in zip(mvcs, mvcs_in):
mf = MeshFunction(dtype_str, mesh, mvc, 0)
mf_in = MeshFunction(dtype_str, mesh, mvc_in, 0)
diff = mf_in.values - mf.values
assert np.all(diff == 0)
def test_read_write_p2_mesh(tempdir):
mesh = cpp.generation.UnitDiscMesh.create(MPI.comm_world, 3,
cpp.mesh.GhostMode.none)
filename = os.path.join(tempdir, "tri6_mesh.xdmf")
with XDMFFile(mesh.mpi_comm(), filename,
encoding=XDMFFile.Encoding.HDF5) as xdmf:
xdmf.write(mesh)
with XDMFFile(mesh.mpi_comm(), filename) as xdmf:
mesh2 = xdmf.read_mesh(cpp.mesh.GhostMode.none)
assert mesh2.num_entities_global(
mesh.topology.dim) == mesh.num_entities_global(mesh.topology.dim)
assert mesh2.num_entities_global(0) == mesh.num_entities_global(0)
def test_save_and_load_2d_mesh(tempdir, encoding, cell_type):
filename = os.path.join(tempdir, "mesh.xdmf")
mesh = create_unit_square(MPI.COMM_WORLD, 12, 12, cell_type)
mesh.name = "square"
with XDMFFile(mesh.comm, filename, "w", encoding=encoding) as file:
file.write_mesh(mesh)
with XDMFFile(MPI.COMM_WORLD, filename, "r", encoding=encoding) as file:
mesh2 = file.read_mesh(name="square")
assert mesh2.name == mesh.name
assert mesh.topology.index_map(0).size_global == mesh2.topology.index_map(0).size_global
assert mesh.topology.index_map(mesh.topology.dim).size_global == mesh2.topology.index_map(
mesh.topology.dim).size_global
def test_3d(tempdir, cell_type, encoding):
filename = os.path.join(tempdir, "meshtags_3d.xdmf")
comm = MPI.COMM_WORLD
mesh = UnitCubeMesh(comm, 4, 4, 4, cell_type)
bottom_facets = locate_entities(mesh, 2, lambda x: np.isclose(x[1], 0.0))
bottom_values = np.full(bottom_facets.shape, 1, dtype=np.intc)
left_facets = locate_entities(mesh, 2, lambda x: np.isclose(x[0], 0.0))
left_values = np.full(left_facets.shape, 2, dtype=np.intc)
indices, pos = np.unique(np.hstack((bottom_facets, left_facets)), return_index=True)
mt = MeshTags(mesh, 2, indices, np.hstack((bottom_values, left_values))[pos])
mt.name = "facets"
top_lines = locate_entities(mesh, 1, lambda x: np.isclose(x[2], 1.0))
top_values = np.full(top_lines.shape, 3, dtype=np.intc)
right_lines = locate_entities(mesh, 1, lambda x: np.isclose(x[0], 1.0))
right_values = np.full(right_lines.shape, 4, dtype=np.intc)
indices, pos = np.unique(np.hstack((top_lines, right_lines)), return_index=True)
mt_lines = MeshTags(mesh, 1, indices, np.hstack((top_values, right_values))[pos])
mt_lines.name = "lines"
with XDMFFile(comm, filename, "w", encoding=encoding) as file:
mesh.topology.create_connectivity_all()
file.write_mesh(mesh)
file.write_meshtags(mt)
file.write_meshtags(mt_lines)
with XDMFFile(comm, filename, "r", encoding=encoding) as file:
mesh_in = file.read_mesh()
mesh_in.topology.create_connectivity_all()
mt_in = file.read_meshtags(mesh_in, "facets")
mt_lines_in = file.read_meshtags(mesh_in, "lines")
assert mt_in.name == "facets"
assert mt_lines_in.name == "lines"
with XDMFFile(comm, os.path.join(tempdir, "meshtags_3d_out.xdmf"), "w", encoding=encoding) as file:
file.write_mesh(mesh_in)
file.write_meshtags(mt_lines_in)
file.write_meshtags(mt_in)
# Check number of owned and marked entities
lines_local = comm.allreduce((mt_lines.indices < mesh.topology.index_map(1).size_local).sum(), op=MPI.SUM)
lines_local_in = comm.allreduce(
(mt_lines_in.indices < mesh_in.topology.index_map(1).size_local).sum(), op=MPI.SUM)
assert lines_local == lines_local_in
def test_save_3d_tensor(tempdir, encoding, cell_type):
filename = os.path.join(tempdir, "u3t.xdmf")
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4, cell_type)
u = Function(TensorFunctionSpace(mesh, ("Lagrange", 2)))
u.vector.set(1.0 + (1j if has_petsc_complex else 0))
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(u)
def test_read_mesh_data(tempdir, tdim, n):
filename = os.path.join(tempdir, "mesh.xdmf")
mesh = mesh_factory(tdim, n)
encoding = XDMFFile.Encoding.HDF5
with XDMFFile(mesh.mpi_comm(), filename, "w", encoding) as file:
file.write_mesh(mesh)
with XDMFFile(MPI.COMM_WORLD, filename, "r") as file:
cell_type = file.read_cell_type()
cells = file.read_topology_data()
x = file.read_geometry_data()
assert cell_type[0] == mesh.topology.cell_type
assert cell_type[1] == 1
assert mesh.topology.index_map(tdim).size_global == mesh.mpi_comm().allreduce(cells.shape[0], op=MPI.SUM)
assert mesh.geometry.index_map().size_global == mesh.mpi_comm().allreduce(x.shape[0], op=MPI.SUM)
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)
mf.values[:] = np.arange(mesh.num_entities(1))
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(mf)
def test_save_3D_cell_function(tempdir, encoding, data_type, cell_type):
dtype_str, dtype = data_type
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4, cell_type)
mf = MeshFunction(dtype_str, mesh, mesh.topology.dim, 0)
mf.name = "cells"
mf.values[:] = np.arange(mesh.num_entities(3), dtype=dtype)
filename = os.path.join(tempdir, "mf_3D_%s.xdmf" % dtype_str)
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 = mf_in.values - mf.values
assert np.all(diff == 0)
def test_multiple_datasets(tempdir, encoding, cell_type):
mesh = UnitSquareMesh(MPI.comm_world, 4, 4, cell_type)
cf0 = MeshFunction('size_t', mesh, 2, 11)
cf0.name = 'cf0'
cf1 = MeshFunction('size_t', mesh, 2, 22)
cf1.name = 'cf1'
filename = os.path.join(tempdir, "multiple_mf.xdmf")
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as xdmf:
xdmf.write(mesh)
xdmf.write(cf0)
xdmf.write(cf1)
with XDMFFile(mesh.mpi_comm(), filename) as xdmf:
mesh = xdmf.read_mesh(cpp.mesh.GhostMode.none)
cf0 = xdmf.read_mf_size_t(mesh, "cf0")
cf1 = xdmf.read_mf_size_t(mesh, "cf1")
assert (cf0.values[0] == 11 and cf1.values[0] == 22)
def test_save_2d_tensor(tempdir, encoding, cell_type):
filename = os.path.join(tempdir, "tensor.xdmf")
mesh = UnitSquareMesh(MPI.COMM_WORLD, 16, 16, cell_type)
u = Function(TensorFunctionSpace(mesh, ("Lagrange", 2)))
u.vector.set(1.0 + (1j if has_petsc_complex else 0))
with XDMFFile(mesh.mpi_comm(), filename, "w", encoding=encoding) as file:
file.write_mesh(mesh)
file.write_function(u)
def test_save_3d_vector_series(tempdir, encoding, cell_type):
filename = os.path.join(tempdir, "u_3D.xdmf")
mesh = create_unit_cube(MPI.COMM_WORLD, 2, 2, 2, cell_type)
u = Function(VectorFunctionSpace(mesh, ("Lagrange", 2)))
with XDMFFile(mesh.comm, filename, "w", encoding=encoding) as file:
file.write_mesh(mesh)
u.vector.set(1.0 + (
1j if np.issubdtype(PETSc.ScalarType, np.complexfloating) else 0))
file.write_function(u, 0.1)
u.vector.set(2.0 + (
2j if np.issubdtype(PETSc.ScalarType, np.complexfloating) else 0))
file.write_function(u, 0.2)
with XDMFFile(mesh.comm, filename, "a", encoding=encoding) as file:
u.vector.set(3.0 + (
3j if np.issubdtype(PETSc.ScalarType, np.complexfloating) else 0))
file.write_function(u, 0.3)
def test_save_2D_vertex_function(tempdir, encoding, data_type, cell_type):
dtype_str, dtype = data_type
mesh = UnitSquareMesh(MPI.comm_world, 32, 32, cell_type)
mf = MeshFunction(dtype_str, mesh, 0, 0)
mf.name = "vertices"
global_indices = mesh.topology.index_map(0).global_indices(False)
mf.values[:] = global_indices[:]
filename = os.path.join(tempdir, "mf_vertex_2D_%s.xdmf" % dtype_str)
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, "vertices")
diff = mf_in.values - mf.values
assert np.all(diff == 0)
def test_save_3D_vertex_function(tempdir, encoding, data_type, cell_type):
dtype_str, dtype = data_type
filename = os.path.join(tempdir, "mf_vertex_3D_%s.xdmf" % dtype_str)
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4, cell_type)
mf = MeshFunction(dtype_str, mesh, 0, 0)
mf.values[:] = np.arange(mesh.num_entities(0), dtype=dtype)
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(mf)
def test_save_2d_vector(tempdir, encoding, cell_type):
filename = os.path.join(tempdir, "u_2dv.xdmf")
mesh = UnitSquareMesh(MPI.comm_world, 16, 16, cell_type)
V = VectorFunctionSpace(mesh, ("Lagrange", 2))
u = Function(V)
u.vector.set(1.0 + (1j if has_petsc_complex else 0))
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(u)
def xtest_read_write_p2_function(tempdir):
mesh = cpp.generation.UnitDiscMesh.create(MPI.comm_world, 3,
cpp.mesh.GhostMode.none)
gdim = mesh.geometry.dim
cmap = fem.create_coordinate_map(mesh.ufl_domain())
mesh.geometry.coord_mapping = cmap
Q = FunctionSpace(mesh, ("Lagrange", 2))
F = Function(Q)
if has_petsc_complex:
def expr_eval(x):
return x[0] + 1.0j * x[0]
F.interpolate(expr_eval)
else:
def expr_eval(x):
return x[0]
F.interpolate(expr_eval)
filename = os.path.join(tempdir, "tri6_function.xdmf")
with XDMFFile(mesh.mpi_comm(), filename,
encoding=XDMFFile.Encoding.HDF5) as xdmf:
xdmf.write(F)
Q = VectorFunctionSpace(mesh, ("Lagrange", 1))
F = Function(Q)
if has_petsc_complex:
def expr_eval(x):
return x[:gdim] + 1.0j * x[:gdim]
F.interpolate(expr_eval)
else:
def expr_eval(x):
return x[:gdim]
F.interpolate(expr_eval)
filename = os.path.join(tempdir, "tri6_vector_function.xdmf")
with XDMFFile(mesh.mpi_comm(), filename,
encoding=XDMFFile.Encoding.HDF5) as xdmf:
xdmf.write(F)
def test_save_2d_scalar(tempdir, encoding, cell_type):
filename = os.path.join(tempdir, "u2.xdmf")
mesh = UnitSquareMesh(MPI.comm_world, 16, 16, cell_type)
# FIXME: This randomly hangs in parallel
V = FunctionSpace(mesh, ("Lagrange", 2))
u = Function(V)
u.vector.set(1.0 + (1j if has_petsc_complex else 0))
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(u)
def test_save_2d_scalar(tempdir, encoding, cell_type):
filename = os.path.join(tempdir, "u2.xdmf")
mesh = UnitSquareMesh(MPI.COMM_WORLD, 12, 12, cell_type)
V = FunctionSpace(mesh, ("Lagrange", 2))
u = Function(V)
u.vector.set(1.0)
with XDMFFile(mesh.mpi_comm(), filename, "w", encoding=encoding) as file:
file.write_mesh(mesh)
file.write_function(u)
def test_save_1d_scalar(tempdir, encoding):
filename2 = os.path.join(tempdir, "u1_.xdmf")
mesh = UnitIntervalMesh(MPI.COMM_WORLD, 32)
V = FunctionSpace(mesh, ("Lagrange", 2))
u = Function(V)
u.vector.set(1.0 + (1j if has_petsc_complex else 0))
with XDMFFile(mesh.mpi_comm(), filename2, "w", encoding=encoding) as file:
file.write_mesh(mesh)
file.write_function(u)
def test_save_3D_facet_function(tempdir, encoding, data_type, cell_type):
dtype_str, dtype = data_type
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4, cell_type)
tdim = mesh.topology.dim
mf = MeshFunction(dtype_str, mesh, tdim - 1, 0)
mf.name = "facets"
global_indices = mesh.topology.global_indices(tdim - 1)
mf.values[:] = global_indices[:]
filename = os.path.join(tempdir, "mf_facet_3D_%s.xdmf" % dtype_str)
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as xdmf:
xdmf.write(mf)
with XDMFFile(mesh.mpi_comm(), filename) as xdmf:
read_function = getattr(xdmf, "read_mf_" + dtype_str)
mf_in = read_function(mesh, "facets")
diff = mf_in.values - mf.values
assert np.all(diff == 0)
def test_save_3d_tensor(tempdir, encoding, cell_type):
filename = os.path.join(tempdir, "u3t.xdmf")
mesh = create_unit_cube(MPI.COMM_WORLD, 4, 4, 4, cell_type)
u = Function(TensorFunctionSpace(mesh, ("Lagrange", 2)))
u.vector.set(1.0 + (
1j if np.issubdtype(PETSc.ScalarType, np.complexfloating) else 0))
with XDMFFile(mesh.comm, filename, "w", encoding=encoding) as file:
file.write_mesh(mesh)
file.write_function(u)
def test_save_3d_scalar(tempdir, encoding, cell_type):
filename = os.path.join(tempdir, "u3.xdmf")
mesh = create_unit_cube(MPI.COMM_WORLD, 4, 3, 4, cell_type)
V = FunctionSpace(mesh, ("Lagrange", 2))
u = Function(V)
u.vector.set(1.0)
with XDMFFile(mesh.comm, filename, "w", encoding=encoding) as file:
file.write_mesh(mesh)
file.write_function(u)
def test_save_1d_scalar(tempdir, encoding):
filename2 = os.path.join(tempdir, "u1_.xdmf")
mesh = UnitIntervalMesh(MPI.comm_world, 32)
# FIXME: This randomly hangs in parallel
V = FunctionSpace(mesh, ("Lagrange", 2))
u = Function(V)
u.vector.set(1.0 + (1j if has_petsc_complex else 0))
with XDMFFile(mesh.mpi_comm(), filename2, encoding=encoding) as file:
file.write(u)
def xtest_submesh(tempdir, d, n, codim, ghost_mode, encoding):
mesh = mesh_factory(d, n, ghost_mode)
edim = d - codim
entities = locate_entities(mesh, edim, lambda x: x[0] >= 0.5)
submesh = create_submesh(mesh, edim, entities)[0]
filename = os.path.join(tempdir, "submesh.xdmf")
# Check writing the mesh doesn't cause a segmentation fault
with XDMFFile(mesh.comm, filename, "w", encoding=encoding) as xdmf:
xdmf.write_mesh(submesh)
