def get_mesh(self, resolution, target_order):
from meshmode.mesh.generation import generate_icosphere
from meshmode.mesh.refinement import refine_uniformly
mesh = refine_uniformly(generate_icosphere(1, target_order),
resolution)
return mesh
def test_mesh_without_vertices(ctx_factory):
ctx = ctx_factory()
queue = cl.CommandQueue(ctx)
# create a mesh
from meshmode.mesh.generation import generate_icosphere
mesh = generate_icosphere(r=1.0, order=4)
# create one without the vertices
from meshmode.mesh import Mesh
grp, = mesh.groups
groups = [
grp.copy(nodes=grp.nodes, vertex_indices=None) for grp in mesh.groups
]
mesh = Mesh(None, groups, is_conforming=False)
# try refining it
from meshmode.mesh.refinement import refine_uniformly
mesh = refine_uniformly(mesh, 1)
# make sure the world doesn't end
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory as GroupFactory
discr = Discretization(ctx, mesh, GroupFactory(4))
discr.nodes().with_queue(queue)
from meshmode.discretization.visualization import make_visualizer
make_visualizer(queue, discr, 4)
def test_mesh_without_vertices(actx_factory):
actx = actx_factory()
# create a mesh
mesh = mgen.generate_icosphere(r=1.0, order=4)
# create one without the vertices
grp, = mesh.groups
groups = [
grp.copy(nodes=grp.nodes, vertex_indices=None) for grp in mesh.groups
]
mesh = Mesh(None, groups, is_conforming=False)
# try refining it
from meshmode.mesh.refinement import refine_uniformly
mesh = refine_uniformly(mesh, 1)
# make sure the world doesn't end
from meshmode.discretization import Discretization
discr = Discretization(actx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(4))
thaw(discr.nodes(), actx)
from meshmode.discretization.visualization import make_visualizer
make_visualizer(actx, discr, 4)
def test_uniform_refinement(ctx_factory, with_adjacency):
make_mesh = partial(generate_box_mesh, (np.linspace(
0.0, 1.0, 2), np.linspace(0.0, 1.0, 3), np.linspace(0.0, 1.0, 2)),
order=4)
mesh = make_mesh()
from meshmode.mesh.refinement import refine_uniformly
mesh = refine_uniformly(mesh, 1, with_adjacency=with_adjacency)
def test_refine_surfaces(actx_factory, mesh_name, visualize=False):
if mesh_name == "torus":
mesh = mgen.generate_torus(10, 1, 40, 4, order=4)
elif mesh_name == "icosphere":
mesh = mgen.generate_icosphere(1, order=4)
else:
raise ValueError(f"invalid mesh name '{mesh_name}'")
if visualize:
actx = actx_factory()
from meshmode.mesh.visualization import vtk_visualize_mesh
vtk_visualize_mesh(actx, mesh, "surface.vtu")
# check for absence of node-vertex consistency error
from meshmode.mesh.refinement import refine_uniformly
refined_mesh = refine_uniformly(mesh, 1)
if visualize:
actx = actx_factory()
from meshmode.mesh.visualization import vtk_visualize_mesh
vtk_visualize_mesh(actx, refined_mesh, "surface-refined.vtu")
def generate_icosphere(
r: float,
order: int,
*,
uniform_refinement_rounds: int = 0,
node_vertex_consistency_tolerance: Optional[Union[float, bool]] = None,
unit_nodes: Optional[np.ndarray] = None):
"""
:param r: radius of the sphere.
:param order: order of the (simplex) elements. If *unit_nodes* is also
provided, the orders should match.
:param uniform_refinement_rounds: number of uniform refinement rounds to
perform after the initial mesh was created.
:param node_vertex_consistency_tolerance: passed to the
:class:`~meshmode.mesh.Mesh` constructor. If *False*, no checks are
performed.
:param unit_nodes: if given, the unit nodes to use. Must have shape
``(3, nnodes)``.
"""
mesh = generate_icosahedron(
r,
order,
node_vertex_consistency_tolerance=node_vertex_consistency_tolerance,
unit_nodes=unit_nodes)
if uniform_refinement_rounds:
from meshmode.mesh.refinement import refine_uniformly
mesh = refine_uniformly(mesh, uniform_refinement_rounds)
# ensure vertices and nodes are still on the sphere of radius r
vertices = mesh.vertices * r / np.sqrt(np.sum(mesh.vertices**2, axis=0))
grp, = mesh.groups
grp = grp.copy(nodes=grp.nodes * r / np.sqrt(np.sum(grp.nodes**2, axis=0)))
from meshmode.mesh import Mesh
return Mesh(
vertices, [grp],
node_vertex_consistency_tolerance=node_vertex_consistency_tolerance,
is_conforming=True)
def test_harmonic_extension_exterior_3d(ctx_factory):
dim = 3 # noqa: F841
mesh_order = 8
fmm_order = 3
bdry_quad_order = mesh_order
bdry_ovsmp_quad_order = 4 * bdry_quad_order
qbx_order = mesh_order
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
from meshmode.mesh.generation import generate_icosphere
from meshmode.mesh.refinement import refine_uniformly
radius = 2.5
base_mesh = generate_icosphere(radius, order=mesh_order)
mesh = refine_uniformly(base_mesh, 1)
pre_density_discr = Discretization(
cl_ctx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(bdry_quad_order))
from pytential.qbx import QBXLayerPotentialSource
qbx, _ = QBXLayerPotentialSource(
pre_density_discr,
fine_order=bdry_ovsmp_quad_order,
qbx_order=qbx_order,
fmm_order=fmm_order,
).with_refinement()
density_discr = qbx.density_discr
ntgts = 200
rho = np.random.rand(ntgts) * 3 + radius + 0.05
theta = np.random.rand(ntgts) * 2 * np.pi
phi = (np.random.rand(ntgts) - 0.5) * np.pi
nodes = density_discr.nodes().with_queue(queue)
source = np.array([0, 1, 2])
def test_func(x):
return 1.0 / la.norm(x.get() - source[:, None], axis=0)
f = cl.array.to_device(queue, test_func(nodes))
targets = cl.array.to_device(
queue,
np.array([
rho * np.cos(phi) * np.cos(theta),
rho * np.cos(phi) * np.sin(theta), rho * np.sin(phi)
]))
exact_f = test_func(targets)
ext_f, _ = compute_harmonic_extension(queue,
PointsTarget(targets),
qbx,
density_discr,
f,
loc_sign=1)
assert np.linalg.norm(exact_f -
ext_f.get()) < 1e-3 * np.linalg.norm(exact_f)
def get_mesh(self, resolution, mesh_order):
from meshmode.mesh.generation import generate_torus
mesh = generate_torus(self.r_major, self.r_minor, order=mesh_order)
from meshmode.mesh.refinement import refine_uniformly
return refine_uniformly(mesh, resolution)
