def msh_to_xdmf2D(file, path):
msh = meshio.read(path + "/" + file)
line_cells = []
triangle_cells = []
line_data = []
triangle_data = []
for cell in msh.cells:
if cell.type == "line":
if len(line_cells) == 0:
line_cells = cell.data
else:
line_cells = np.vstack([line_cells, cell.data])
elif cell.type == "triangle":
if len(triangle_cells) == 0:
triangle_cells = cell.data
else:
triangle_cells = np.vstack([triangle_cells, cell.data])
for key in msh.cell_data_dict["gmsh:physical"].keys():
if key == "line":
line_data = msh.cell_data_dict["gmsh:physical"][key]
elif key == "triangle":
triangle_data = msh.cell_data_dict["gmsh:physical"][key]
triangle_mesh = meshio.Mesh(points=msh.points,
cells={"triangle": triangle_cells},
cell_data={"name_to_read": [triangle_data]})
line_mesh = meshio.Mesh(points=msh.points,
cells={"line": line_cells},
cell_data={"name_to_read": [line_data]})
meshio.write(path + "/" + "mesh.xdmf", triangle_mesh)
meshio.write(path + "/" + "subdomains.xdmf", line_mesh)
def test_information_xdmf():
mesh_out = meshio.Mesh(
numpy.array([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 1.0, 0.0],
[0.0, 1.0, 0.0]]) / 3,
[("triangle", numpy.array([[0, 1, 2], [0, 2, 3]]))],
field_data={
"bottom": numpy.array([1, 1]),
"right": numpy.array([2, 1]),
"top": numpy.array([3, 1]),
"left": numpy.array([4, 1]),
},
)
# write the data
points, cells, field_data = mesh_out.points, mesh_out.cells, mesh_out.field_data
assert cells[0].type == "triangle"
meshio.write(
"mesh.xdmf",
meshio.Mesh(points=points, cells=[cells[0]], field_data=field_data),
)
# read it back in
mesh_in = meshio.read("mesh.xdmf")
assert len(mesh_in.field_data) == len(mesh_out.field_data)
def generate_sphere(R, res):
geo = geooc()
from numpy import pi
#cylinder = geo.add_cylinder([0,0,R], [0,L,0], R, char_length=res)
#box = geo.add_box([-R,-0.1*L,R], [2.1*R,1.2*L,1.1*R], char_length=res)
#diff = geo.boolean_difference([cylinder], [box])
# Uniform refinement of points
# geo.add_raw_code("pts_bo1[] = PointsOf{Volume{bo1};};")
# geo.add_raw_code("Characteristic Length{pts_bo1[]} ="+"{0};".format(res))
box = geo.add_box([-R,-R,R], [2*R,2*R, 1.1*R])
sphere = geo.add_ball([0,0,R],R)
diff = geo.boolean_difference([sphere], [box])
geo.add_raw_code("Physical Surface(2) = {2};")
geo.add_raw_code("Physical Surface(1) = {1};")
# Minimum field at line of contact
geo.add_raw_code("Point(25) = {0,0,0};")
geo.add_raw_code("Field[1] = Distance; Field[1].NodesList = {25};")
geo.add_raw_code("Field[2] = Threshold; Field[2].IField=1; Field[2].LcMin = {0}; Field[2].LcMax = {1}; Field[2].DistMin={2}; Field[2].DistMax={3};".format(res, 5*res, 0.3*R, 0.6*R)) #5
geo.add_raw_code("Field[3] = Min; Field[3].FieldsList = {2};")
geo.add_raw_code("Background Field = 2;")
geo.add_physical(diff, label="1")
gmesh = generate_mesh(geo, geo_filename='mesh/sphere.geo')
points, cells = gmesh.points, gmesh.cells
meshio.write("mesh/mesh_" + str(i) + ".xdmf", meshio.Mesh(points=gmesh.points, cells={"tetra": gmesh.cells["tetra"]}))
meshio.write("mesh/mf_" + str(i) + ".xdmf", meshio.Mesh(points=gmesh.points, cells={"triangle": gmesh.cells["triangle"]},
cell_data={"triangle": {"name_to_read": gmesh.cell_data["triangle"]["gmsh:physical"]}}))
def convert_msh_to_xdmf(filepath):
import meshio
msh = meshio.read(filepath)
for cell in msh.cells:
if cell.type == "triangle":
triangle_cells = cell.data
elif cell.type == "line":
line_cells = cell.data
for key in msh.cell_data_dict["gmsh:physical"].keys():
if key == "line":
line_data = msh.cell_data_dict["gmsh:physical"][key]
elif key == "triangle":
triangle_data = msh.cell_data_dict["gmsh:physical"][key]
triangle_mesh = meshio.Mesh(points=msh.points,
cells={"triangle": triangle_cells},
cell_data={"subdomains": [triangle_data]})
line_mesh = meshio.Mesh(points=msh.points,
cells={"line": line_cells},
cell_data={"boundary_conditions": [line_data]})
meshio.write("%s_triangle.xdmf" % filepath.split('.')[0], triangle_mesh)
meshio.write("%s_line.xdmf" % filepath.split('.')[0], line_mesh)
print("successfully saved in:" + filepath.split('.')[0])
def background_mesh(res=0.025):
"""
Create rectangular background mesh for the Poisson problem
"""
geometry = Geometry()
rectangle = geometry.add_rectangle(0, L, 0, H, 0, res)
geometry.add_physical_surface(rectangle.surface, label=12)
geometry.add_physical_line(rectangle.line_loop.lines, label=outer_marker)
(points, cells, point_data, cell_data,
field_data) = generate_mesh(geometry, prune_z_0=True)
meshio.write(
"meshes/multimesh_0.xdmf",
meshio.Mesh(points=points, cells={"triangle": cells["triangle"]}))
meshio.write(
"meshes/mf_0.xdmf",
meshio.Mesh(points=points,
cells={"line": cells["line"]},
cell_data={
"line": {
"name_to_read": cell_data["line"]["gmsh:physical"]
}
}))
def front_mesh_wedge(res=0.025):
"""
Creates a wedged mesh with symmetry line through y = c_y
"""
geometry = Geometry()
mesh_r = width_scale*res
c = geometry.add_point((c_x,c_y,0))
# Elliptic obstacle
y_fac = 1
r_ =0.7
p1 = geometry.add_point((c_x-r_x, c_y,0),lcar=res/2)
pt1 = geometry.add_point((c_x-r_*r_x,c_y+y_fac*r_x,0),lcar=res/2)
pt2 = geometry.add_point((c_x+r_*r_x,c_y+y_fac*r_x,0),lcar=res/2)
pb1 = geometry.add_point((c_x-r_*r_x, c_y-y_fac*r_x,0),lcar=res/2)
pb2 = geometry.add_point((c_x+r_*r_x, c_y-y_fac*r_x,0),lcar=res/2)
p2 = geometry.add_point((c_x+r_x, c_y,0),lcar=res/2)
# embed()
arc_1 = geometry.add_bspline([p1, pt1,pt2, p2])
arc_2 = geometry.add_bspline([p2, pb2,pb1, p1])
# Surrounding mesh
p3 = geometry.add_point((c_x-r_x-mesh_r, c_y,0),lcar=res)
p4 = geometry.add_point((c_x+r_x+mesh_r, c_y,0),lcar=res)
pt_1 = geometry.add_point((c_x-r_*r_x*y_fac, c_y+y_fac*r_x+mesh_r,0),
lcar=res)
pt_2 = geometry.add_point((c_x+r_*r_x*y_fac, c_y+y_fac*r_x+mesh_r,0)
,lcar=res)
pb_1 = geometry.add_point((c_x-r_*r_x*y_fac, c_y-y_fac*r_x-mesh_r,0),
lcar=res)
pb_2 = geometry.add_point((c_x+r_*r_x*y_fac, c_y-y_fac*r_x-mesh_r,0),
lcar=res)
arc_5 = geometry.add_bspline([p3, pt_1, pt_2, p4])
arc_6 = geometry.add_bspline([p4, pb_2, pb_1, p3])
obstacle_loop = geometry.add_line_loop([arc_1, arc_2])
outer_loop = geometry.add_line_loop([arc_5,arc_6])
donut = geometry.add_plane_surface(obstacle_loop, holes = [outer_loop])
geometry.add_physical_surface([donut],label=12)
geometry.add_physical_line(obstacle_loop.lines, label=inner_marker)
geometry.add_physical_line(outer_loop.lines, label=outer_marker)
# Generate mesh
(points, cells, point_data,
cell_data, field_data) = generate_mesh(geometry, prune_z_0=True,
geo_filename="meshes/test.geo")
# Save mesh and mesh-function to file
meshio.write("multimesh_1.xdmf", meshio.Mesh(
points=points, cells={"triangle": cells["triangle"]}))
meshio.write("mf_1.xdmf", meshio.Mesh(
points=points, cells={"line": cells["line"]},
cell_data={"line": {"name_to_read":
cell_data["line"]["gmsh:physical"]}}))
import os
os.system("mv multimesh_1.* meshes/")
os.system("mv mf_1.* meshes/")
def front_mesh(res=0.025):
geometry = Geometry()
c = geometry.add_point((c_x, c_y, 0))
mesh_r = 5 * res # Width of mesh
# Elliptic obstacle
p1 = geometry.add_point((c_x - r_x, c_y, 0))
p2 = geometry.add_point((c_x, c_y + r_y, 0))
p3 = geometry.add_point((c_x + r_x, c_y, 0))
p4 = geometry.add_point((c_x, c_y - r_y, 0))
arc_1 = geometry.add_ellipse_arc(p1, c, p2, p2)
arc_2 = geometry.add_ellipse_arc(p2, c, p3, p3)
arc_3 = geometry.add_ellipse_arc(p3, c, p4, p4)
arc_4 = geometry.add_ellipse_arc(p4, c, p1, p1)
obstacle_loop = geometry.add_line_loop([arc_1, arc_2, arc_3, arc_4])
# Surrounding mesh
p1 = geometry.add_point((c_x - r_x - mesh_r, c_y, 0))
p2 = geometry.add_point((c_x, c_y + r_y + mesh_r, 0))
p3 = geometry.add_point((c_x + r_x + mesh_r, c_y, 0))
p4 = geometry.add_point((c_x, c_y - r_y - mesh_r, 0))
arc_5 = geometry.add_ellipse_arc(p1, c, p2, p2)
arc_6 = geometry.add_ellipse_arc(p2, c, p3, p3)
arc_7 = geometry.add_ellipse_arc(p3, c, p4, p4)
arc_8 = geometry.add_ellipse_arc(p4, c, p1, p1)
loop = geometry.add_line_loop([arc_5, arc_6, arc_7, arc_8])
mesh = geometry.add_plane_surface(loop, holes=[obstacle_loop])
geometry.add_physical_surface(mesh, label=12)
geometry.add_physical_line(loop.lines, label=outer_marker)
geometry.add_physical_line(obstacle_loop.lines, label=inner_marker)
# Create refined mesh around geometry
field = geometry.add_boundary_layer(edges_list=obstacle_loop.lines,
hfar=res,
hwall_n=res / 2,
thickness=2 * res)
geometry.add_background_field([field])
# Generate mesh
(points, cells, point_data, cell_data,
field_data) = generate_mesh(geometry,
prune_z_0=True,
geo_filename="meshes/test.geo")
# Save mesh and mesh-function to file
meshio.write(
"meshes/multimesh_1.xdmf",
meshio.Mesh(points=points, cells={"triangle": cells["triangle"]}))
meshio.write(
"meshes/mf_1.xdmf",
meshio.Mesh(points=points,
cells={"line": cells["line"]},
cell_data={
"line": {
"name_to_read": cell_data["line"]["gmsh:physical"]
}
}))
def single_mesh(res=0.025):
"""
Creates a single mesh containing a circular obstacle
"""
geometry = Geometry()
c = geometry.add_point((c_x, c_y, 0))
# Elliptic obstacle
p1 = geometry.add_point((c_x - r_x, c_y, 0))
p2 = geometry.add_point((c_x, c_y + r_x, 0))
p3 = geometry.add_point((c_x + r_x, c_y, 0))
p4 = geometry.add_point((c_x, c_y - r_x, 0))
arc_1 = geometry.add_ellipse_arc(p1, c, p2, p2)
arc_2 = geometry.add_ellipse_arc(p2, c, p3, p3)
arc_3 = geometry.add_ellipse_arc(p3, c, p4, p4)
arc_4 = geometry.add_ellipse_arc(p4, c, p1, p1)
obstacle_loop = geometry.add_line_loop([arc_1, arc_2, arc_3, arc_4])
rectangle = geometry.add_rectangle(0,
L,
0,
H,
0,
res,
holes=[obstacle_loop])
flow_list = [rectangle.line_loop.lines[3]]
obstacle_list = obstacle_loop.lines
walls_list = [rectangle.line_loop.lines[0], rectangle.line_loop.lines[2]]
geometry.add_physical_surface(rectangle.surface, label=12)
geometry.add_physical_line(flow_list, label=inflow)
geometry.add_physical_line(walls_list, label=walls)
geometry.add_physical_line([rectangle.line_loop.lines[1]], label=outflow)
geometry.add_physical_line(obstacle_list, label=obstacle)
field = geometry.add_boundary_layer(edges_list=obstacle_loop.lines,
hfar=res,
hwall_n=res / 8,
thickness=res / 2)
geometry.add_background_field([field])
(points, cells, point_data, cell_data,
field_data) = generate_mesh(geometry,
prune_z_0=True,
geo_filename="test.geo")
meshio.write(
"mesh.xdmf",
meshio.Mesh(points=points, cells={"triangle": cells["triangle"]}))
meshio.write(
"mf.xdmf",
meshio.Mesh(points=points,
cells={"line": cells["line"]},
cell_data={
"line": {
"name_to_read": cell_data["line"]["gmsh:physical"]
}
}))
def front_mesh_symmetric(res=0.025):
"""
Creates a donut mesh with symmetry line through y = c_y
"""
geometry = Geometry()
mesh_r = width_scale*res
c = geometry.add_point((c_x,c_y,0))
# Elliptic obstacle
p1 = geometry.add_point((c_x-r_x, c_y,0))
p2 = geometry.add_point((c_x+r_x, c_y,0))
# embed()
arc_1 = geometry.add_circle_arc(p1, c, p2)
arc_2 = geometry.add_circle_arc(p2, c, p1)
# Surrounding mesh
p3 = geometry.add_point((c_x-r_x-mesh_r, c_y,0))
p4 = geometry.add_point((c_x+r_x+mesh_r, c_y,0))
arc_5 = geometry.add_circle_arc(p3, c, p4)
arc_6 = geometry.add_circle_arc(p4, c, p3)
line_front = geometry.add_line(p3, p1)
line_back = geometry.add_line(p2, p4)
surface_top = geometry.add_line_loop([line_front, arc_1, line_back, -arc_5])
surface_bottom = geometry.add_line_loop([line_front, -arc_2, line_back,
arc_6])
obstacle_loop = geometry.add_line_loop([arc_1, arc_2])
outer_loop = geometry.add_line_loop([arc_5,arc_6])
top = geometry.add_plane_surface(surface_top)
bottom = geometry.add_plane_surface(surface_bottom)
geometry.add_physical_surface([top, bottom],label=12)
geometry.add_physical_line(obstacle_loop.lines, label=inner_marker)
geometry.add_physical_line(outer_loop.lines, label=outer_marker)
# Create refined mesh around geometry
field = geometry.add_boundary_layer(edges_list=obstacle_loop.lines,
hfar=res, hwall_n=res/3,
thickness=0.1*mesh_r)
geometry.add_background_field([field])
# Generate mesh
(points, cells, point_data,
cell_data, field_data) = generate_mesh(geometry, prune_z_0=True,
geo_filename="meshes/test.geo")
# Save mesh and mesh-function to file
meshio.write("multimesh_1.xdmf", meshio.Mesh(
points=points, cells={"triangle": cells["triangle"]}))
meshio.write("mf_1.xdmf", meshio.Mesh(
points=points, cells={"line": cells["line"]},
cell_data={"line": {"name_to_read":
cell_data["line"]["gmsh:physical"]}}))
import os
os.system("mv multimesh_1.* meshes/")
os.system("mv mf_1.* meshes/")
def single_mesh(res=0.025):
"""
Create rectangular background mesh for the Poisson problem
"""
geometry = Geometry()
c = geometry.add_point((c_x, c_y, 0))
mesh_r = 5 * res # Width of mesh
# Elliptic obstacle
p1 = geometry.add_point((c_x - r_x, c_y, 0))
p2 = geometry.add_point((c_x, c_y + r_y, 0))
p3 = geometry.add_point((c_x + r_x, c_y, 0))
p4 = geometry.add_point((c_x, c_y - r_y, 0))
arc_1 = geometry.add_ellipse_arc(p1, c, p2, p2)
arc_2 = geometry.add_ellipse_arc(p2, c, p3, p3)
arc_3 = geometry.add_ellipse_arc(p3, c, p4, p4)
arc_4 = geometry.add_ellipse_arc(p4, c, p1, p1)
obstacle_loop = geometry.add_line_loop([arc_1, arc_2, arc_3, arc_4])
# Surrounding mesh
rectangle = geometry.add_rectangle(0,
L,
0,
H,
0,
res,
holes=[obstacle_loop])
geometry.add_physical_surface(rectangle.surface, label=12)
geometry.add_physical_line(obstacle_loop.lines, label=inner_marker)
geometry.add_physical_line(rectangle.line_loop.lines, label=outer_marker)
# Create refined mesh around geometry
field = geometry.add_boundary_layer(edges_list=obstacle_loop.lines,
hfar=res,
hwall_n=res / 2,
thickness=2 * res)
geometry.add_background_field([field])
# Generate mesh
(points, cells, point_data, cell_data,
field_data) = generate_mesh(geometry,
prune_z_0=True,
geo_filename="meshes/test_single.geo")
# Save mesh and mesh-function to file
meshio.write(
"meshes/singlemesh.xdmf",
meshio.Mesh(points=points, cells={"triangle": cells["triangle"]}))
meshio.write(
"meshes/mf.xdmf",
meshio.Mesh(points=points,
cells={"line": cells["line"]},
cell_data={
"line": {
"name_to_read": cell_data["line"]["gmsh:physical"]
}
}))
def background_mesh(res=0.025):
"""
Create rectangular background mesh for the Poisson problem
"""
geo = Geometry()
# Create points for square with two inlets and one outlet
points = []
points.append(geo.add_point((0, 0, 0), res))
points.append(geo.add_point((1, 0, 0), res))
points.append(geo.add_point((1, 1, 0), res))
points.append(geo.add_point(outlet[1], res))
points.append(geo.add_point(outlet[0], res))
points.append(geo.add_point((0, 1, 0), res))
points.append(geo.add_point(inlet1[1], res))
points.append(geo.add_point(inlet1[0], res))
points.append(geo.add_point(inlet0[1], res))
points.append(geo.add_point(inlet0[0], res))
# Connect points as lines
lines = []
for i in range(len(points) - 1):
lines.append(geo.add_line(points[i], points[i + 1]))
lines.append(geo.add_line(points[-1], points[0]))
# Create geometry
line_loop = geo.add_line_loop(lines)
square = geo.add_plane_surface(line_loop)
# Create cell and facet function
wall_lines = lines[0:3] + lines[4:6] + [lines[7]] + [lines[9]]
inlet0_lines = [lines[8]]
inlet1_lines = [lines[6]]
outlet_lines = [lines[3]]
geo.add_physical_surface([square], label=12)
geo.add_physical_line(inlet0_lines, label=inlet0_marker)
geo.add_physical_line(inlet1_lines, label=inlet1_marker)
geo.add_physical_line(outlet_lines, label=outlet_marker)
geo.add_physical_line(wall_lines, label=wall_marker)
# Create mesh
(points, cells, point_data, cell_data,
field_data) = generate_mesh(geo, prune_z_0=True) #,
#geo_filename="meshes/tmp.geo")
meshio.write(
"meshes/multimesh_0.xdmf",
meshio.Mesh(points=points, cells={"triangle": cells["triangle"]}))
meshio.write(
"meshes/mf_0.xdmf",
meshio.Mesh(points=points,
cells={"line": cells["line"]},
cell_data={
"line": {
"name_to_read": cell_data["line"]["gmsh:physical"]
}
}))
def Generate_PBRpygmsh(xlim,
ylim,
f_ids,
meszf=0.003,
folder='pygmeshio_data'):
# meszf = mesh element size factor
# rectangle geometry
xmin, xmax = xlim
ymin, ymax = ylim
WAid, INid = f_ids # Wall and inlet boundaries ids.
# Pygmsh files
pygmsh_geo = os.path.join(folder, "PBR.geo")
pygmsh_msh = os.path.join(folder, "PBR.msh")
pygmsh_mesh = os.path.join(folder, "PBR_mesh.xdmf")
pygmsh_facets = os.path.join(folder, "PBR_facets.xdmf")
geom = pygmsh.built_in.Geometry()
rect = geom.add_rectangle(xmin, xmax, ymin, ymax, 0.0, lcar=meszf)
geom.add_physical([rect.line_loop.lines[0]], 10)
geom.add_physical([rect.line_loop.lines[1]], 11)
geom.add_physical([rect.line_loop.lines[2]], WAid) # Wall boundary
geom.add_physical([rect.line_loop.lines[3]], INid) # Inlet boundary
geom.add_physical([rect.surface], 20)
mesh = pygmsh.generate_mesh(geom,
dim=2,
prune_z_0=True,
geo_filename=pygmsh_geo,
msh_filename=pygmsh_msh)
cells = np.vstack(
np.array(
[cells.data for cells in mesh.cells if cells.type == "triangle"]))
triangle_mesh = meshio.Mesh(points=mesh.points,
cells=[("triangle", cells)])
facet_cells = np.vstack(
np.array([cells.data for cells in mesh.cells if cells.type == "line"]))
facet_data = mesh.cell_data_dict["gmsh:physical"]["line"]
facet_mesh = meshio.Mesh(points=mesh.points,
cells=[("line", facet_cells)],
cell_data={"name_to_read": [facet_data]})
# Write mesh
meshio.xdmf.write(pygmsh_mesh, triangle_mesh)
meshio.xdmf.write(pygmsh_facets, facet_mesh)
return pygmsh_mesh, pygmsh_facets
def front_mesh_unsym(res=0.025):
"""
Creates unsymmetric donut mesh
"""
geometry = Geometry()
mesh_r = width_scale*res
c = geometry.add_point((c_x,c_y,0))
# Elliptic obstacle
p1 = geometry.add_point((c_x-r_x, c_y,0),lcar=res/2)
p2 = geometry.add_point((c_x+r_x, c_y,0),lcar=res/2)
arc_1 = geometry.add_circle_arc(p1, c, p2)
arc_2 = geometry.add_circle_arc(p2, c, p1)
# Surrounding mesh
p3 = geometry.add_point((c_x-r_x-mesh_r, c_y,0),lcar=res)
p4 = geometry.add_point((c_x+r_x+mesh_r, c_y,0),lcar=res)
arc_5 = geometry.add_circle_arc(p3, c, p4)
arc_6 = geometry.add_circle_arc(p4, c, p3)
obstacle_loop = geometry.add_line_loop([arc_1, arc_2])
outer_loop = geometry.add_line_loop([arc_5,arc_6])
donut = geometry.add_plane_surface(obstacle_loop, holes=[outer_loop])
geometry.add_physical_surface([donut],label=12)
geometry.add_physical_line(obstacle_loop.lines, label=inner_marker)
geometry.add_physical_line(outer_loop.lines, label=outer_marker)
# Create refined mesh around geometry
# field = geometry.add_boundary_layer(edges_list=obstacle_loop.lines,
# hfar=res, hwall_n=res/3,
# thickness=2*res)
# geometry.add_background_field([field])
# Generate mesh
(points, cells, point_data,
cell_data, field_data) = generate_mesh(geometry, prune_z_0=True,
geo_filename="meshes/test.geo")
# Save mesh and mesh-function to file
meshio.write("meshes/multimesh_1.xdmf", meshio.Mesh(
points=points, cells={"triangle": cells["triangle"]}))
meshio.write("meshes/mf_1.xdmf", meshio.Mesh(
points=points, cells={"line": cells["line"]},
cell_data={"line": {"name_to_read":
cell_data["line"]["gmsh:physical"]}}))
def single_mesh(res=0.025):
geometry = Geometry()
c = geometry.add_point((c_x, c_y, 0))
# Elliptic obstacle
p1 = geometry.add_point((c_x - r_x, c_y, 0))
p2 = geometry.add_point((c_x, c_y + r_y, 0))
p3 = geometry.add_point((c_x + r_x, c_y, 0))
p4 = geometry.add_point((c_x, c_y - r_y, 0))
arc_1 = geometry.add_ellipse_arc(p1, c, p2, p2)
arc_2 = geometry.add_ellipse_arc(p2, c, p3, p3)
arc_3 = geometry.add_ellipse_arc(p3, c, p4, p4)
arc_4 = geometry.add_ellipse_arc(p4, c, p1, p1)
obstacle_loop = geometry.add_line_loop([arc_1, arc_2, arc_3, arc_4])
rectangle = geometry.add_rectangle(0,
L,
0,
H,
0,
res,
holes=[obstacle_loop])
geometry.add_physical_surface(rectangle.surface, label=12)
geometry.add_physical_line(obstacle_loop.lines, label=inner_marker)
geometry.add_physical_line(rectangle.line_loop.lines, label=outer_marker)
field = geometry.add_boundary_layer(edges_list=obstacle_loop.lines,
hfar=res,
hwall_n=res / 2,
thickness=2 * res)
geometry.add_background_field([field])
(points, cells, point_data, cell_data,
field_data) = generate_mesh(geometry, prune_z_0=True)
meshio.write(
"meshes/singlemesh.xdmf",
meshio.Mesh(points=points, cells={"triangle": cells["triangle"]}))
meshio.write(
"meshes/mf.xdmf",
meshio.Mesh(points=points,
cells={"line": cells["line"]},
cell_data={
"line": {
"name_to_read": cell_data["line"]["gmsh:physical"]
}
}))
def save(self,
filename: str,
point_data: Optional[Dict[str, ndarray]] = None,
cell_data: Optional[Dict[str, ndarray]] = None) -> None:
"""Export the mesh and fields using meshio.
Parameters
----------
filename
The output filename, with suffix determining format;
e.g. .msh, .vtk, .xdmf
point_data
Data related to the vertices of the mesh.
cell_data
Data related to the elements of the mesh.
"""
import meshio
if point_data is not None:
if not isinstance(point_data, dict):
raise ValueError("point_data should be "
"a dictionary of ndarrays.")
if cell_data is not None:
if not isinstance(point_data, dict):
raise ValueError("cell_data should be "
"a dictionary of ndarrays.")
cells = {self.meshio_type: self.t.T}
mesh = meshio.Mesh(self.p.T, cells, point_data, cell_data)
meshio.write(filename, mesh)
def toSTL(self, stlname, **kwargs):
"""save surface shape a stl file using meshio
Parameters:
stlname -- string, the filename you want to save, final name is 'stlname.vts'
kwargs -- optional keyword arguments used for self.plot3d.
Returns:
mesh: Mesh object in meshio
"""
import meshio
kwargs.setdefault("npol", 120)
kwargs.setdefault("ntor", 180)
_xx, _yy, _zz, _nn = self.plot3d("noplot", **kwargs)
npol = kwargs["npol"]
ntor = kwargs["ntor"]
points = np.ascontiguousarray(
np.transpose([_xx.ravel(), _yy.ravel(),
_zz.ravel()]))
con = []
for i in range(npol - 1):
for j in range(ntor - 1):
ij = i * ntor + j
con.append([ij, ij + 1, ij + ntor + 1])
con.append([ij, ij + ntor, ij + ntor + 1])
cells = [("triangle", np.array(con))]
mesh = meshio.Mesh(points, cells)
mesh.write(stlname)
return mesh
def plot_results_over_line(model, data, lines=(-0.5, 0, 0.5), ndata=5, save_name=""):
device = 'cpu'
model = model.to(device)
model.load_state_dict(torch.load("models/model" + save_name + ".pth", map_location=device))
model.eval()
with torch.no_grad():
for i, d in enumerate(data):
if i > ndata:
break
d = d.to(device=device)
pred = model(d)
pred = pred.numpy()[:, 0]
gt = d.y.numpy()[:, 0]
cells = d.face.numpy()
points = d.x.numpy()
points[:, 2] = 0.
mesh = meshio.Mesh(points=points, cells=[("triangle", cells.T)])
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
for line in lines:
plot_mesh_onto_line(mesh, val=pred, x=line)
plot_mesh_onto_line(mesh, val=gt, x=line, linestyle="--")
plt.subplot(1, 2, 2)
for line in lines:
plot_mesh_onto_line(mesh, val=pred, y=line)
plot_mesh_onto_line(mesh, val=gt, y=line, linestyle="--")
plt.show()
def convert_vtk_mesh_to_meshio(vtk_mesh):
mesh_vtu_wrapped = dsa.WrapDataObject(vtk_mesh)
points = np.array(mesh_vtu_wrapped.GetPoints())
cells = np.array(mesh_vtu_wrapped.GetCells())
vtk_cell_type = np.unique(mesh_vtu_wrapped.GetCellTypes())[0]
if vtk_cell_type == 5:
mio_cell_type = 'triangle'
n_cell_comp = 3
elif vtk_cell_type == 10:
mio_cell_type = 'tetrahedron'
n_cell_comp = 4
n_cells = len(cells)
cells_reshaped = cells.reshape(
(int(n_cells / (n_cell_comp + 1)), n_cell_comp + 1))
cells_reshaped = cells_reshaped[:, 1:]
mio_cells = {mio_cell_type: cells_reshaped}
mio_points = points
mio_cell_data = {}
for cell_data_name in mesh_vtu_wrapped.CellData.keys():
data = mesh_vtu_wrapped.CellData.GetArray(cell_data_name)
mio_cell_data['ElementBlockIds'] = data
mio_mesh = mio.Mesh(mio_points, mio_cells)
if len(mio_cell_data) > 0:
mio_mesh.cell_data[mio_cell_type] = mio_cell_data
return mio_mesh
def test(lcar=1.0):
lbw = [2, 3, 5]
geom = pygmsh.built_in.Geometry()
points = [geom.add_point([x, 0.0, 0.0], lcar) for x in [0.0, lbw[0]]]
line = geom.add_line(*points)
_, rectangle, _ = geom.extrude(line,
translation_axis=[0.0, lbw[1], 0.0],
num_layers=lbw[1],
recombine=True)
geom.extrude(
rectangle,
translation_axis=[0.0, 0.0, lbw[2]],
num_layers=lbw[2],
recombine=True,
)
# compute_volume only supports 3D for tetras, but does return
# surface area for quads
ref = sum(l * w for l, w in permutations(lbw, 2)) # surface area
mesh = pygmsh.generate_mesh(geom, prune_vertices=False)
# TODO compute hex volumes
assert (abs(
compute_volume(
meshio.Mesh(mesh.points, {"quad": mesh.cells_dict["quad"]})) - ref)
< 1.0e-2 * ref)
return mesh
def test_square_circle_slice():
"""Test planar suface square with circular hole.
Also test for surface area of fragments.
"""
with pygmsh.occ.Geometry() as geom:
square = square_loop(geom)
curve_loop = circle_loop(geom)
surf1 = geom.add_plane_surface(square)
surf2 = geom.add_plane_surface(curve_loop)
geom.boolean_fragments(surf1, surf2)
# Gmsh 4 default format MSH4 doesn't have geometrical entities.
mesh = geom.generate_mesh()
ref = 1.0
val = compute_volume(mesh)
assert np.abs(val - ref) < 1e-3 * ref
outer_mask = np.where(mesh.cell_data["gmsh:geometrical"][2] == 13)[0]
outer_cells = {}
outer_cells["triangle"] = mesh.cells_dict["triangle"][outer_mask]
inner_mask = np.where(mesh.cell_data["gmsh:geometrical"][2] == 12)[0]
inner_cells = {}
inner_cells["triangle"] = mesh.cells_dict["triangle"][inner_mask]
ref = 1 - 0.1**2 * np.pi
value = compute_volume(meshio.Mesh(mesh.points, outer_cells))
assert np.abs(value - ref) < 1e-2 * ref
def test_fragments_diff_union():
"""Test planar surface with holes.
Construct it with boolean operations and verify that it is the same.
"""
# construct surface using boolean
geo_object = pygmsh.opencascade.Geometry(0.04, 0.04)
geo_object, square = square_loop(geo_object)
geo_object, line_loop = circle_loop(geo_object)
surf1 = geo_object.add_plane_surface(square)
surf2 = geo_object.add_plane_surface(line_loop)
geo_object.add_physical([surf1], label=1)
geo_object.add_physical([surf2], label=2)
surf_diff = geo_object.boolean_difference([surf1], [surf2],
delete_other=False)
geo_object.boolean_union([surf_diff, surf2])
mesh = pygmsh.generate_mesh(geo_object)
assert np.abs((compute_volume(mesh) - 1) / 1) < 1e-3
surf = 1 - 0.1**2 * np.pi
outer_mask = np.where(
mesh.cell_data_dict["gmsh:physical"]["triangle"] == 1)[0]
outer_cells = {}
outer_cells["triangle"] = mesh.cells_dict["triangle"][outer_mask]
inner_mask = np.where(
mesh.cell_data_dict["gmsh:physical"]["triangle"] == 2)[0]
inner_cells = {}
inner_cells["triangle"] = mesh.cells_dict["triangle"][inner_mask]
value = compute_volume(meshio.Mesh(mesh.points, outer_cells))
assert np.abs(value - surf) < 1e-2 * surf
def save(
self,
filename: str,
point_data: Optional[Union[ndarray, Dict[str, ndarray]]] = None,
cell_data: Optional[Union[ndarray, Dict[str,
ndarray]]] = None) -> None:
"""Export the mesh and fields using meshio.
Parameters
----------
filename
The filename for vtk-file.
point_data
Data related to the vertices of the mesh. Numpy array for one
output, or dict for multiple.
cell_data
Data related to the elements of the mesh. Numpy array for one
output, or dict for multiple
"""
import meshio
if point_data is not None:
if not isinstance(point_data, dict):
point_data = {'0': point_data}
if cell_data is not None:
if not isinstance(point_data, dict):
cell_data = {'0': cell_data}
cells = {self.meshio_type: self.t.T}
mesh = meshio.Mesh(self.p.T, cells, point_data, cell_data)
meshio.write(filename, mesh)
def save(self,
filename: str,
point_data: Optional[Dict[str, ndarray]] = None,
cell_data: Optional[Dict[str, ndarray]] = None):
"""Export the mesh and fields using meshio. (Hexahedron version.)
Parameters
----------
filename
The filename for vtk-file.
point_data
ndarray for one output or dict for multiple
cell_data
ndarray for one output or dict for multiple
"""
import meshio
# vtk requires a different ordering
t = self.t[[0, 3, 6, 2, 1, 5, 7, 4], :]
if point_data is not None:
if not isinstance(point_data, dict):
raise ValueError("point_data should be "
"a dictionary of ndarrays.")
if cell_data is not None:
if not isinstance(point_data, dict):
raise ValueError("cell_data should be "
"a dictionary of ndarrays.")
cells = {'hexahedron': t.T}
mesh = meshio.Mesh(self.p.T, cells, point_data, cell_data)
meshio.write(filename, mesh)
def to_meshio(self):
"""
Convert mesh to :class:`meshio.Mesh`.
Returns
-------
meshio.Mesh
Output mesh.
"""
keys = ["points", "point_data", "field_data"]
kwargs = {key: getattr(self, key) for key in keys}
version = get_meshio_version()
cell_data = {k: self.split(v) for k, v in self.cell_data.items()}
if version[0] >= 4:
kwargs.update({
"cells": self.cells,
"cell_data": cell_data,
"point_sets": self.point_sets,
"cell_sets": self.cell_sets,
})
else:
cells, cell_data = get_old_meshio_cells(self.cells, cell_data)
kwargs.update({
"cells": cells,
"cell_data": cell_data,
"node_sets": self.point_sets,
})
return meshio.Mesh(**kwargs)
def main():
if len(sys.argv) != 4:
print(f'Usage: {sys.argv[0]} [inputFile] [resultFile] [outFile]')
exit()
inputFile, resultFile, outFile = sys.argv[1:]
# read TLC data
input_dict = read_TLC_input(inputFile)
result_dict = read_TLC_result(resultFile)
# compute TLC result mesh
pts = result_dict["resV"]
nV, nDim = pts.shape
if nDim < 3: # pad to 3D points
pts = np.pad(pts,((0,0),(0,3-nDim)))
raw_cells = input_dict["cells"]
nF, simplex_size = raw_cells.shape
if simplex_size == 3: # tri
cells = [ ("triangle", raw_cells)]
else: # tet
cells = [ ("tetra", raw_cells) ]
resMesh = meshio.Mesh(pts, cells)
# write result mesh to file
meshio.write(outFile, resMesh)
def test_elset():
points = np.array(
[[1.0, 0.0, 0.0], [1.0, 1.0, 0.0], [2.0, 0.5, 0.0], [0.0, 0.5, 0.0]]
)
cells = [
("triangle", np.array([[0, 1, 2]])),
("triangle", np.array([[0, 1, 3]])),
]
cell_sets = {
"right": [np.array([0]), np.array([])],
"left": [np.array([]), np.array([1])],
}
mesh_ref = meshio.Mesh(points, cells, cell_sets=cell_sets)
with tempfile.TemporaryDirectory() as temp_dir:
filepath = pathlib.Path(temp_dir) / "test.inp"
meshio.abaqus.write(filepath, mesh_ref)
mesh = meshio.abaqus.read(filepath)
assert np.allclose(mesh_ref.points, mesh.points)
assert len(mesh_ref.cells) == len(mesh.cells)
for ic, cell in enumerate(mesh_ref.cells):
assert cell.type == mesh.cells[ic].type
assert np.allclose(cell.data, mesh.cells[ic].data)
assert sorted(mesh_ref.cell_sets.keys()) == sorted(mesh.cell_sets.keys())
for k, v in mesh_ref.cell_sets.items():
for ic in range(len(mesh_ref.cells)):
assert np.allclose(v[ic], mesh.cell_sets[k][ic])
def test_square_circle_slice():
"""Test planar suface square with circular hole.
Also test for surface area of fragments.
"""
geo_object = built_in_opencascade_geos_fragments()
# Gmsh 4 default format MSH4 doesn't have geometrical entities.
mesh = pygmsh.generate_mesh(geo_object,
extra_gmsh_arguments=["-format", "msh2"])
ref = 1
val = compute_volume(mesh)
assert np.abs(val - ref) < 1e-3 * ref
outer_mask = np.where(mesh.cell_data["gmsh:geometrical"][2] == 13)[0]
outer_cells = {}
outer_cells["triangle"] = mesh.cells_dict["triangle"][outer_mask]
inner_mask = np.where(mesh.cell_data["gmsh:geometrical"][2] == 12)[0]
inner_cells = {}
inner_cells["triangle"] = mesh.cells_dict["triangle"][inner_mask]
ref = 1 - 0.1**2 * np.pi
value = compute_volume(meshio.Mesh(mesh.points, outer_cells))
assert np.abs(value - ref) < 1e-2 * ref
return
def gosplElev(coords, cells, elev, gmesh, visvtk=False):
Gmesh = meshplex.MeshTri(coords, cells)
s = Gmesh.idx_hierarchy.shape
a = np.sort(Gmesh.idx_hierarchy.reshape(s[0], -1).T)
if meshplex.__version__ >= "0.16.0":
Gmesh.edges = {"points": np.unique(a, axis=0)}
ngbNbs, ngbID = definegtin(len(coords), Gmesh.cells("points"),
Gmesh.edges["points"])
elif meshplex.__version__ >= "0.14.0":
Gmesh.edges = {"points": np.unique(a, axis=0)}
ngbNbs, ngbID = definegtin(len(coords), Gmesh.cells["points"],
Gmesh.edges["points"])
else:
Gmesh.edges = {"nodes": np.unique(a, axis=0)}
ngbNbs, ngbID = definegtin(len(coords), Gmesh.cells["nodes"],
Gmesh.edges["nodes"])
np.savez_compressed(gmesh,
v=coords,
c=cells,
n=ngbID[:, :8].astype(int),
z=elev)
if visvtk:
paleovtk = gmesh + ".vtk"
vis_mesh = meshio.Mesh(coords, {"triangle": cells},
point_data={"z": elev})
meshio.write(paleovtk, vis_mesh)
print("Writing VTK file {}".format(paleovtk))
return
def _write(self, fields: Iterable[Field], file_name: str, meshio_geom) -> None:
cell_data = {}
# we need to split the data for each group of geometrically uniform cells
cell_id = meshio_geom[2]
num_block = cell_id.size
for field in fields:
if field.values is None:
continue
# for each field create a sub-vector for each geometrically uniform group of cells
cell_data[field.name] = np.empty(num_block, dtype=object)
# fill up the data
for block, ids in enumerate(cell_id):
if field.values.ndim == 1:
cell_data[field.name][block] = field.values[ids]
elif field.values.ndim == 2:
cell_data[field.name][block] = field.values[:, ids].T
else:
raise ValueError
# add also the cells ids
cell_data.update({self.cell_id_key: cell_id})
# create the meshio object
meshio_grid_to_export = meshio.Mesh(
meshio_geom[0], meshio_geom[1], cell_data=cell_data
)
meshio.write(file_name, meshio_grid_to_export, binary=self.binary)
def test_fragments_diff_union():
"""Test planar surface with holes.
Construct it with boolean operations and verify that it is the same.
"""
# construct surface using boolean
with pygmsh.occ.Geometry() as geom:
geom.characteristic_length_min = 0.04
geom.characteristic_length_max = 0.04
square = square_loop(geom)
surf1 = geom.add_plane_surface(square)
curve_loop = circle_loop(geom)
surf2 = geom.add_plane_surface(curve_loop)
geom.add_physical([surf1], label="1")
geom.add_physical([surf2], label="2")
geom.boolean_difference(surf1, surf2, delete_other=False)
mesh = geom.generate_mesh()
ref = 1.0
assert np.abs(compute_volume(mesh) - ref) < 1e-3 * ref
surf = 1 - 0.1**2 * np.pi
outer_mask = np.where(
mesh.cell_data_dict["gmsh:geometrical"]["triangle"] == 1)[0]
outer_cells = {}
outer_cells["triangle"] = mesh.cells_dict["triangle"][outer_mask]
inner_mask = np.where(
mesh.cell_data_dict["gmsh:geometrical"]["triangle"] == 2)[0]
inner_cells = {}
inner_cells["triangle"] = mesh.cells_dict["triangle"][inner_mask]
value = compute_volume(meshio.Mesh(mesh.points, outer_cells))
assert np.abs(value - surf) < 1e-2 * surf
