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.name = "volume_marker"
mp = cpp.mesh.midpoints(mesh, tdim, range(mesh.num_entities(tdim)))
for i in range(mesh.num_cells()):
if mp[i, 1] > 0.1:
meshfn.values[i] = 1
if mp[i, 1] > 0.9:
meshfn.values[i] = 2
for mvc_dim in range(0, tdim + 1):
mvc = MeshValueCollection(dtype_str, mesh, mvc_dim)
tag = "dim_{}_marker".format(mvc_dim)
mvc.name = tag
mesh.create_connectivity(mvc_dim, tdim)
mp = cpp.mesh.midpoints(mesh, mvc_dim,
range(mesh.num_entities(mvc_dim)))
for e in range(mesh.num_entities(mvc_dim)):
if (mp[e, 0] > 0.5):
mvc.set_value(e, dtype(1))
filename = os.path.join(tempdir, "mvc_{}.xdmf".format(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_and_read_meshfunction_3D(tempdir):
filename = os.path.join(tempdir, "meshfn-3d.h5")
# Write to file
mesh = UnitCubeMesh(MPI.comm_world, 2, 2, 2)
mf_file = HDF5File(mesh.mpi_comm(), filename, "w")
# save meshfuns to compare when reading back
meshfunctions = []
for i in range(0, 4):
mf = MeshFunction('double', mesh, i, 0.0)
# NB choose a value to set which will be the same
# on every process for each entity
for cell in MeshEntities(mesh, i):
mf[cell] = cell.midpoint()[0]
meshfunctions.append(mf)
mf_file.write(mf, "/meshfunction/group/%d/meshfun" % i)
mf_file.close()
# Read back from file
mf_file = HDF5File(mesh.mpi_comm(), filename, "r")
for i in range(0, 4):
mf2 = mf_file.read_mf_double(mesh,
"/meshfunction/group/%d/meshfun" % i)
for cell in MeshEntities(mesh, i):
assert meshfunctions[i][cell] == mf2[cell]
mf_file.close()
def test_save_and_read_mesh_value_collection(tempdir):
ndiv = 2
filename = os.path.join(tempdir, "mesh_value_collection.h5")
mesh = UnitCubeMesh(MPI.comm_world, ndiv, ndiv, ndiv)
# write to file
with HDF5File(mesh.mpi_comm(), filename, 'w') as f:
for dim in range(mesh.topology.dim):
mvc = MeshValueCollection("size_t", mesh, dim)
mesh.create_entities(dim)
mp = cpp.mesh.midpoints(mesh, dim, range(mesh.num_entities(dim)))
for e in range(mesh.num_entities(dim)):
# this can be easily computed to the check the value
val = int(ndiv * mp[e].sum()) + 1
mvc.set_value(e, val)
f.write(mvc, "/mesh_value_collection_{}".format(dim))
# read from file
with HDF5File(mesh.mpi_comm(), filename, 'r') as f:
for dim in range(mesh.topology.dim):
mvc = f.read_mvc_size_t(mesh,
"/mesh_value_collection_{}".format(dim))
mp = cpp.mesh.midpoints(mesh, dim, range(mesh.num_entities(dim)))
# check the values
for (cell, lidx), val in mvc.values().items():
eidx = MeshEntity(mesh, mesh.topology.dim,
cell).entities(dim)[lidx]
mid = mp[eidx]
assert val == int(ndiv * mid.sum()) + 1
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_save_and_read_mesh_value_collection(tempdir):
ndiv = 2
filename = os.path.join(tempdir, "mesh_value_collection.h5")
mesh = UnitCubeMesh(MPI.comm_world, ndiv, ndiv, ndiv)
def point2list(p):
return [p[0], p[1], p[2]]
# write to file
with HDF5File(mesh.mpi_comm(), filename, 'w') as f:
for dim in range(mesh.topology.dim):
mvc = MeshValueCollection("size_t", mesh, dim)
mesh.create_entities(dim)
for e in MeshEntities(mesh, dim):
# this can be easily computed to the check the value
val = int(ndiv * sum(point2list(e.midpoint()))) + 1
mvc.set_value(e.index(), val)
f.write(mvc, "/mesh_value_collection_{}".format(dim))
# read from file
with HDF5File(mesh.mpi_comm(), filename, 'r') as f:
for dim in range(mesh.topology.dim):
mvc = f.read_mvc_size_t(mesh,
"/mesh_value_collection_{}".format(dim))
# check the values
for (cell, lidx), val in mvc.values().items():
eidx = Cell(mesh, cell).entities(dim)[lidx]
mid = point2list(MeshEntity(mesh, dim, eidx).midpoint())
assert val == int(ndiv * sum(mid)) + 1
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_3D_facet_function(tempdir, encoding, data_type):
dtype_str, dtype = data_type
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4)
mf = MeshFunction(dtype_str, mesh, mesh.topology.dim - 1, 0)
mf.rename("facets")
if (MPI.size(mesh.mpi_comm()) == 1):
for facet in Facets(mesh):
mf[facet] = dtype(facet.index())
else:
for facet in Facets(mesh):
mf[facet] = dtype(facet.global_index())
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 = 0
for facet in Facets(mesh):
diff += (mf_in[facet] - mf[facet])
assert diff == 0
def test_save_and_read_meshfunction_3D(tempdir):
filename = os.path.join(tempdir, "meshfn-3d.h5")
# Write to file
mesh = UnitCubeMesh(MPI.comm_world, 2, 2, 2)
mf_file = HDF5File(mesh.mpi_comm(), filename, "w")
# save meshfuns to compare when reading back
meshfunctions = []
for i in range(0, 4):
mf = MeshFunction('double', mesh, i, 0.0)
mp = cpp.mesh.midpoints(mesh, i, range(mesh.num_entities(i)))
# NB choose a value to set which will be the same on every
# process for each entity
mf.values[:] = mp[:, 0]
meshfunctions.append(mf)
mf_file.write(mf, "/meshfunction/group/%d/meshfun" % i)
mf_file.close()
# Read back from file
mf_file = HDF5File(mesh.mpi_comm(), filename, "r")
for i in range(0, 4):
mf2 = mf_file.read_mf_double(mesh,
"/meshfunction/group/%d/meshfun" % i)
assert numpy.all(meshfunctions[i].values == mf2.values)
mf_file.close()
def test_save_and_read_mesh_3D(tempdir):
filename = os.path.join(tempdir, "mesh3d.h5")
# Write to file
mesh0 = UnitCubeMesh(MPI.comm_world, 10, 10, 10)
mesh_file = HDF5File(mesh0.mpi_comm(), filename, "w")
mesh_file.write(mesh0, "/my_mesh")
mesh_file.close()
# Read from file
mesh_file = HDF5File(mesh0.mpi_comm(), filename, "r")
mesh1 = mesh_file.read_mesh("/my_mesh", False, cpp.mesh.GhostMode.none)
mesh_file.close()
assert mesh0.num_entities_global(0) == mesh1.num_entities_global(0)
dim = mesh0.topology.dim
assert mesh0.num_entities_global(dim) == mesh1.num_entities_global(dim)
# Read from file, and use partition from file
mesh_file = HDF5File(mesh0.mpi_comm(), filename, "r")
mesh2 = mesh_file.read_mesh("/my_mesh", True, cpp.mesh.GhostMode.none)
mesh_file.close()
assert mesh0.num_cells() == mesh2.num_cells()
dim = mesh0.topology.dim
assert mesh0.num_entities_global(dim) == mesh1.num_entities_global(dim)
def test_ghost_3d(mode):
N = 2
num_cells = N * N * N * 6
mesh = UnitCubeMesh(MPI.comm_world, N, N, N, ghost_mode=mode)
if MPI.size(mesh.mpi_comm()) > 1:
assert MPI.sum(mesh.mpi_comm(), mesh.num_cells()) > num_cells
assert mesh.num_entities_global(0) == 27
assert mesh.num_entities_global(3) == num_cells
def test_save_points_3D(tempdir, encoding):
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4)
points = mesh.geometry.points
vals = numpy.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 test_append_and_load_mesh_value_collections(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, 2, 2, 2)
mesh.init()
for d in range(mesh.geometry.dim + 1):
mesh.init_global(d)
mvc_v = MeshValueCollection(dtype_str, mesh, 0)
mvc_v.rename("vertices")
mvc_e = MeshValueCollection(dtype_str, mesh, 1)
mvc_e.rename("edges")
mvc_f = MeshValueCollection(dtype_str, mesh, 2)
mvc_f.rename("facets")
mvc_c = MeshValueCollection(dtype_str, mesh, 3)
mvc_c.rename("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:
for ent in MeshEntities(mesh, mvc.dim):
assert (mvc.set_value(ent.index(), dtype(ent.global_index())))
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 = 0
for ent in MeshEntities(mesh, mf.dim):
diff += (mf_in[ent] - mf[ent])
assert (diff == 0)
def test_compute_first_entity_collision_3d(self):
reference = [876, 877, 878, 879, 880, 881]
p = Point(0.3, 0.3, 0.3)
mesh = UnitCubeMesh(8, 8, 8)
tree = BoundingBoxTree()
tree.build(mesh)
first = tree.compute_first_entity_collision(p)
if MPI.size(mesh.mpi_comm()) == 1:
self.assertIn(first, reference)
tree = mesh.bounding_box_tree()
first = tree.compute_first_entity_collision(p)
if MPI.size(mesh.mpi_comm()) == 1:
self.assertIn(first, reference)
def test_UnitCubeMeshDistributed():
"""Create mesh of unit cube."""
mesh = UnitCubeMesh(MPI.comm_world, 5, 7, 9)
assert mesh.num_entities_global(0) == 480
assert mesh.num_entities_global(3) == 1890
assert mesh.geometry.dim == 3
assert MPI.sum(mesh.mpi_comm(), mesh.topology.ghost_offset(0)) == 480
def test_save_3D_cell_function(tempdir, encoding, data_type):
dtype_str, dtype = data_type
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4)
mf = MeshFunction(dtype_str, mesh, mesh.topology.dim, 0)
mf.name = "cells"
mf.values[:] = numpy.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 numpy.all(diff == 0)
def test_compute_entity_collisions_tree_3d(self):
references = [[set([18, 19, 20, 21, 22, 23, 42, 43, 44, 45, 46, 47]),
set([0, 1, 2, 3, 4, 5, 24, 25, 26, 27, 28, 29])],
[set([7, 8, 30, 31, 32]),
set([15, 16, 17, 39, 41])]]
points = [Point(0.52, 0.51, 0.3), Point(0.9, -0.9, 0.3)]
for i, point in enumerate(points):
mesh_A = UnitCubeMesh(2, 2, 2)
mesh_B = UnitCubeMesh(2, 2, 2)
mesh_B.translate(point)
tree_A = BoundingBoxTree()
tree_A.build(mesh_A)
tree_B = BoundingBoxTree()
tree_B.build(mesh_B)
entities_A, entities_B = tree_A.compute_entity_collisions(tree_B)
if MPI.size(mesh_A.mpi_comm()) == 1:
self.assertEqual(set(entities_A), references[i][0])
self.assertEqual(set(entities_B), references[i][1])
def test_save_3d_tensor(tempdir, encoding):
filename = os.path.join(tempdir, "u3t.xdmf")
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4)
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_append_and_load_mesh_value_collections(tempdir, encoding, data_type):
dtype_str, dtype = data_type
mesh = UnitCubeMesh(MPI.comm_world, 2, 2, 2)
mesh.create_connectivity_all()
for d in range(mesh.geometry.dim + 1):
mesh.create_global_indices(d)
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)
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 numpy.all(diff == 0)
def test_save_points_3D(tempdir, encoding):
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4)
points, values = [], []
for v in Vertices(mesh):
points.append(v.point())
values.append(v.point().norm())
vals = numpy.array(values)
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 test_save_3D_vertex_function(tempdir, encoding, data_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)
mf = MeshFunction(dtype_str, mesh, 0, 0)
mf.values[:] = numpy.arange(mesh.num_entities(0), dtype=dtype)
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(mf)
def test_save_3d_vector(tempdir, encoding):
filename = os.path.join(tempdir, "u_3Dv.xdmf")
mesh = UnitCubeMesh(MPI.comm_world, 2, 2, 2)
u = Function(VectorFunctionSpace(mesh, ("Lagrange", 1)))
A = 1.0 + (1j if has_petsc_complex else 0)
c = Constant((1.0 + A, 2.0 + 2 * A, 3.0 + 3 * A))
u.interpolate(c)
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(u)
def test_save_3D_facet_function(tempdir, encoding, data_type):
dtype_str, dtype = data_type
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4)
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 numpy.all(diff == 0)
def test_save_3d_tensor(tempdir, encoding):
if invalid_config(encoding):
pytest.skip("XDMF unsupported in current configuration")
filename = os.path.join(tempdir, "u3t.xdmf")
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4)
u = Function(TensorFunctionSpace(mesh, "Lagrange", 2))
u.vector()[:] = 1.0
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(u)
def test_mesh_point_3d(self):
"Test mesh-point intersection in 3D"
point = Point(0.1, 0.2, 0.3)
mesh = UnitCubeMesh(8, 8, 8)
intersection = intersect(mesh, point)
if MPI.size(mesh.mpi_comm()) == 1:
self.assertEqual(intersection.intersected_cells(), [816])
def test_mesh_point_3d(self):
"Test mesh-point intersection in 3D"
point = Point(0.1, 0.2, 0.3)
mesh = UnitCubeMesh(8, 8, 8)
intersection = intersect(mesh, point)
if MPI.size(mesh.mpi_comm()) == 1:
self.assertEqual(intersection.intersected_cells(), [816])
def test_compute_first_collision_3d(self):
reference = {1: [1364],
2: [1967, 1968, 1970, 1972, 1974, 1976],
3: [876, 877, 878, 879, 880, 881]}
p = Point(0.3, 0.3, 0.3)
mesh = UnitCubeMesh(8, 8, 8)
for dim in range(1, 4):
tree = BoundingBoxTree()
tree.build(mesh, dim)
first = tree.compute_first_collision(p)
if MPI.size(mesh.mpi_comm()) == 1:
self.assertIn(first, reference[dim])
tree = mesh.bounding_box_tree()
first = tree.compute_first_collision(p)
if MPI.size(mesh.mpi_comm()) == 1:
self.assertIn(first, reference[mesh.topology().dim()])
def test_compute_closest_entity_3d(self):
reference = (0, 0.1)
p = Point(0.1, 0.05, -0.1)
mesh = UnitCubeMesh(8, 8, 8)
tree = BoundingBoxTree()
tree.build(mesh)
entity, distance = tree.compute_closest_entity(p)
if MPI.size(mesh.mpi_comm()) == 1:
self.assertEqual(entity, reference[0])
self.assertAlmostEqual(distance, reference[1])
tree = mesh.bounding_box_tree()
entity, distance = tree.compute_closest_entity(p)
if MPI.size(mesh.mpi_comm()) == 1:
self.assertEqual(entity, reference[0])
self.assertAlmostEqual(distance, reference[1])
def test_save_3D_vertex_function(tempdir, encoding, data_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)
mf = MeshFunction(dtype_str, mesh, 0, 0)
for vertex in Vertices(mesh):
mf[vertex] = dtype(vertex.index())
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(mf)
def test_save_and_load_3d_mesh(tempdir, encoding):
filename = os.path.join(tempdir, "mesh_3D.xdmf")
mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4)
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(mesh)
with XDMFFile(MPI.comm_world, filename) as file:
mesh2 = file.read_mesh(cpp.mesh.GhostMode.none)
assert mesh.num_entities_global(0) == mesh2.num_entities_global(0)
dim = mesh.topology.dim
assert mesh.num_entities_global(dim) == mesh2.num_entities_global(dim)
def test_save_and_read_mesh_value_collection_with_only_one_marked_entity(
tempdir):
ndiv = 2
filename = os.path.join(tempdir, "mesh_value_collection.h5")
mesh = UnitCubeMesh(MPI.comm_world, ndiv, ndiv, ndiv)
mvc = MeshValueCollection("size_t", mesh, 3)
mesh.create_entities(3)
if MPI.rank(mesh.mpi_comm()) == 0:
mvc.set_value(0, 1)
# write to file
with HDF5File(mesh.mpi_comm(), filename, 'w') as f:
f.write(mvc, "/mesh_value_collection")
# read from file
with HDF5File(mesh.mpi_comm(), filename, 'r') as f:
mvc = f.read_mvc_size_t(mesh, "/mesh_value_collection")
assert MPI.sum(mesh.mpi_comm(), mvc.size()) == 1
if MPI.rank(mesh.mpi_comm()) == 0:
assert mvc.get_value(0, 0) == 1
def test_save_3d_vector_series(tempdir, encoding):
filename = os.path.join(tempdir, "u_3D.xdmf")
mesh = UnitCubeMesh(MPI.comm_world, 2, 2, 2)
u = Function(VectorFunctionSpace(mesh, ("Lagrange", 2)))
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
u.vector.set(1.0 + (1j if has_petsc_complex else 0))
file.write(u, 0.1)
u.vector.set(2.0 + (2j if has_petsc_complex else 0))
file.write(u, 0.2)
u.vector.set(3.0 + (3j if has_petsc_complex else 0))
file.write(u, 0.3)
def test_compute_entity_collisions_3d(self):
reference = set([876, 877, 878, 879, 880, 881])
p = Point(0.3, 0.3, 0.3)
mesh = UnitCubeMesh(8, 8, 8)
tree = BoundingBoxTree()
tree.build(mesh)
entities = tree.compute_entity_collisions(p)
if MPI.size(mesh.mpi_comm()) == 1:
self.assertEqual(set(entities), reference)
def test_compute_collisions_point_3d(self):
reference = {1: set([1364]),
2: set([1967, 1968, 1970, 1972, 1974, 1976]),
3: set([876, 877, 878, 879, 880, 881])}
p = Point(0.3, 0.3, 0.3)
mesh = UnitCubeMesh(8, 8, 8)
for dim in range(1, 4):
tree = BoundingBoxTree()
tree.build(mesh, dim)
entities = tree.compute_collisions(p)
if MPI.size(mesh.mpi_comm()) == 1:
self.assertEqual(set(entities), reference[dim])
