def get_observation_mesh(self, target_order):
from meshmode.mesh.generation import generate_sphere
if self.is_interior:
return generate_sphere(5, target_order)
else:
return generate_sphere(0.5, target_order)
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_target_specific_qbx(actx_factory, op, helmholtz_k, qbx_order):
logging.basicConfig(level=logging.INFO)
actx = actx_factory()
target_order = 4
fmm_tol = 1e-3
from meshmode.mesh.generation import generate_sphere
mesh = generate_sphere(1, target_order)
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
from pytential.qbx import QBXLayerPotentialSource
pre_density_discr = Discretization(
actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order))
from sumpy.expansion.level_to_order import SimpleExpansionOrderFinder
qbx = QBXLayerPotentialSource(
pre_density_discr,
4 * target_order,
qbx_order=qbx_order,
fmm_level_to_order=SimpleExpansionOrderFinder(fmm_tol),
fmm_backend="fmmlib",
_expansions_in_tree_have_extent=True,
_expansion_stick_out_factor=0.9,
_use_target_specific_qbx=False,
)
kernel_length_scale = 5 / abs(helmholtz_k) if helmholtz_k else None
places = {
"qbx": qbx,
"qbx_target_specific": qbx.copy(_use_target_specific_qbx=True)
}
from pytential.qbx.refinement import refine_geometry_collection
places = GeometryCollection(places, auto_where="qbx")
places = refine_geometry_collection(
places, kernel_length_scale=kernel_length_scale)
density_discr = places.get_discretization("qbx")
nodes = thaw(density_discr.nodes(), actx)
u_dev = actx.np.sin(nodes[0])
if helmholtz_k == 0:
kernel = LaplaceKernel(3)
kernel_kwargs = {}
else:
kernel = HelmholtzKernel(3, allow_evanescent=True)
kernel_kwargs = {"k": sym.var("k")}
u_sym = sym.var("u")
if op == "S":
op = sym.S
elif op == "D":
op = sym.D
elif op == "Sp":
op = sym.Sp
else:
raise ValueError("unknown operator: '%s'" % op)
expr = op(kernel, u_sym, qbx_forced_limit=-1, **kernel_kwargs)
bound_op = bind(places, expr)
pot_ref = actx.to_numpy(
flatten(bound_op(actx, u=u_dev, k=helmholtz_k), actx))
bound_op = bind(places, expr, auto_where="qbx_target_specific")
pot_tsqbx = actx.to_numpy(
flatten(bound_op(actx, u=u_dev, k=helmholtz_k), actx))
assert np.allclose(pot_tsqbx, pot_ref, atol=1e-13, rtol=1e-13)
def main():
# cl.array.to_device(queue, numpy_array)
from meshmode.mesh.io import generate_gmsh, FileSource
from meshmode.mesh.generation import generate_sphere
mesh = generate_sphere(1, target_order, uniform_refinement_rounds=1)
from meshmode.mesh.processing import perform_flips
# Flip elements--gmsh generates inside-out geometry.
mesh = perform_flips(mesh, np.ones(mesh.nelements))
print("%d elements" % mesh.nelements)
from meshmode.mesh.processing import find_bounding_box
bbox_min, bbox_max = find_bounding_box(mesh)
bbox_center = 0.5 * (bbox_min + bbox_max)
bbox_size = max(bbox_max - bbox_min) / 2
logger.info("%d elements" % mesh.nelements)
from pytential.qbx import QBXLayerPotentialSource
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
density_discr = Discretization(
cl_ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order))
qbx = QBXLayerPotentialSource(density_discr,
4 * target_order,
qbx_order,
fmm_order=False,
fmm_backend="fmmlib")
from pytential.symbolic.pde.maxwell import MuellerAugmentedMFIEOperator
pde_op = MuellerAugmentedMFIEOperator(
omega=1.0,
epss=[1.0, 1.0],
mus=[1.0, 1.0],
)
from pytential import bind, sym
unk = pde_op.make_unknown("sigma")
sym_operator = pde_op.operator(unk)
sym_rhs = pde_op.rhs(sym.make_sym_vector("Einc", 3),
sym.make_sym_vector("Hinc", 3))
sym_repr = pde_op.representation(1, unk)
if 1:
expr = sym_repr
print(sym.pretty(expr))
print("#" * 80)
from pytential.target import PointsTarget
tgt_points = np.zeros((3, 1))
tgt_points[0, 0] = 100
tgt_points[1, 0] = -200
tgt_points[2, 0] = 300
bound_op = bind((qbx, PointsTarget(tgt_points)), expr)
print(bound_op.code)
if 1:
def green3e(x, y, z, source, strength, k):
# electric field corresponding to dyadic green's function
# due to monochromatic electric dipole located at "source".
# "strength" is the the intensity of the dipole.
# E = (I + Hess)(exp(ikr)/r) dot (strength)
#
dx = x - source[0]
dy = y - source[1]
dz = z - source[2]
rr = np.sqrt(dx**2 + dy**2 + dz**2)
fout = np.exp(1j * k * rr) / rr
evec = fout * strength
qmat = np.zeros((3, 3), dtype=np.complex128)
qmat[0, 0] = (2 * dx**2 - dy**2 - dz**2) * (1 - 1j * k * rr)
qmat[1, 1] = (2 * dy**2 - dz**2 - dx**2) * (1 - 1j * k * rr)
qmat[2, 2] = (2 * dz**2 - dx**2 - dy**2) * (1 - 1j * k * rr)
qmat[0, 0] = qmat[0, 0] + (-k**2 * dx**2 * rr**2)
qmat[1, 1] = qmat[1, 1] + (-k**2 * dy**2 * rr**2)
qmat[2, 2] = qmat[2, 2] + (-k**2 * dz**2 * rr**2)
qmat[0, 1] = (3 - k**2 * rr**2 - 3 * 1j * k * rr) * (dx * dy)
qmat[1, 2] = (3 - k**2 * rr**2 - 3 * 1j * k * rr) * (dy * dz)
qmat[2, 0] = (3 - k**2 * rr**2 - 3 * 1j * k * rr) * (dz * dx)
qmat[1, 0] = qmat[0, 1]
qmat[2, 1] = qmat[1, 2]
qmat[0, 2] = qmat[2, 0]
fout = np.exp(1j * k * rr) / rr**5 / k**2
fvec = fout * np.dot(qmat, strength)
evec = evec + fvec
return evec
def green3m(x, y, z, source, strength, k):
# magnetic field corresponding to dyadic green's function
# due to monochromatic electric dipole located at "source".
# "strength" is the the intensity of the dipole.
# H = curl((I + Hess)(exp(ikr)/r) dot (strength)) =
# strength \cross \grad (exp(ikr)/r)
#
dx = x - source[0]
dy = y - source[1]
dz = z - source[2]
rr = np.sqrt(dx**2 + dy**2 + dz**2)
fout = (1 - 1j * k * rr) * np.exp(1j * k * rr) / rr**3
fvec = np.zeros(3, dtype=np.complex128)
fvec[0] = fout * dx
fvec[1] = fout * dy
fvec[2] = fout * dz
hvec = np.cross(strength, fvec)
return hvec
def dipole3e(x, y, z, source, strength, k):
#
# evalaute electric and magnetic field due
# to monochromatic electric dipole located at "source"
# with intensity "strength"
evec = green3e(x, y, z, source, strength, k)
evec = evec * 1j * k
hvec = green3m(x, y, z, source, strength, k)
# print(hvec)
# print(strength)
return evec, hvec
def dipole3m(x, y, z, source, strength, k):
#
# evalaute electric and magnetic field due
# to monochromatic magnetic dipole located at "source"
# with intensity "strength"
evec = green3m(x, y, z, source, strength, k)
hvec = green3e(x, y, z, source, strength, k)
hvec = -hvec * 1j * k
return evec, hvec
def dipole3eall(x, y, z, sources, strengths, k):
ns = len(strengths)
evec = np.zeros(3, dtype=np.complex128)
hvec = np.zeros(3, dtype=np.complex128)
for i in range(ns):
evect, hvect = dipole3e(x, y, z, sources[i], strengths[i], k)
evec = evec + evect
hvec = hvec + hvect
nodes = density_discr.nodes().with_queue(queue).get()
source = [0.01, -0.03, 0.02]
# source = cl.array.to_device(queue,np.zeros(3))
# source[0] = 0.01
# source[1] =-0.03
# source[2] = 0.02
strength = np.ones(3)
# evec = cl.array.to_device(queue,np.zeros((3,len(nodes[0])),dtype=np.complex128))
# hvec = cl.array.to_device(queue,np.zeros((3,len(nodes[0])),dtype=np.complex128))
evec = np.zeros((3, len(nodes[0])), dtype=np.complex128)
hvec = np.zeros((3, len(nodes[0])), dtype=np.complex128)
for i in range(len(nodes[0])):
evec[:, i], hvec[:, i] = dipole3e(nodes[0][i], nodes[1][i],
nodes[2][i], source, strength, k)
print(np.shape(hvec))
print(type(evec))
print(type(hvec))
evec = cl.array.to_device(queue, evec)
hvec = cl.array.to_device(queue, hvec)
bvp_rhs = bind(qbx, sym_rhs)(queue, Einc=evec, Hinc=hvec)
print(np.shape(bvp_rhs))
print(type(bvp_rhs))
# print(bvp_rhs)
1 / -1
bound_op = bind(qbx, sym_operator)
from pytential.solve import gmres
if 1:
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)
sigma = gmres_result.solution
fld_at_tgt = bind((qbx, PointsTarget(tgt_points)),
sym_repr)(queue, sigma=sigma, k=k)
fld_at_tgt = np.array([fi.get() for fi in fld_at_tgt])
print(fld_at_tgt)
fld_exact_e, fld_exact_h = dipole3e(tgt_points[0, 0], tgt_points[1, 0],
tgt_points[2,
0], source, strength, k)
print(fld_exact_e)
print(fld_exact_h)
1 / 0
# }}}
#mlab.figure(bgcolor=(1, 1, 1))
if 1:
from meshmode.discretization.visualization import make_visualizer
bdry_vis = make_visualizer(queue, density_discr, target_order)
bdry_normals = bind(density_discr, sym.normal(3))(queue)\
.as_vector(dtype=object)
bdry_vis.write_vtk_file("source.vtu", [
("sigma", sigma),
("bdry_normals", bdry_normals),
])
fplot = FieldPlotter(bbox_center,
extent=2 * bbox_size,
npoints=(150, 150, 1))
qbx_stick_out = qbx.copy(target_stick_out_factor=0.1)
from pytential.target import PointsTarget
from pytential.qbx import QBXTargetAssociationFailedException
rho_sym = sym.var("rho")
try:
fld_in_vol = bind((qbx_stick_out, PointsTarget(fplot.points)),
sym.make_obj_array([
sym.S(pde_op.kernel,
rho_sym,
k=sym.var("k"),
qbx_forced_limit=None),
sym.d_dx(
3,
sym.S(pde_op.kernel,
rho_sym,
k=sym.var("k"),
qbx_forced_limit=None)),
sym.d_dy(
3,
sym.S(pde_op.kernel,
rho_sym,
k=sym.var("k"),
qbx_forced_limit=None)),
sym.d_dz(
3,
sym.S(pde_op.kernel,
rho_sym,
k=sym.var("k"),
qbx_forced_limit=None)),
]))(queue, jt=jt, rho=rho, k=k)
except QBXTargetAssociationFailedException as e:
fplot.write_vtk_file(
"failed-targets.vts",
[("failed_targets", e.failed_target_flags.get(queue))])
raise
fld_in_vol = sym.make_obj_array([fiv.get() for fiv in fld_in_vol])
#fplot.show_scalar_in_mayavi(fld_in_vol.real, max_val=5)
fplot.write_vtk_file("potential.vts", [
("potential", fld_in_vol[0]),
("grad", fld_in_vol[1:]),
])
def test_sphere_eigenvalues(actx_factory, mode_m, mode_n, qbx_order,
fmm_backend):
special = pytest.importorskip("scipy.special")
logging.basicConfig(level=logging.INFO)
actx = actx_factory()
target_order = 8
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
from pytential.qbx import QBXLayerPotentialSource
from pytools.convergence import EOCRecorder
s_eoc_rec = EOCRecorder()
d_eoc_rec = EOCRecorder()
sp_eoc_rec = EOCRecorder()
dp_eoc_rec = EOCRecorder()
def rel_err(comp, ref):
return actx.to_numpy(
norm(density_discr, comp - ref) / norm(density_discr, ref))
for nrefinements in [0, 1]:
from meshmode.mesh.generation import generate_sphere
mesh = generate_sphere(1,
target_order,
uniform_refinement_rounds=nrefinements)
pre_density_discr = Discretization(
actx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(target_order))
qbx = QBXLayerPotentialSource(
pre_density_discr,
4 * target_order,
qbx_order,
fmm_order=6,
fmm_backend=fmm_backend,
)
places = GeometryCollection(qbx)
density_discr = places.get_discretization(places.auto_source.geometry)
nodes = thaw(density_discr.nodes(), actx)
r = actx.np.sqrt(nodes[0] * nodes[0] + nodes[1] * nodes[1] +
nodes[2] * nodes[2])
phi = actx.np.arccos(nodes[2] / r)
theta = actx.np.arctan2(nodes[0], nodes[1])
ymn = unflatten(theta,
actx.from_numpy(
special.sph_harm(
mode_m, mode_n,
actx.to_numpy(flatten(theta, actx)),
actx.to_numpy(flatten(phi, actx)))),
actx,
strict=False)
from sumpy.kernel import LaplaceKernel
lap_knl = LaplaceKernel(3)
# {{{ single layer
s_sigma_op = bind(
places, sym.S(lap_knl, sym.var("sigma"), qbx_forced_limit=+1))
s_sigma = s_sigma_op(actx, sigma=ymn)
s_eigval = 1 / (2 * mode_n + 1)
h_max = actx.to_numpy(bind(places, sym.h_max(qbx.ambient_dim))(actx))
s_eoc_rec.add_data_point(h_max, rel_err(s_sigma, s_eigval * ymn))
# }}}
# {{{ double layer
d_sigma_op = bind(
places, sym.D(lap_knl, sym.var("sigma"), qbx_forced_limit="avg"))
d_sigma = d_sigma_op(actx, sigma=ymn)
d_eigval = -1 / (2 * (2 * mode_n + 1))
d_eoc_rec.add_data_point(h_max, rel_err(d_sigma, d_eigval * ymn))
# }}}
# {{{ S'
sp_sigma_op = bind(
places, sym.Sp(lap_knl, sym.var("sigma"), qbx_forced_limit="avg"))
sp_sigma = sp_sigma_op(actx, sigma=ymn)
sp_eigval = -1 / (2 * (2 * mode_n + 1))
sp_eoc_rec.add_data_point(h_max, rel_err(sp_sigma, sp_eigval * ymn))
# }}}
# {{{ D'
dp_sigma_op = bind(
places, sym.Dp(lap_knl, sym.var("sigma"), qbx_forced_limit="avg"))
dp_sigma = dp_sigma_op(actx, sigma=ymn)
dp_eigval = -(mode_n * (mode_n + 1)) / (2 * mode_n + 1)
dp_eoc_rec.add_data_point(h_max, rel_err(dp_sigma, dp_eigval * ymn))
# }}}
print("Errors for S:")
print(s_eoc_rec)
required_order = qbx_order + 1
assert s_eoc_rec.order_estimate() > required_order - 1.5
print("Errors for D:")
print(d_eoc_rec)
required_order = qbx_order
assert d_eoc_rec.order_estimate() > required_order - 0.5
print("Errors for S':")
print(sp_eoc_rec)
required_order = qbx_order
assert sp_eoc_rec.order_estimate() > required_order - 1.5
print("Errors for D':")
print(dp_eoc_rec)
required_order = qbx_order
assert dp_eoc_rec.order_estimate() > required_order - 1.5
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 get_mesh(self, resolution, mesh_order):
from meshmode.mesh.generation import generate_sphere
return generate_sphere(self.radius,
mesh_order,
uniform_refinement_rounds=resolution)
def run_exterior_stokes(actx_factory, *,
ambient_dim, target_order, qbx_order, resolution,
fmm_order=False, # FIXME: FMM is slower than direct evaluation
source_ovsmp=None,
radius=1.5,
mu=1.0,
visualize=False,
_target_association_tolerance=0.05,
_expansions_in_tree_have_extent=True):
actx = actx_factory()
# {{{ geometry
if source_ovsmp is None:
source_ovsmp = 4 if ambient_dim == 2 else 8
places = {}
if ambient_dim == 2:
from meshmode.mesh.generation import make_curve_mesh, ellipse
mesh = make_curve_mesh(
lambda t: radius * ellipse(1.0, t),
np.linspace(0.0, 1.0, resolution + 1),
target_order)
elif ambient_dim == 3:
from meshmode.mesh.generation import generate_sphere
mesh = generate_sphere(radius, target_order + 1,
uniform_refinement_rounds=resolution)
else:
raise ValueError(f"unsupported dimension: {ambient_dim}")
pre_density_discr = Discretization(actx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(target_order))
from pytential.qbx import QBXLayerPotentialSource
qbx = QBXLayerPotentialSource(pre_density_discr,
fine_order=source_ovsmp * target_order,
qbx_order=qbx_order,
fmm_order=fmm_order,
target_association_tolerance=_target_association_tolerance,
_expansions_in_tree_have_extent=_expansions_in_tree_have_extent)
places["source"] = qbx
from extra_int_eq_data import make_source_and_target_points
point_source, point_target = make_source_and_target_points(
actx,
side=+1,
inner_radius=0.5 * radius,
outer_radius=2.0 * radius,
ambient_dim=ambient_dim,
)
places["point_source"] = point_source
places["point_target"] = point_target
if visualize:
from sumpy.visualization import make_field_plotter_from_bbox
from meshmode.mesh.processing import find_bounding_box
fplot = make_field_plotter_from_bbox(
find_bounding_box(mesh),
h=0.1, extend_factor=1.0)
mask = np.linalg.norm(fplot.points, ord=2, axis=0) > (radius + 0.25)
from pytential.target import PointsTarget
plot_target = PointsTarget(fplot.points[:, mask].copy())
places["plot_target"] = plot_target
del mask
places = GeometryCollection(places, auto_where="source")
density_discr = places.get_discretization("source")
logger.info("ndofs: %d", density_discr.ndofs)
logger.info("nelements: %d", density_discr.mesh.nelements)
# }}}
# {{{ symbolic
sym_normal = sym.make_sym_vector("normal", ambient_dim)
sym_mu = sym.var("mu")
if ambient_dim == 2:
from pytential.symbolic.stokes import HsiaoKressExteriorStokesOperator
sym_omega = sym.make_sym_vector("omega", ambient_dim)
op = HsiaoKressExteriorStokesOperator(omega=sym_omega)
elif ambient_dim == 3:
from pytential.symbolic.stokes import HebekerExteriorStokesOperator
op = HebekerExteriorStokesOperator()
else:
raise AssertionError()
sym_sigma = op.get_density_var("sigma")
sym_bc = op.get_density_var("bc")
sym_op = op.operator(sym_sigma, normal=sym_normal, mu=sym_mu)
sym_rhs = op.prepare_rhs(sym_bc, mu=mu)
sym_velocity = op.velocity(sym_sigma, normal=sym_normal, mu=sym_mu)
sym_source_pot = op.stokeslet.apply(sym_sigma, sym_mu, qbx_forced_limit=None)
# }}}
# {{{ boundary conditions
normal = bind(places, sym.normal(ambient_dim).as_vector())(actx)
np.random.seed(42)
charges = make_obj_array([
actx.from_numpy(np.random.randn(point_source.ndofs))
for _ in range(ambient_dim)
])
if ambient_dim == 2:
total_charge = make_obj_array([
actx.to_numpy(actx.np.sum(c)) for c in charges
])
omega = bind(places, total_charge * sym.Ones())(actx)
if ambient_dim == 2:
bc_context = {"mu": mu, "omega": omega}
op_context = {"mu": mu, "omega": omega, "normal": normal}
else:
bc_context = {}
op_context = {"mu": mu, "normal": normal}
bc = bind(places, sym_source_pot,
auto_where=("point_source", "source"))(actx, sigma=charges, mu=mu)
rhs = bind(places, sym_rhs)(actx, bc=bc, **bc_context)
bound_op = bind(places, sym_op)
# }}}
# {{{ solve
from pytential.solve import gmres
gmres_tol = 1.0e-9
result = gmres(
bound_op.scipy_op(actx, "sigma", np.float64, **op_context),
rhs,
x0=rhs,
tol=gmres_tol,
progress=visualize,
stall_iterations=0,
hard_failure=True)
sigma = result.solution
# }}}
# {{{ check velocity at "point_target"
velocity = bind(places, sym_velocity,
auto_where=("source", "point_target"))(actx, sigma=sigma, **op_context)
ref_velocity = bind(places, sym_source_pot,
auto_where=("point_source", "point_target"))(actx, sigma=charges, mu=mu)
v_error = [
dof_array_rel_error(actx, u, uref)
for u, uref in zip(velocity, ref_velocity)]
h_max = actx.to_numpy(
bind(places, sym.h_max(ambient_dim))(actx)
)
logger.info("resolution %4d h_max %.5e error " + ("%.5e " * ambient_dim),
resolution, h_max, *v_error)
# }}}}
# {{{ visualize
if not visualize:
return h_max, v_error
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(actx, density_discr, target_order)
filename = "stokes_solution_{}d_{}_ovsmp_{}.vtu".format(
ambient_dim, resolution, source_ovsmp)
vis.write_vtk_file(filename, [
("density", sigma),
("bc", bc),
("rhs", rhs),
], overwrite=True)
# }}}
return h_max, v_error