def get_mesh(self, resolution, target_order):
from meshmode.mesh.io import generate_gmsh, FileSource
base_mesh = generate_gmsh(
FileSource("ellipsoid.step"), 2, order=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" % resolution])
from meshmode.mesh.processing import perform_flips
# Flip elements--gmsh generates inside-out geometry.
base_mesh = perform_flips(base_mesh, np.ones(base_mesh.nelements))
from meshmode.mesh.processing import affine_map, merge_disjoint_meshes
from meshmode.mesh.tools import rand_rotation_matrix
pitch = 10
meshes = [
affine_map(
base_mesh,
A=rand_rotation_matrix(3),
b=pitch*np.array([
(ix-self.nx//2),
(iy-self.ny//2),
(iz-self.ny//2)]))
for ix in range(self.nx)
for iy in range(self.ny)
for iz in range(self.nz)
]
mesh = merge_disjoint_meshes(meshes, single_group=True)
return mesh
def get_mesh(self, resolution, target_order):
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(
FileSource("rounded-cube.step"), 2, order=3,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" % resolution])
from meshmode.mesh.processing import perform_flips, affine_map
mesh = affine_map(mesh, b=np.array([-0.5, -0.5, -0.5]))
mesh = affine_map(mesh, A=np.eye(3)*2)
# now centered at origin and extends to -1,1
# Flip elements--gmsh generates inside-out geometry.
return perform_flips(mesh, np.ones(mesh.nelements))
def make_mesh(nx, ny):
from meshmode.mesh.generation import ellipse, make_curve_mesh
from functools import partial
base_mesh = make_curve_mesh(
partial(ellipse, 1),
np.linspace(0, 1, nelements+1),
mesh_order)
from meshmode.mesh.processing import affine_map, merge_disjoint_meshes
dx = 2 / nx
meshes = [
affine_map(
base_mesh,
A=np.diag([dx*0.25, dx*0.25]),
b=np.array([dx*(ix-nx/2), dx*(iy-ny/2)]))
for ix in range(nx)
for iy in range(ny)]
mesh = merge_disjoint_meshes(meshes, single_group=True)
if 0:
from meshmode.mesh.visualization import draw_curve
draw_curve(mesh)
import matplotlib.pyplot as plt
plt.show()
return mesh
def test_circle_mesh(visualize=False):
from meshmode.mesh.io import generate_gmsh, FileSource
logger.info("BEGIN GEN")
mesh = generate_gmsh(
FileSource("circle.step"),
2,
order=2,
force_ambient_dim=2,
other_options=["-string", "Mesh.CharacteristicLengthMax = 0.05;"],
target_unit="MM",
)
logger.info("END GEN")
logger.info("nelements: %d", mesh.nelements)
from meshmode.mesh.processing import affine_map
mesh = affine_map(mesh, A=3 * np.eye(2))
if visualize:
from meshmode.mesh.visualization import draw_2d_mesh
draw_2d_mesh(mesh,
fill=None,
draw_vertex_numbers=False,
draw_nodal_adjacency=True,
set_bounding_box=True)
import matplotlib.pyplot as pt
pt.axis("equal")
pt.savefig("circle_mesh", dpi=300)
def make_mesh(nx, ny, visualize=False):
from meshmode.mesh.generation import ellipse, make_curve_mesh
from functools import partial
base_mesh = make_curve_mesh(partial(ellipse, 1),
np.linspace(0, 1, nelements + 1), mesh_order)
from meshmode.mesh.processing import affine_map, merge_disjoint_meshes
dx = 2 / nx
meshes = [
affine_map(base_mesh,
A=np.diag([dx * 0.25, dx * 0.25]),
b=np.array([dx * (ix - nx / 2), dx * (iy - ny / 2)]))
for ix in range(nx) for iy in range(ny)
]
mesh = merge_disjoint_meshes(meshes, single_group=True)
if visualize:
from meshmode.mesh.visualization import draw_curve
draw_curve(mesh)
import matplotlib.pyplot as plt
plt.show()
return mesh
def test_merge_and_map(ctx_getter, visualize=False):
from meshmode.mesh.io import generate_gmsh, FileSource
mesh_order = 3
mesh = generate_gmsh(
FileSource("blob-2d.step"), 2, order=mesh_order,
force_ambient_dim=2,
other_options=["-string", "Mesh.CharacteristicLengthMax = 0.02;"]
)
from meshmode.mesh.processing import merge_dijsoint_meshes, affine_map
mesh2 = affine_map(mesh, A=np.eye(2), b=np.array([5, 0]))
mesh3 = merge_dijsoint_meshes((mesh2, mesh))
if visualize:
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
PolynomialWarpAndBlendGroupFactory
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
discr = Discretization(cl_ctx, mesh3,
PolynomialWarpAndBlendGroupFactory(3))
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(queue, discr, 1)
vis.write_vtk_file("merged.vtu", [])
def test_merge_and_map(ctx_getter, visualize=False):
from meshmode.mesh.io import generate_gmsh, FileSource
mesh_order = 3
mesh = generate_gmsh(
FileSource("blob-2d.step"),
2,
order=mesh_order,
force_ambient_dim=2,
other_options=["-string", "Mesh.CharacteristicLengthMax = 0.02;"])
from meshmode.mesh.processing import merge_disjoint_meshes, affine_map
mesh2 = affine_map(mesh, A=np.eye(2), b=np.array([5, 0]))
mesh3 = merge_disjoint_meshes((mesh2, mesh))
if visualize:
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
PolynomialWarpAndBlendGroupFactory
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
discr = Discretization(cl_ctx, mesh3,
PolynomialWarpAndBlendGroupFactory(3))
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(queue, discr, 1)
vis.write_vtk_file("merged.vtu", [])
def get_mesh(self, resolution, target_order):
from meshmode.mesh.io import generate_gmsh, FileSource
base_mesh = generate_gmsh(FileSource("ellipsoid.step"),
2,
order=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" %
resolution
])
from meshmode.mesh.processing import perform_flips
# Flip elements--gmsh generates inside-out geometry.
base_mesh = perform_flips(base_mesh, np.ones(base_mesh.nelements))
from meshmode.mesh.processing import affine_map, merge_disjoint_meshes
from meshmode.mesh.tools import rand_rotation_matrix
pitch = 10
meshes = [
affine_map(base_mesh,
A=rand_rotation_matrix(3),
b=pitch * np.array([(ix - self.nx // 2),
(iy - self.ny // 2),
(iz - self.ny // 2)]))
for ix in range(self.nx) for iy in range(self.ny)
for iz in range(self.nz)
]
mesh = merge_disjoint_meshes(meshes, single_group=True)
return mesh
def get_mesh(self, resolution, target_order):
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(
FileSource("rounded-cube.step"), 2, order=3,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" % resolution])
from meshmode.mesh.processing import perform_flips, affine_map
mesh = affine_map(mesh, b=np.array([-0.5, -0.5, -0.5]))
mesh = affine_map(mesh, A=np.eye(3)*2)
# now centered at origin and extends to -1,1
# Flip elements--gmsh generates inside-out geometry.
return perform_flips(mesh, np.ones(mesh.nelements))
def get_mesh(self, resolution, mesh_order):
mesh = super().get_mesh(resolution, mesh_order)
from meshmode.mesh.processing import affine_map
return affine_map(mesh,
A=np.diag([
self.radius,
self.radius,
self.radius / self.aspect_ratio,
]))
def test_merge_and_map(ctx_factory, visualize=False):
from meshmode.mesh.io import generate_gmsh, FileSource
from meshmode.mesh.generation import generate_box_mesh
from meshmode.mesh import TensorProductElementGroup
from meshmode.discretization.poly_element import (
PolynomialWarpAndBlendGroupFactory,
LegendreGaussLobattoTensorProductGroupFactory)
mesh_order = 3
if 1:
mesh = generate_gmsh(
FileSource("blob-2d.step"),
2,
order=mesh_order,
force_ambient_dim=2,
other_options=["-string", "Mesh.CharacteristicLengthMax = 0.02;"])
discr_grp_factory = PolynomialWarpAndBlendGroupFactory(3)
else:
mesh = generate_box_mesh((
np.linspace(0, 1, 4),
np.linspace(0, 1, 4),
np.linspace(0, 1, 4),
),
10,
group_factory=TensorProductElementGroup)
discr_grp_factory = LegendreGaussLobattoTensorProductGroupFactory(3)
from meshmode.mesh.processing import merge_disjoint_meshes, affine_map
mesh2 = affine_map(mesh,
A=np.eye(mesh.ambient_dim),
b=np.array([5, 0, 0])[:mesh.ambient_dim])
mesh3 = merge_disjoint_meshes((mesh2, mesh))
mesh3.facial_adjacency_groups
mesh3.copy()
if visualize:
from meshmode.discretization import Discretization
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
discr = Discretization(cl_ctx, mesh3, discr_grp_factory)
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(queue, discr, 3, element_shrink_factor=0.8)
vis.write_vtk_file("merged.vtu", [])
def get_mesh(self, resolution, mesh_order):
from meshmode.mesh import TensorProductElementGroup
from meshmode.mesh.generation import generate_sphere
mesh = generate_sphere(1.0,
mesh_order,
uniform_refinement_rounds=resolution,
group_cls=TensorProductElementGroup)
if abs(self.aspect_ratio - 1.0) > 1.0e-14:
from meshmode.mesh.processing import affine_map
mesh = affine_map(mesh,
A=np.diag([1.0, 1.0, 1 / self.aspect_ratio]))
return mesh
def test_merge_and_map(ctx_factory, visualize=False):
from meshmode.mesh.io import generate_gmsh, FileSource
from meshmode.mesh.generation import generate_box_mesh
from meshmode.mesh import TensorProductElementGroup
from meshmode.discretization.poly_element import (
PolynomialWarpAndBlendGroupFactory,
LegendreGaussLobattoTensorProductGroupFactory)
mesh_order = 3
if 1:
mesh = generate_gmsh(
FileSource("blob-2d.step"), 2, order=mesh_order,
force_ambient_dim=2,
other_options=["-string", "Mesh.CharacteristicLengthMax = 0.02;"]
)
discr_grp_factory = PolynomialWarpAndBlendGroupFactory(3)
else:
mesh = generate_box_mesh(
(
np.linspace(0, 1, 4),
np.linspace(0, 1, 4),
np.linspace(0, 1, 4),
),
10, group_factory=TensorProductElementGroup)
discr_grp_factory = LegendreGaussLobattoTensorProductGroupFactory(3)
from meshmode.mesh.processing import merge_disjoint_meshes, affine_map
mesh2 = affine_map(mesh,
A=np.eye(mesh.ambient_dim),
b=np.array([5, 0, 0])[:mesh.ambient_dim])
mesh3 = merge_disjoint_meshes((mesh2, mesh))
mesh3.facial_adjacency_groups
mesh3.copy()
if visualize:
from meshmode.discretization import Discretization
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
discr = Discretization(cl_ctx, mesh3, discr_grp_factory)
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(queue, discr, 3, element_shrink_factor=0.8)
vis.write_vtk_file("merged.vtu", [])
def main():
from meshmode.mesh.generation import ( # noqa
make_curve_mesh, starfish)
mesh1 = make_curve_mesh(starfish, np.linspace(0, 1, 20), 4)
from meshmode.mesh.processing import affine_map, merge_disjoint_meshes
mesh2 = affine_map(mesh1, b=np.array([2, 3]))
mesh = merge_disjoint_meshes((mesh1, mesh2))
from meshmode.mesh.visualization import draw_2d_mesh
draw_2d_mesh(mesh, set_bounding_box=True)
import matplotlib.pyplot as pt
pt.show()
def main():
from meshmode.mesh.generation import ( # noqa
make_curve_mesh, starfish)
mesh1 = make_curve_mesh(starfish, np.linspace(0, 1, 20), 4)
from meshmode.mesh.processing import affine_map, merge_disjoint_meshes
mesh2 = affine_map(mesh1, b=np.array([2, 3]))
mesh = merge_disjoint_meshes((mesh1, mesh2))
from meshmode.mesh.visualization import draw_2d_mesh
draw_2d_mesh(mesh, set_bounding_box=True)
import matplotlib.pyplot as pt
pt.show()
def test_copy_visualizer(actx_factory, ambient_dim, visualize=True):
actx = actx_factory()
target_order = 4
if ambient_dim == 2:
nelements = 128
mesh = mgen.make_curve_mesh(partial(mgen.ellipse, 1.0),
np.linspace(0.0, 1.0, nelements + 1),
target_order)
elif ambient_dim == 3:
mesh = mgen.generate_icosphere(1.0,
target_order,
uniform_refinement_rounds=2)
else:
raise ValueError(f"unsupported dimension: {ambient_dim}")
from meshmode.mesh.processing import affine_map
translated_mesh = affine_map(mesh,
b=np.array([2.5, 0.0, 0.0][:ambient_dim]))
from meshmode.discretization import Discretization
discr = Discretization(actx, mesh,
PolynomialWarpAndBlendGroupFactory(target_order))
translated_discr = Discretization(
actx, translated_mesh,
PolynomialWarpAndBlendGroupFactory(target_order))
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(actx, discr, target_order, force_equidistant=True)
assert vis._vtk_connectivity
assert vis._vtk_lagrange_connectivity
translated_vis = vis.copy_with_same_connectivity(actx, translated_discr)
assert translated_vis._cached_vtk_connectivity is not None
assert translated_vis._cached_vtk_lagrange_connectivity is not None
assert translated_vis._vtk_connectivity \
is vis._vtk_connectivity
assert translated_vis._vtk_lagrange_connectivity \
is vis._vtk_lagrange_connectivity
if not visualize:
return
vis.write_vtk_file(f"visualizer_copy_{ambient_dim}d_orig.vtu", [],
overwrite=True)
translated_vis.write_vtk_file(
f"visualizer_copy_{ambient_dim}d_translated.vtu", [], overwrite=True)
def test_merge_and_map(actx_factory, group_cls, visualize=False):
from meshmode.mesh.io import generate_gmsh, FileSource
order = 3
mesh_order = 3
if group_cls is SimplexElementGroup:
mesh = generate_gmsh(
FileSource("blob-2d.step"),
2,
order=mesh_order,
force_ambient_dim=2,
other_options=["-string", "Mesh.CharacteristicLengthMax = 0.02;"],
target_unit="MM",
)
discr_grp_factory = PolynomialWarpAndBlendGroupFactory(order)
else:
ambient_dim = 3
mesh = mgen.generate_regular_rect_mesh(a=(0, ) * ambient_dim,
b=(1, ) * ambient_dim,
nelements_per_axis=(4, ) *
ambient_dim,
order=mesh_order,
group_cls=group_cls)
discr_grp_factory = LegendreGaussLobattoTensorProductGroupFactory(
order)
from meshmode.mesh.processing import merge_disjoint_meshes, affine_map
mesh2 = affine_map(mesh,
A=np.eye(mesh.ambient_dim),
b=np.array([2, 0, 0])[:mesh.ambient_dim])
mesh3 = merge_disjoint_meshes((mesh2, mesh))
assert mesh3.facial_adjacency_groups
mesh4 = mesh3.copy()
if visualize:
from meshmode.discretization import Discretization
actx = actx_factory()
discr = Discretization(actx, mesh4, discr_grp_factory)
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(actx, discr, 3, element_shrink_factor=0.8)
vis.write_vtk_file("merge_and_map.vtu", [])
def replicate_along_axes(mesh, shape, sep_ratio):
from meshmode.mesh.processing import (find_bounding_box, affine_map,
merge_disjoint_meshes)
bbox = find_bounding_box(mesh)
sizes = bbox[1] - bbox[0]
meshes = [mesh]
for i in range(mesh.ambient_dim):
for j in range(1, shape[i]):
vec = np.zeros(mesh.ambient_dim)
vec[i] = j * sizes[i] * (1 + sep_ratio)
meshes.append(affine_map(mesh, A=None, b=vec))
# FIXME: https://gitlab.tiker.net/inducer/pytential/issues/6
mesh = merge_disjoint_meshes(meshes, single_group=True)
meshes = [mesh]
return mesh
def test_circle_mesh(do_plot=False):
from meshmode.mesh.io import generate_gmsh, FileSource
print("BEGIN GEN")
mesh = generate_gmsh(
FileSource("circle.step"), 2, order=2,
force_ambient_dim=2,
other_options=[
"-string", "Mesh.CharacteristicLengthMax = 0.05;"]
)
print("END GEN")
print(mesh.nelements)
from meshmode.mesh.processing import affine_map
mesh = affine_map(mesh, A=3*np.eye(2))
if do_plot:
from meshmode.mesh.visualization import draw_2d_mesh
draw_2d_mesh(mesh, fill=None, draw_nodal_adjacency=True,
set_bounding_box=True)
import matplotlib.pyplot as pt
pt.show()
def test_circle_mesh(do_plot=False):
from meshmode.mesh.io import generate_gmsh, FileSource
print("BEGIN GEN")
mesh = generate_gmsh(
FileSource("circle.step"), 2, order=2,
force_ambient_dim=2,
other_options=[
"-string", "Mesh.CharacteristicLengthMax = 0.05;"]
)
print("END GEN")
print(mesh.nelements)
from meshmode.mesh.processing import affine_map
mesh = affine_map(mesh, A=3*np.eye(2))
if do_plot:
from meshmode.mesh.visualization import draw_2d_mesh
draw_2d_mesh(mesh, fill=None, draw_connectivity=True,
set_bounding_box=True)
import matplotlib.pyplot as pt
pt.show()
def test_partial_affine_map(dim=2):
orig_mesh = mgen.generate_regular_rect_mesh(a=(0, ) * dim,
b=(5, 3, 4)[:dim],
npoints_per_axis=(10, 6,
7)[:dim],
order=1)
from meshmode.mesh.processing import affine_map
mesh = affine_map(orig_mesh, b=np.pi)
mesh = affine_map(orig_mesh, b=np.pi)
assert la.norm(orig_mesh.vertices - mesh.vertices + np.pi) < 1.0e-14
mesh = affine_map(orig_mesh, b=np.array([np.pi] * dim))
assert la.norm(orig_mesh.vertices - mesh.vertices + np.pi) < 1.0e-14
mesh = affine_map(orig_mesh, A=np.pi)
mesh = affine_map(orig_mesh, A=np.pi)
assert la.norm(orig_mesh.vertices - mesh.vertices / np.pi) < 1.0e-14
mesh = affine_map(orig_mesh, A=np.pi * np.eye(dim))
assert la.norm(orig_mesh.vertices - mesh.vertices / np.pi) < 1.0e-14
def main(mesh_name="ellipse", visualize=False):
import logging
logging.basicConfig(level=logging.INFO) # INFO for more progress info
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
from meshmode.mesh.generation import ellipse, make_curve_mesh
from functools import partial
if mesh_name == "ellipse":
mesh = make_curve_mesh(partial(ellipse, 1),
np.linspace(0, 1, nelements + 1), mesh_order)
elif mesh_name == "ellipse_array":
base_mesh = make_curve_mesh(partial(ellipse, 1),
np.linspace(0, 1, nelements + 1),
mesh_order)
from meshmode.mesh.processing import affine_map, merge_disjoint_meshes
nx = 2
ny = 2
dx = 2 / nx
meshes = [
affine_map(base_mesh,
A=np.diag([dx * 0.25, dx * 0.25]),
b=np.array([dx * (ix - nx / 2), dx * (iy - ny / 2)]))
for ix in range(nx) for iy in range(ny)
]
mesh = merge_disjoint_meshes(meshes, single_group=True)
if visualize:
from meshmode.mesh.visualization import draw_curve
draw_curve(mesh)
import matplotlib.pyplot as plt
plt.show()
else:
raise ValueError(f"unknown mesh name: {mesh_name}")
pre_density_discr = Discretization(
actx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(bdry_quad_order))
from pytential.qbx import (QBXLayerPotentialSource,
QBXTargetAssociationFailedException)
qbx = QBXLayerPotentialSource(pre_density_discr,
fine_order=bdry_ovsmp_quad_order,
qbx_order=qbx_order,
fmm_order=fmm_order)
from sumpy.visualization import FieldPlotter
fplot = FieldPlotter(np.zeros(2), extent=5, npoints=500)
targets = actx.from_numpy(fplot.points)
from pytential import GeometryCollection
places = GeometryCollection(
{
"qbx":
qbx,
"qbx_high_target_assoc_tol":
qbx.copy(target_association_tolerance=0.05),
"targets":
PointsTarget(targets)
},
auto_where="qbx")
density_discr = places.get_discretization("qbx")
# {{{ describe bvp
from sumpy.kernel import LaplaceKernel, HelmholtzKernel
kernel = HelmholtzKernel(2)
sigma_sym = sym.var("sigma")
sqrt_w = sym.sqrt_jac_q_weight(2)
inv_sqrt_w_sigma = sym.cse(sigma_sym / sqrt_w)
# Brakhage-Werner parameter
alpha = 1j
# -1 for interior Dirichlet
# +1 for exterior Dirichlet
loc_sign = +1
k_sym = sym.var("k")
bdry_op_sym = (
-loc_sign * 0.5 * sigma_sym + sqrt_w *
(alpha * sym.S(kernel, inv_sqrt_w_sigma, k=k_sym, qbx_forced_limit=+1)
- sym.D(kernel, inv_sqrt_w_sigma, k=k_sym, qbx_forced_limit="avg")))
# }}}
bound_op = bind(places, bdry_op_sym)
# {{{ fix rhs and solve
from meshmode.dof_array import thaw
nodes = thaw(actx, density_discr.nodes())
k_vec = np.array([2, 1])
k_vec = k * k_vec / la.norm(k_vec, 2)
def u_incoming_func(x):
return actx.np.exp(1j * (x[0] * k_vec[0] + x[1] * k_vec[1]))
bc = -u_incoming_func(nodes)
bvp_rhs = bind(places, sqrt_w * sym.var("bc"))(actx, bc=bc)
from pytential.solve import gmres
gmres_result = gmres(bound_op.scipy_op(actx,
sigma_sym.name,
dtype=np.complex128,
k=k),
bvp_rhs,
tol=1e-8,
progress=True,
stall_iterations=0,
hard_failure=True)
# }}}
# {{{ postprocess/visualize
repr_kwargs = dict(source="qbx_high_target_assoc_tol",
target="targets",
qbx_forced_limit=None)
representation_sym = (
alpha * sym.S(kernel, inv_sqrt_w_sigma, k=k_sym, **repr_kwargs) -
sym.D(kernel, inv_sqrt_w_sigma, k=k_sym, **repr_kwargs))
u_incoming = u_incoming_func(targets)
ones_density = density_discr.zeros(actx)
for elem in ones_density:
elem.fill(1)
indicator = actx.to_numpy(
bind(places, sym.D(LaplaceKernel(2), sigma_sym,
**repr_kwargs))(actx, sigma=ones_density))
try:
fld_in_vol = actx.to_numpy(
bind(places, representation_sym)(actx,
sigma=gmres_result.solution,
k=k))
except QBXTargetAssociationFailedException as e:
fplot.write_vtk_file("helmholtz-dirichlet-failed-targets.vts",
[("failed", e.failed_target_flags.get(queue))])
raise
#fplot.show_scalar_in_mayavi(fld_in_vol.real, max_val=5)
fplot.write_vtk_file("helmholtz-dirichlet-potential.vts", [
("potential", fld_in_vol),
("indicator", indicator),
("u_incoming", actx.to_numpy(u_incoming)),
])
def main():
import logging
logging.basicConfig(level=logging.WARNING) # INFO for more progress info
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
from meshmode.mesh.generation import ellipse, make_curve_mesh
from functools import partial
if 0:
mesh = make_curve_mesh(
partial(ellipse, 1),
np.linspace(0, 1, nelements+1),
mesh_order)
else:
base_mesh = make_curve_mesh(
partial(ellipse, 1),
np.linspace(0, 1, nelements+1),
mesh_order)
from meshmode.mesh.processing import affine_map, merge_disjoint_meshes
nx = 2
ny = 2
dx = 2 / nx
meshes = [
affine_map(
base_mesh,
A=np.diag([dx*0.25, dx*0.25]),
b=np.array([dx*(ix-nx/2), dx*(iy-ny/2)]))
for ix in range(nx)
for iy in range(ny)]
mesh = merge_disjoint_meshes(meshes, single_group=True)
if 0:
from meshmode.mesh.visualization import draw_curve
draw_curve(mesh)
import matplotlib.pyplot as plt
plt.show()
pre_density_discr = Discretization(
cl_ctx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(bdry_quad_order))
from pytential.qbx import (
QBXLayerPotentialSource, QBXTargetAssociationFailedException)
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
# {{{ describe bvp
from sumpy.kernel import LaplaceKernel, HelmholtzKernel
kernel = HelmholtzKernel(2)
cse = sym.cse
sigma_sym = sym.var("sigma")
sqrt_w = sym.sqrt_jac_q_weight(2)
inv_sqrt_w_sigma = cse(sigma_sym/sqrt_w)
# Brakhage-Werner parameter
alpha = 1j
# -1 for interior Dirichlet
# +1 for exterior Dirichlet
loc_sign = +1
bdry_op_sym = (-loc_sign*0.5*sigma_sym
+ sqrt_w*(
alpha*sym.S(kernel, inv_sqrt_w_sigma, k=sym.var("k"),
qbx_forced_limit=+1)
- sym.D(kernel, inv_sqrt_w_sigma, k=sym.var("k"),
qbx_forced_limit="avg")
))
# }}}
bound_op = bind(qbx, bdry_op_sym)
# {{{ fix rhs and solve
nodes = density_discr.nodes().with_queue(queue)
k_vec = np.array([2, 1])
k_vec = k * k_vec / la.norm(k_vec, 2)
def u_incoming_func(x):
return cl.clmath.exp(
1j * (x[0] * k_vec[0] + x[1] * k_vec[1]))
bc = -u_incoming_func(nodes)
bvp_rhs = bind(qbx, sqrt_w*sym.var("bc"))(queue, bc=bc)
from pytential.solve import gmres
gmres_result = gmres(
bound_op.scipy_op(queue, "sigma", dtype=np.complex128, k=k),
bvp_rhs, tol=1e-8, progress=True,
stall_iterations=0,
hard_failure=True)
# }}}
# {{{ postprocess/visualize
sigma = gmres_result.solution
repr_kwargs = dict(k=sym.var("k"), qbx_forced_limit=None)
representation_sym = (
alpha*sym.S(kernel, inv_sqrt_w_sigma, **repr_kwargs)
- sym.D(kernel, inv_sqrt_w_sigma, **repr_kwargs))
from sumpy.visualization import FieldPlotter
fplot = FieldPlotter(np.zeros(2), extent=5, npoints=500)
targets = cl.array.to_device(queue, fplot.points)
u_incoming = u_incoming_func(targets)
qbx_stick_out = qbx.copy(target_association_tolerance=0.05)
ones_density = density_discr.zeros(queue)
ones_density.fill(1)
indicator = bind(
(qbx_stick_out, PointsTarget(targets)),
sym.D(LaplaceKernel(2), sym.var("sigma"), qbx_forced_limit=None))(
queue, sigma=ones_density).get()
try:
fld_in_vol = bind(
(qbx_stick_out, PointsTarget(targets)),
representation_sym)(queue, sigma=sigma, k=k).get()
except QBXTargetAssociationFailedException as e:
fplot.write_vtk_file(
"failed-targets.vts",
[
("failed", e.failed_target_flags.get(queue))
]
)
raise
#fplot.show_scalar_in_mayavi(fld_in_vol.real, max_val=5)
fplot.write_vtk_file(
"potential-helm.vts",
[
("potential", fld_in_vol),
("indicator", indicator),
("u_incoming", u_incoming.get()),
]
)
def main():
import logging
logging.basicConfig(level=logging.WARNING) # INFO for more progress info
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
from meshmode.mesh.generation import generate_torus
rout = 10
rin = 1
if 1:
base_mesh = generate_torus(rout, rin, 40, 4, mesh_order)
from meshmode.mesh.processing import affine_map, merge_disjoint_meshes
# nx = 1
# ny = 1
nz = 1
dz = 0
meshes = [
affine_map(base_mesh,
A=np.diag([1, 1, 1]),
b=np.array([0, 0, iz * dz])) for iz in range(nz)
]
mesh = merge_disjoint_meshes(meshes, single_group=True)
if 0:
from meshmode.mesh.visualization import draw_curve
draw_curve(mesh)
import matplotlib.pyplot as plt
plt.show()
pre_density_discr = Discretization(
cl_ctx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(bdry_quad_order))
from pytential.qbx import (QBXLayerPotentialSource,
QBXTargetAssociationFailedException)
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
# {{{ describe bvp
from sumpy.kernel import LaplaceKernel
kernel = LaplaceKernel(3)
cse = sym.cse
sigma_sym = sym.var("sigma")
#sqrt_w = sym.sqrt_jac_q_weight(3)
sqrt_w = 1
inv_sqrt_w_sigma = cse(sigma_sym / sqrt_w)
# -1 for interior Dirichlet
# +1 for exterior Dirichlet
loc_sign = +1
bdry_op_sym = (
loc_sign * 0.5 * sigma_sym + sqrt_w *
(sym.S(kernel, inv_sqrt_w_sigma) + sym.D(kernel, inv_sqrt_w_sigma)))
# }}}
bound_op = bind(qbx, bdry_op_sym)
# {{{ fix rhs and solve
nodes = density_discr.nodes().with_queue(queue)
source = np.array([rout, 0, 0])
def u_incoming_func(x):
# return 1/cl.clmath.sqrt( (x[0] - source[0])**2
# +(x[1] - source[1])**2
# +(x[2] - source[2])**2 )
return 1.0 / la.norm(x.get() - source[:, None], axis=0)
bc = cl.array.to_device(queue, u_incoming_func(nodes))
bvp_rhs = bind(qbx, sqrt_w * sym.var("bc"))(queue, bc=bc)
from pytential.solve import gmres
gmres_result = gmres(bound_op.scipy_op(queue, "sigma", dtype=np.float64),
bvp_rhs,
tol=1e-14,
progress=True,
stall_iterations=0,
hard_failure=True)
sigma = bind(qbx,
sym.var("sigma") / sqrt_w)(queue, sigma=gmres_result.solution)
# }}}
from meshmode.discretization.visualization import make_visualizer
bdry_vis = make_visualizer(queue, density_discr, 20)
bdry_vis.write_vtk_file("laplace.vtu", [
("sigma", sigma),
])
# {{{ postprocess/visualize
repr_kwargs = dict(qbx_forced_limit=None)
representation_sym = (sym.S(kernel, inv_sqrt_w_sigma, **repr_kwargs) +
sym.D(kernel, inv_sqrt_w_sigma, **repr_kwargs))
from sumpy.visualization import FieldPlotter
fplot = FieldPlotter(np.zeros(3), extent=20, npoints=50)
targets = cl.array.to_device(queue, fplot.points)
qbx_stick_out = qbx.copy(target_stick_out_factor=0.2)
try:
fld_in_vol = bind((qbx_stick_out, PointsTarget(targets)),
representation_sym)(queue, sigma=sigma).get()
except QBXTargetAssociationFailedException as e:
fplot.write_vtk_file("failed-targets.vts",
[("failed", e.failed_target_flags.get(queue))])
raise
#fplot.show_scalar_in_mayavi(fld_in_vol.real, max_val=5)
fplot.write_vtk_file("potential-laplace-3d.vts", [
("potential", fld_in_vol),
])
pt.clf()
else:
from meshmode.discretization.visualization import make_visualizer
from meshmode.mesh.processing import ( # noqa
affine_map, merge_disjoint_meshes)
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
from meshmode.mesh.generation import generate_icosphere
ref_mesh = generate_icosphere(1, generator.nproxy)
# NOTE: this does not plot the actual proxy points
for i in range(srcindices.nblocks):
mesh = affine_map(ref_mesh,
A=(pxyradii[i] * np.eye(ambient_dim)),
b=pxycenters[:, i].reshape(-1))
mesh = merge_disjoint_meshes([mesh, density_discr.mesh])
discr = Discretization(
actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(10))
vis = make_visualizer(actx, discr, 10)
filename = "test_proxy_generator_{}d_{:04}.vtu".format(
ambient_dim, i)
vis.write_vtk_file(filename, [])
# }}}
@pytest.mark.parametrize("case", PROXY_TEST_CASES)
def main():
import logging
logging.basicConfig(level=logging.WARNING) # INFO for more progress info
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
from meshmode.mesh.generation import generate_torus
rout = 10
rin = 1
if 1:
base_mesh = generate_torus(
rout, rin, 40, 4,
mesh_order)
from meshmode.mesh.processing import affine_map, merge_disjoint_meshes
# nx = 1
# ny = 1
nz = 1
dz = 0
meshes = [
affine_map(
base_mesh,
A=np.diag([1, 1, 1]),
b=np.array([0, 0, iz*dz]))
for iz in range(nz)]
mesh = merge_disjoint_meshes(meshes, single_group=True)
if 0:
from meshmode.mesh.visualization import draw_curve
draw_curve(mesh)
import matplotlib.pyplot as plt
plt.show()
pre_density_discr = Discretization(
cl_ctx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(bdry_quad_order))
from pytential.qbx import (
QBXLayerPotentialSource, QBXTargetAssociationFailedException)
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
# {{{ describe bvp
from sumpy.kernel import LaplaceKernel
kernel = LaplaceKernel(3)
cse = sym.cse
sigma_sym = sym.var("sigma")
#sqrt_w = sym.sqrt_jac_q_weight(3)
sqrt_w = 1
inv_sqrt_w_sigma = cse(sigma_sym/sqrt_w)
# -1 for interior Dirichlet
# +1 for exterior Dirichlet
loc_sign = +1
bdry_op_sym = (loc_sign*0.5*sigma_sym
+ sqrt_w*(
sym.S(kernel, inv_sqrt_w_sigma)
+ sym.D(kernel, inv_sqrt_w_sigma)
))
# }}}
bound_op = bind(qbx, bdry_op_sym)
# {{{ fix rhs and solve
nodes = density_discr.nodes().with_queue(queue)
source = np.array([rout, 0, 0])
def u_incoming_func(x):
# return 1/cl.clmath.sqrt( (x[0] - source[0])**2
# +(x[1] - source[1])**2
# +(x[2] - source[2])**2 )
return 1.0/la.norm(x.get()-source[:, None], axis=0)
bc = cl.array.to_device(queue, u_incoming_func(nodes))
bvp_rhs = bind(qbx, sqrt_w*sym.var("bc"))(queue, bc=bc)
from pytential.solve import gmres
gmres_result = gmres(
bound_op.scipy_op(queue, "sigma", dtype=np.float64),
bvp_rhs, tol=1e-14, progress=True,
stall_iterations=0,
hard_failure=True)
sigma = bind(qbx, sym.var("sigma")/sqrt_w)(queue, sigma=gmres_result.solution)
# }}}
from meshmode.discretization.visualization import make_visualizer
bdry_vis = make_visualizer(queue, density_discr, 20)
bdry_vis.write_vtk_file("laplace.vtu", [
("sigma", sigma),
])
# {{{ postprocess/visualize
repr_kwargs = dict(qbx_forced_limit=None)
representation_sym = (
sym.S(kernel, inv_sqrt_w_sigma, **repr_kwargs)
+ sym.D(kernel, inv_sqrt_w_sigma, **repr_kwargs))
from sumpy.visualization import FieldPlotter
fplot = FieldPlotter(np.zeros(3), extent=20, npoints=50)
targets = cl.array.to_device(queue, fplot.points)
qbx_stick_out = qbx.copy(target_stick_out_factor=0.2)
try:
fld_in_vol = bind(
(qbx_stick_out, PointsTarget(targets)),
representation_sym)(queue, sigma=sigma).get()
except QBXTargetAssociationFailedException as e:
fplot.write_vtk_file(
"failed-targets.vts",
[
("failed", e.failed_target_flags.get(queue))
]
)
raise
#fplot.show_scalar_in_mayavi(fld_in_vol.real, max_val=5)
fplot.write_vtk_file(
"potential-laplace-3d.vts",
[
("potential", fld_in_vol),
]
)
def find_mode():
import warnings
warnings.simplefilter("error", np.ComplexWarning)
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
k0 = 1.4447
k1 = k0*1.02
beta_sym = sym.var("beta")
from pytential.symbolic.pde.scalar import ( # noqa
DielectricSRep2DBoundaryOperator as SRep,
DielectricSDRep2DBoundaryOperator as SDRep)
pde_op = SDRep(
mode="te",
k_vacuum=1,
interfaces=((0, 1, sym.DEFAULT_SOURCE),),
domain_k_exprs=(k0, k1),
beta=beta_sym,
use_l2_weighting=False)
u_sym = pde_op.make_unknown("u")
op = pde_op.operator(u_sym)
# {{{ discretization setup
from meshmode.mesh.generation import ellipse, make_curve_mesh
curve_f = partial(ellipse, 1)
target_order = 7
qbx_order = 4
nelements = 30
from meshmode.mesh.processing import affine_map
mesh = make_curve_mesh(curve_f,
np.linspace(0, 1, nelements+1),
target_order)
lambda_ = 1.55
circle_radius = 3.4*2*np.pi/lambda_
mesh = affine_map(mesh, A=circle_radius*np.eye(2))
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
from pytential.qbx import QBXLayerPotentialSource
density_discr = Discretization(
cl_ctx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(target_order))
qbx = QBXLayerPotentialSource(density_discr, 4*target_order,
qbx_order,
# Don't use FMM for now
fmm_order=False)
# }}}
x_vec = np.random.randn(len(u_sym)*density_discr.nnodes)
y_vec = np.random.randn(len(u_sym)*density_discr.nnodes)
def muller_solve_func(beta):
from pytential.symbolic.execution import build_matrix
mat = build_matrix(
queue, qbx, op, u_sym,
context={"beta": beta}).get()
return 1/x_vec.dot(la.solve(mat, y_vec))
starting_guesses = (1+0j)*(
k0
+ (k1-k0) * np.random.rand(3))
from pytential.muller import muller
beta, niter = muller(muller_solve_func, z_start=starting_guesses)
print("beta")
def test_surface_divergence_theorem(actx_factory, mesh_name, visualize=False):
r"""Check the surface divergence theorem.
.. math::
\int_Sigma \phi \nabla_i f_i =
\int_\Sigma \nabla_i \phi f_i +
\int_\Sigma \kappa \phi f_i n_i +
\int_{\partial \Sigma} \phi f_i m_i
where :math:`n_i` is the surface normal and :class:`m_i` is the
face normal (which should be orthogonal to both the surface normal
and the face tangent).
"""
actx = actx_factory()
# {{{ cases
if mesh_name == "2-1-ellipse":
from mesh_data import EllipseMeshBuilder
builder = EllipseMeshBuilder(radius=3.1, aspect_ratio=2.0)
elif mesh_name == "spheroid":
from mesh_data import SpheroidMeshBuilder
builder = SpheroidMeshBuilder()
elif mesh_name == "circle":
from mesh_data import EllipseMeshBuilder
builder = EllipseMeshBuilder(radius=1.0, aspect_ratio=1.0)
elif mesh_name == "starfish":
from mesh_data import StarfishMeshBuilder
builder = StarfishMeshBuilder()
elif mesh_name == "sphere":
from mesh_data import SphereMeshBuilder
builder = SphereMeshBuilder(radius=1.0, mesh_order=16)
else:
raise ValueError("unknown mesh name: %s" % mesh_name)
# }}}
# {{{ convergence
def f(x):
return flat_obj_array(
actx.np.sin(3 * x[1]) + actx.np.cos(3 * x[0]) + 1.0,
actx.np.sin(2 * x[0]) + actx.np.cos(x[1]),
3.0 * actx.np.cos(x[0] / 2) + actx.np.cos(x[1]),
)[:ambient_dim]
from pytools.convergence import EOCRecorder
eoc_global = EOCRecorder()
eoc_local = EOCRecorder()
theta = np.pi / 3.33
ambient_dim = builder.ambient_dim
if ambient_dim == 2:
mesh_rotation = np.array([
[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)],
])
else:
mesh_rotation = np.array([
[1.0, 0.0, 0.0],
[0.0, np.cos(theta), -np.sin(theta)],
[0.0, np.sin(theta), np.cos(theta)],
])
mesh_offset = np.array([0.33, -0.21, 0.0])[:ambient_dim]
for i, resolution in enumerate(builder.resolutions):
from meshmode.mesh.processing import affine_map
from meshmode.discretization.connection import FACE_RESTR_ALL
mesh = builder.get_mesh(resolution, builder.mesh_order)
mesh = affine_map(mesh, A=mesh_rotation, b=mesh_offset)
from meshmode.discretization.poly_element import \
QuadratureSimplexGroupFactory
qtag = dof_desc.DISCR_TAG_QUAD
dcoll = DiscretizationCollection(actx,
mesh,
order=builder.order,
discr_tag_to_group_factory={
qtag:
QuadratureSimplexGroupFactory(
2 * builder.order)
})
volume = dcoll.discr_from_dd(dof_desc.DD_VOLUME)
logger.info("ndofs: %d", volume.ndofs)
logger.info("nelements: %d", volume.mesh.nelements)
dd = dof_desc.DD_VOLUME
dq = dd.with_discr_tag(qtag)
df = dof_desc.as_dofdesc(FACE_RESTR_ALL)
ambient_dim = dcoll.ambient_dim
# variables
f_num = f(thaw(dcoll.nodes(dd=dd), actx))
f_quad_num = f(thaw(dcoll.nodes(dd=dq), actx))
from grudge.geometry import normal, summed_curvature
kappa = summed_curvature(actx, dcoll, dd=dq)
normal = normal(actx, dcoll, dd=dq)
face_normal = thaw(dcoll.normal(df), actx)
face_f = op.project(dcoll, dd, df, f_num)
# operators
stiff = op.mass(
dcoll,
sum(
op.local_d_dx(dcoll, i, f_num_i)
for i, f_num_i in enumerate(f_num)))
stiff_t = sum(
op.weak_local_d_dx(dcoll, i, f_num_i)
for i, f_num_i in enumerate(f_num))
kterm = op.mass(dcoll, dq, kappa * f_quad_num.dot(normal))
flux = op.face_mass(dcoll, face_f.dot(face_normal))
# sum everything up
op_global = op.nodal_sum(dcoll, dd, stiff - (stiff_t + kterm))
op_local = op.elementwise_sum(dcoll, dd,
stiff - (stiff_t + kterm + flux))
err_global = abs(op_global)
err_local = op.norm(dcoll, op_local, np.inf)
logger.info("errors: global %.5e local %.5e", err_global, err_local)
# compute max element size
from grudge.dt_utils import h_max_from_volume
h_max = h_max_from_volume(dcoll)
eoc_global.add_data_point(h_max, actx.to_numpy(err_global))
eoc_local.add_data_point(h_max, err_local)
if visualize:
from grudge.shortcuts import make_visualizer
vis = make_visualizer(dcoll)
filename = f"surface_divergence_theorem_{mesh_name}_{i:04d}.vtu"
vis.write_vtk_file(filename, [("r", actx.np.log10(op_local))],
overwrite=True)
# }}}
order = min(builder.order, builder.mesh_order) - 0.5
logger.info("\n%s", str(eoc_global))
logger.info("\n%s", str(eoc_local))
assert eoc_global.max_error() < 1.0e-12 \
or eoc_global.order_estimate() > order - 0.5
assert eoc_local.max_error() < 1.0e-12 \
or eoc_local.order_estimate() > order - 0.5
def test_geometry_collection_caching(ctx_factory):
# NOTE: checks that the on-demand caching works properly in
# the `GeometryCollection`. This is done by constructing a few separated
# spheres, putting a few `QBXLayerPotentialSource`s on them and requesting
# the `nodes` on each `discr_stage`.
ctx = ctx_factory()
queue = cl.CommandQueue(ctx)
actx = PyOpenCLArrayContext(queue)
ndim = 2
nelements = 1024
target_order = 7
qbx_order = 4
ngeometry = 3
# construct discretizations
from meshmode.mesh.generation import ellipse, make_curve_mesh
from meshmode.mesh.processing import affine_map
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
discrs = []
radius = 1.0
for k in range(ngeometry):
if k == 0:
mesh = make_curve_mesh(partial(ellipse, radius),
np.linspace(0.0, 1.0, nelements + 1),
target_order)
else:
mesh = affine_map(discrs[0].mesh, b=np.array([3 * k * radius, 0]))
discr = Discretization(
actx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(target_order))
discrs.append(discr)
# construct qbx source
from pytential.qbx import QBXLayerPotentialSource
lpots = []
sources = [f"source_{k}" for k in range(ngeometry)]
for k, density_discr in enumerate(discrs):
qbx = QBXLayerPotentialSource(density_discr,
fine_order=2 * target_order,
qbx_order=qbx_order,
fmm_order=False)
lpots.append(qbx)
# construct a geometry collection
from pytential import GeometryCollection
places = GeometryCollection(dict(zip(sources, lpots)))
print(places.places)
# check on-demand refinement
from pytential import bind, sym
discr_stages = [
sym.QBX_SOURCE_STAGE1, sym.QBX_SOURCE_STAGE2,
sym.QBX_SOURCE_QUAD_STAGE2
]
for k in range(ngeometry):
for discr_stage in discr_stages:
with pytest.raises(KeyError):
discr = places._get_discr_from_cache(sources[k], discr_stage)
dofdesc = sym.DOFDescriptor(sources[k], discr_stage=discr_stage)
bind(places, sym.nodes(ndim, dofdesc=dofdesc))(actx)
discr = places._get_discr_from_cache(sources[k], discr_stage)
assert discr is not None
def test_surface_divergence_theorem(actx_factory, mesh_name, visualize=False):
r"""Check the surface divergence theorem.
.. math::
\int_Sigma \phi \nabla_i f_i =
\int_\Sigma \nabla_i \phi f_i +
\int_\Sigma \kappa \phi f_i n_i +
\int_{\partial \Sigma} \phi f_i m_i
where :math:`n_i` is the surface normal and :class:`m_i` is the
face normal (which should be orthogonal to both the surface normal
and the face tangent).
"""
actx = actx_factory()
# {{{ cases
if mesh_name == "2-1-ellipse":
from mesh_data import EllipseMeshBuilder
builder = EllipseMeshBuilder(radius=3.1, aspect_ratio=2.0)
elif mesh_name == "spheroid":
from mesh_data import SpheroidMeshBuilder
builder = SpheroidMeshBuilder()
elif mesh_name == "circle":
from mesh_data import EllipseMeshBuilder
builder = EllipseMeshBuilder(radius=1.0, aspect_ratio=1.0)
elif mesh_name == "starfish":
from mesh_data import StarfishMeshBuilder
builder = StarfishMeshBuilder()
elif mesh_name == "sphere":
from mesh_data import SphereMeshBuilder
builder = SphereMeshBuilder(radius=1.0, mesh_order=16)
else:
raise ValueError("unknown mesh name: %s" % mesh_name)
# }}}
# {{{ convergene
def f(x):
return flat_obj_array(
sym.sin(3 * x[1]) + sym.cos(3 * x[0]) + 1.0,
sym.sin(2 * x[0]) + sym.cos(x[1]),
3.0 * sym.cos(x[0] / 2) + sym.cos(x[1]),
)[:ambient_dim]
from pytools.convergence import EOCRecorder
eoc_global = EOCRecorder()
eoc_local = EOCRecorder()
theta = np.pi / 3.33
ambient_dim = builder.ambient_dim
if ambient_dim == 2:
mesh_rotation = np.array([
[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)],
])
else:
mesh_rotation = np.array([
[1.0, 0.0, 0.0],
[0.0, np.cos(theta), -np.sin(theta)],
[0.0, np.sin(theta), np.cos(theta)],
])
mesh_offset = np.array([0.33, -0.21, 0.0])[:ambient_dim]
for i, resolution in enumerate(builder.resolutions):
from meshmode.mesh.processing import affine_map
from meshmode.discretization.connection import FACE_RESTR_ALL
mesh = builder.get_mesh(resolution, builder.mesh_order)
mesh = affine_map(mesh, A=mesh_rotation, b=mesh_offset)
from meshmode.discretization.poly_element import \
QuadratureSimplexGroupFactory
discr = DiscretizationCollection(actx,
mesh,
order=builder.order,
discr_tag_to_group_factory={
"product":
QuadratureSimplexGroupFactory(
2 * builder.order)
})
volume = discr.discr_from_dd(dof_desc.DD_VOLUME)
logger.info("ndofs: %d", volume.ndofs)
logger.info("nelements: %d", volume.mesh.nelements)
dd = dof_desc.DD_VOLUME
dq = dd.with_discr_tag("product")
df = dof_desc.as_dofdesc(FACE_RESTR_ALL)
ambient_dim = discr.ambient_dim
dim = discr.dim
# variables
sym_f = f(sym.nodes(ambient_dim, dd=dd))
sym_f_quad = f(sym.nodes(ambient_dim, dd=dq))
sym_kappa = sym.summed_curvature(ambient_dim, dim=dim, dd=dq)
sym_normal = sym.surface_normal(ambient_dim, dim=dim,
dd=dq).as_vector()
sym_face_normal = sym.normal(df, ambient_dim, dim=dim - 1)
sym_face_f = sym.project(dd, df)(sym_f)
# operators
sym_stiff = sum(
sym.StiffnessOperator(d)(f) for d, f in enumerate(sym_f))
sym_stiff_t = sum(
sym.StiffnessTOperator(d)(f) for d, f in enumerate(sym_f))
sym_k = sym.MassOperator(dq,
dd)(sym_kappa * sym_f_quad.dot(sym_normal))
sym_flux = sym.FaceMassOperator()(sym_face_f.dot(sym_face_normal))
# sum everything up
sym_op_global = sym.NodalSum(dd)(sym_stiff - (sym_stiff_t + sym_k))
sym_op_local = sym.ElementwiseSumOperator(dd)(sym_stiff -
(sym_stiff_t + sym_k +
sym_flux))
# evaluate
op_global = bind(discr, sym_op_global)(actx)
op_local = bind(discr, sym_op_local)(actx)
err_global = abs(op_global)
err_local = bind(discr, sym.norm(np.inf, sym.var("x")))(actx,
x=op_local)
logger.info("errors: global %.5e local %.5e", err_global, err_local)
# compute max element size
h_max = bind(
discr,
sym.h_max_from_volume(discr.ambient_dim, dim=discr.dim,
dd=dd))(actx)
eoc_global.add_data_point(h_max, err_global)
eoc_local.add_data_point(h_max, err_local)
if visualize:
from grudge.shortcuts import make_visualizer
vis = make_visualizer(discr, vis_order=builder.order)
filename = f"surface_divergence_theorem_{mesh_name}_{i:04d}.vtu"
vis.write_vtk_file(filename, [("r", actx.np.log10(op_local))],
overwrite=True)
# }}}
order = min(builder.order, builder.mesh_order) - 0.5
logger.info("\n%s", str(eoc_global))
logger.info("\n%s", str(eoc_local))
assert eoc_global.max_error() < 1.0e-12 \
or eoc_global.order_estimate() > order - 0.5
assert eoc_local.max_error() < 1.0e-12 \
or eoc_local.order_estimate() > order - 0.5
def main(mesh_name="torus", visualize=False):
import logging
logging.basicConfig(level=logging.WARNING) # INFO for more progress info
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
if mesh_name == "torus":
rout = 10
rin = 1
from meshmode.mesh.generation import generate_torus
base_mesh = generate_torus(
rout, rin, 40, 4,
mesh_order)
from meshmode.mesh.processing import affine_map, merge_disjoint_meshes
# nx = 1
# ny = 1
nz = 1
dz = 0
meshes = [
affine_map(
base_mesh,
A=np.diag([1, 1, 1]),
b=np.array([0, 0, iz*dz]))
for iz in range(nz)]
mesh = merge_disjoint_meshes(meshes, single_group=True)
if visualize:
from meshmode.mesh.visualization import draw_curve
draw_curve(mesh)
import matplotlib.pyplot as plt
plt.show()
else:
raise ValueError(f"unknown mesh name: {mesh_name}")
pre_density_discr = Discretization(
actx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(bdry_quad_order))
from pytential.qbx import (
QBXLayerPotentialSource, QBXTargetAssociationFailedException)
qbx = QBXLayerPotentialSource(
pre_density_discr, fine_order=bdry_ovsmp_quad_order, qbx_order=qbx_order,
fmm_order=fmm_order,
)
from sumpy.visualization import FieldPlotter
fplot = FieldPlotter(np.zeros(3), extent=20, npoints=50)
targets = actx.from_numpy(fplot.points)
from pytential import GeometryCollection
places = GeometryCollection({
"qbx": qbx,
"qbx_target_assoc": qbx.copy(target_association_tolerance=0.2),
"targets": PointsTarget(targets)
}, auto_where="qbx")
density_discr = places.get_discretization("qbx")
# {{{ describe bvp
from sumpy.kernel import LaplaceKernel
kernel = LaplaceKernel(3)
sigma_sym = sym.var("sigma")
#sqrt_w = sym.sqrt_jac_q_weight(3)
sqrt_w = 1
inv_sqrt_w_sigma = sym.cse(sigma_sym/sqrt_w)
# -1 for interior Dirichlet
# +1 for exterior Dirichlet
loc_sign = +1
bdry_op_sym = (loc_sign*0.5*sigma_sym
+ sqrt_w*(
sym.S(kernel, inv_sqrt_w_sigma, qbx_forced_limit=+1)
+ sym.D(kernel, inv_sqrt_w_sigma, qbx_forced_limit="avg")
))
# }}}
bound_op = bind(places, bdry_op_sym)
# {{{ fix rhs and solve
from meshmode.dof_array import thaw, flatten, unflatten
nodes = thaw(actx, density_discr.nodes())
source = np.array([rout, 0, 0])
def u_incoming_func(x):
from pytools.obj_array import obj_array_vectorize
x = obj_array_vectorize(actx.to_numpy, flatten(x))
x = np.array(list(x))
# return 1/cl.clmath.sqrt( (x[0] - source[0])**2
# +(x[1] - source[1])**2
# +(x[2] - source[2])**2 )
return 1.0/la.norm(x - source[:, None], axis=0)
bc = unflatten(actx,
density_discr,
actx.from_numpy(u_incoming_func(nodes)))
bvp_rhs = bind(places, sqrt_w*sym.var("bc"))(actx, bc=bc)
from pytential.solve import gmres
gmres_result = gmres(
bound_op.scipy_op(actx, "sigma", dtype=np.float64),
bvp_rhs, tol=1e-14, progress=True,
stall_iterations=0,
hard_failure=True)
sigma = bind(places, sym.var("sigma")/sqrt_w)(
actx, sigma=gmres_result.solution)
# }}}
from meshmode.discretization.visualization import make_visualizer
bdry_vis = make_visualizer(actx, density_discr, 20)
bdry_vis.write_vtk_file("laplace.vtu", [
("sigma", sigma),
])
# {{{ postprocess/visualize
repr_kwargs = dict(
source="qbx_target_assoc",
target="targets",
qbx_forced_limit=None)
representation_sym = (
sym.S(kernel, inv_sqrt_w_sigma, **repr_kwargs)
+ sym.D(kernel, inv_sqrt_w_sigma, **repr_kwargs))
try:
fld_in_vol = actx.to_numpy(
bind(places, representation_sym)(actx, sigma=sigma))
except QBXTargetAssociationFailedException as e:
fplot.write_vtk_file("laplace-dirichlet-3d-failed-targets.vts", [
("failed", e.failed_target_flags.get(queue)),
])
raise
#fplot.show_scalar_in_mayavi(fld_in_vol.real, max_val=5)
fplot.write_vtk_file("laplace-dirichlet-3d-potential.vts", [
("potential", fld_in_vol),
])
def plot_proxy_geometry(actx,
places,
indices,
pxy=None,
nbrindices=None,
with_qbx_centers=False,
suffix=None):
dofdesc = places.auto_source
discr = places.get_discretization(dofdesc.geometry, dofdesc.discr_stage)
ambient_dim = places.ambient_dim
if suffix is None:
suffix = f"{ambient_dim}d"
suffix = suffix.replace(".", "_")
import matplotlib.pyplot as pt
pt.figure(figsize=(10, 8), dpi=300)
pt.plot(np.diff(indices.ranges))
pt.savefig(f"test_proxy_geometry_{suffix}_ranges")
pt.clf()
if ambient_dim == 2:
sources = actx.to_numpy(flatten(discr.nodes(),
actx)).reshape(ambient_dim, -1)
if pxy is not None:
proxies = np.stack(pxy.points)
pxycenters = np.stack(pxy.centers)
pxyranges = pxy.indices.ranges
if with_qbx_centers:
ci = actx.to_numpy(
flatten(
bind(places, sym.expansion_centers(ambient_dim, -1))(actx),
actx)).reshape(ambient_dim, -1)
ce = actx.to_numpy(
flatten(
bind(places, sym.expansion_centers(ambient_dim, +1))(actx),
actx)).reshape(ambient_dim, -1)
r = actx.to_numpy(
flatten(
bind(places, sym.expansion_radii(ambient_dim))(actx),
actx))
fig = pt.figure(figsize=(10, 8), dpi=300)
if indices.indices.shape[0] != discr.ndofs:
pt.plot(sources[0], sources[1], "ko", ms=2.0, alpha=0.5)
for i in range(indices.nblocks):
isrc = indices.block_indices(i)
pt.plot(sources[0, isrc], sources[1, isrc], "o", ms=2.0)
if with_qbx_centers:
ax = pt.gca()
for j in isrc:
c = pt.Circle(ci[:, j], r[j], color="k", alpha=0.1)
ax.add_artist(c)
c = pt.Circle(ce[:, j], r[j], color="k", alpha=0.1)
ax.add_artist(c)
if pxy is not None:
ipxy = np.s_[pxyranges[i]:pxyranges[i + 1]]
pt.plot(proxies[0, ipxy], proxies[1, ipxy], "o", ms=2.0)
if nbrindices is not None:
inbr = nbrindices.block_indices(i)
pt.plot(sources[0, inbr], sources[1, inbr], "o", ms=2.0)
pt.xlim([-2, 2])
pt.ylim([-2, 2])
pt.gca().set_aspect("equal")
pt.savefig(f"test_proxy_geometry_{suffix}")
pt.close(fig)
elif ambient_dim == 3:
from meshmode.discretization.visualization import make_visualizer
marker = -42.0 * np.ones(discr.ndofs)
for i in range(indices.nblocks):
isrc = indices.block_indices(i)
marker[isrc] = 10.0 * (i + 1.0)
template_ary = thaw(discr.nodes()[0], actx)
marker_dev = unflatten(template_ary, actx.from_numpy(marker), actx)
vis = make_visualizer(actx, discr)
vis.write_vtk_file(f"test_proxy_geometry_{suffix}.vtu",
[("marker", marker_dev)],
overwrite=False)
if nbrindices:
for i in range(indices.nblocks):
isrc = indices.block_indices(i)
inbr = nbrindices.block_indices(i)
marker.fill(0.0)
marker[indices.indices] = 0.0
marker[isrc] = -42.0
marker[inbr] = +42.0
marker_dev = unflatten(template_ary, actx.from_numpy(marker),
actx)
vis.write_vtk_file(
f"test_proxy_geometry_{suffix}_neighbor_{i:04d}.vtu",
[("marker", marker_dev)],
overwrite=False)
if pxy:
# NOTE: this does not plot the actual proxy points, just sphere
# with the same center and radius as the proxy balls
from meshmode.mesh.processing import (affine_map,
merge_disjoint_meshes)
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
from meshmode.mesh.generation import generate_sphere
ref_mesh = generate_sphere(1, 4, uniform_refinement_rounds=1)
pxycenters = np.stack(pxy.centers)
for i in range(indices.nblocks):
mesh = affine_map(ref_mesh,
A=pxy.radii[i],
b=pxycenters[:, i].reshape(-1))
mesh = merge_disjoint_meshes([mesh, discr.mesh])
discr = Discretization(
actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(4))
vis = make_visualizer(actx, discr)
filename = f"test_proxy_geometry_{suffix}_block_{i:04d}.vtu"
vis.write_vtk_file(filename, [], overwrite=False)
else:
raise ValueError
def find_mode():
logging.basicConfig(level=logging.INFO)
import warnings
warnings.simplefilter("error", np.ComplexWarning)
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
n0 = 1.444
n1 = 1.4475
lambda_ = 1.5
k_vacuum = 2 * np.pi / lambda_
from pytential.symbolic.pde.maxwell.waveguide import \
SecondKindInfZMuellerOperator
pde_op = SecondKindInfZMuellerOperator(interfaces=((0, 1,
sym.DEFAULT_SOURCE), ),
domain_n_exprs=("n0", "n1"),
ne="ne",
use_l2_weighting=True)
base_context = {
"n0": n0,
"n1": n1,
"k_v": k_vacuum,
}
u_sym = pde_op.make_unknown("u")
op = pde_op.operator(u_sym)
# {{{ discretization setup
from meshmode.mesh.generation import ellipse, make_curve_mesh
curve_f = partial(ellipse, 1)
target_order = 7
qbx_order = 3
nelements = 30
from meshmode.mesh.processing import affine_map
mesh = make_curve_mesh(curve_f, np.linspace(0, 1, nelements + 1),
target_order)
circle_radius = 4 * k_vacuum
mesh = affine_map(mesh, A=circle_radius * np.eye(2))
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
from pytential.qbx import QBXLayerPotentialSource
pre_density_discr = Discretization(
cl_ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order))
qbx, _ = QBXLayerPotentialSource(
pre_density_discr,
4 * target_order,
qbx_order,
#fmm_order=qbx_order+5
fmm_order=False).with_refinement()
density_discr = qbx.density_discr
# }}}
x_vec = np.random.randn(len(u_sym) * density_discr.nnodes)
y_vec = np.random.randn(len(u_sym) * density_discr.nnodes)
bound_op = bind(qbx, op)
def muller_solve_func(ne):
from pytential.solve import gmres
gmres_result = gmres(bound_op.scipy_op(queue,
"u",
np.complex128,
ne=ne,
**base_context),
y_vec,
tol=1e-12,
progress=True,
stall_iterations=0,
hard_failure=False)
minv_y = gmres_result.solution
print("gmres state:", gmres_result.state)
z = 1 / x_vec.dot(minv_y)
print("muller func value:", repr(z))
return z
starting_guesses = (1 + 0j) * (n0 + (n1 - n0) * np.random.rand(3))
from pytential.muller import muller
ne, niter = muller(muller_solve_func, z_start=starting_guesses)
print("ne", ne)
def test_proxy_generator(ctx_factory, ndim, factor, visualize=False):
ctx = ctx_factory()
queue = cl.CommandQueue(ctx)
qbx = _build_qbx_discr(queue, ndim=ndim)
srcindices = _build_block_index(qbx.density_discr, factor=factor)
from pytential.linalg.proxy import ProxyGenerator
generator = ProxyGenerator(qbx, ratio=1.1)
proxies, pxyranges, pxycenters, pxyradii = generator(queue, srcindices)
proxies = np.vstack([p.get() for p in proxies])
pxyranges = pxyranges.get()
pxycenters = np.vstack([c.get() for c in pxycenters])
pxyradii = pxyradii.get()
for i in range(srcindices.nblocks):
ipxy = np.s_[pxyranges[i]:pxyranges[i + 1]]
r = la.norm(proxies[:, ipxy] - pxycenters[:, i].reshape(-1, 1), axis=0)
assert np.allclose(r - pxyradii[i], 0.0, atol=1.0e-14)
srcindices = srcindices.get(queue)
if visualize:
if qbx.ambient_dim == 2:
import matplotlib.pyplot as pt
density_nodes = qbx.density_discr.nodes().get(queue)
ci = bind(qbx, sym.expansion_centers(qbx.ambient_dim, -1))(queue)
ci = np.vstack([c.get(queue) for c in ci])
ce = bind(qbx, sym.expansion_centers(qbx.ambient_dim, +1))(queue)
ce = np.vstack([c.get(queue) for c in ce])
r = bind(qbx, sym.expansion_radii(qbx.ambient_dim))(queue).get()
for i in range(srcindices.nblocks):
isrc = srcindices.block_indices(i)
ipxy = np.s_[pxyranges[i]:pxyranges[i + 1]]
pt.figure(figsize=(10, 8))
axis = pt.gca()
for j in isrc:
c = pt.Circle(ci[:, j], r[j], color='k', alpha=0.1)
axis.add_artist(c)
c = pt.Circle(ce[:, j], r[j], color='k', alpha=0.1)
axis.add_artist(c)
pt.plot(density_nodes[0],
density_nodes[1],
'ko',
ms=2.0,
alpha=0.5)
pt.plot(density_nodes[0, srcindices.indices],
density_nodes[1, srcindices.indices],
'o',
ms=2.0)
pt.plot(density_nodes[0, isrc],
density_nodes[1, isrc],
'o',
ms=2.0)
pt.plot(proxies[0, ipxy], proxies[1, ipxy], 'o', ms=2.0)
pt.xlim([-1.5, 1.5])
pt.ylim([-1.5, 1.5])
filename = "test_proxy_generator_{}d_{:04}.png".format(ndim, i)
pt.savefig(filename, dpi=300)
pt.clf()
else:
from meshmode.discretization.visualization import make_visualizer
from meshmode.mesh.processing import ( # noqa
affine_map, merge_disjoint_meshes)
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
from meshmode.mesh.generation import generate_icosphere
ref_mesh = generate_icosphere(1, generator.nproxy)
# NOTE: this does not plot the actual proxy points
for i in range(srcindices.nblocks):
mesh = affine_map(ref_mesh,
A=(pxyradii[i] * np.eye(ndim)),
b=pxycenters[:, i].reshape(-1))
mesh = merge_disjoint_meshes([mesh, qbx.density_discr.mesh])
discr = Discretization(
ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(10))
vis = make_visualizer(queue, discr, 10)
filename = "test_proxy_generator_{}d_{:04}.vtu".format(ndim, i)
vis.write_vtk_file(filename, [])
def test_proxy_generator(ctx_factory, ndim, factor, visualize=False):
ctx = ctx_factory()
queue = cl.CommandQueue(ctx)
qbx = _build_qbx_discr(queue, ndim=ndim)
srcindices = _build_block_index(qbx.density_discr,
method='nodes', factor=factor)
from pytential.linalg.proxy import ProxyGenerator
generator = ProxyGenerator(qbx, ratio=1.1)
proxies, pxyranges, pxycenters, pxyradii = generator(queue, srcindices)
proxies = np.vstack([p.get() for p in proxies])
pxyranges = pxyranges.get()
pxycenters = np.vstack([c.get() for c in pxycenters])
pxyradii = pxyradii.get()
for i in range(srcindices.nblocks):
ipxy = np.s_[pxyranges[i]:pxyranges[i + 1]]
r = la.norm(proxies[:, ipxy] - pxycenters[:, i].reshape(-1, 1), axis=0)
assert np.allclose(r - pxyradii[i], 0.0, atol=1.0e-14)
srcindices = srcindices.get(queue)
if visualize:
if qbx.ambient_dim == 2:
import matplotlib.pyplot as pt
from pytential.qbx.utils import get_centers_on_side
density_nodes = qbx.density_discr.nodes().get(queue)
ci = get_centers_on_side(qbx, -1)
ci = np.vstack([c.get(queue) for c in ci])
ce = get_centers_on_side(qbx, +1)
ce = np.vstack([c.get(queue) for c in ce])
r = qbx._expansion_radii("nsources").get(queue)
for i in range(srcindices.nblocks):
isrc = srcindices.block_indices(i)
ipxy = np.s_[pxyranges[i]:pxyranges[i + 1]]
pt.figure(figsize=(10, 8))
axis = pt.gca()
for j in isrc:
c = pt.Circle(ci[:, j], r[j], color='k', alpha=0.1)
axis.add_artist(c)
c = pt.Circle(ce[:, j], r[j], color='k', alpha=0.1)
axis.add_artist(c)
pt.plot(density_nodes[0], density_nodes[1],
'ko', ms=2.0, alpha=0.5)
pt.plot(density_nodes[0, srcindices.indices],
density_nodes[1, srcindices.indices],
'o', ms=2.0)
pt.plot(density_nodes[0, isrc], density_nodes[1, isrc],
'o', ms=2.0)
pt.plot(proxies[0, ipxy], proxies[1, ipxy],
'o', ms=2.0)
pt.xlim([-1.5, 1.5])
pt.ylim([-1.5, 1.5])
filename = "test_proxy_generator_{}d_{:04}.png".format(ndim, i)
pt.savefig(filename, dpi=300)
pt.clf()
else:
from meshmode.discretization.visualization import make_visualizer
from meshmode.mesh.processing import ( # noqa
affine_map, merge_disjoint_meshes)
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
from meshmode.mesh.generation import generate_icosphere
ref_mesh = generate_icosphere(1, generator.nproxy)
# NOTE: this does not plot the actual proxy points
for i in range(srcindices.nblocks):
mesh = affine_map(ref_mesh,
A=(pxyradii[i] * np.eye(ndim)),
b=pxycenters[:, i].reshape(-1))
mesh = merge_disjoint_meshes([mesh, qbx.density_discr.mesh])
discr = Discretization(ctx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(10))
vis = make_visualizer(queue, discr, 10)
filename = "test_proxy_generator_{}d_{:04}.vtu".format(ndim, i)
if os.path.isfile(filename):
os.remove(filename)
vis.write_vtk_file(filename, [])
def main():
import logging
logging.basicConfig(level=logging.WARNING) # INFO for more progress info
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
from meshmode.mesh.generation import ellipse, make_curve_mesh
from functools import partial
if 0:
mesh = make_curve_mesh(partial(ellipse, 1),
np.linspace(0, 1, nelements + 1), mesh_order)
else:
base_mesh = make_curve_mesh(partial(ellipse, 1),
np.linspace(0, 1, nelements + 1),
mesh_order)
from meshmode.mesh.processing import affine_map, merge_disjoint_meshes
nx = 2
ny = 2
dx = 2 / nx
meshes = [
affine_map(base_mesh,
A=np.diag([dx * 0.25, dx * 0.25]),
b=np.array([dx * (ix - nx / 2), dx * (iy - ny / 2)]))
for ix in range(nx) for iy in range(ny)
]
mesh = merge_disjoint_meshes(meshes, single_group=True)
if 0:
from meshmode.mesh.visualization import draw_curve
draw_curve(mesh)
import matplotlib.pyplot as plt
plt.show()
pre_density_discr = Discretization(
cl_ctx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(bdry_quad_order))
from pytential.qbx import (QBXLayerPotentialSource,
QBXTargetAssociationFailedException)
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
# {{{ describe bvp
from sumpy.kernel import LaplaceKernel, HelmholtzKernel
kernel = HelmholtzKernel(2)
cse = sym.cse
sigma_sym = sym.var("sigma")
sqrt_w = sym.sqrt_jac_q_weight(2)
inv_sqrt_w_sigma = cse(sigma_sym / sqrt_w)
# Brakhage-Werner parameter
alpha = 1j
# -1 for interior Dirichlet
# +1 for exterior Dirichlet
loc_sign = +1
bdry_op_sym = (-loc_sign * 0.5 * sigma_sym + sqrt_w * (alpha * sym.S(
kernel, inv_sqrt_w_sigma, k=sym.var("k"), qbx_forced_limit=+1) - sym.D(
kernel, inv_sqrt_w_sigma, k=sym.var("k"), qbx_forced_limit="avg")))
# }}}
bound_op = bind(qbx, bdry_op_sym)
# {{{ fix rhs and solve
nodes = density_discr.nodes().with_queue(queue)
k_vec = np.array([2, 1])
k_vec = k * k_vec / la.norm(k_vec, 2)
def u_incoming_func(x):
return cl.clmath.exp(1j * (x[0] * k_vec[0] + x[1] * k_vec[1]))
bc = -u_incoming_func(nodes)
bvp_rhs = bind(qbx, sqrt_w * sym.var("bc"))(queue, bc=bc)
from pytential.solve import gmres
gmres_result = gmres(bound_op.scipy_op(queue,
"sigma",
dtype=np.complex128,
k=k),
bvp_rhs,
tol=1e-8,
progress=True,
stall_iterations=0,
hard_failure=True)
# }}}
# {{{ postprocess/visualize
sigma = gmres_result.solution
repr_kwargs = dict(k=sym.var("k"), qbx_forced_limit=None)
representation_sym = (
alpha * sym.S(kernel, inv_sqrt_w_sigma, **repr_kwargs) -
sym.D(kernel, inv_sqrt_w_sigma, **repr_kwargs))
from sumpy.visualization import FieldPlotter
fplot = FieldPlotter(np.zeros(2), extent=5, npoints=500)
targets = cl.array.to_device(queue, fplot.points)
u_incoming = u_incoming_func(targets)
qbx_stick_out = qbx.copy(target_association_tolerance=0.05)
ones_density = density_discr.zeros(queue)
ones_density.fill(1)
indicator = bind((qbx_stick_out, PointsTarget(targets)),
sym.D(LaplaceKernel(2),
sym.var("sigma"),
qbx_forced_limit=None))(queue,
sigma=ones_density).get()
try:
fld_in_vol = bind((qbx_stick_out, PointsTarget(targets)),
representation_sym)(queue, sigma=sigma, k=k).get()
except QBXTargetAssociationFailedException as e:
fplot.write_vtk_file("failed-targets.vts",
[("failed", e.failed_target_flags.get(queue))])
raise
#fplot.show_scalar_in_mayavi(fld_in_vol.real, max_val=5)
fplot.write_vtk_file("potential-helm.vts", [
("potential", fld_in_vol),
("indicator", indicator),
("u_incoming", u_incoming.get()),
])
def find_mode():
import warnings
warnings.simplefilter("error", np.ComplexWarning)
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
k0 = 1.4447
k1 = k0 * 1.02
beta_sym = sym.var("beta")
from pytential.symbolic.pde.scalar import ( # noqa
DielectricSRep2DBoundaryOperator as SRep,
DielectricSDRep2DBoundaryOperator as SDRep)
pde_op = SDRep(mode="te",
k_vacuum=1,
interfaces=((0, 1, sym.DEFAULT_SOURCE), ),
domain_k_exprs=(k0, k1),
beta=beta_sym,
use_l2_weighting=False)
u_sym = pde_op.make_unknown("u")
op = pde_op.operator(u_sym)
# {{{ discretization setup
from meshmode.mesh.generation import ellipse, make_curve_mesh
curve_f = partial(ellipse, 1)
target_order = 7
qbx_order = 4
nelements = 30
from meshmode.mesh.processing import affine_map
mesh = make_curve_mesh(curve_f, np.linspace(0, 1, nelements + 1),
target_order)
lambda_ = 1.55
circle_radius = 3.4 * 2 * np.pi / lambda_
mesh = affine_map(mesh, A=circle_radius * np.eye(2))
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
from pytential.qbx import QBXLayerPotentialSource
density_discr = Discretization(
cl_ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order))
qbx = QBXLayerPotentialSource(
density_discr,
4 * target_order,
qbx_order,
# Don't use FMM for now
fmm_order=False)
# }}}
x_vec = np.random.randn(len(u_sym) * density_discr.nnodes)
y_vec = np.random.randn(len(u_sym) * density_discr.nnodes)
def muller_solve_func(beta):
from pytential.symbolic.execution import build_matrix
mat = build_matrix(queue, qbx, op, u_sym, context={"beta": beta}).get()
return 1 / x_vec.dot(la.solve(mat, y_vec))
starting_guesses = (1 + 0j) * (k0 + (k1 - k0) * np.random.rand(3))
from pytential.muller import muller
beta, niter = muller(muller_solve_func, z_start=starting_guesses)
print("beta")
