def test_balls_intersection():
radius = 1.0
displacement = 0.5
s0 = pygalmesh.Ball([displacement, 0, 0], radius)
s1 = pygalmesh.Ball([-displacement, 0, 0], radius)
u = pygalmesh.Intersection([s0, s1])
a = numpy.sqrt(radius ** 2 - displacement ** 2)
edge_size = 0.1
n = int(2 * numpy.pi * a / edge_size)
circ = [
[0.0, a * numpy.cos(i * 2 * numpy.pi / n), a * numpy.sin(i * 2 * numpy.pi / n)]
for i in range(n)
]
circ.append(circ[0])
mesh = pygalmesh.generate_mesh(
u, feature_edges=[circ], cell_size=0.15, edge_size=edge_size, verbose=False
)
assert abs(max(mesh.points[:, 0]) - (radius - displacement)) < 0.02
assert abs(min(mesh.points[:, 0]) + (radius - displacement)) < 0.02
assert abs(max(mesh.points[:, 1]) - a) < 0.02
assert abs(min(mesh.points[:, 1]) + a) < 0.02
assert abs(max(mesh.points[:, 2]) - a) < 0.02
assert abs(min(mesh.points[:, 2]) + a) < 0.02
vol = sum(helpers.compute_volumes(mesh.points, mesh.cells["tetra"]))
h = radius - displacement
ref_vol = 2 * (h * numpy.pi / 6.0 * (3 * a ** 2 + h ** 2))
assert abs(vol - ref_vol) < 0.1
return
def test_ball_with_sizing_field():
class Field(pygalmesh.SizingFieldBase):
def eval(self, x):
return abs(numpy.sqrt(numpy.dot(x, x)) - 0.5) / 5 + 0.025
mesh = pygalmesh.generate_with_sizing_field(
pygalmesh.Ball([0.0, 0.0, 0.0], 1.0),
facet_angle=30,
facet_size=0.1,
facet_distance=0.025,
cell_radius_edge_ratio=2,
cell_size=Field(),
verbose=False,
)
assert abs(max(mesh.points[:, 0]) - 1.0) < 0.02
assert abs(min(mesh.points[:, 0]) + 1.0) < 0.02
assert abs(max(mesh.points[:, 1]) - 1.0) < 0.02
assert abs(min(mesh.points[:, 1]) + 1.0) < 0.02
assert abs(max(mesh.points[:, 2]) - 1.0) < 0.02
assert abs(min(mesh.points[:, 2]) + 1.0) < 0.02
vol = sum(helpers.compute_volumes(mesh.points, mesh.cells["tetra"]))
assert abs(vol - 4.0 / 3.0 * numpy.pi) < 0.15
return
def test_sphere():
radius = 1.0
s = pygalmesh.Ball([0.0, 0.0, 0.0], radius)
pygalmesh.generate_surface_mesh(s,
'out.off',
angle_bound=30,
radius_bound=0.1,
distance_bound=0.1,
verbose=False)
vertices, cells, _, _, _ = meshio.read('out.off')
tol = 1.0e-2
assert abs(max(vertices[:, 0]) - radius) < tol
assert abs(min(vertices[:, 0]) + radius) < tol
assert abs(max(vertices[:, 1]) - radius) < tol
assert abs(min(vertices[:, 1]) + radius) < tol
assert abs(max(vertices[:, 2]) - radius) < tol
assert abs(min(vertices[:, 2]) + radius) < tol
areas = compute_triangle_areas(vertices, cells['triangle'])
surface_area = sum(areas)
assert abs(surface_area - 4 * numpy.pi * radius**2) < 0.1
return
def test_sphere():
radius = 1.0
s = pygalmesh.Ball([0.0, 0.0, 0.0], radius)
pygalmesh.generate_surface_mesh(
s,
"out.off",
angle_bound=30,
radius_bound=0.1,
distance_bound=0.1,
verbose=False,
)
mesh = meshio.read("out.off")
tol = 1.0e-2
assert abs(max(mesh.points[:, 0]) - radius) < tol
assert abs(min(mesh.points[:, 0]) + radius) < tol
assert abs(max(mesh.points[:, 1]) - radius) < tol
assert abs(min(mesh.points[:, 1]) + radius) < tol
assert abs(max(mesh.points[:, 2]) - radius) < tol
assert abs(min(mesh.points[:, 2]) + radius) < tol
areas = compute_triangle_areas(mesh.points, mesh.cells["triangle"])
surface_area = sum(areas)
assert abs(surface_area - 4 * numpy.pi * radius**2) < 0.1
return
def test_balls_difference():
radius = 1.0
displacement = 0.5
s0 = pygalmesh.Ball([displacement, 0, 0], radius)
s1 = pygalmesh.Ball([-displacement, 0, 0], radius)
u = pygalmesh.Difference(s0, s1)
a = numpy.sqrt(radius**2 - displacement**2)
edge_size = 0.15
n = int(2 * numpy.pi * a / edge_size)
circ = [[
0.0, a * numpy.cos(i * 2 * numpy.pi / n),
a * numpy.sin(i * 2 * numpy.pi / n)
] for i in range(n)]
circ.append(circ[0])
pygalmesh.generate_mesh(
u,
"out.mesh",
feature_edges=[circ],
cell_size=0.15,
edge_size=edge_size,
facet_angle=25,
facet_size=0.15,
cell_radius_edge_ratio=2.0,
verbose=False,
)
mesh = meshio.read("out.mesh")
tol = 0.02
assert abs(max(mesh.points[:, 0]) - (radius + displacement)) < tol
assert abs(min(mesh.points[:, 0]) - 0.0) < tol
assert abs(max(mesh.points[:, 1]) - radius) < tol
assert abs(min(mesh.points[:, 1]) + radius) < tol
assert abs(max(mesh.points[:, 2]) - radius) < tol
assert abs(min(mesh.points[:, 2]) + radius) < tol
vol = sum(compute_volumes(mesh.points, mesh.cells["tetra"]))
h = radius - displacement
ref_vol = 4.0 / 3.0 * numpy.pi * radius**3 - 2 * h * numpy.pi / 6.0 * (
3 * a**2 + h**2)
assert abs(vol - ref_vol) < 0.05
return
def test_balls_union():
radius = 1.0
displacement = 0.5
s0 = pygalmesh.Ball([displacement, 0, 0], radius)
s1 = pygalmesh.Ball([-displacement, 0, 0], radius)
u = pygalmesh.Union([s0, s1])
a = numpy.sqrt(radius**2 - displacement**2)
edge_size = 0.1
n = int(2 * numpy.pi * a / edge_size)
circ = [[
0.0, a * numpy.cos(i * 2 * numpy.pi / n),
a * numpy.sin(i * 2 * numpy.pi / n)
] for i in range(n)]
circ.append(circ[0])
pygalmesh.generate_mesh(u,
'out.mesh',
feature_edges=[circ],
cell_size=0.15,
edge_size=edge_size,
verbose=False)
vertices, cells, _, _, _ = meshio.read('out.mesh')
assert abs(max(vertices[:, 0]) - (radius + displacement)) < 0.02
assert abs(min(vertices[:, 0]) + (radius + displacement)) < 0.02
assert abs(max(vertices[:, 1]) - radius) < 0.02
assert abs(min(vertices[:, 1]) + radius) < 0.02
assert abs(max(vertices[:, 2]) - radius) < 0.02
assert abs(min(vertices[:, 2]) + radius) < 0.02
vol = sum(compute_volumes(vertices, cells['tetra']))
h = radius - displacement
ref_vol = 2 * (4.0 / 3.0 * numpy.pi * radius**3 - h * numpy.pi / 6.0 *
(3 * a**2 + h**2))
assert abs(vol - ref_vol) < 0.1
return
def test_ball():
s = pygalmesh.Ball([0.0, 0.0, 0.0], 1.0)
mesh = pygalmesh.generate_mesh(s, cell_size=0.2, verbose=False)
assert abs(max(mesh.points[:, 0]) - 1.0) < 0.02
assert abs(min(mesh.points[:, 0]) + 1.0) < 0.02
assert abs(max(mesh.points[:, 1]) - 1.0) < 0.02
assert abs(min(mesh.points[:, 1]) + 1.0) < 0.02
assert abs(max(mesh.points[:, 2]) - 1.0) < 0.02
assert abs(min(mesh.points[:, 2]) + 1.0) < 0.02
vol = sum(helpers.compute_volumes(mesh.points, mesh.cells["tetra"]))
assert abs(vol - 4.0 / 3.0 * numpy.pi) < 0.15
return
def generate_tetrahedral_mesh():
"""Generates a fairly large mesh."""
if pathlib.Path.is_file("cache.xdmf"):
mesh = meshio.read("cache.xdmf")
else:
import pygalmesh
s = pygalmesh.Ball([0, 0, 0], 1.0)
mesh = pygalmesh.generate_mesh(s, cell_size=2.0e-2, verbose=True)
# mesh = pygalmesh.generate_mesh(s, cell_size=1.0e-1, verbose=True)
mesh.cells = {"tetra": mesh.cells["tetra"]}
mesh.point_data = []
mesh.cell_data = {"tetra": {}}
mesh.write("cache.xdmf")
return mesh
def test_ball():
s = pygalmesh.Ball([0.0, 0.0, 0.0], 1.0)
pygalmesh.generate_mesh(s, 'out.mesh', cell_size=0.2, verbose=False)
vertices, cells, _, _, _ = meshio.read('out.mesh')
assert abs(max(vertices[:, 0]) - 1.0) < 0.02
assert abs(min(vertices[:, 0]) + 1.0) < 0.02
assert abs(max(vertices[:, 1]) - 1.0) < 0.02
assert abs(min(vertices[:, 1]) + 1.0) < 0.02
assert abs(max(vertices[:, 2]) - 1.0) < 0.02
assert abs(min(vertices[:, 2]) + 1.0) < 0.02
vol = sum(compute_volumes(vertices, cells['tetra']))
assert abs(vol - 4.0 / 3.0 * numpy.pi) < 0.15
return
def generate_mesh():
"""Generates a fairly large mesh.
"""
# import meshzoo
# points, cells = meshzoo.rectangle(nx=300, ny=300)
# return meshio.Mesh(points, {"triangle": cells})
if os.path.isfile("cache.xdmf"):
mesh = meshio.read("cache.xdmf")
else:
s = pygalmesh.Ball([0, 0, 0], 1.0)
mesh = pygalmesh.generate_mesh(s, cell_size=2.0e-2, verbose=True)
# mesh = pygalmesh.generate_mesh(s, cell_size=1.0e-1, verbose=True)
mesh.cells = {"tetra": mesh.cells["tetra"]}
mesh.point_data = []
mesh.cell_data = {"tetra": {}}
mesh.write("cache.xdmf")
print(mesh)
return mesh
def test_sphere():
radius = 1.0
s = pygalmesh.Ball([0.0, 0.0, 0.0], radius)
mesh = pygalmesh.generate_surface_mesh(s,
angle_bound=30,
radius_bound=0.1,
distance_bound=0.1,
verbose=False)
tol = 1.0e-2
assert abs(max(mesh.points[:, 0]) - radius) < tol
assert abs(min(mesh.points[:, 0]) + radius) < tol
assert abs(max(mesh.points[:, 1]) - radius) < tol
assert abs(min(mesh.points[:, 1]) + radius) < tol
assert abs(max(mesh.points[:, 2]) - radius) < tol
assert abs(min(mesh.points[:, 2]) + radius) < tol
areas = helpers.compute_triangle_areas(mesh.points,
mesh.get_cells_type("triangle"))
surface_area = sum(areas)
assert abs(surface_area - 4 * numpy.pi * radius**2) < 0.1
def run_cgal(HMIN=0.025):
t1 = time.time()
mesh = pygalmesh.generate_mesh(
pygalmesh.Ball([0.0, 0.0, 0.0], 1.0),
cell_size=lambda x: abs(numpy.sqrt(numpy.dot(x, x)) - 0.5) / 5 + HMIN,
facet_angle=30,
cell_radius_edge_ratio=2.0,
)
elapsed = time.time() - t1
# mesh.write("cgal_sphere.vtk")
plex = meshplex.MeshTetra(mesh.points, mesh.cells[1][1])
angles = plex.q_min_sin_dihedral_angles
quality = plex.q_radius_ratio
num_cells = len(mesh.cells[1][1])
num_vertices = len(mesh.points)
return angles, quality, elapsed, num_vertices, num_cells
def ball(h):
s = pygalmesh.Ball([0, 0, 0], 1.0)
# The circumradius of a regular tetrahedron with the given edge_size is sqrt(3 / 8)
# * edge_size ~= 0.61 * edge_size. Relax it a bit and just use h.
mesh = pygalmesh.generate_mesh(s, max_cell_circumradius=h, verbose=False)
return mesh.points, mesh.get_cells_type("tetra")
def sphere(h):
s = pygalmesh.Ball([0, 0, 0], 1.0)
mesh = pygalmesh.generate_surface_mesh(
s, max_radius_surface_delaunay_ball=h, verbose=False
)
return mesh.points, mesh.get_cells_type("triangle")
import os
import matplotlib.pyplot as plt
import numpy
import pygalmesh
s = pygalmesh.Ball([0, 0, 0], 1.0)
mesh = pygalmesh.generate_mesh(s, cell_size=3.0e-2, verbose=True)
mesh.cells = {"tetra": mesh.cells["tetra"]}
mesh.point_data = {}
mesh.cell_data = {}
print("num points: {}".format(mesh.points.shape[0]))
formats = {
"vtu": ".vtu",
"vtk": ".vtk",
"gmsh": ".msh",
"abaqus": ".inp",
# "ansys": ".ans",
"cgns": ".cgns",
"dolfin-xml": ".xml",
"mdpa": ".mdpa",
"med": ".med",
"medit": ".mesh",
"moab": ".h5m",
# "obj": ".obj",
# "ply": ".ply",
# "stl": ".stl",
"nastran": ".bdf",
# "off": ".off",
