def __init__(self, mesh_path=None):
self.global_preprocessing_time = Stopwatch()
self.local_preprocessing_time = Stopwatch()
self.solving_time = Stopwatch()
if mesh_path is not None:
self.PATH = mesh_path
logger.debug('Loading mesh...')
# with XDMFFile(self.PATH + '.xdmf') as fh:
# self._mesh = Mesh()
# fh.read(self._mesh)
#
# with XDMFFile(self.PATH + '_boundaries.xdmf') as fh:
# mvc = MeshValueCollection("size_t", self._mesh, 2)
# fh.read(mvc, "boundaries")
# self._boundaries = cpp.mesh.MeshFunctionSizet(self._mesh, mvc)
#
# with XDMFFile(self.PATH + '_subdomains.xdmf') as fh:
# mvc = MeshValueCollection("size_t", self._mesh, 3)
# fh.read(mvc, "subdomains")
# self._subdomains = cpp.mesh.MeshFunctionSizet(self._mesh, mvc)
self._mesh = Mesh(self.PATH + '.xml')
self._subdomains = MeshFunction("size_t", self._mesh,
self.PATH + '_physical_region.xml')
self._boundaries = MeshFunction("size_t", self._mesh,
self.PATH + '_facet_region.xml')
logger.debug('Done.')
self._degree = None
def __init__(self, x0, y0, z0, R, n):
class SphereSurface(SubDomain):
def inside(self, x, on_boundary):
return on_boundary
class X_Symmetric(SubDomain):
def inside(self, x, on_boundary):
return near(x[0], x0)
class Y_Symmetric(SubDomain):
def inside(self, x, on_boundary):
return near(x[1], y0)
class Z_Symmetric(SubDomain):
def inside(self, x, on_boundary):
return near(x[2], z0)
self.geometry = Sphere(Point(x0, y0, z0), R, segments=n) - Box(Point(x0 + R, y0, z0 - R), Point(x0 - R, y0 - R, z0 + R)) - Box(Point(x0 - R, y0 + R, z0), Point(x0 + R, y0, z0 - R)) - Box(Point(x0, y0, z0), Point(x0 - R, y0 + R, z0 + R))
self.mesh = generate_mesh(self.geometry, n)
self.domains = MeshFunction("size_t", self.mesh, self.mesh.topology().dim())
self.domains.set_all(0)
self.dx = Measure('dx', domain=self.mesh, subdomain_data=self.domains)
self.boundaries = MeshFunction("size_t", self.mesh, self.mesh.topology().dim()-1)
self.boundaries.set_all(0)
self.sphereSurface = SphereSurface()
self.sphereSurface.mark(self.boundaries, 1)
self.x_symmetric = X_Symmetric()
self.x_symmetric.mark(self.boundaries, 2)
self.y_symmetric = Y_Symmetric()
self.y_symmetric.mark(self.boundaries, 3)
self.z_symmetric = Z_Symmetric()
self.z_symmetric.mark(self.boundaries, 4)
self.ds = Measure('ds', domain=self.mesh, subdomain_data=self.boundaries)
self.dS = Measure('dS', domain=self.mesh, subdomain_data=self.boundaries)
def test_meshfunction_where_equal():
mesh = UnitSquareMesh(MPI.comm_self, 2, 2)
cf = MeshFunction("size_t", mesh, mesh.topology.dim, 0)
cf.set_all(1)
cf[0] = 3
cf[3] = 3
assert list(cf.where_equal(3)) == [0, 3]
assert list(cf.where_equal(1)) == [1, 2, 4, 5, 6, 7]
ff = MeshFunction("size_t", mesh, mesh.topology.dim - 1, 100)
ff.set_all(0)
ff[0] = 1
ff[2] = 3
ff[3] = 3
assert list(ff.where_equal(1)) == [0]
assert list(ff.where_equal(3)) == [2, 3]
assert list(ff.where_equal(0)) == [1] + list(range(4, ff.size()))
vf = MeshFunction("size_t", mesh, 0, 0)
vf.set_all(3)
vf[1] = 1
vf[2] = 1
assert list(vf.where_equal(1)) == [1, 2]
assert list(vf.where_equal(3)) == [0] + list(range(3, vf.size()))
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_mesh_function_assign_2D_facets():
mesh = UnitSquareMesh(MPI.comm_world, 3, 3)
mesh.create_entities(1)
tdim = mesh.topology.dim
num_cell_facets = cpp.mesh.cell_num_entities(mesh.cell_type, tdim - 1)
f = MeshFunction("int", mesh, tdim - 1, 25)
connectivity = mesh.topology.connectivity(tdim, tdim - 1)
for c in range(mesh.num_cells()):
facets = connectivity.connections(c)
for i in range(num_cell_facets):
assert 25 == f.values[facets[i]]
g = MeshValueCollection("int", mesh, 1)
g.assign(f)
assert mesh.num_entities(tdim - 1) == len(f.values)
assert mesh.num_cells() * 3 == g.size()
for c in range(mesh.num_cells()):
for i in range(num_cell_facets):
assert 25 == g.get_value(c, i)
f2 = MeshFunction("int", mesh, g, 0)
connectivity = mesh.topology.connectivity(tdim, tdim - 1)
for c in range(mesh.num_cells()):
facets = connectivity.connections(c)
for i in range(num_cell_facets):
assert f2.values[facets[i]] == g.get_value(c, i)
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 c in range(ncells):
f.values[c] = ncells - c
g = MeshValueCollection("int", mesh, 2)
g.assign(f)
assert ncells == len(f.values)
assert ncells == g.size()
f2 = MeshFunction("int", mesh, g, 0)
for c in range(mesh.num_cells()):
value = ncells - c
assert value == g.get_value(c, 0)
assert f2.values[c] == g.get_value(c, 0)
h = MeshValueCollection("int", mesh, 2)
global_indices = mesh.topology.global_indices(2)
ncells_global = mesh.num_entities_global(2)
for c in range(mesh.num_cells()):
if global_indices[c] in [5, 8, 10]:
continue
value = ncells_global - global_indices[c]
h.set_value(c, int(value))
f3 = MeshFunction("int", mesh, h, 0)
values = f3.values
values[values > ncells_global] = 0.
assert MPI.sum(mesh.mpi_comm(), values.sum() * 1.0) == 140.
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 refine_meshes(self, subdomain):
sub1_marker = MeshFunction("bool", self.mesh1,
self.mesh1.topology().dim())
sub2_marker = MeshFunction("bool", self.mesh2,
self.mesh2.topology().dim())
subdomain.mark(sub1_marker, True)
subdomain.mark(sub2_marker, True)
self.mesh1 = refine(self.mesh1, sub1_marker)
self.mesh2 = refine(self.mesh2, sub2_marker)
def read_mesh():
# mesh = Mesh("data/backward_facing_step.xml")
# subdomains = MeshFunction("size_t", mesh, "data/backward_facing_step_physical_region.xml")
# boundaries = MeshFunction("size_t", mesh, "data/backward_facing_step_facet_region.xml")
mesh = Mesh("data/hyperelastic_cube.xml")
subdomains = MeshFunction("size_t", mesh, "data/hyperelastic_cube_physical_region.xml")
boundaries = MeshFunction("size_t", mesh, "data/hyperelastic_cube_facet_region.xml")
restrictions = MeshRestriction(mesh, "data/hyperelastic_cube_interface_restriction.rtc.xml")
return (mesh, subdomains, boundaries, restrictions)
def mesh_generator(n):
mesh = UnitSquareMesh(n, n, "left/right")
dim = mesh.topology().dim()
domains = MeshFunction("size_t", mesh, dim)
domains.set_all(0)
dx = Measure("dx", subdomain_data=domains)
boundaries = MeshFunction("size_t", mesh, dim - 1)
boundaries.set_all(0)
ds = Measure("ds", subdomain_data=boundaries)
return mesh, dx, ds
def read_h5(h5Path):
mesh = Mesh()
hdf = HDF5File(mesh.mpi_comm(), h5Path, 'r')
hdf.read(mesh, '/mesh', False)
subdomains = MeshFunction('size_t', mesh, 3)
boundaries = MeshFunction('size_t', mesh, 2)
hdf.read(subdomains, '/subdomains')
hdf.read(boundaries, '/boundaries')
return mesh, subdomains, boundaries
def show_fenics_mesh(fname):
# boundary layer, quad element is not supported
from dolfin import Mesh, MeshFunction, plot, interactive # TODO: fenicsX may have change API
mesh = Mesh(fname+".xml")
if os.path.exists(fname+"_physical_region.xml"):
subdomains = MeshFunction("size_t", mesh, fname+"_physical_region.xml")
plot(subdomains)
if os.path.exists(fname+"_facet_region.xml"):
boundaries = MeshFunction("size_t", mesh, fname+"_facet_region.xml")
plot(boundaries)
plot(mesh)
interactive() # FIXME: this event loop may conflict with FreeCAD GUI's
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_Create(cube):
"""Create MeshFunctions."""
v = MeshFunction("size_t", cube, 0, 0)
assert v.size() == cube.num_vertices()
v = MeshFunction("size_t", cube, 1, 0)
assert v.size() == cube.num_entities(1)
v = MeshFunction("size_t", cube, 2, 0)
assert v.size() == cube.num_facets()
v = MeshFunction("size_t", cube, 3, 0)
assert v.size() == cube.num_cells()
def _read(self, mesh, filename, encoding=None):
assert filename.endswith(".rtc.xml") or filename.endswith(".rtc.xdmf")
# Read in MeshFunctions
D = mesh.topology().dim()
for d in range(D + 1):
if filename.endswith(".rtc.xml"):
mesh_function_d = MeshFunction("bool", mesh, filename + "/mesh_function_" + str(d) + ".xml")
else:
mesh_function_d = MeshFunction("bool", mesh, d)
xdmf_file = XDMFFile(filename + "/mesh_function_" + str(d) + ".xdmf")
if encoding is not None:
xdmf_file.read(mesh_function_d, encoding)
else:
xdmf_file.read(mesh_function_d)
self.append(mesh_function_d)
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_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_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[:] = numpy.arange(mesh.num_entities(1))
with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file:
file.write(mf)
def test_closed_boundary(advection_scheme):
# FIXME: rk3 scheme does not bounces off the wall properly
xmin, xmax = 0., 1.
ymin, ymax = 0., 1.
mesh = RectangleMesh(Point(xmin, ymin), Point(xmax, ymax), 10, 10)
# Particle
x = np.array([[0.975, 0.475]])
# Given velocity field:
vexpr = Constant((1., 0.))
# Given time do_step:
dt = 0.05
# Then bounced position is
x_bounced = np.array([[0.975, 0.475]])
p = particles(x, [x, x], mesh)
V = VectorFunctionSpace(mesh, "CG", 1)
v = Function(V)
v.assign(vexpr)
# Different boundary parts
bound_left = UnitSquareLeft()
bound_right = UnitSquareRight()
bound_top = UnitSquareTop()
bound_bottom = UnitSquareBottom()
# Mark all facets
facet_marker = MeshFunction('size_t', mesh, mesh.topology().dim() - 1)
facet_marker.set_all(0)
# Mark as closed
bound_right.mark(facet_marker, 1)
# Mark other boundaries as open
bound_left.mark(facet_marker, 2)
bound_top.mark(facet_marker, 2)
bound_bottom.mark(facet_marker, 2)
if advection_scheme == 'euler':
ap = advect_particles(p, V, v, facet_marker)
elif advection_scheme == 'rk2':
ap = advect_rk2(p, V, v, facet_marker)
elif advection_scheme == 'rk3':
ap = advect_rk3(p, V, v, facet_marker)
else:
assert False
# Do one timestep, particle must bounce from wall of
ap.do_step(dt)
xpE = p.positions()
# Check if particle correctly bounced off from closed wall
xpE_root = comm.gather(xpE, root=0)
if comm.rank == 0:
xpE_root = np.float64(np.vstack(xpE_root))
error = np.linalg.norm(x_bounced - xpE_root)
assert(error < 1e-10)
class OCylinderFlowConstant(object):
'Flow past a cylinder in the bend of O shaped turn. Constant force.'
name = 'o-cylinder-constant'
# Forcing
f = Constant((0., 0.))
# Mesh and function marking facets
mesh = Mesh(mesh_path('o-cylinder.xml'))
f_f = MeshFunction('size_t', mesh,
mesh_path('o-cylinder_facet_region.xml'))
# Inflow and Noslip domains to be used for BC construction
inflow = [f_f, 18]
noslip = [f_f, 17]
# Duration
T = 10
# Inflow profile
U_max = 3.5
unit = 0.1 # Basic scaling unit for mesh definition
s = 3 # Arm length of the channel, ALWAYS SYNC THIS VALUE WITH .geo
u_in = InflowProfileConstant(U_max=U_max,
t=0,
unit=unit,
s=s,
K=T,
compute_width=compute_width_O_cylinder)
# Reynolds number
Re = Constant(100)
def convert_meshfunctions_to_submesh(mesh, submesh, meshfunctions_on_mesh):
assert meshfunctions_on_mesh is None or (isinstance(
meshfunctions_on_mesh, list) and len(meshfunctions_on_mesh) > 0)
if meshfunctions_on_mesh is None:
return None
meshfunctions_on_submesh = list()
# Create submesh subdomains
for mesh_subdomain in meshfunctions_on_mesh:
submesh_subdomain = MeshFunction("size_t", submesh,
mesh_subdomain.dim())
submesh_subdomain.set_all(0)
assert submesh_subdomain.dim() in (submesh.topology().dim(),
submesh.topology().dim() - 1)
if submesh_subdomain.dim() == submesh.topology().dim():
for submesh_cell in cells(submesh):
submesh_subdomain.array()[
submesh_cell.index()] = mesh_subdomain.array()[
submesh.submesh_to_mesh_cell_local_indices[
submesh_cell.index()]]
elif submesh_subdomain.dim() == submesh.topology().dim() - 1:
for submesh_facet in facets(submesh):
submesh_subdomain.array()[
submesh_facet.index()] = mesh_subdomain.array()[
submesh.submesh_to_mesh_facet_local_indices[
submesh_facet.index()]]
else: # impossible to arrive here anyway, thanks to the assert
raise TypeError(
"Invalid arguments in convert_meshfunctions_to_submesh.")
meshfunctions_on_submesh.append(submesh_subdomain)
return meshfunctions_on_submesh
def test_convert_diffpack(self):
from dolfin import Mesh, MPI, MeshFunction, mpi_comm_world
if MPI.size(mpi_comm_world()) != 1:
return
fname = os.path.join("data", "diffpack_tet")
dfname = fname + ".xml"
# Read triangle file and convert to a dolfin xml mesh file
meshconvert.diffpack2xml(fname + ".grid", dfname)
# Read in dolfin mesh and check number of cells and vertices
mesh = Mesh(dfname)
self.assertEqual(mesh.num_vertices(), 27)
self.assertEqual(mesh.num_cells(), 48)
self.assertEqual(len(mesh.domains().markers(3)), 48)
self.assertEqual(len(mesh.domains().markers(2)), 16)
mf_basename = dfname.replace(".xml", "_marker_%d.xml")
for marker, num in [(3, 9), (6, 9), (7, 3), (8, 1)]:
mf_name = mf_basename % marker
mf = MeshFunction("size_t", mesh, mf_name)
self.assertEqual(sum(mf.array() == marker), num)
os.unlink(mf_name)
# Clean up
os.unlink(dfname)
def boundaries(mesh):
boundaries = MeshFunction("size_t", mesh, mesh.topology().dim() - 1, 0)
for f in facets(mesh):
boundaries.array()[f.index()] = 0
for v in vertices(f):
boundaries.array()[f.index()] += v.global_index()
return boundaries
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_numpy_access(dtype, mesh):
dtype_str, dtype = dtype
mf = MeshFunction(dtype_str, mesh, 0, 0)
values = mf.values
values[:] = numpy.random.rand(len(values))
assert numpy.all(values == mf.values)
def test_multiple_datasets(tempdir, encoding):
mesh = UnitSquareMesh(MPI.comm_world, 2, 2)
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_convert_diffpack_2d(self):
from dolfin import Mesh, MPI, MeshFunction
fname = os.path.join(os.path.dirname(__file__), "data", "diffpack_tri")
dfname = fname + ".xml"
# Read triangle file and convert to a dolfin xml mesh file
meshconvert.diffpack2xml(fname + ".grid", dfname)
# Read in dolfin mesh and check number of cells and vertices
mesh = Mesh(dfname)
self.assertEqual(mesh.num_vertices(), 41)
self.assertEqual(mesh.num_cells(), 64)
self.assertEqual(len(mesh.domains().markers(2)), 64)
mf_basename = dfname.replace(".xml", "_marker_%d.xml")
for marker, num in [(1, 10), (2, 5), (3, 5)]:
mf_name = mf_basename % marker
mf = MeshFunction("size_t", mesh, mf_name)
self.assertEqual(sum(mf.array() == marker), num)
os.unlink(mf_name)
# Clean up
os.unlink(dfname)
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 convert(msh_file, h5_file):
'''Convert msh file to h5_file'''
root, _ = os.path.splitext(msh_file)
assert os.path.splitext(msh_file)[1] == '.msh'
assert os.path.splitext(h5_file)[1] == '.h5'
# Get the xml mesh
xml_file = '.'.join([root, 'xml'])
subprocess.call(['dolfin-convert %s %s' % (msh_file, xml_file)],
shell=True)
# Success?
assert os.path.exists(xml_file)
mesh = Mesh(xml_file)
out = HDF5File(mesh.mpi_comm(), h5_file, 'w')
out.write(mesh, 'mesh')
for region in ('facet_region.xml', ):
name, _ = region.split('_')
r_xml_file = '_'.join([root, region])
f = MeshFunction('size_t', mesh, r_xml_file)
out.write(f, name)
# Sucess?
assert os.path.exists(h5_file)
return mesh
