h=(0.05, 0.05, 0.3),
extend_factor=0.3)
fplot_tgt = PointsTarget(actx.from_numpy(fplot.points))
places.update({
"qbx_target_tol": qbx_tgt_tol,
"plot_targets": fplot_tgt,
})
from pytential import GeometryCollection
places = GeometryCollection(places)
density_discr = places.get_discretization(places.auto_source.geometry)
# {{{ system solve
h_max = bind(places, sym.h_max(qbx.ambient_dim))(actx)
pde_test_inc = EHField(
vector_from_device(
actx.queue, eval_inc_field_at(places, target="patch_target")))
source_maxwell_resids = [
calc_patch.norm(x, np.inf) /
calc_patch.norm(pde_test_inc.e, np.inf)
for x in frequency_domain_maxwell(calc_patch, pde_test_inc.e,
pde_test_inc.h, case.k)
]
print("Source Maxwell residuals:", source_maxwell_resids)
assert max(source_maxwell_resids) < 1e-6
inc_field_scat = EHField(eval_inc_field_at(places,
for resolution in case.resolutions:
scat_mesh = case.get_mesh(resolution, case.target_order)
observation_mesh = case.get_observation_mesh(case.target_order)
pre_scat_discr = Discretization(
cl_ctx, scat_mesh,
InterpolatoryQuadratureSimplexGroupFactory(case.target_order))
qbx, _ = QBXLayerPotentialSource(
pre_scat_discr,
fine_order=4 * case.target_order,
qbx_order=case.qbx_order,
fmm_level_to_order=SimpleExpansionOrderFinder(case.fmm_tolerance),
fmm_backend=case.fmm_backend).with_refinement(
_expansion_disturbance_tolerance=0.05)
h_max = bind(qbx, sym.h_max(qbx.ambient_dim))(queue)
scat_discr = qbx.density_discr
obs_discr = Discretization(
cl_ctx, observation_mesh,
InterpolatoryQuadratureSimplexGroupFactory(case.target_order))
inc_field_scat = EHField(eval_inc_field_at(scat_discr))
inc_field_obs = EHField(eval_inc_field_at(obs_discr))
# {{{ system solve
inc_xyz_sym = EHField(sym.make_sym_vector("inc_fld", 6))
bound_j_op = bind(qbx, mfie.j_operator(loc_sign, jt_sym))
j_rhs = bind(qbx,
def test_sphere_eigenvalues(ctx_factory, mode_m, mode_n, qbx_order,
fmm_backend):
logging.basicConfig(level=logging.INFO)
special = pytest.importorskip("scipy.special")
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
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 (norm(density_discr, comp - ref) / norm(density_discr, ref))
for nrefinements in [0, 1]:
from meshmode.mesh.generation import generate_icosphere
mesh = generate_icosphere(1, target_order)
from meshmode.mesh.refinement import Refiner
refiner = Refiner(mesh)
for i in range(nrefinements):
flags = np.ones(mesh.nelements, dtype=bool)
refiner.refine(flags)
mesh = refiner.get_current_mesh()
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)
from meshmode.dof_array import flatten, unflatten, thaw
density_discr = places.get_discretization(places.auto_source.geometry)
nodes = thaw(actx, density_discr.nodes())
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(
actx, density_discr,
actx.from_numpy(
special.sph_harm(mode_m, mode_n, actx.to_numpy(flatten(theta)),
actx.to_numpy(flatten(phi)))))
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 = 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 test_ellipse_eigenvalues(ctx_factory,
ellipse_aspect,
mode_nr,
qbx_order,
force_direct,
visualize=False):
logging.basicConfig(level=logging.INFO)
print("ellipse_aspect: %s, mode_nr: %d, qbx_order: %d" %
(ellipse_aspect, mode_nr, qbx_order))
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
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()
if ellipse_aspect != 1:
nelements_values = [60, 100, 150, 200]
else:
nelements_values = [30, 70]
# See
#
# [1] G. J. Rodin and O. Steinbach, "Boundary Element Preconditioners
# for Problems Defined on Slender Domains", SIAM Journal on Scientific
# Computing, Vol. 24, No. 4, pg. 1450, 2003.
# https://dx.doi.org/10.1137/S1064827500372067
for nelements in nelements_values:
mesh = make_curve_mesh(partial(ellipse, ellipse_aspect),
np.linspace(0, 1, nelements + 1), target_order)
fmm_order = 12
if force_direct:
fmm_order = False
pre_density_discr = Discretization(
actx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(target_order))
qbx = QBXLayerPotentialSource(
pre_density_discr,
4 * target_order,
qbx_order,
fmm_order=fmm_order,
_expansions_in_tree_have_extent=True,
)
places = GeometryCollection(qbx)
density_discr = places.get_discretization(places.auto_source.geometry)
from meshmode.dof_array import thaw, flatten
nodes = thaw(actx, density_discr.nodes())
if visualize:
# plot geometry, centers, normals
centers = bind(places, sym.expansion_centers(qbx.ambient_dim,
+1))(actx)
normals = bind(places,
sym.normal(qbx.ambient_dim))(actx).as_vector(object)
nodes_h = np.array(
[actx.to_numpy(axis) for axis in flatten(nodes)])
centers_h = np.array(
[actx.to_numpy(axis) for axis in flatten(centers)])
normals_h = np.array(
[actx.to_numpy(axis) for axis in flatten(normals)])
pt.plot(nodes_h[0], nodes_h[1], "x-")
pt.plot(centers_h[0], centers_h[1], "o")
pt.quiver(nodes_h[0], nodes_h[1], normals_h[0], normals_h[1])
pt.gca().set_aspect("equal")
pt.show()
angle = actx.np.arctan2(nodes[1] * ellipse_aspect, nodes[0])
ellipse_fraction = ((1 - ellipse_aspect) /
(1 + ellipse_aspect))**mode_nr
# (2.6) in [1]
J = actx.np.sqrt( # noqa
actx.np.sin(angle)**2 +
(1 / ellipse_aspect)**2 * actx.np.cos(angle)**2)
from sumpy.kernel import LaplaceKernel
lap_knl = LaplaceKernel(2)
# {{{ single layer
sigma_sym = sym.var("sigma")
s_sigma_op = sym.S(lap_knl, sigma_sym, qbx_forced_limit=+1)
sigma = actx.np.cos(mode_nr * angle) / J
s_sigma = bind(places, s_sigma_op)(actx, sigma=sigma)
# SIGN BINGO! :)
s_eigval = 1 / (2 * mode_nr) * (1 + (-1)**mode_nr * ellipse_fraction)
# (2.12) in [1]
s_sigma_ref = s_eigval * J * sigma
if 0:
#pt.plot(s_sigma.get(), label="result")
#pt.plot(s_sigma_ref.get(), label="ref")
pt.plot(actx.to_numpy(flatten(s_sigma_ref - s_sigma)), label="err")
pt.legend()
pt.show()
h_max = bind(places, sym.h_max(qbx.ambient_dim))(actx)
s_err = (norm(density_discr, s_sigma - s_sigma_ref) /
norm(density_discr, s_sigma_ref))
s_eoc_rec.add_data_point(h_max, s_err)
# }}}
# {{{ double layer
d_sigma_op = sym.D(lap_knl, sigma_sym, qbx_forced_limit="avg")
sigma = actx.np.cos(mode_nr * angle)
d_sigma = bind(places, d_sigma_op)(actx, sigma=sigma)
# SIGN BINGO! :)
d_eigval = -(-1)**mode_nr * 1 / 2 * ellipse_fraction
d_sigma_ref = d_eigval * sigma
if 0:
pt.plot(actx.to_numpy(flatten(d_sigma)), label="result")
pt.plot(actx.to_numpy(flatten(d_sigma_ref)), label="ref")
pt.legend()
pt.show()
if ellipse_aspect == 1:
d_ref_norm = norm(density_discr, sigma)
else:
d_ref_norm = norm(density_discr, d_sigma_ref)
d_err = (norm(density_discr, d_sigma - d_sigma_ref) / d_ref_norm)
d_eoc_rec.add_data_point(h_max, d_err)
# }}}
if ellipse_aspect == 1:
# {{{ S'
sp_sigma_op = sym.Sp(lap_knl,
sym.var("sigma"),
qbx_forced_limit="avg")
sigma = actx.np.cos(mode_nr * angle)
sp_sigma = bind(places, sp_sigma_op)(actx, sigma=sigma)
sp_eigval = 0
sp_sigma_ref = sp_eigval * sigma
sp_err = (norm(density_discr, sp_sigma - sp_sigma_ref) /
norm(density_discr, sigma))
sp_eoc_rec.add_data_point(h_max, sp_err)
# }}}
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 - 1.5
if ellipse_aspect == 1:
print("Errors for S':")
print(sp_eoc_rec)
required_order = qbx_order
assert sp_eoc_rec.order_estimate() > required_order - 1.5
def test_3d_jump_relations(ctx_factory, relation, visualize=False):
# logging.basicConfig(level=logging.INFO)
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
if relation == "div_s":
target_order = 3
else:
target_order = 4
qbx_order = target_order
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
for nel_factor in [6, 10, 14]:
from meshmode.mesh.generation import generate_torus
mesh = generate_torus(
5, 2, order=target_order,
n_major=2*nel_factor, n_minor=nel_factor)
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
pre_discr = Discretization(
actx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(3))
from pytential.qbx import QBXLayerPotentialSource
qbx = QBXLayerPotentialSource(
pre_discr, fine_order=4*target_order,
qbx_order=qbx_order,
fmm_order=qbx_order + 5,
fmm_backend="fmmlib"
)
places = GeometryCollection(qbx)
density_discr = places.get_discretization(places.auto_source.geometry)
from sumpy.kernel import LaplaceKernel
knl = LaplaceKernel(3)
def nxcurlS(qbx_forced_limit):
return sym.n_cross(sym.curl(sym.S(
knl,
sym.cse(sym.tangential_to_xyz(density_sym), "jxyz"),
qbx_forced_limit=qbx_forced_limit)))
from meshmode.dof_array import thaw
x, y, z = thaw(actx, density_discr.nodes())
m = actx.np
if relation == "nxcurls":
density_sym = sym.make_sym_vector("density", 2)
jump_identity_sym = (
nxcurlS(+1)
- (nxcurlS("avg") + 0.5*sym.tangential_to_xyz(density_sym)))
# The tangential coordinate system is element-local, so we can't just
# conjure up some globally smooth functions, interpret their values
# in the tangential coordinate system, and be done. Instead, generate
# an XYZ function and project it.
density = bind(places,
sym.xyz_to_tangential(sym.make_sym_vector("jxyz", 3)))(
actx,
jxyz=sym.make_obj_array([
m.cos(0.5*x) * m.cos(0.5*y) * m.cos(0.5*z),
m.sin(0.5*x) * m.cos(0.5*y) * m.sin(0.5*z),
m.sin(0.5*x) * m.cos(0.5*y) * m.cos(0.5*z),
]))
elif relation == "sp":
density = m.cos(2*x) * m.cos(2*y) * m.cos(z)
density_sym = sym.var("density")
jump_identity_sym = (
sym.Sp(knl, density_sym, qbx_forced_limit=+1)
- (sym.Sp(knl, density_sym, qbx_forced_limit="avg")
- 0.5*density_sym))
elif relation == "div_s":
density = m.cos(2*x) * m.cos(2*y) * m.cos(z)
density_sym = sym.var("density")
jump_identity_sym = (
sym.div(sym.S(knl, sym.normal(3).as_vector()*density_sym,
qbx_forced_limit="avg"))
+ sym.D(knl, density_sym, qbx_forced_limit="avg"))
else:
raise ValueError("unexpected value of 'relation': %s" % relation)
bound_jump_identity = bind(places, jump_identity_sym)
jump_identity = bound_jump_identity(actx, density=density)
h_max = bind(places, sym.h_max(qbx.ambient_dim))(actx)
err = (
norm(density_discr, jump_identity, np.inf)
/ norm(density_discr, density, np.inf))
print("ERROR", h_max, err)
eoc_rec.add_data_point(h_max, err)
# {{{ visualization
if visualize and relation == "nxcurls":
nxcurlS_ext = bind(places, nxcurlS(+1))(actx, density=density)
nxcurlS_avg = bind(places, nxcurlS("avg"))(actx, density=density)
jtxyz = bind(places, sym.tangential_to_xyz(density_sym))(
actx, density=density)
from meshmode.discretization.visualization import make_visualizer
bdry_vis = make_visualizer(actx, qbx.density_discr, target_order+3)
bdry_normals = bind(places, sym.normal(3))(actx)\
.as_vector(dtype=object)
bdry_vis.write_vtk_file("source-%s.vtu" % nel_factor, [
("jt", jtxyz),
("nxcurlS_ext", nxcurlS_ext),
("nxcurlS_avg", nxcurlS_avg),
("bdry_normals", bdry_normals),
])
if visualize and relation == "sp":
op = sym.Sp(knl, density_sym, qbx_forced_limit=+1)
sp_ext = bind(places, op)(actx, density=density)
op = sym.Sp(knl, density_sym, qbx_forced_limit="avg")
sp_avg = bind(places, op)(actx, density=density)
from meshmode.discretization.visualization import make_visualizer
bdry_vis = make_visualizer(actx, qbx.density_discr, target_order+3)
bdry_normals = bind(places,
sym.normal(3))(actx).as_vector(dtype=object)
bdry_vis.write_vtk_file("source-%s.vtu" % nel_factor, [
("density", density),
("sp_ext", sp_ext),
("sp_avg", sp_avg),
("bdry_normals", bdry_normals),
])
# }}}
print(eoc_rec)
assert eoc_rec.order_estimate() >= qbx_order - 1.5
x0=rhs,
tol=1.0e-7,
progress=visualize,
stall_iterations=0,
hard_failure=True)
result = bind(places, sym.real(sym_result))(
actx, sigma=actx.np.real(result.solution),
**solution.context)
ref_result = solution.exact(actx, density_discr)
# }}}
from pytential import norm
h_max = actx.to_numpy(
bind(places, sym.h_max(places.ambient_dim))(actx)
)
error = actx.to_numpy(
norm(density_discr, result - ref_result, p=2)
/ norm(density_discr, ref_result, p=2)
)
eoc.add_data_point(h_max, error)
logger.info("resolution %3d h_max %.5e rel_error %.5e",
resolution, h_max, error)
if not visualize:
continue
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(actx, density_discr, case.target_order)
def run_exterior_stokes_2d(ctx_factory,
nelements,
mesh_order=4,
target_order=4,
qbx_order=4,
fmm_order=10,
mu=1,
circle_rad=1.5,
do_plot=False):
# This program tests an exterior Stokes flow in 2D using the
# compound representation given in Hsiao & Kress,
# ``On an integral equation for the two-dimensional exterior Stokes problem,''
# Applied Numerical Mathematics 1 (1985).
logging.basicConfig(level=logging.INFO)
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
ovsmp_target_order = 4 * target_order
from meshmode.mesh.generation import ( # noqa
make_curve_mesh, starfish, ellipse, drop)
mesh = make_curve_mesh(lambda t: circle_rad * ellipse(1, t),
np.linspace(0, 1, nelements + 1), target_order)
coarse_density_discr = Discretization(
cl_ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order))
from pytential.qbx import QBXLayerPotentialSource
target_association_tolerance = 0.05
qbx, _ = QBXLayerPotentialSource(
coarse_density_discr,
fine_order=ovsmp_target_order,
qbx_order=qbx_order,
fmm_order=fmm_order,
target_association_tolerance=target_association_tolerance,
_expansions_in_tree_have_extent=True,
).with_refinement()
density_discr = qbx.density_discr
normal = bind(density_discr, sym.normal(2).as_vector())(queue)
path_length = bind(density_discr, sym.integral(2, 1, 1))(queue)
# {{{ describe bvp
from pytential.symbolic.stokes import StressletWrapper, StokesletWrapper
dim = 2
cse = sym.cse
sigma_sym = sym.make_sym_vector("sigma", dim)
meanless_sigma_sym = cse(sigma_sym - sym.mean(2, 1, sigma_sym))
int_sigma = sym.Ones() * sym.integral(2, 1, sigma_sym)
nvec_sym = sym.make_sym_vector("normal", dim)
mu_sym = sym.var("mu")
# -1 for interior Dirichlet
# +1 for exterior Dirichlet
loc_sign = 1
stresslet_obj = StressletWrapper(dim=2)
stokeslet_obj = StokesletWrapper(dim=2)
bdry_op_sym = (-loc_sign * 0.5 * sigma_sym - stresslet_obj.apply(
sigma_sym, nvec_sym, mu_sym, qbx_forced_limit='avg') +
stokeslet_obj.apply(
meanless_sigma_sym, mu_sym, qbx_forced_limit='avg') -
(0.5 / np.pi) * int_sigma)
# }}}
bound_op = bind(qbx, bdry_op_sym)
# {{{ fix rhs and solve
def fund_soln(x, y, loc, strength):
#with direction (1,0) for point source
r = cl.clmath.sqrt((x - loc[0])**2 + (y - loc[1])**2)
scaling = strength / (4 * np.pi * mu)
xcomp = (-cl.clmath.log(r) + (x - loc[0])**2 / r**2) * scaling
ycomp = ((x - loc[0]) * (y - loc[1]) / r**2) * scaling
return [xcomp, ycomp]
def rotlet_soln(x, y, loc):
r = cl.clmath.sqrt((x - loc[0])**2 + (y - loc[1])**2)
xcomp = -(y - loc[1]) / r**2
ycomp = (x - loc[0]) / r**2
return [xcomp, ycomp]
def fund_and_rot_soln(x, y, loc, strength):
#with direction (1,0) for point source
r = cl.clmath.sqrt((x - loc[0])**2 + (y - loc[1])**2)
scaling = strength / (4 * np.pi * mu)
xcomp = ((-cl.clmath.log(r) + (x - loc[0])**2 / r**2) * scaling -
(y - loc[1]) * strength * 0.125 / r**2 + 3.3)
ycomp = (((x - loc[0]) * (y - loc[1]) / r**2) * scaling +
(x - loc[0]) * strength * 0.125 / r**2 + 1.5)
return [xcomp, ycomp]
nodes = density_discr.nodes().with_queue(queue)
fund_soln_loc = np.array([0.5, -0.2])
strength = 100.
bc = fund_and_rot_soln(nodes[0], nodes[1], fund_soln_loc, strength)
omega_sym = sym.make_sym_vector("omega", dim)
u_A_sym_bdry = stokeslet_obj.apply( # noqa: N806
omega_sym, mu_sym, qbx_forced_limit=1)
omega = [
cl.array.to_device(queue,
(strength / path_length) * np.ones(len(nodes[0]))),
cl.array.to_device(queue, np.zeros(len(nodes[0])))
]
bvp_rhs = bind(qbx,
sym.make_sym_vector("bc", dim) + u_A_sym_bdry)(queue,
bc=bc,
mu=mu,
omega=omega)
gmres_result = gmres(bound_op.scipy_op(queue,
"sigma",
np.float64,
mu=mu,
normal=normal),
bvp_rhs,
x0=bvp_rhs,
tol=1e-9,
progress=True,
stall_iterations=0,
hard_failure=True)
# }}}
# {{{ postprocess/visualize
sigma = gmres_result.solution
sigma_int_val_sym = sym.make_sym_vector("sigma_int_val", 2)
int_val = bind(qbx, sym.integral(2, 1, sigma_sym))(queue, sigma=sigma)
int_val = -int_val / (2 * np.pi)
print("int_val = ", int_val)
u_A_sym_vol = stokeslet_obj.apply( # noqa: N806
omega_sym, mu_sym, qbx_forced_limit=2)
representation_sym = (
-stresslet_obj.apply(sigma_sym, nvec_sym, mu_sym, qbx_forced_limit=2) +
stokeslet_obj.apply(meanless_sigma_sym, mu_sym, qbx_forced_limit=2) -
u_A_sym_vol + sigma_int_val_sym)
nsamp = 30
eval_points_1d = np.linspace(-3., 3., nsamp)
eval_points = np.zeros((2, len(eval_points_1d)**2))
eval_points[0, :] = np.tile(eval_points_1d, len(eval_points_1d))
eval_points[1, :] = np.repeat(eval_points_1d, len(eval_points_1d))
def circle_mask(test_points, radius):
return (test_points[0, :]**2 + test_points[1, :]**2 > radius**2)
def outside_circle(test_points, radius):
mask = circle_mask(test_points, radius)
return np.array([row[mask] for row in test_points])
eval_points = outside_circle(eval_points, radius=circle_rad)
from pytential.target import PointsTarget
vel = bind((qbx, PointsTarget(eval_points)),
representation_sym)(queue,
sigma=sigma,
mu=mu,
normal=normal,
sigma_int_val=int_val,
omega=omega)
print("@@@@@@@@")
fplot = FieldPlotter(np.zeros(2), extent=6, npoints=100)
plot_pts = outside_circle(fplot.points, radius=circle_rad)
plot_vel = bind((qbx, PointsTarget(plot_pts)),
representation_sym)(queue,
sigma=sigma,
mu=mu,
normal=normal,
sigma_int_val=int_val,
omega=omega)
def get_obj_array(obj_array):
return make_obj_array([ary.get() for ary in obj_array])
exact_soln = fund_and_rot_soln(cl.array.to_device(queue, eval_points[0]),
cl.array.to_device(queue, eval_points[1]),
fund_soln_loc, strength)
vel = get_obj_array(vel)
err = vel - get_obj_array(exact_soln)
# FIXME: Pointwise relative errors don't make sense!
rel_err = err / (get_obj_array(exact_soln))
if 0:
print("@@@@@@@@")
print("vel[0], err[0], rel_err[0] ***** vel[1], err[1], rel_err[1]: ")
for i in range(len(vel[0])):
print("%15.8e, %15.8e, %15.8e ***** %15.8e, %15.8e, %15.8e\n" %
(vel[0][i], err[0][i], rel_err[0][i], vel[1][i], err[1][i],
rel_err[1][i]))
print("@@@@@@@@")
l2_err = np.sqrt((6. / (nsamp - 1))**2 * np.sum(err[0] * err[0]) +
(6. / (nsamp - 1))**2 * np.sum(err[1] * err[1]))
l2_rel_err = np.sqrt((6. /
(nsamp - 1))**2 * np.sum(rel_err[0] * rel_err[0]) +
(6. /
(nsamp - 1))**2 * np.sum(rel_err[1] * rel_err[1]))
print("L2 error estimate: ", l2_err)
print("L2 rel error estimate: ", l2_rel_err)
print("max error at sampled points: ", max(abs(err[0])), max(abs(err[1])))
print("max rel error at sampled points: ", max(abs(rel_err[0])),
max(abs(rel_err[1])))
if do_plot:
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
full_pot = np.zeros_like(fplot.points) * float("nan")
mask = circle_mask(fplot.points, radius=circle_rad)
for i, vel in enumerate(plot_vel):
full_pot[i, mask] = vel.get()
plt.quiver(fplot.points[0],
fplot.points[1],
full_pot[0],
full_pot[1],
linewidth=0.1)
plt.savefig("exterior-2d-field.pdf")
# }}}
h_max = bind(qbx, sym.h_max(qbx.ambient_dim))(queue)
return h_max, l2_err
def test_3d_jump_relations(actx_factory, relation, visualize=False):
# logging.basicConfig(level=logging.INFO)
actx = actx_factory()
if relation == "div_s":
target_order = 3
else:
target_order = 4
qbx_order = target_order
if relation == "sp":
resolutions = [10, 14, 18]
else:
resolutions = [6, 10, 14]
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
for nel_factor in resolutions:
from meshmode.mesh.generation import generate_torus
mesh = generate_torus(
5,
2,
n_major=2 * nel_factor,
n_minor=nel_factor,
order=target_order,
)
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
pre_density_discr = Discretization(
actx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(target_order))
from pytential.qbx import QBXLayerPotentialSource
qbx = QBXLayerPotentialSource(pre_density_discr,
fine_order=5 * target_order,
qbx_order=qbx_order,
fmm_order=qbx_order + 5,
fmm_backend="fmmlib")
places = GeometryCollection(qbx)
density_discr = places.get_discretization(places.auto_source.geometry)
from sumpy.kernel import LaplaceKernel
knl = LaplaceKernel(places.ambient_dim)
def nxcurlS(qbx_forced_limit):
sigma_sym = sym.cse(sym.tangential_to_xyz(density_sym), "jxyz")
return sym.n_cross(
sym.curl(
sym.S(knl, sigma_sym, qbx_forced_limit=qbx_forced_limit)))
x, y, z = thaw(density_discr.nodes(), actx)
if relation == "nxcurls":
density_sym = sym.make_sym_vector("density", 2)
jump_identity_sym = (nxcurlS(+1) - nxcurlS("avg") -
0.5 * sym.tangential_to_xyz(density_sym))
# The tangential coordinate system is element-local, so we can't just
# conjure up some globally smooth functions, interpret their values
# in the tangential coordinate system, and be done. Instead, generate
# an XYZ function and project it.
jxyz = sym.make_obj_array([
actx.np.cos(0.5 * x) * actx.np.cos(0.5 * y) *
actx.np.cos(0.5 * z),
actx.np.sin(0.5 * x) * actx.np.cos(0.5 * y) *
actx.np.sin(0.5 * z),
actx.np.sin(0.5 * x) * actx.np.cos(0.5 * y) *
actx.np.cos(0.5 * z),
])
density = bind(
places,
sym.xyz_to_tangential(sym.make_sym_vector("jxyz",
3)))(actx, jxyz=jxyz)
elif relation == "sp":
density_sym = sym.var("density")
jump_identity_sym = (
0.5 * density_sym +
sym.Sp(knl, density_sym, qbx_forced_limit=+1) -
sym.Sp(knl, density_sym, qbx_forced_limit="avg"))
density = actx.np.cos(2 * x) * actx.np.cos(2 * y) * actx.np.cos(z)
elif relation == "div_s":
density_sym = sym.var("density")
sigma_sym = sym.normal(
places.ambient_dim).as_vector() * density_sym
jump_identity_sym = (
sym.div(sym.S(knl, sigma_sym, qbx_forced_limit="avg")) +
sym.D(knl, density_sym, qbx_forced_limit="avg"))
density = actx.np.cos(2 * x) * actx.np.cos(2 * y) * actx.np.cos(z)
else:
raise ValueError(f"unexpected value of 'relation': '{relation}'")
bound_jump_identity = bind(places, jump_identity_sym)
jump_identity = bound_jump_identity(actx, density=density)
h_max = actx.to_numpy(
bind(places, sym.h_max(places.ambient_dim))(actx))
err = actx.to_numpy(
norm(density_discr, jump_identity, np.inf) /
norm(density_discr, density, np.inf))
eoc_rec.add_data_point(h_max, err)
logging.info("error: nel %d h_max %.5e %.5e", nel_factor, h_max, err)
# {{{ visualization
if not visualize:
continue
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(actx, density_discr, target_order)
normals = bind(places,
sym.normal(places.ambient_dim).as_vector())(actx)
error = actx.np.log10(actx.np.abs(jump_identity) + 1.0e-15)
if relation == "nxcurls":
nxcurlS_ext = bind(places, nxcurlS(+1))(actx, density=density)
nxcurlS_avg = bind(places, nxcurlS("avg"))(actx, density=density)
jtxyz = bind(places,
sym.tangential_to_xyz(density_sym))(actx,
density=density)
vis.write_vtk_file(f"source-nxcurls-{nel_factor:03d}.vtu", [
("jt", jtxyz),
("nxcurlS_ext", nxcurlS_ext),
("nxcurlS_avg", nxcurlS_avg),
("bdry_normals", normals),
("error", error),
])
elif relation == "sp":
op = sym.Sp(knl, density_sym, qbx_forced_limit=+1)
sp_ext = bind(places, op)(actx, density=density)
op = sym.Sp(knl, density_sym, qbx_forced_limit="avg")
sp_avg = bind(places, op)(actx, density=density)
vis.write_vtk_file(f"source-sp-{nel_factor:03d}.vtu", [
("density", density),
("sp_ext", sp_ext),
("sp_avg", sp_avg),
("bdry_normals", normals),
("error", error),
])
elif relation == "div_s":
vis.write_vtk_file(f"source-div-{nel_factor:03d}.vtu", [
("density", density),
("bdry_normals", normals),
("error", error),
])
# }}}
logger.info("\n%s", str(eoc_rec))
assert eoc_rec.order_estimate() >= qbx_order - 1.5
def run_exterior_stokes(
ctx_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):
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
# {{{ 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_icosphere
mesh = generate_icosphere(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(
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:
assert False
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.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"
def rnorm2(x, y):
y_norm = actx.np.linalg.norm(y.dot(y), ord=2)
if y_norm < 1.0e-14:
y_norm = 1.0
d = x - y
return actx.np.linalg.norm(d.dot(d), ord=2) / y_norm
ps_velocity = bind(places,
sym_velocity,
auto_where=("source", "point_target"))(actx,
sigma=sigma,
**op_context)
ex_velocity = bind(places,
sym_source_pot,
auto_where=("point_source",
"point_target"))(actx, sigma=charges, mu=mu)
v_error = rnorm2(ps_velocity, ex_velocity)
h_max = bind(places, sym.h_max(ambient_dim))(actx)
logger.info("resolution %4d h_max %.5e error %.5e", 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
