def add_reinforcement(self, shape, mat_id, **kwargs):
"""Add reinforcement in a circle (for now), confine concrete inside if needed"""
if shape == 'circle':
if 'conf_id' in kwargs:
reinforcement_builder = GeometryBuilder()
reinforcement_builder.add_geometry(
*make_circle(kwargs['D'] /
2, kwargs['c'], kwargs['count']))
r = ReinforcementProperties(reinforcement_builder.points,
kwargs['bar'], mat_id)
self.reinforcement.append(r)
# Add points for confinement into mesh
self.builder.add_geometry(*make_circle(kwargs['D'] /
2, kwargs['c']))
self.ele_mat_primitive.append(
(kwargs['D'] / 2, kwargs['c'], kwargs['conf_id']))
else:
reinforcement_builder = GeometryBuilder()
reinforcement_builder.add_geometry(
*make_circle(kwargs['D'] /
2, kwargs['c'], kwargs['count']))
r = ReinforcementProperties(reinforcement_builder.points,
kwargs['bar'], mat_id)
self.reinforcement.append(r)
else:
# Rectangular reinforcement
# not implemented for now
print("I can only currently add type='circle' reinforcement")
exit()
def ball(h):
from meshpy.geometry import (
EXT_OPEN,
GeometryBuilder,
generate_surface_of_revolution,
)
from meshpy.tet import MeshInfo, build
r = 3
polar_subdivision = int(math.pi / h)
dphi = math.pi / polar_subdivision
def truncate(val):
return 0 if abs(val) < 1e-10 else val
rz = [
[truncate(r * math.sin(i * dphi)), r * math.cos(i * dphi)]
for i in range(polar_subdivision + 1)
]
geob = GeometryBuilder()
radial_subdivision = int(2 * math.pi / h)
geob.add_geometry(
*generate_surface_of_revolution(
rz, closure=EXT_OPEN, radial_subdiv=radial_subdivision
)
)
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh = build(mesh_info)
return numpy.array(mesh.points), numpy.array(mesh.elements)
def create_ball_mesh(num_longi_points=10):
radius = 5.0
radial_subdiv = 2 * num_longi_points
dphi = np.pi / num_longi_points
# Make sure the nodes meet at the poles of the ball.
def truncate(r):
if abs(r) < 1e-10:
return 0
else:
return r
# Compute the volume of a canonical tetrahedron
# with edgelength radius*dphi.
a = radius * dphi
canonical_tet_volume = np.sqrt(2.0) / 12 * a**3
# Build outline for surface of revolution.
rz = [(truncate(radius * np.sin(i * dphi)), radius * np.cos(i * dphi))
for i in range(num_longi_points + 1)]
geob = GeometryBuilder()
geob.add_geometry(*generate_surface_of_revolution(
rz, closure=EXT_OPEN, radial_subdiv=radial_subdiv))
mesh_info = MeshInfo()
geob.set(mesh_info)
meshpy_mesh = build(mesh_info, max_volume=canonical_tet_volume)
return np.array(meshpy_mesh.points), np.array(meshpy_mesh.elements)
def main():
from math import pi, cos, sin
from meshpy.tet import MeshInfo, build
from meshpy.geometry import (
generate_surface_of_revolution,
EXT_OPEN,
GeometryBuilder,
)
r = 3
points = 10
dphi = pi / points
def truncate(r):
if abs(r) < 1e-10:
return 0
else:
return r
rz = [(truncate(r * sin(i * dphi)), r * cos(i * dphi))
for i in range(points + 1)]
geob = GeometryBuilder()
geob.add_geometry(*generate_surface_of_revolution(
rz, closure=EXT_OPEN, radial_subdiv=10))
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh = build(mesh_info)
mesh.write_vtk("ball.vtk")
def create_mesh(big_r=1.0, small_r=0.5, num_points=10):
dphi = 2 * np.pi / num_points
# Compute the volume of a canonical tetrahedron
# with edgelength radius2*dphi.
a = small_r * dphi
canonical_tet_volume = np.sqrt(2.0) / 12 * a ** 3
radial_subdiv = int(2 * np.pi * big_r / a)
rz = [
(big_r + small_r * np.cos(i * dphi), 0.5 * small_r * np.sin(i * dphi))
for i in range(num_points)
]
geob = GeometryBuilder()
geob.add_geometry(
*generate_surface_of_revolution(
rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=radial_subdiv
)
)
mesh_info = MeshInfo()
geob.set(mesh_info)
meshpy_mesh = build(mesh_info, max_volume=canonical_tet_volume)
return np.array(meshpy_mesh.points), np.array(meshpy_mesh.elements)
def main():
from math import pi, cos, sin
from meshpy.tet import MeshInfo, build
from meshpy.geometry import \
generate_surface_of_revolution, EXT_OPEN, \
GeometryBuilder
r = 1
l = 1
rz = [(0, 0), (r, 0), (r, l), (0, l)]
geob = GeometryBuilder()
geob.add_geometry(*generate_surface_of_revolution(
rz, radial_subdiv=20, ring_markers=[1, 2, 3]))
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh = build(mesh_info, max_volume=0.01)
mesh.write_vtk("cylinder.vtk")
mesh.write_neu(file("cylinder.neu", "w"), {
1: ("minus_z", 1),
2: ("outer", 2),
3: ("plus_z", 3),
})
def main():
from math import pi, cos, sin
from meshpy.tet import MeshInfo, build
from meshpy.geometry import (
generate_surface_of_revolution,
EXT_CLOSED_IN_RZ,
GeometryBuilder,
)
big_r = 3
little_r = 2.9
points = 50
dphi = 2 * pi / points
rz = [(big_r + little_r * cos(i * dphi), little_r * sin(i * dphi))
for i in range(points)]
geob = GeometryBuilder()
geob.add_geometry(*generate_surface_of_revolution(
rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=20))
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh_info.save_nodes("torus")
mesh_info.save_poly("torus")
mesh = build(mesh_info)
mesh.write_vtk("torus.vtk")
mesh.save_elements("torus_mesh")
mesh.save_nodes("torus_mesh")
mesh.write_neu(open("torus.neu", "w"), {1: ("pec", 0)})
def __init__(self, figsize=6):
# Material Properties
self.materials = {}
# Mesh Properties
self.builder = GeometryBuilder()
self.reinforcement = []
self.outer_facets = []
self.mesh_areas = {}
self.mesh_centroids = {}
self.mesh = None
# Data structure to assign material ids after mesh generation
self.ele_mat_primitive = []
self.ele_mat = {}
# Load step Data
self.load_angle = 0
self.phi_list = []
self.M_list = []
# States of all elements at each load step from analysis
self.state_id = 0
self.states = {}
self.state_y_loc = {}
self.analysis_model = FiberModel()
# Failure check for end of analysis (conf crush/ bar fracture)
self.fail = False
# Plot settings
self.figsize = figsize
def make_mesh(a, b, pml_width=0.25, **kwargs):
from meshpy.geometry import GeometryBuilder, make_circle
geob = GeometryBuilder()
circle_centers = [(-1.5, 0), (1.5, 0)]
for cent in circle_centers:
geob.add_geometry(*make_circle(1, cent))
geob.wrap_in_box(1)
geob.wrap_in_box(pml_width)
mesh_mod = geob.mesher_module()
mi = mesh_mod.MeshInfo()
geob.set(mi)
mi.set_holes(circle_centers)
built_mi = mesh_mod.build(mi, **kwargs)
def boundary_tagger(fvi, el, fn, points):
return []
from hedge.mesh import make_conformal_mesh_ext
from hedge.mesh.element import Triangle
pts = np.asarray(built_mi.points, dtype=np.float64)
return make_conformal_mesh_ext(
pts, [Triangle(i, el, pts) for i, el in enumerate(built_mi.elements)],
boundary_tagger)
def test_tet_mesh(visualize=False):
pytest.importorskip("meshpy")
from math import pi, cos, sin
from meshpy.tet import MeshInfo, build
from meshpy.geometry import \
GeometryBuilder, generate_surface_of_revolution, EXT_CLOSED_IN_RZ
pytest.importorskip("meshpy")
big_r = 3
little_r = 1.5
points = 50
dphi = 2 * pi / points
rz = np.array(
[[big_r + little_r * cos(i * dphi), little_r * sin(i * dphi)]
for i in range(points)])
geo = GeometryBuilder()
geo.add_geometry(*generate_surface_of_revolution(
rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=20))
mesh_info = MeshInfo()
geo.set(mesh_info)
mesh = build(mesh_info)
def tet_face_vertices(vertices):
return [
(vertices[0], vertices[1], vertices[2]),
(vertices[0], vertices[1], vertices[3]),
(vertices[0], vertices[2], vertices[3]),
(vertices[1], vertices[2], vertices[3]),
]
face_map = {}
for el_id, el in enumerate(mesh.elements):
for fid, face_vertices in enumerate(tet_face_vertices(el)):
face_map.setdefault(frozenset(face_vertices), []).append(
(el_id, fid))
adjacency = {}
for face_vertices, els_faces in face_map.items():
if len(els_faces) == 2:
(e1, f1), (e2, f2) = els_faces
adjacency.setdefault(e1, []).append(e2)
adjacency.setdefault(e2, []).append(e1)
cuts, part_vert = pymetis.part_graph(17, adjacency)
if visualize:
import pyvtk
vtkelements = pyvtk.VtkData(
pyvtk.UnstructuredGrid(mesh.points, tetra=mesh.elements), "Mesh",
pyvtk.CellData(pyvtk.Scalars(part_vert, name="partition")))
vtkelements.tofile('split.vtk')
def main():
import numpy
from math import pi, cos, sin
from meshpy.tet import MeshInfo, build
from meshpy.geometry import GeometryBuilder, Marker, \
generate_extrusion, make_box
from meshpy.naca import generate_naca
geob = GeometryBuilder()
box_marker = Marker.FIRST_USER_MARKER
wing_length = 2
wing_subdiv = 5
rz_points = [
(0, -wing_length * 1.05),
(0.7, -wing_length * 1.05),
] + [(r, x) for x, r in zip(
numpy.linspace(-wing_length, 0, wing_subdiv, endpoint=False),
numpy.linspace(0.8, 1, wing_subdiv, endpoint=False))] + [(1, 0)] + [
(r, x) for x, r in zip(
numpy.linspace(wing_length, 0, wing_subdiv, endpoint=False),
numpy.linspace(0.8, 1, wing_subdiv, endpoint=False))
][::-1] + [(0.7, wing_length * 1.05), (0, wing_length * 1.05)]
geob.add_geometry(*generate_extrusion(
rz_points=rz_points,
base_shape=generate_naca("0012", verbose=False, number_of_points=20),
ring_markers=(wing_subdiv * 2 + 4) * [box_marker]))
from meshpy.tools import make_swizzle_matrix
swizzle_matrix = make_swizzle_matrix("z:x,y:y,x:z")
geob.apply_transform(lambda p: numpy.dot(swizzle_matrix, p))
def deform_wing(p):
x, y, z = p
return numpy.array([
x, y + 0.1 * abs(x / wing_length)**2,
z + 0.8 * abs(x / wing_length)**1.2
])
geob.apply_transform(deform_wing)
points, facets, _, facet_markers = make_box(
numpy.array([-wing_length - 1, -1, -1.5]),
numpy.array([wing_length + 1, 1, 3]))
geob.add_geometry(points, facets, facet_markers=facet_markers)
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh_info.set_holes([(0, 0, 0.5)])
mesh = build(mesh_info)
print "%d elements" % len(mesh.elements)
mesh.write_vtk("airfoil3d.vtk")
def make_mesh(max_volume):
def round_trip_connect(seq):
result = []
for i in range(len(seq)):
result.append((i, (i+1)%len(seq)))
return result
shapes = read_shape()
#from matplotlib.pyplot import plot,show
#plot(shapes[0][:,0], shapes[0][:,1])
#show()
from meshpy.geometry import GeometryBuilder, Marker
builder = GeometryBuilder()
for shape in shapes:
from meshpy.geometry import make_box
points = shape
facets = round_trip_connect(range(len(points)))
builder.add_geometry(points=points, facets=facets,
facet_markers=Marker.FIRST_USER_MARKER)
points, facets, facet_markers = make_box((-200, -600), (400, -300))
builder.add_geometry(points=points, facets=facets,
facet_markers=facet_markers)
def transform(pt):
x, y = pt
return -0.01*x, -0.01*y
builder.apply_transform(transform)
from meshpy.triangle import MeshInfo, build
mi = MeshInfo()
builder.set(mi)
holes = []
for shape, sign, frac in zip(shapes, [1, 1, -1, 1, 1, 1], [0.5, 0, 0, 0, 0, 0]):
avg = np.average(shape, axis=0)
start_idx = int(frac*shape.shape[0])
start = shape[start_idx]
holes.append(transform(start + sign*0.01*(avg-start)))
mi.set_holes(holes)
mesh = build(mi,
allow_boundary_steiner=True,
generate_faces=True,
max_volume=max_volume)
return mesh
def main():
from ply import parse_ply
import sys
data = parse_ply(sys.argv[1])
from meshpy.geometry import GeometryBuilder
builder = GeometryBuilder()
builder.add_geometry(points=[pt[:3] for pt in data["vertex"].data],
facets=[fd[0] for fd in data["face"].data])
builder.wrap_in_box(1)
from meshpy.tet import MeshInfo, build
mi = MeshInfo()
builder.set(mi)
mi.set_holes([builder.center()])
mesh = build(mi)
print("%d elements" % len(mesh.elements))
mesh.write_vtk("out.vtk")
def main():
import numpy
from math import pi, cos, sin
from meshpy.tet import MeshInfo, build
from meshpy.geometry import GeometryBuilder, Marker, make_box
geob = GeometryBuilder()
box_marker = Marker.FIRST_USER_MARKER
extent_small = 0.1*numpy.ones(3, dtype=numpy.float64)
points, facets, _, _ = \
make_box(-extent_small, extent_small)
geob.add_geometry(points, facets, facet_markers=box_marker)
# make small "separator box" for region attribute
geob.wrap_in_box(0.3)
points, facets, _, facet_markers = \
make_box(numpy.array([-1,-1,-1]), numpy.array([1,1,5]))
geob.add_geometry(points, facets, facet_markers=facet_markers)
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh_info.set_holes([(0,0,0)])
# region attributes
mesh_info.regions.resize(1)
mesh_info.regions[0] = (
# point in region
list(extent_small*2) + [
# region number
1,
# max volume in region
0.0001])
mesh = build(mesh_info, max_volume=0.02, volume_constraints=True, attributes=True)
print ("%d elements" % len(mesh.elements))
mesh.write_vtk("box-in-box.vtk")
def test_2d_gauss_theorem(actx_factory):
"""Verify Gauss's theorem explicitly on a mesh"""
pytest.importorskip("meshpy")
from meshpy.geometry import make_circle, GeometryBuilder
from meshpy.triangle import MeshInfo, build
geob = GeometryBuilder()
geob.add_geometry(*make_circle(1))
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh_info = build(mesh_info)
from meshmode.mesh.io import from_meshpy
mesh = from_meshpy(mesh_info, order=1)
actx = actx_factory()
discr = DGDiscretizationWithBoundaries(actx, mesh, order=2)
def f(x):
return flat_obj_array(
sym.sin(3*x[0])+sym.cos(3*x[1]),
sym.sin(2*x[0])+sym.cos(x[1]))
gauss_err = bind(discr,
sym.integral((
sym.nabla(2) * f(sym.nodes(2))
).sum())
- # noqa: W504
sym.integral(
sym.project("vol", sym.BTAG_ALL)(f(sym.nodes(2)))
.dot(sym.normal(sym.BTAG_ALL, 2)),
dd=sym.BTAG_ALL)
)(actx)
assert abs(gauss_err) < 1e-13
def main():
from meshpy.tet import MeshInfo, build
from meshpy.geometry import generate_surface_of_revolution, GeometryBuilder
simple_rz = [
(0, 0),
(1, 1),
(1, 2),
(0, 3),
]
geob = GeometryBuilder()
geob.add_geometry(*generate_surface_of_revolution(simple_rz))
mesh_info = MeshInfo()
geob.set(mesh_info)
# mesh_info.save_nodes("test")
# mesh_info.save_poly("test")
# mesh_info.load_poly("test")
mesh = build(mesh_info)
mesh.write_vtk("my_mesh.vtk")
def test_2d_gauss_theorem(actx_factory):
"""Verify Gauss's theorem explicitly on a mesh"""
pytest.importorskip("meshpy")
from meshpy.geometry import make_circle, GeometryBuilder
from meshpy.triangle import MeshInfo, build
geob = GeometryBuilder()
geob.add_geometry(*make_circle(1))
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh_info = build(mesh_info)
from meshmode.mesh.io import from_meshpy
from meshmode.mesh import BTAG_ALL
mesh = from_meshpy(mesh_info, order=1)
actx = actx_factory()
dcoll = DiscretizationCollection(actx, mesh, order=2)
volm_disc = dcoll.discr_from_dd(dof_desc.DD_VOLUME)
x_volm = thaw(volm_disc.nodes(), actx)
def f(x):
return flat_obj_array(
actx.np.sin(3 * x[0]) + actx.np.cos(3 * x[1]),
actx.np.sin(2 * x[0]) + actx.np.cos(x[1]))
f_volm = f(x_volm)
int_1 = op.integral(dcoll, "vol", op.local_div(dcoll, f_volm))
prj_f = op.project(dcoll, "vol", BTAG_ALL, f_volm)
normal = thaw(dcoll.normal(BTAG_ALL), actx)
int_2 = op.integral(dcoll, BTAG_ALL, prj_f.dot(normal))
assert abs(int_1 - int_2) < 1e-13
def createSphere(center, R, m, n, mv=1):
"""
The function computes the panelisation of a sphere using the predefined
tools available in the Python module meshpy.
INPUTS:
- R: radius of the sphere (m)
- m: number of radial subdivisions of the mesh (integer)
- n: number of circumferential subdivisions of the mesh (integer)
- mv: maxium valume of an element in the thetrahedral mesh
(the mesh is actually 3D but we only extract the surface panels)
OUTPUTS:
- verts: coordinates of each vertices of the panelisation
- faces: triplets of indices representing the vertices of each triangular panel
- tris: triplets explicitly representing the coordinates of the vertices
of each triangular face.
"""
rz = []
rz.append((0, R))
for i in xrange(1, n):
rz.append((R * np.sin(i * np.pi / n), R * np.cos(i * np.pi / n)))
rz.append((0, -R))
geob = GeometryBuilder()
geob.add_geometry(*generate_surface_of_revolution(rz, radial_subdiv=m))
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh = build(mesh_info, max_volume=mv)
verts = np.array(mesh.points)
faces = np.array(mesh.faces)
tris = verts[faces]
bars = []
return verts, bars, faces # , tris
def test_torus():
from math import pi, cos, sin
from meshpy.tet import MeshInfo, build
from meshpy.geometry import generate_surface_of_revolution, \
EXT_CLOSED_IN_RZ, GeometryBuilder
big_r = 3
little_r = 2.9
points = 50
dphi = 2 * pi / points
rz = [(big_r + little_r * cos(i * dphi), little_r * sin(i * dphi))
for i in range(points)]
geob = GeometryBuilder()
geob.add_geometry(*generate_surface_of_revolution(
rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=20))
mesh_info = MeshInfo()
geob.set(mesh_info)
build(mesh_info)
def make_nacamesh():
def round_trip_connect(seq):
result = []
for i in range(len(seq)):
result.append((i, (i + 1) % len(seq)))
return result
pt_back = numpy.array([1, 0])
#def max_area(pt):
#max_area_front = 1e-2*la.norm(pt)**2 + 1e-5
#max_area_back = 1e-2*la.norm(pt-pt_back)**2 + 1e-4
#return min(max_area_front, max_area_back)
def max_area(pt):
x = pt[0]
if x < 0:
return 1e-2 * la.norm(pt)**2 + 1e-5
elif x > 1:
return 1e-2 * la.norm(pt - pt_back)**2 + 1e-5
else:
return 1e-2 * pt[1]**2 + 1e-5
def needs_refinement(vertices, area):
barycenter = sum(numpy.array(v) for v in vertices) / 3
return bool(area > max_area(barycenter))
from meshpy.naca import get_naca_points
points = get_naca_points(naca_digits="2412", number_of_points=80)
from meshpy.geometry import GeometryBuilder, Marker
from meshpy.triangle import write_gnuplot_mesh
profile_marker = Marker.FIRST_USER_MARKER
builder = GeometryBuilder()
builder.add_geometry(points=points,
facets=round_trip_connect(points),
facet_markers=profile_marker)
builder.wrap_in_box(4, (10, 8))
from meshpy.triangle import MeshInfo, build
mi = MeshInfo()
builder.set(mi)
mi.set_holes([builder.center()])
mesh = build(
mi,
refinement_func=needs_refinement,
#allow_boundary_steiner=False,
generate_faces=True)
write_gnuplot_mesh("mesh.dat", mesh)
print("%d elements" % len(mesh.elements))
fvi2fm = mesh.face_vertex_indices_to_face_marker
face_marker_to_tag = {
profile_marker: "noslip",
Marker.MINUS_X: "inflow",
Marker.PLUS_X: "outflow",
Marker.MINUS_Y: "inflow",
Marker.PLUS_Y: "inflow"
#Marker.MINUS_Y: "minus_y",
#Marker.PLUS_Y: "plus_y"
}
def bdry_tagger(fvi, el, fn, all_v):
face_marker = fvi2fm[fvi]
return [face_marker_to_tag[face_marker]]
from grudge.mesh import make_conformal_mesh_ext
vertices = numpy.asarray(mesh.points, order="C")
from grudge.mesh.element import Triangle
return make_conformal_mesh_ext(
vertices,
[
Triangle(i, el_idx, vertices)
for i, el_idx in enumerate(mesh.elements)
],
bdry_tagger,
#periodicity=[None, ("minus_y", "plus_y")]
)
def make_boxmesh():
from meshpy.tet import MeshInfo, build
from meshpy.geometry import GeometryBuilder, Marker, make_box
geob = GeometryBuilder()
box_marker = Marker.FIRST_USER_MARKER
extent_small = 0.1 * numpy.ones(3, dtype=numpy.float64)
geob.add_geometry(*make_box(-extent_small, extent_small))
# make small "separator box" for region attribute
geob.add_geometry(
*make_box(-extent_small *
4, numpy.array([4, 0.4, 0.4], dtype=numpy.float64)))
geob.add_geometry(*make_box(numpy.array([-1, -1, -1], dtype=numpy.float64),
numpy.array([5, 1, 1], dtype=numpy.float64)))
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh_info.set_holes([(0, 0, 0)])
# region attributes
mesh_info.regions.resize(1)
mesh_info.regions[0] = (
# point in region
list(extent_small * 2) + [
# region number
1,
# max volume in region
#0.0001
0.005
])
mesh = build(mesh_info,
max_volume=0.02,
volume_constraints=True,
attributes=True)
print("%d elements" % len(mesh.elements))
#mesh.write_vtk("box-in-box.vtk")
#print "done writing"
fvi2fm = mesh.face_vertex_indices_to_face_marker
face_marker_to_tag = {
box_marker: "noslip",
Marker.MINUS_X: "inflow",
Marker.PLUS_X: "outflow",
Marker.MINUS_Y: "inflow",
Marker.PLUS_Y: "inflow",
Marker.PLUS_Z: "inflow",
Marker.MINUS_Z: "inflow"
}
def bdry_tagger(fvi, el, fn, all_v):
face_marker = fvi2fm[fvi]
return [face_marker_to_tag[face_marker]]
from grudge.mesh import make_conformal_mesh
return make_conformal_mesh(mesh.points, mesh.elements, bdry_tagger)
def __init__(self):
self.geob = GeometryBuilder()
def test_convergence_advec(ctx_factory,
mesh_name,
mesh_pars,
op_type,
flux_type,
order,
visualize=False):
"""Test whether 2D advection actually converges"""
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
for mesh_par in mesh_pars:
if mesh_name == "segment":
from meshmode.mesh.generation import generate_box_mesh
mesh = generate_box_mesh([np.linspace(-1.0, 1.0, mesh_par)],
order=order)
dim = 1
dt_factor = 1.0
elif mesh_name == "disk":
pytest.importorskip("meshpy")
from meshpy.geometry import make_circle, GeometryBuilder
from meshpy.triangle import MeshInfo, build
geob = GeometryBuilder()
geob.add_geometry(*make_circle(1))
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh_info = build(mesh_info, max_volume=mesh_par)
from meshmode.mesh.io import from_meshpy
mesh = from_meshpy(mesh_info, order=1)
dim = 2
dt_factor = 4
elif mesh_name.startswith("rect"):
dim = int(mesh_name[4:])
from meshmode.mesh.generation import generate_regular_rect_mesh
mesh = generate_regular_rect_mesh(a=(-0.5, ) * dim,
b=(0.5, ) * dim,
n=(mesh_par, ) * dim,
order=4)
if dim == 2:
dt_factor = 4
elif dim == 3:
dt_factor = 2
else:
raise ValueError("dt_factor not known for %dd" % dim)
else:
raise ValueError("invalid mesh name: " + mesh_name)
v = np.array([0.27, 0.31, 0.1])[:dim]
norm_v = la.norm(v)
def f(x):
return sym.sin(10 * x)
def u_analytic(x):
return f(-v.dot(x) / norm_v + sym.var("t", sym.DD_SCALAR) * norm_v)
from grudge.models.advection import (StrongAdvectionOperator,
WeakAdvectionOperator)
discr = DGDiscretizationWithBoundaries(actx, mesh, order=order)
op_class = {
"strong": StrongAdvectionOperator,
"weak": WeakAdvectionOperator,
}[op_type]
op = op_class(v,
inflow_u=u_analytic(sym.nodes(dim, sym.BTAG_ALL)),
flux_type=flux_type)
bound_op = bind(discr, op.sym_operator())
u = bind(discr, u_analytic(sym.nodes(dim)))(actx, t=0)
def rhs(t, u):
return bound_op(t=t, u=u)
if dim == 3:
final_time = 0.1
else:
final_time = 0.2
h_max = bind(discr, sym.h_max_from_volume(discr.ambient_dim))(actx)
dt = dt_factor * h_max / order**2
nsteps = (final_time // dt) + 1
dt = final_time / nsteps + 1e-15
from grudge.shortcuts import set_up_rk4
dt_stepper = set_up_rk4("u", dt, u, rhs)
last_u = None
from grudge.shortcuts import make_visualizer
vis = make_visualizer(discr, vis_order=order)
step = 0
for event in dt_stepper.run(t_end=final_time):
if isinstance(event, dt_stepper.StateComputed):
step += 1
logger.debug("[%04d] t = %.5f", step, event.t)
last_t = event.t
last_u = event.state_component
if visualize:
vis.write_vtk_file("fld-%s-%04d.vtu" % (mesh_par, step),
[("u", event.state_component)])
error_l2 = bind(discr,
sym.norm(2,
sym.var("u") - u_analytic(sym.nodes(dim))))(
t=last_t, u=last_u)
logger.info("h_max %.5e error %.5e", h_max, error_l2)
eoc_rec.add_data_point(h_max, error_l2)
logger.info(
"\n%s", eoc_rec.pretty_print(abscissa_label="h",
error_label="L2 Error"))
assert eoc_rec.order_estimate() > order
def test_convergence_advec(actx_factory,
mesh_name,
mesh_pars,
op_type,
flux_type,
order,
visualize=False):
"""Test whether 2D advection actually converges"""
actx = actx_factory()
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
for mesh_par in mesh_pars:
if mesh_name == "segment":
mesh = mgen.generate_box_mesh([np.linspace(-1.0, 1.0, mesh_par)],
order=order)
dim = 1
dt_factor = 1.0
elif mesh_name == "disk":
pytest.importorskip("meshpy")
from meshpy.geometry import make_circle, GeometryBuilder
from meshpy.triangle import MeshInfo, build
geob = GeometryBuilder()
geob.add_geometry(*make_circle(1))
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh_info = build(mesh_info, max_volume=mesh_par)
from meshmode.mesh.io import from_meshpy
mesh = from_meshpy(mesh_info, order=1)
dim = 2
dt_factor = 4
elif mesh_name.startswith("rect"):
dim = int(mesh_name[-1:])
mesh = mgen.generate_regular_rect_mesh(
a=(-0.5, ) * dim,
b=(0.5, ) * dim,
nelements_per_axis=(mesh_par, ) * dim,
order=4)
if dim == 2:
dt_factor = 4
elif dim == 3:
dt_factor = 2
else:
raise ValueError("dt_factor not known for %dd" % dim)
elif mesh_name.startswith("warped"):
dim = int(mesh_name[-1:])
mesh = mgen.generate_warped_rect_mesh(dim,
order=order,
nelements_side=mesh_par)
if dim == 2:
dt_factor = 4
elif dim == 3:
dt_factor = 2
else:
raise ValueError("dt_factor not known for %dd" % dim)
else:
raise ValueError("invalid mesh name: " + mesh_name)
v = np.array([0.27, 0.31, 0.1])[:dim]
norm_v = la.norm(v)
def f(x):
return actx.np.sin(10 * x)
def u_analytic(x, t=0):
return f(-v.dot(x) / norm_v + t * norm_v)
from grudge.models.advection import (StrongAdvectionOperator,
WeakAdvectionOperator)
from meshmode.mesh import BTAG_ALL
dcoll = DiscretizationCollection(actx, mesh, order=order)
op_class = {
"strong": StrongAdvectionOperator,
"weak": WeakAdvectionOperator
}[op_type]
adv_operator = op_class(dcoll,
v,
inflow_u=lambda t: u_analytic(
thaw(dcoll.nodes(dd=BTAG_ALL), actx), t=t),
flux_type=flux_type)
nodes = thaw(dcoll.nodes(), actx)
u = u_analytic(nodes, t=0)
def rhs(t, u):
return adv_operator.operator(t, u)
if dim == 3:
final_time = 0.1
else:
final_time = 0.2
from grudge.dt_utils import h_max_from_volume
h_max = h_max_from_volume(dcoll, dim=dcoll.ambient_dim)
dt = dt_factor * h_max / order**2
nsteps = (final_time // dt) + 1
dt = final_time / nsteps + 1e-15
from grudge.shortcuts import set_up_rk4
dt_stepper = set_up_rk4("u", dt, u, rhs)
last_u = None
from grudge.shortcuts import make_visualizer
vis = make_visualizer(dcoll)
step = 0
for event in dt_stepper.run(t_end=final_time):
if isinstance(event, dt_stepper.StateComputed):
step += 1
logger.debug("[%04d] t = %.5f", step, event.t)
last_t = event.t
last_u = event.state_component
if visualize:
vis.write_vtk_file("fld-%s-%04d.vtu" % (mesh_par, step),
[("u", event.state_component)])
error_l2 = op.norm(dcoll, last_u - u_analytic(nodes, t=last_t), 2)
logger.info("h_max %.5e error %.5e", h_max, error_l2)
eoc_rec.add_data_point(h_max, actx.to_numpy(error_l2))
logger.info(
"\n%s", eoc_rec.pretty_print(abscissa_label="h",
error_label="L2 Error"))
if mesh_name.startswith("warped"):
# NOTE: curvilinear meshes are hard
assert eoc_rec.order_estimate() > order - 0.5
else:
assert eoc_rec.order_estimate() > order
def make_squaremesh():
def round_trip_connect(seq):
result = []
for i in range(len(seq)):
result.append((i, (i + 1) % len(seq)))
return result
def needs_refinement(vertices, area):
x = sum(numpy.array(v) for v in vertices) / 3
max_area_volume = 0.7e-2 + 0.03 * (0.05 * x[1]**2 +
0.3 * min(x[0] + 1, 0)**2)
max_area_corners = 1e-3 + 0.001 * max(
la.norm(x - corner)**4 for corner in obstacle_corners)
return bool(area > 2.5 * min(max_area_volume, max_area_corners))
from meshpy.geometry import make_box
points, facets, _, _ = make_box((-0.5, -0.5), (0.5, 0.5))
obstacle_corners = points[:]
from meshpy.geometry import GeometryBuilder, Marker
profile_marker = Marker.FIRST_USER_MARKER
builder = GeometryBuilder()
builder.add_geometry(points=points,
facets=facets,
facet_markers=profile_marker)
points, facets, _, facet_markers = make_box((-16, -22), (25, 22))
builder.add_geometry(points=points,
facets=facets,
facet_markers=facet_markers)
from meshpy.triangle import MeshInfo, build
mi = MeshInfo()
builder.set(mi)
mi.set_holes([(0, 0)])
mesh = build(mi,
refinement_func=needs_refinement,
allow_boundary_steiner=True,
generate_faces=True)
print("%d elements" % len(mesh.elements))
from meshpy.triangle import write_gnuplot_mesh
write_gnuplot_mesh("mesh.dat", mesh)
fvi2fm = mesh.face_vertex_indices_to_face_marker
face_marker_to_tag = {
profile_marker: "noslip",
Marker.MINUS_X: "inflow",
Marker.PLUS_X: "outflow",
Marker.MINUS_Y: "inflow",
Marker.PLUS_Y: "inflow"
}
def bdry_tagger(fvi, el, fn, all_v):
face_marker = fvi2fm[fvi]
return [face_marker_to_tag[face_marker]]
from grudge.mesh import make_conformal_mesh_ext
vertices = numpy.asarray(mesh.points, dtype=float, order="C")
from grudge.mesh.element import Triangle
return make_conformal_mesh_ext(vertices, [
Triangle(i, el_idx, vertices) for i, el_idx in enumerate(mesh.elements)
], bdry_tagger)
vtkelements.tofile(filename)
def area_of_tri(nodes):
v1 = np.array(nodes[0].coord[:2]) - np.array(nodes[1].coord[:2])
v2 = np.array(nodes[0].coord[:2]) - np.array(nodes[2].coord[:2])
area = np.cross(v1, v2) / 2.
return area
if __name__ == "__main__":
#mesh
r = 1
l = 2
rz = [(0, 0), (r, 0), (r, l), (0, l)]
geob = GeometryBuilder()
geob.add_geometry(*generate_surface_of_revolution(
rz, radial_subdiv=20, ring_markers=[1, 2, 3]))
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh = build(mesh_info, max_volume=0.01)
E = 210e6
nu = 0.3
P = 2000
points = np.array(mesh.points)
cells = np.array(mesh.elements)
face_cells = np.array(mesh.faces)
z_face0_cells = [
c for c in face_cells if np.isclose(points[c][:, 2], 0).all()
]
def make_wingmesh():
import numpy
from math import pi, cos, sin
from meshpy.tet import MeshInfo, build
from meshpy.geometry import GeometryBuilder, Marker, \
generate_extrusion, make_box
geob = GeometryBuilder()
profile_marker = Marker.FIRST_USER_MARKER
wing_length = 2
wing_subdiv = 5
rz_points = [
(0, -wing_length * 1.05),
(0.7, -wing_length * 1.05),
] + [(r, x) for x, r in zip(
numpy.linspace(-wing_length, 0, wing_subdiv, endpoint=False),
numpy.linspace(0.8, 1, wing_subdiv, endpoint=False))] + [(1, 0)] + [
(r, x) for x, r in zip(
numpy.linspace(wing_length, 0, wing_subdiv, endpoint=False),
numpy.linspace(0.8, 1, wing_subdiv, endpoint=False))
][::-1] + [(0.7, wing_length * 1.05), (0, wing_length * 1.05)]
from meshpy.naca import get_naca_points
geob.add_geometry(*generate_extrusion(
rz_points=rz_points,
base_shape=get_naca_points("0012", number_of_points=20),
ring_markers=(wing_subdiv * 2 + 4) * [profile_marker]))
def deform_wing(p):
x, y, z = p
return numpy.array([
x + 0.8 * abs(z / wing_length)**1.2,
y + 0.1 * abs(z / wing_length)**2, z
])
geob.apply_transform(deform_wing)
points, facets, facet_markers = make_box(
numpy.array([-1.5, -1, -wing_length - 1], dtype=numpy.float64),
numpy.array([3, 1, wing_length + 1], dtype=numpy.float64))
geob.add_geometry(points, facets, facet_markers=facet_markers)
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh_info.set_holes([(0.5, 0, 0)])
mesh = build(mesh_info)
print("%d elements" % len(mesh.elements))
fvi2fm = mesh.face_vertex_indices_to_face_marker
face_marker_to_tag = {
profile_marker: "noslip",
Marker.MINUS_X: "inflow",
Marker.PLUS_X: "outflow",
Marker.MINUS_Y: "inflow",
Marker.PLUS_Y: "inflow",
Marker.PLUS_Z: "inflow",
Marker.MINUS_Z: "inflow"
}
def bdry_tagger(fvi, el, fn, all_v):
face_marker = fvi2fm[fvi]
return [face_marker_to_tag[face_marker]]
from grudge.mesh import make_conformal_mesh
return make_conformal_mesh(mesh.points, mesh.elements, bdry_tagger)