def get_extension_bie_symbolic_operator(loc_sign=1):
"""
loc_sign:
-1 for interior Dirichlet
+1 for exterior Dirichlet
"""
logger = logging.getLogger("SETUP")
logger.info(locals())
dim = 2
cse = sym.cse
sigma_sym = sym.make_sym_vector("sigma", dim)
int_sigma = sym.Ones() * sym.integral(2, 1, sigma_sym)
nvec_sym = sym.make_sym_vector("normal", dim)
mu_sym = sym.var("mu")
stresslet_obj = StressletWrapper(dim=dim)
stokeslet_obj = StokesletWrapper(dim=dim)
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(sigma_sym, mu_sym, qbx_forced_limit='avg') +
int_sigma)
return bdry_op_sym
def make_unknown(self, name):
num_densities = (2 * (int(self.ez_enabled) + int(self.hz_enabled)) *
len(self.interfaces))
assert num_densities == len(self.bcs)
return sym.make_sym_vector(name, num_densities)
def get_operator(self, ambient_dim, qbx_forced_limit="avg"):
knl = self.knl_class(ambient_dim)
kwargs = self.knl_sym_kwargs.copy()
kwargs["qbx_forced_limit"] = qbx_forced_limit
if self.op_type == "scalar":
sym_u = sym.var("u")
sym_op = sym.S(knl, sym_u, **kwargs)
elif self.op_type == "scalar_mixed":
sym_u = sym.var("u")
sym_op = sym.S(knl, 0.3 * sym_u, **kwargs) \
+ sym.D(knl, 0.5 * sym_u, **kwargs)
elif self.op_type == "vector":
sym_u = sym.make_sym_vector("u", ambient_dim)
sym_op = make_obj_array([
sym.Sp(knl, sym_u[0], **kwargs) +
sym.D(knl, sym_u[1], **kwargs),
sym.S(knl, 0.4 * sym_u[0], **kwargs) +
0.3 * sym.D(knl, sym_u[0], **kwargs)
])
else:
raise ValueError(f"unknown operator type: '{self.op_type}'")
sym_op = 0.5 * sym_u + sym_op
return sym_u, sym_op
def make_unknown(self, name):
num_densities = (
2
* (int(self.ez_enabled) + int(self.hz_enabled))
* len(self.interfaces))
assert num_densities == len(self.bcs)
return sym.make_sym_vector(name, num_densities)
def __init__(self, dim=None):
if dim == 2:
d = sym.make_sym_vector("d", dim)
z = d[0] + var("I") * d[1]
expr = z
scaling = -1 / (8 * var("pi"))
else:
raise NotImplementedError("unsupported dimensionality")
super(ComplexLinearKernel, self).__init__(dim,
expression=expr,
global_scaling_const=scaling,
is_complex_valued=True)
def __init__(self, dim=None):
if dim == 2:
d = sym.make_sym_vector("d", dim)
z = d[0] + var("I") * d[1]
conj_z = d[0] - var("I") * d[1]
r = var("sqrt")(np.dot(conj_z, z))
expr = var("log")(r)
scaling = 1 / (4 * var("pi"))
else:
raise NotImplementedError("unsupported dimensionality")
super(ComplexLogKernel, self).__init__(dim,
expression=expr,
global_scaling_const=scaling,
is_complex_valued=True)
def _build_op(lpot_id,
k=0,
ndim=2,
source=sym.DEFAULT_SOURCE,
target=sym.DEFAULT_TARGET,
qbx_forced_limit="avg"):
from sumpy.kernel import LaplaceKernel, HelmholtzKernel
if k:
knl = HelmholtzKernel(ndim)
knl_kwargs = {"k": k}
else:
knl = LaplaceKernel(ndim)
knl_kwargs = {}
lpot_kwargs = {
"qbx_forced_limit": qbx_forced_limit,
"source": source,
"target": target}
lpot_kwargs.update(knl_kwargs)
if lpot_id == 1:
# scalar single-layer potential
u_sym = sym.var("u")
op = sym.S(knl, u_sym, **lpot_kwargs)
elif lpot_id == 2:
# scalar combination of layer potentials
u_sym = sym.var("u")
op = sym.S(knl, 0.3 * u_sym, **lpot_kwargs) \
+ sym.D(knl, 0.5 * u_sym, **lpot_kwargs)
elif lpot_id == 3:
# vector potential
u_sym = sym.make_sym_vector("u", 2)
u0_sym, u1_sym = u_sym
op = make_obj_array([
sym.Sp(knl, u0_sym, **lpot_kwargs)
+ sym.D(knl, u1_sym, **lpot_kwargs),
sym.S(knl, 0.4 * u0_sym, **lpot_kwargs)
+ 0.3 * sym.D(knl, u0_sym, **lpot_kwargs)
])
else:
raise ValueError("Unknown lpot_id: {}".format(lpot_id))
op = 0.5 * u_sym + op
return op, u_sym, knl_kwargs
def get_density_var(self, name: str):
"""
:returns: a symbolic array corresponding to the density
with the given *name*.
"""
return sym.make_sym_vector(name, 2)
def make_unknown(self, name):
return sym.make_sym_vector(name, 6)
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 main(nelements):
import logging
logging.basicConfig(level=logging.INFO)
def get_obj_array(obj_array):
from pytools.obj_array import make_obj_array
return make_obj_array([
ary.get()
for ary in obj_array
])
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
from meshmode.mesh.generation import ( # noqa
make_curve_mesh, starfish, ellipse, drop)
mesh = make_curve_mesh(
lambda t: starfish(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,
).with_refinement()
density_discr = qbx.density_discr
nodes = density_discr.nodes().with_queue(queue)
# Get normal vectors for the density discretization -- used in integration with stresslet
mv_normal = bind(density_discr, sym.normal(2))(queue)
normal = mv_normal.as_vector(np.object)
# {{{ describe bvp
from sumpy.kernel import LaplaceKernel
from pytential.symbolic.stokes import StressletWrapper
from pytools.obj_array import make_obj_array
dim=2
cse = sym.cse
nvec_sym = sym.make_sym_vector("normal", dim)
sigma_sym = sym.make_sym_vector("sigma", dim)
mu_sym = sym.var("mu")
sqrt_w = sym.sqrt_jac_q_weight(2)
inv_sqrt_w_sigma = cse(sigma_sym/sqrt_w)
# -1 for interior Dirichlet
# +1 for exterior Dirichlet
loc_sign = -1
# Create stresslet object
stresslet_obj = StressletWrapper(dim=2)
# Describe boundary operator
bdry_op_sym = loc_sign * 0.5 * sigma_sym + sqrt_w * stresslet_obj.apply(inv_sqrt_w_sigma, nvec_sym, mu_sym, qbx_forced_limit='avg')
# Bind to the qbx discretization
bound_op = bind(qbx, bdry_op_sym)
# }}}
# {{{ fix rhs and solve
def fund_soln(x, y, loc):
#with direction (1,0) for point source
r = cl.clmath.sqrt((x - loc[0])**2 + (y - loc[1])**2)
scaling = 1./(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 couette_soln(x, y, dp, h):
scaling = 1./(2*mu)
xcomp = scaling * dp * ((y+(h/2.))**2 - h * (y+(h/2.)))
ycomp = scaling * 0*y
return [xcomp, ycomp]
if soln_type == 'fundamental':
pt_loc = np.array([2.0, 0.0])
bc = fund_soln(nodes[0], nodes[1], pt_loc)
else:
dp = -10.
h = 2.5
bc = couette_soln(nodes[0], nodes[1], dp, h)
# Get rhs vector
bvp_rhs = bind(qbx, sqrt_w*sym.make_sym_vector("bc",dim))(queue, bc=bc)
from pytential.solve import gmres
gmres_result = gmres(
bound_op.scipy_op(queue, "sigma", np.float64, mu=mu, normal=normal),
bvp_rhs, tol=1e-9, progress=True,
stall_iterations=0,
hard_failure=True)
# }}}
# {{{ postprocess/visualize
sigma = gmres_result.solution
# Describe representation of solution for evaluation in domain
representation_sym = stresslet_obj.apply(inv_sqrt_w_sigma, nvec_sym, mu_sym, qbx_forced_limit=-2)
from sumpy.visualization import FieldPlotter
nsamp = 10
eval_points_1d = np.linspace(-1., 1., 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))
gamma_sym = sym.var("gamma")
inv_sqrt_w_gamma = cse(gamma_sym/sqrt_w)
constant_laplace_rep = sym.D(LaplaceKernel(dim=2), inv_sqrt_w_gamma, qbx_forced_limit=None)
sqrt_w_vec = bind(qbx, sqrt_w)(queue)
def general_mask(test_points):
const_density = bind((qbx, PointsTarget(test_points)), constant_laplace_rep)(queue, gamma=sqrt_w_vec).get()
return (abs(const_density) > 0.1)
def inside_domain(test_points):
mask = general_mask(test_points)
return np.array([
row[mask]
for row in test_points])
def stride_hack(arr):
from numpy.lib.stride_tricks import as_strided
return np.array(as_strided(arr, strides=(8 * len(arr[0]), 8)))
eval_points = inside_domain(eval_points)
eval_points_dev = cl.array.to_device(queue, eval_points)
# Evaluate the solution at the evaluation points
vel = bind(
(qbx, PointsTarget(eval_points_dev)),
representation_sym)(queue, sigma=sigma, mu=mu, normal=normal)
print("@@@@@@@@")
vel = get_obj_array(vel)
if soln_type == 'fundamental':
exact_soln = fund_soln(eval_points_dev[0], eval_points_dev[1], pt_loc)
else:
exact_soln = couette_soln(eval_points_dev[0], eval_points_dev[1], dp, h)
err = vel - get_obj_array(exact_soln)
print("@@@@@@@@")
print("L2 error estimate: ", np.sqrt((2./(nsamp-1))**2*np.sum(err[0]*err[0]) + (2./(nsamp-1))**2*np.sum(err[1]*err[1])))
max_error_loc = [abs(err[0]).argmax(), abs(err[1]).argmax()]
print("max error at sampled points: ", max(abs(err[0])), max(abs(err[1])))
print("exact velocity at max error points: x -> ", err[0][max_error_loc[0]], ", y -> ", err[1][max_error_loc[1]])
from pytential.symbolic.mappers import DerivativeTaker
rep_pressure = stresslet_obj.apply_pressure(inv_sqrt_w_sigma, nvec_sym, mu_sym, qbx_forced_limit=-2)
pressure = bind((qbx, PointsTarget(eval_points_dev)),
rep_pressure)(queue, sigma=sigma, mu=mu, normal=normal)
pressure = pressure.get()
print "pressure = ", pressure
x_dir_vecs = np.zeros((2,len(eval_points[0])))
x_dir_vecs[0,:] = 1.0
y_dir_vecs = np.zeros((2, len(eval_points[0])))
y_dir_vecs[1,:] = 1.0
x_dir_vecs = cl.array.to_device(queue, x_dir_vecs)
y_dir_vecs = cl.array.to_device(queue, y_dir_vecs)
dir_vec_sym = sym.make_sym_vector("force_direction", dim)
rep_stress = stresslet_obj.apply_stress(inv_sqrt_w_sigma, nvec_sym, dir_vec_sym, mu_sym, qbx_forced_limit=-2)
applied_stress_x = bind((qbx, PointsTarget(eval_points_dev)),
rep_stress)(queue, sigma=sigma, normal=normal, force_direction=x_dir_vecs, mu=mu)
applied_stress_x = get_obj_array(applied_stress_x)
applied_stress_y = bind((qbx, PointsTarget(eval_points_dev)),
rep_stress)(queue, sigma=sigma, normal=normal, force_direction=y_dir_vecs, mu=mu)
applied_stress_y = get_obj_array(applied_stress_y)
print "stress applied to x direction: ", applied_stress_x
print "stress applied to y direction: ", applied_stress_y
import matplotlib.pyplot as plt
plt.quiver(eval_points[0], eval_points[1], vel[0], vel[1], linewidth=0.1)
file_name = "field-n%s.pdf"%(nelements)
plt.savefig(file_name)
return (max(abs(err[0])), max(abs(err[1])))
def test_3d_jump_relations(ctx_factory, relation, visualize=False):
# logging.basicConfig(level=logging.INFO)
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
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_outer=2*nel_factor, n_inner=nel_factor)
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
pre_discr = Discretization(
cl_ctx, 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"
).with_refinement()
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)))
x, y, z = qbx.density_discr.nodes().with_queue(queue)
m = cl.clmath
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(
qbx,
sym.xyz_to_tangential(sym.make_sym_vector("jxyz", 3)))(
queue,
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(qbx, jump_identity_sym)
jump_identity = bound_jump_identity(queue, density=density)
err = (
norm(qbx, queue, jump_identity, np.inf)
/ norm(qbx, queue, density, np.inf))
print("ERROR", qbx.h_max, err)
eoc_rec.add_data_point(qbx.h_max, err)
# {{{ visualization
if visualize and relation == "nxcurls":
nxcurlS_ext = bind(qbx, nxcurlS(+1))(queue, density=density)
nxcurlS_avg = bind(qbx, nxcurlS("avg"))(queue, density=density)
jtxyz = bind(qbx, sym.tangential_to_xyz(density_sym))(
queue, density=density)
from meshmode.discretization.visualization import make_visualizer
bdry_vis = make_visualizer(queue, qbx.density_discr, target_order+3)
bdry_normals = bind(qbx, sym.normal(3))(queue)\
.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":
sp_ext = bind(qbx, sym.Sp(knl, density_sym, qbx_forced_limit=+1))(
queue, density=density)
sp_avg = bind(qbx, sym.Sp(knl, density_sym, qbx_forced_limit="avg"))(
queue, density=density)
from meshmode.discretization.visualization import make_visualizer
bdry_vis = make_visualizer(queue, qbx.density_discr, target_order+3)
bdry_normals = bind(qbx, sym.normal(3))(queue)\
.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
xx = fd.SpatialCoordinate(m)
r"""
..math:
\ln(\sqrt{(x+1)^2 + (y+1)^2})
i.e. a shift of the fundamental solution
"""
expr = fd.ln(fd.sqrt((xx[0] + 2)**2 + (xx[1] + 2)**2))
f = fd.Function(V).interpolate(expr)
gradf = fd.Function(Vdim).interpolate(fd.grad(expr))
# Let's create an operator which plugs in f, \partial_n f
# to Green's formula
sigma = sym.make_sym_vector("sigma", 2)
op = -(sym.D(LaplaceKernel(2),
sym.var("u"),
qbx_forced_limit=None)
- sym.S(LaplaceKernel(2),
sym.n_dot(sigma),
qbx_forced_limit=None))
from meshmode.mesh import BTAG_ALL
outer_bdy_id = BTAG_ALL
# Think of this like :mod:`pytential`'s :function:`bind`
pyt_op = fd2mm.fd_bind(cl_ctx,
fspace_analog, op, source=(V, outer_bdy_id),
target=V, with_refinement=with_refinement,
qbx_kwargs=qbx_kwargs
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
def make_unknown(self, name):
return sym.make_sym_vector(name, len(self.unknown_index))
def compute_biharmonic_extension(queue,
target_discr,
qbx,
density_discr,
f,
fx,
fy,
target_association_tolerance=0.05):
"""Biharmoc extension. Currently only support
interior domains in 2D (i.e., extension is on the exterior).
"""
# pylint: disable=invalid-unary-operand-type
dim = 2
queue = setup_command_queue(queue=queue)
qbx_forced_limit = 1
normal = get_normal_vectors(queue, density_discr, loc_sign=1)
bdry_op_sym = get_extension_bie_symbolic_operator(loc_sign=1)
bound_op = bind(qbx, bdry_op_sym)
bc = [fy, -fx]
bvp_rhs = bind(qbx, sym.make_sym_vector("bc", dim))(queue, bc=bc)
gmres_result = gmres(bound_op.scipy_op(queue,
"sigma",
np.float64,
mu=1.,
normal=normal),
bvp_rhs,
tol=1e-9,
progress=True,
stall_iterations=0,
hard_failure=True)
mu = gmres_result.solution
arclength_parametrization_derivatives_sym = sym.make_sym_vector(
"arclength_parametrization_derivatives", dim)
density_mu_sym = sym.make_sym_vector("mu", dim)
dxids_sym = arclength_parametrization_derivatives_sym[0] + \
1j * arclength_parametrization_derivatives_sym[1]
dxids_conj_sym = arclength_parametrization_derivatives_sym[0] - \
1j * arclength_parametrization_derivatives_sym[1]
density_rho_sym = density_mu_sym[1] - 1j * density_mu_sym[0]
density_conj_rho_sym = density_mu_sym[1] + 1j * density_mu_sym[0]
# convolutions
GS1 = sym.IntG( # noqa: N806
ComplexLinearLogKernel(dim),
density_rho_sym,
qbx_forced_limit=None)
GS2 = sym.IntG( # noqa: N806
ComplexLinearKernel(dim),
density_conj_rho_sym,
qbx_forced_limit=None)
GD1 = sym.IntG( # noqa: N806
ComplexFractionalKernel(dim),
density_rho_sym * dxids_sym,
qbx_forced_limit=None)
GD2 = [
sym.IntG( # noqa: N806
AxisTargetDerivative(iaxis, ComplexLogKernel(dim)),
density_conj_rho_sym * dxids_sym +
density_rho_sym * dxids_conj_sym,
qbx_forced_limit=qbx_forced_limit) for iaxis in range(dim)
]
GS1_bdry = sym.IntG( # noqa: N806
ComplexLinearLogKernel(dim),
density_rho_sym,
qbx_forced_limit=qbx_forced_limit)
GS2_bdry = sym.IntG( # noqa: N806
ComplexLinearKernel(dim),
density_conj_rho_sym,
qbx_forced_limit=qbx_forced_limit)
GD1_bdry = sym.IntG( # noqa: N806
ComplexFractionalKernel(dim),
density_rho_sym * dxids_sym,
qbx_forced_limit=qbx_forced_limit)
xp, yp = get_arclength_parametrization_derivative(queue, density_discr)
xp = -xp
yp = -yp
tangent = get_tangent_vectors(queue,
density_discr,
loc_sign=qbx_forced_limit)
# check and fix the direction of parametrization
# logger.info("Fix all negative signs in:" +
# str(xp * tangent[0] + yp * tangent[1]))
grad_v2 = [
bind(qbx,
GD2[iaxis])(queue,
mu=mu,
arclength_parametrization_derivatives=make_obj_array(
[xp, yp])).real for iaxis in range(dim)
]
v2_tangent_der = sum(tangent[iaxis] * grad_v2[iaxis]
for iaxis in range(dim))
from pytential.symbolic.pde.scalar import NeumannOperator
from sumpy.kernel import LaplaceKernel
operator_v1 = NeumannOperator(LaplaceKernel(dim),
loc_sign=qbx_forced_limit)
bound_op_v1 = bind(qbx, operator_v1.operator(var("sigma")))
# FIXME: the positive sign works here
rhs_v1 = operator_v1.prepare_rhs(1 * v2_tangent_der)
gmres_result = gmres(bound_op_v1.scipy_op(queue, "sigma",
dtype=np.float64),
rhs_v1,
tol=1e-9,
progress=True,
stall_iterations=0,
hard_failure=True)
sigma = gmres_result.solution
qbx_stick_out = qbx.copy(
target_association_tolerance=target_association_tolerance)
v1 = bind((qbx_stick_out, target_discr),
operator_v1.representation(var("sigma"),
qbx_forced_limit=None))(queue,
sigma=sigma)
grad_v1 = bind(
(qbx_stick_out, target_discr),
operator_v1.representation(
var("sigma"),
qbx_forced_limit=None,
map_potentials=lambda pot: sym.grad(dim, pot)))(queue, sigma=sigma)
v1_bdry = bind(
qbx,
operator_v1.representation(var("sigma"),
qbx_forced_limit=qbx_forced_limit))(
queue, sigma=sigma)
z_conj = target_discr.nodes()[0] - 1j * target_discr.nodes()[1]
z_conj_bdry = density_discr.nodes().with_queue(queue)[0] \
- 1j * density_discr.nodes().with_queue(queue)[1]
int_rho = 1 / (8 * np.pi) * bind(
qbx, sym.integral(dim, dim - 1, density_rho_sym))(queue, mu=mu)
omega_S1 = bind( # noqa: N806
(qbx_stick_out, target_discr), GS1)(queue, mu=mu).real
omega_S2 = -1 * bind( # noqa: N806
(qbx_stick_out, target_discr), GS2)(queue, mu=mu).real
omega_S3 = (z_conj * int_rho).real # noqa: N806
omega_S = -(omega_S1 + omega_S2 + omega_S3) # noqa: N806
grad_omega_S1 = bind( # noqa: N806
(qbx_stick_out, target_discr), sym.grad(dim, GS1))(queue, mu=mu).real
grad_omega_S2 = -1 * bind( # noqa: N806
(qbx_stick_out, target_discr), sym.grad(dim, GS2))(queue, mu=mu).real
grad_omega_S3 = (int_rho * make_obj_array([1., -1.])).real # noqa: N806
grad_omega_S = -(grad_omega_S1 + grad_omega_S2 + grad_omega_S3
) # noqa: N806
omega_S1_bdry = bind(qbx, GS1_bdry)(queue, mu=mu).real # noqa: N806
omega_S2_bdry = -1 * bind(qbx, GS2_bdry)(queue, mu=mu).real # noqa: N806
omega_S3_bdry = (z_conj_bdry * int_rho).real # noqa: N806
omega_S_bdry = -(omega_S1_bdry + omega_S2_bdry + omega_S3_bdry
) # noqa: N806
omega_D1 = bind( # noqa: N806
(qbx_stick_out, target_discr),
GD1)(queue,
mu=mu,
arclength_parametrization_derivatives=make_obj_array([xp,
yp])).real
omega_D = (omega_D1 + v1) # noqa: N806
grad_omega_D1 = bind( # noqa: N806
(qbx_stick_out, target_discr), sym.grad(dim, GD1))(
queue,
mu=mu,
arclength_parametrization_derivatives=make_obj_array([xp,
yp])).real
grad_omega_D = grad_omega_D1 + grad_v1 # noqa: N806
omega_D1_bdry = bind( # noqa: N806
qbx, GD1_bdry)(queue,
mu=mu,
arclength_parametrization_derivatives=make_obj_array(
[xp, yp])).real
omega_D_bdry = (omega_D1_bdry + v1_bdry) # noqa: N806
int_bdry_mu = bind(
qbx, sym.integral(dim, dim - 1, sym.make_sym_vector("mu", dim)))(queue,
mu=mu)
omega_W = ( # noqa: N806
int_bdry_mu[0] * target_discr.nodes()[1] -
int_bdry_mu[1] * target_discr.nodes()[0])
grad_omega_W = make_obj_array( # noqa: N806
[-int_bdry_mu[1], int_bdry_mu[0]])
omega_W_bdry = ( # noqa: N806
int_bdry_mu[0] * density_discr.nodes().with_queue(queue)[1] -
int_bdry_mu[1] * density_discr.nodes().with_queue(queue)[0])
int_bdry = bind(qbx, sym.integral(dim, dim - 1, var("integrand")))(
queue, integrand=omega_S_bdry + omega_D_bdry + omega_W_bdry)
debugging_info = {}
debugging_info['omega_S'] = omega_S
debugging_info['omega_D'] = omega_D
debugging_info['omega_W'] = omega_W
debugging_info['omega_v1'] = v1
debugging_info['omega_D1'] = omega_D1
int_interior_func_bdry = bind(qbx,
sym.integral(2, 1,
var("integrand")))(queue,
integrand=f)
path_length = get_path_length(queue, density_discr)
ext_f = omega_S + omega_D + omega_W + (int_interior_func_bdry -
int_bdry) / path_length
grad_f = grad_omega_S + grad_omega_D + grad_omega_W
return ext_f, grad_f[0], grad_f[1], debugging_info
def make_unknown(self, name):
return sym.make_sym_vector(name, 2)
def get_density_var(self, name="sigma"):
"""
:returns: a symbolic vector corresponding to the density.
"""
return sym.make_sym_vector(name, self.ambient_dim)
def make_unknown(self, name):
return sym.make_sym_vector(name, len(self.unknown_index))
\f{1}{4\pi \sqrt{(x-2)^2 + (y-2)^2 + (z-2)^2)}}
i.e. a shift of the fundamental solution
"""
expr = fd.Constant(1 / 4 / fd.pi) * 1 / fd.sqrt(
(x - 2)**2 + (y - 2)**2 + (z-2)**2)
f = fd.Function(V).interpolate(expr)
gradf = fd.Function(Vdim).interpolate(fd.grad(expr))
# Let's create an operator which plugs in f, \partial_n f
# to Green's formula
qbx_forced_limit = None
sigma = sym.make_sym_vector("sigma", ambient_dim)
op = -(sym.D(LaplaceKernel(ambient_dim),
sym.var("u"),
qbx_forced_limit=qbx_forced_limit)
- sym.S(LaplaceKernel(ambient_dim),
sym.n_dot(sigma),
qbx_forced_limit=qbx_forced_limit))
from meshmode.mesh import BTAG_ALL
outer_bdy_id = BTAG_ALL
# Think of this like :mod:`pytential`'s :function:`bind`
pyt_op = fd2mm.fd_bind(cl_ctx, fspace_analog, op, source=(V, outer_bdy_id),
target=V, with_refinement=with_refinement,
qbx_kwargs=qbx_kwargs)
def main(nelements):
import logging
logging.basicConfig(level=logging.INFO)
def get_obj_array(obj_array):
from pytools.obj_array import make_obj_array
return make_obj_array([ary.get() for ary in obj_array])
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
from meshmode.mesh.generation import ( # noqa
make_curve_mesh, starfish, ellipse, drop)
mesh = make_curve_mesh(lambda t: starfish(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,
).with_refinement()
density_discr = qbx.density_discr
nodes = density_discr.nodes().with_queue(queue)
# Get normal vectors for the density discretization -- used in integration with stresslet
mv_normal = bind(density_discr, sym.normal(2))(queue)
normal = mv_normal.as_vector(np.object)
# {{{ describe bvp
from sumpy.kernel import LaplaceKernel
from pytential.symbolic.stokes import StressletWrapper
from pytools.obj_array import make_obj_array
dim = 2
cse = sym.cse
nvec_sym = sym.make_sym_vector("normal", dim)
sigma_sym = sym.make_sym_vector("sigma", dim)
mu_sym = sym.var("mu")
sqrt_w = sym.sqrt_jac_q_weight(2)
inv_sqrt_w_sigma = cse(sigma_sym / sqrt_w)
# -1 for interior Dirichlet
# +1 for exterior Dirichlet
loc_sign = -1
# Create stresslet object
stresslet_obj = StressletWrapper(dim=2)
# Describe boundary operator
bdry_op_sym = loc_sign * 0.5 * sigma_sym + sqrt_w * stresslet_obj.apply(
inv_sqrt_w_sigma, nvec_sym, mu_sym, qbx_forced_limit='avg')
# Bind to the qbx discretization
bound_op = bind(qbx, bdry_op_sym)
# }}}
# {{{ fix rhs and solve
def fund_soln(x, y, loc):
#with direction (1,0) for point source
r = cl.clmath.sqrt((x - loc[0])**2 + (y - loc[1])**2)
scaling = 1. / (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 couette_soln(x, y, dp, h):
scaling = 1. / (2 * mu)
xcomp = scaling * dp * ((y + (h / 2.))**2 - h * (y + (h / 2.)))
ycomp = scaling * 0 * y
return [xcomp, ycomp]
if soln_type == 'fundamental':
pt_loc = np.array([2.0, 0.0])
bc = fund_soln(nodes[0], nodes[1], pt_loc)
else:
dp = -10.
h = 2.5
bc = couette_soln(nodes[0], nodes[1], dp, h)
# Get rhs vector
bvp_rhs = bind(qbx, sqrt_w * sym.make_sym_vector("bc", dim))(queue, bc=bc)
from pytential.solve import gmres
gmres_result = gmres(bound_op.scipy_op(queue,
"sigma",
np.float64,
mu=mu,
normal=normal),
bvp_rhs,
tol=1e-9,
progress=True,
stall_iterations=0,
hard_failure=True)
# }}}
# {{{ postprocess/visualize
sigma = gmres_result.solution
# Describe representation of solution for evaluation in domain
representation_sym = stresslet_obj.apply(inv_sqrt_w_sigma,
nvec_sym,
mu_sym,
qbx_forced_limit=-2)
from sumpy.visualization import FieldPlotter
nsamp = 10
eval_points_1d = np.linspace(-1., 1., 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))
gamma_sym = sym.var("gamma")
inv_sqrt_w_gamma = cse(gamma_sym / sqrt_w)
constant_laplace_rep = sym.D(LaplaceKernel(dim=2),
inv_sqrt_w_gamma,
qbx_forced_limit=None)
sqrt_w_vec = bind(qbx, sqrt_w)(queue)
def general_mask(test_points):
const_density = bind((qbx, PointsTarget(test_points)),
constant_laplace_rep)(queue,
gamma=sqrt_w_vec).get()
return (abs(const_density) > 0.1)
def inside_domain(test_points):
mask = general_mask(test_points)
return np.array([row[mask] for row in test_points])
def stride_hack(arr):
from numpy.lib.stride_tricks import as_strided
return np.array(as_strided(arr, strides=(8 * len(arr[0]), 8)))
eval_points = inside_domain(eval_points)
eval_points_dev = cl.array.to_device(queue, eval_points)
# Evaluate the solution at the evaluation points
vel = bind((qbx, PointsTarget(eval_points_dev)),
representation_sym)(queue, sigma=sigma, mu=mu, normal=normal)
print("@@@@@@@@")
vel = get_obj_array(vel)
if soln_type == 'fundamental':
exact_soln = fund_soln(eval_points_dev[0], eval_points_dev[1], pt_loc)
else:
exact_soln = couette_soln(eval_points_dev[0], eval_points_dev[1], dp,
h)
err = vel - get_obj_array(exact_soln)
print("@@@@@@@@")
print(
"L2 error estimate: ",
np.sqrt((2. / (nsamp - 1))**2 * np.sum(err[0] * err[0]) +
(2. / (nsamp - 1))**2 * np.sum(err[1] * err[1])))
max_error_loc = [abs(err[0]).argmax(), abs(err[1]).argmax()]
print("max error at sampled points: ", max(abs(err[0])), max(abs(err[1])))
print("exact velocity at max error points: x -> ",
err[0][max_error_loc[0]], ", y -> ", err[1][max_error_loc[1]])
from pytential.symbolic.mappers import DerivativeTaker
rep_pressure = stresslet_obj.apply_pressure(inv_sqrt_w_sigma,
nvec_sym,
mu_sym,
qbx_forced_limit=-2)
pressure = bind((qbx, PointsTarget(eval_points_dev)),
rep_pressure)(queue, sigma=sigma, mu=mu, normal=normal)
pressure = pressure.get()
print "pressure = ", pressure
x_dir_vecs = np.zeros((2, len(eval_points[0])))
x_dir_vecs[0, :] = 1.0
y_dir_vecs = np.zeros((2, len(eval_points[0])))
y_dir_vecs[1, :] = 1.0
x_dir_vecs = cl.array.to_device(queue, x_dir_vecs)
y_dir_vecs = cl.array.to_device(queue, y_dir_vecs)
dir_vec_sym = sym.make_sym_vector("force_direction", dim)
rep_stress = stresslet_obj.apply_stress(inv_sqrt_w_sigma,
nvec_sym,
dir_vec_sym,
mu_sym,
qbx_forced_limit=-2)
applied_stress_x = bind((qbx, PointsTarget(eval_points_dev)),
rep_stress)(queue,
sigma=sigma,
normal=normal,
force_direction=x_dir_vecs,
mu=mu)
applied_stress_x = get_obj_array(applied_stress_x)
applied_stress_y = bind((qbx, PointsTarget(eval_points_dev)),
rep_stress)(queue,
sigma=sigma,
normal=normal,
force_direction=y_dir_vecs,
mu=mu)
applied_stress_y = get_obj_array(applied_stress_y)
print "stress applied to x direction: ", applied_stress_x
print "stress applied to y direction: ", applied_stress_y
import matplotlib.pyplot as plt
plt.quiver(eval_points[0], eval_points[1], vel[0], vel[1], linewidth=0.1)
file_name = "field-n%s.pdf" % (nelements)
plt.savefig(file_name)
return (max(abs(err[0])), max(abs(err[1])))
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
"""For (say) is_interior=False (the 'exterior' MFIE), this test verifies
extinction of the combined (incoming + scattered) field on the interior
of the scatterer.
"""
logging.basicConfig(level=logging.INFO)
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
np.random.seed(12)
knl_kwargs = {"k": case.k}
# {{{ come up with a solution to Maxwell's equations
j_sym = sym.make_sym_vector("j", 3)
jt_sym = sym.make_sym_vector("jt", 2)
rho_sym = sym.var("rho")
from pytential.symbolic.pde.maxwell import (PECChargeCurrentMFIEOperator,
get_sym_maxwell_point_source,
get_sym_maxwell_plane_wave)
mfie = PECChargeCurrentMFIEOperator()
test_source = case.get_source(queue)
calc_patch = CalculusPatch(np.array([-3, 0, 0]), h=0.01)
calc_patch_tgt = PointsTarget(cl.array.to_device(queue, calc_patch.points))
rng = cl.clrandom.PhiloxGenerator(cl_ctx, seed=12)
src_j = rng.normal(queue, (3, test_source.nnodes), dtype=np.float64)
def nonlocal_integral_eq(
mesh,
scatterer_bdy_id,
outer_bdy_id,
wave_number,
options_prefix=None,
solver_parameters=None,
fspace=None,
vfspace=None,
true_sol_grad=None,
queue=None,
fspace_analog=None,
qbx_kwargs=None,
):
r"""
see run_method for descriptions of unlisted args
args:
:arg queue: A command queue for the computing context
gamma and beta are used to precondition
with the following equation:
\Delta u - \kappa^2 \gamma u = 0
(\partial_n - i\kappa\beta) u |_\Sigma = 0
"""
with_refinement = True
# away from the excluded region, but firedrake and meshmode point
# into
pyt_inner_normal_sign = -1
ambient_dim = mesh.geometric_dimension()
# {{{ Create operator
from pytential import sym
r"""
..math:
x \in \Sigma
grad_op(x) =
\nabla(
\int_\Gamma(
u(y) \partial_n H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
)
"""
grad_op = pyt_inner_normal_sign * sym.grad(
ambient_dim,
sym.D(HelmholtzKernel(ambient_dim),
sym.var("u"),
k=sym.var("k"),
qbx_forced_limit=None))
r"""
..math:
x \in \Sigma
op(x) =
i \kappa \cdot
\int_\Gamma(
u(y) \partial_n H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
"""
op = pyt_inner_normal_sign * 1j * sym.var("k") * (sym.D(
HelmholtzKernel(ambient_dim),
sym.var("u"),
k=sym.var("k"),
qbx_forced_limit=None))
pyt_grad_op = fd2mm.fd_bind(
queue.context,
fspace_analog,
grad_op,
source=(fspace, scatterer_bdy_id),
target=(vfspace, outer_bdy_id),
with_refinement=with_refinement,
qbx_kwargs=qbx_kwargs,
)
pyt_op = fd2mm.fd_bind(
queue.context,
fspace_analog,
op,
source=(fspace, scatterer_bdy_id),
target=(fspace, outer_bdy_id),
with_refinement=with_refinement,
qbx_kwargs=qbx_kwargs,
)
# }}}
class MatrixFreeB(object):
def __init__(self, A, pyt_grad_op, pyt_op, queue, kappa):
"""
:arg kappa: The wave number
"""
self.queue = queue
self.k = kappa
self.pyt_op = pyt_op
self.pyt_grad_op = pyt_grad_op
self.A = A
# {{{ Create some functions needed for multing
self.x_fntn = Function(fspace)
self.potential_int = Function(fspace)
self.potential_int.dat.data[:] = 0.0
self.grad_potential_int = Function(vfspace)
self.grad_potential_int.dat.data[:] = 0.0
self.pyt_result = Function(fspace)
self.n = FacetNormal(mesh)
self.v = TestFunction(fspace)
# }}}
def mult(self, mat, x, y):
# Perform pytential operation
self.x_fntn.dat.data[:] = x[:]
self.pyt_op(self.queue,
self.potential_int,
u=self.x_fntn,
k=self.k)
self.pyt_grad_op(self.queue,
self.grad_potential_int,
u=self.x_fntn,
k=self.k)
# Integrate the potential
r"""
Compute the inner products using firedrake. Note this
will be subtracted later, hence appears off by a sign.
.. math::
\langle
n(x) \cdot \nabla(
\int_\Gamma(
u(y) \partial_n H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
), v
\rangle_\Sigma
- \langle
i \kappa \cdot
\int_\Gamma(
u(y) \partial_n H_0^{(1)}(\kappa |x - y|)
)d\gamma(y), v
\rangle_\Sigma
"""
self.pyt_result = assemble(
inner(inner(self.grad_potential_int, self.n), self.v) *
ds(outer_bdy_id) -
inner(self.potential_int, self.v) * ds(outer_bdy_id))
# y <- Ax - evaluated potential
self.A.mult(x, y)
with self.pyt_result.dat.vec_ro as ep:
y.axpy(-1, ep)
# {{{ Compute normal helmholtz operator
u = TrialFunction(fspace)
v = TestFunction(fspace)
r"""
.. math::
\langle
\nabla u, \nabla v
\rangle
- \kappa^2 \cdot \langle
u, v
\rangle
- i \kappa \langle
u, v
\rangle_\Sigma
"""
a = inner(grad(u), grad(v)) * dx \
- Constant(wave_number**2) * inner(u, v) * dx \
- Constant(1j * wave_number) * inner(u, v) * ds(outer_bdy_id)
# get the concrete matrix from a general bilinear form
A = assemble(a).M.handle
# }}}
# {{{ Setup Python matrix
B = PETSc.Mat().create()
# build matrix context
Bctx = MatrixFreeB(A, pyt_grad_op, pyt_op, queue, wave_number)
# set up B as same size as A
B.setSizes(*A.getSizes())
B.setType(B.Type.PYTHON)
B.setPythonContext(Bctx)
B.setUp()
# }}}
# {{{ Create rhs
# Remember f is \partial_n(true_sol)|_\Gamma
# so we just need to compute \int_\Gamma\partial_n(true_sol) H(x-y)
from pytential import sym
sigma = sym.make_sym_vector("sigma", ambient_dim)
r"""
..math:
x \in \Sigma
grad_op(x) =
\nabla(
\int_\Gamma(
f(y) H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
)
"""
grad_op = pyt_inner_normal_sign * \
sym.grad(ambient_dim, sym.S(HelmholtzKernel(ambient_dim),
sym.n_dot(sigma),
k=sym.var("k"), qbx_forced_limit=None))
r"""
..math:
x \in \Sigma
op(x) =
i \kappa \cdot
\int_\Gamma(
f(y) H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
)
"""
op = 1j * sym.var("k") * pyt_inner_normal_sign * \
sym.S(HelmholtzKernel(ambient_dim),
sym.n_dot(sigma),
k=sym.var("k"),
qbx_forced_limit=None)
rhs_grad_op = fd2mm.fd_bind(
queue.context,
fspace_analog,
grad_op,
source=(vfspace, scatterer_bdy_id),
target=(vfspace, outer_bdy_id),
with_refinement=with_refinement,
qbx_kwargs=qbx_kwargs,
)
rhs_op = fd2mm.fd_bind(
queue.context,
fspace_analog,
op,
source=(vfspace, scatterer_bdy_id),
target=(fspace, outer_bdy_id),
with_refinement=with_refinement,
qbx_kwargs=qbx_kwargs,
)
f_grad_convoluted = Function(vfspace)
f_convoluted = Function(fspace)
rhs_grad_op(queue, f_grad_convoluted, sigma=true_sol_grad, k=wave_number)
rhs_op(queue, f_convoluted, sigma=true_sol_grad, k=wave_number)
r"""
\langle
f, v
\rangle_\Gamma
+ \langle
i \kappa \cdot \int_\Gamma(
f(y) H_0^{(1)}(\kappa |x - y|)
)d\gamma(y), v
\rangle_\Sigma
- \langle
n(x) \cdot \nabla(
\int_\Gamma(
f(y) H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
), v
\rangle_\Sigma
"""
rhs_form = inner(inner(true_sol_grad, FacetNormal(mesh)),
v) * ds(scatterer_bdy_id) \
+ inner(f_convoluted, v) * ds(outer_bdy_id) \
- inner(inner(f_grad_convoluted, FacetNormal(mesh)),
v) * ds(outer_bdy_id)
rhs = assemble(rhs_form)
# {{{ set up a solver:
solution = Function(fspace, name="Computed Solution")
# {{{ Used for preconditioning
if 'gamma' in solver_parameters or 'beta' in solver_parameters:
gamma = complex(solver_parameters.pop('gamma', 1.0))
import cmath
beta = complex(solver_parameters.pop('beta', cmath.sqrt(gamma)))
p = inner(grad(u), grad(v)) * dx \
- Constant(wave_number**2 * gamma) * inner(u, v) * dx \
- Constant(1j * wave_number * beta) * inner(u, v) * ds(outer_bdy_id)
P = assemble(p).M.handle
else:
P = A
# }}}
# Set up options to contain solver parameters:
ksp = PETSc.KSP().create()
if solver_parameters['pc_type'] == 'pyamg':
del solver_parameters['pc_type'] # We are using the AMG preconditioner
pyamg_tol = solver_parameters.get('pyamg_tol', None)
if pyamg_tol is not None:
pyamg_tol = float(pyamg_tol)
pyamg_maxiter = solver_parameters.get('pyamg_maxiter', None)
if pyamg_maxiter is not None:
pyamg_maxiter = int(pyamg_maxiter)
ksp.setOperators(B)
ksp.setUp()
pc = ksp.pc
pc.setType(pc.Type.PYTHON)
pc.setPythonContext(
AMGTransmissionPreconditioner(wave_number,
fspace,
A,
tol=pyamg_tol,
maxiter=pyamg_maxiter,
use_plane_waves=True))
# Otherwise use regular preconditioner
else:
ksp.setOperators(B, P)
options_manager = OptionsManager(solver_parameters, options_prefix)
options_manager.set_from_options(ksp)
with rhs.dat.vec_ro as b:
with solution.dat.vec as x:
ksp.solve(b, x)
# }}}
return ksp, solution
def test_greens_formula(degree, family, ambient_dim):
fine_order = 4 * degree
# Parameter to tune accuracy of pytential
fmm_order = 5
# This should be (order of convergence = qbx_order + 1)
qbx_order = degree
with_refinement = True
qbx_kwargs = {
'fine_order': fine_order,
'fmm_order': fmm_order,
'qbx_order': qbx_order
}
if ambient_dim == 2:
mesh = mesh2d
r"""
..math:
\ln(\sqrt{(x+1)^2 + (y+1)^2})
i.e. a shift of the fundamental solution
"""
x, y = fd.SpatialCoordinate(mesh)
expr = fd.ln(fd.sqrt((x + 2)**2 + (y + 2)**2))
elif ambient_dim == 3:
mesh = mesh3d
x, y, z = fd.SpatialCoordinate(mesh)
r"""
..math:
\f{1}{4\pi \sqrt{(x-2)^2 + (y-2)^2 + (z-2)^2)}}
i.e. a shift of the fundamental solution
"""
expr = fd.Constant(1 / 4 / fd.pi) * 1 / fd.sqrt((x - 2)**2 +
(y - 2)**2 +
(z - 2)**2)
else:
raise ValueError("Ambient dimension must be 2 or 3, not %s" %
ambient_dim)
# Let's compute some layer potentials!
V = fd.FunctionSpace(mesh, family, degree)
Vdim = fd.VectorFunctionSpace(mesh, family, degree)
mesh_analog = fd2mm.MeshAnalog(mesh)
fspace_analog = fd2mm.FunctionSpaceAnalog(cl_ctx, mesh_analog, V)
true_sol = fd.Function(V).interpolate(expr)
grad_true_sol = fd.Function(Vdim).interpolate(fd.grad(expr))
# Let's create an operator which plugs in f, \partial_n f
# to Green's formula
sigma = sym.make_sym_vector("sigma", ambient_dim)
op = -(sym.D(
LaplaceKernel(ambient_dim), sym.var("u"), qbx_forced_limit=None) -
sym.S(LaplaceKernel(ambient_dim),
sym.n_dot(sigma),
qbx_forced_limit=None))
from meshmode.mesh import BTAG_ALL
outer_bdy_id = BTAG_ALL
# Think of this like :mod:`pytential`'s :function:`bind`
pyt_op = fd2mm.fd_bind(cl_ctx,
fspace_analog,
op,
source=(V, outer_bdy_id),
target=V,
qbx_kwargs=qbx_kwargs,
with_refinement=with_refinement)
# Compute the operation and store in result
result = fd.Function(V)
pyt_op(queue, u=true_sol, sigma=grad_true_sol, result_function=result)
# Compare with f
fnorm = fd.sqrt(fd.assemble(fd.inner(true_sol, true_sol) * fd.dx))
l2_err = fd.sqrt(
fd.assemble(fd.inner(true_sol - result, true_sol - result) * fd.dx))
rel_l2_err = l2_err / fnorm
# TODO: Make this more strict
assert rel_l2_err < 0.09
def main():
# cl.array.to_device(queue, numpy_array)
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(
FileSource("ellipsoid.step"), 2, order=2,
other_options=["-string", "Mesh.CharacteristicLengthMax = %g;" % h])
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=qbx_order + 10, fmm_backend="fmmlib")
from pytential.symbolic.pde.maxwell import MuellerAugmentedMFIEOperator
pde_op = MuellerAugmentedMFIEOperator(
omega=0.4,
epss=[1.4, 1.0],
mus=[1.2, 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(0, 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)
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 0:
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=bvp_rhs,k=k)
fld_at_tgt = np.array([
fi.get() for fi in fld_at_tgt
])
print(fld_at_tgt)
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_tgt_tol = qbx.copy(target_association_tolerance=0.1)
from pytential.target import PointsTarget
from pytential.qbx import QBXTargetAssociationFailedException
rho_sym = sym.var("rho")
try:
fld_in_vol = bind(
(qbx_tgt_tol, 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_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 nonlocal_integral_eq(
mesh,
scatterer_bdy_id,
outer_bdy_id,
wave_number,
options_prefix=None,
solver_parameters=None,
fspace=None,
vfspace=None,
true_sol_grad_expr=None,
actx=None,
dgfspace=None,
dgvfspace=None,
meshmode_src_connection=None,
qbx_kwargs=None,
):
r"""
see run_method for descriptions of unlisted args
args:
gamma and beta are used to precondition
with the following equation:
\Delta u - \kappa^2 \gamma u = 0
(\partial_n - i\kappa\beta) u |_\Sigma = 0
"""
# make sure we get outer bdy id as tuple in case it consists of multiple ids
if isinstance(outer_bdy_id, int):
outer_bdy_id = [outer_bdy_id]
outer_bdy_id = tuple(outer_bdy_id)
# away from the excluded region, but firedrake and meshmode point
# into
pyt_inner_normal_sign = -1
ambient_dim = mesh.geometric_dimension()
# {{{ Build src and tgt
# build connection meshmode near src boundary -> src boundary inside meshmode
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
from meshmode.discretization.connection import make_face_restriction
factory = InterpolatoryQuadratureSimplexGroupFactory(
dgfspace.finat_element.degree)
src_bdy_connection = make_face_restriction(actx,
meshmode_src_connection.discr,
factory, scatterer_bdy_id)
# source is a qbx layer potential
from pytential.qbx import QBXLayerPotentialSource
disable_refinement = (fspace.mesh().geometric_dimension() == 3)
qbx = QBXLayerPotentialSource(src_bdy_connection.to_discr,
**qbx_kwargs,
_disable_refinement=disable_refinement)
# get target indices and point-set
target_indices, target = get_target_points_and_indices(
fspace, outer_bdy_id)
# }}}
# build the operations
from pytential import bind, sym
r"""
..math:
x \in \Sigma
grad_op(x) =
\nabla(
\int_\Gamma(
u(y) \partial_n H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
)
"""
grad_op = pyt_inner_normal_sign * sym.grad(
ambient_dim,
sym.D(HelmholtzKernel(ambient_dim),
sym.var("u"),
k=sym.var("k"),
qbx_forced_limit=None))
r"""
..math:
x \in \Sigma
op(x) =
i \kappa \cdot
\int_\Gamma(
u(y) \partial_n H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
"""
op = pyt_inner_normal_sign * 1j * sym.var("k") * (sym.D(
HelmholtzKernel(ambient_dim),
sym.var("u"),
k=sym.var("k"),
qbx_forced_limit=None))
# bind the operations
pyt_grad_op = bind((qbx, target), grad_op)
pyt_op = bind((qbx, target), op)
# }}}
class MatrixFreeB(object):
def __init__(self, A, pyt_grad_op, pyt_op, actx, kappa):
"""
:arg kappa: The wave number
"""
self.actx = actx
self.k = kappa
self.pyt_op = pyt_op
self.pyt_grad_op = pyt_grad_op
self.A = A
self.meshmode_src_connection = meshmode_src_connection
# {{{ Create some functions needed for multing
self.x_fntn = Function(fspace)
# CG
self.potential_int = Function(fspace)
self.potential_int.dat.data[:] = 0.0
self.grad_potential_int = Function(vfspace)
self.grad_potential_int.dat.data[:] = 0.0
self.pyt_result = Function(fspace)
self.n = FacetNormal(mesh)
self.v = TestFunction(fspace)
# some meshmode ones
self.x_mm_fntn = self.meshmode_src_connection.discr.empty(
self.actx, dtype='c')
# }}}
def mult(self, mat, x, y):
# Copy function data into the fivredrake function
self.x_fntn.dat.data[:] = x[:]
# Transfer the function to meshmode
self.meshmode_src_connection.from_firedrake(project(
self.x_fntn, dgfspace),
out=self.x_mm_fntn)
# Restrict to boundary
x_mm_fntn_on_bdy = src_bdy_connection(self.x_mm_fntn)
# Apply the operation
potential_int_mm = self.pyt_op(self.actx,
u=x_mm_fntn_on_bdy,
k=self.k)
grad_potential_int_mm = self.pyt_grad_op(self.actx,
u=x_mm_fntn_on_bdy,
k=self.k)
# Store in firedrake
self.potential_int.dat.data[target_indices] = potential_int_mm.get(
)
for dim in range(grad_potential_int_mm.shape[0]):
self.grad_potential_int.dat.data[
target_indices, dim] = grad_potential_int_mm[dim].get()
# Integrate the potential
r"""
Compute the inner products using firedrake. Note this
will be subtracted later, hence appears off by a sign.
.. math::
\langle
n(x) \cdot \nabla(
\int_\Gamma(
u(y) \partial_n H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
), v
\rangle_\Sigma
- \langle
i \kappa \cdot
\int_\Gamma(
u(y) \partial_n H_0^{(1)}(\kappa |x - y|)
)d\gamma(y), v
\rangle_\Sigma
"""
self.pyt_result = assemble(
inner(inner(self.grad_potential_int, self.n), self.v) *
ds(outer_bdy_id) -
inner(self.potential_int, self.v) * ds(outer_bdy_id))
# y <- Ax - evaluated potential
self.A.mult(x, y)
with self.pyt_result.dat.vec_ro as ep:
y.axpy(-1, ep)
# {{{ Compute normal helmholtz operator
u = TrialFunction(fspace)
v = TestFunction(fspace)
r"""
.. math::
\langle
\nabla u, \nabla v
\rangle
- \kappa^2 \cdot \langle
u, v
\rangle
- i \kappa \langle
u, v
\rangle_\Sigma
"""
a = inner(grad(u), grad(v)) * dx \
- Constant(wave_number**2) * inner(u, v) * dx \
- Constant(1j * wave_number) * inner(u, v) * ds(outer_bdy_id)
# get the concrete matrix from a general bilinear form
A = assemble(a).M.handle
# }}}
# {{{ Setup Python matrix
B = PETSc.Mat().create()
# build matrix context
Bctx = MatrixFreeB(A, pyt_grad_op, pyt_op, actx, wave_number)
# set up B as same size as A
B.setSizes(*A.getSizes())
B.setType(B.Type.PYTHON)
B.setPythonContext(Bctx)
B.setUp()
# }}}
# {{{ Create rhs
# Remember f is \partial_n(true_sol)|_\Gamma
# so we just need to compute \int_\Gamma\partial_n(true_sol) H(x-y)
sigma = sym.make_sym_vector("sigma", ambient_dim)
r"""
..math:
x \in \Sigma
grad_op(x) =
\nabla(
\int_\Gamma(
f(y) H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
)
"""
grad_op = pyt_inner_normal_sign * \
sym.grad(ambient_dim, sym.S(HelmholtzKernel(ambient_dim),
sym.n_dot(sigma),
k=sym.var("k"), qbx_forced_limit=None))
r"""
..math:
x \in \Sigma
op(x) =
i \kappa \cdot
\int_\Gamma(
f(y) H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
)
"""
op = 1j * sym.var("k") * pyt_inner_normal_sign * \
sym.S(HelmholtzKernel(ambient_dim),
sym.n_dot(sigma),
k=sym.var("k"),
qbx_forced_limit=None)
rhs_grad_op = bind((qbx, target), grad_op)
rhs_op = bind((qbx, target), op)
# Transfer to meshmode
metadata = {'quadrature_degree': 2 * fspace.ufl_element().degree()}
dg_true_sol_grad = project(true_sol_grad_expr,
dgvfspace,
form_compiler_parameters=metadata)
true_sol_grad_mm = meshmode_src_connection.from_firedrake(dg_true_sol_grad,
actx=actx)
true_sol_grad_mm = src_bdy_connection(true_sol_grad_mm)
# Apply the operations
f_grad_convoluted_mm = rhs_grad_op(actx,
sigma=true_sol_grad_mm,
k=wave_number)
f_convoluted_mm = rhs_op(actx, sigma=true_sol_grad_mm, k=wave_number)
# Transfer function back to firedrake
f_grad_convoluted = Function(vfspace)
f_convoluted = Function(fspace)
f_grad_convoluted.dat.data[:] = 0.0
f_convoluted.dat.data[:] = 0.0
for dim in range(f_grad_convoluted_mm.shape[0]):
f_grad_convoluted.dat.data[target_indices,
dim] = f_grad_convoluted_mm[dim].get()
f_convoluted.dat.data[target_indices] = f_convoluted_mm.get()
r"""
\langle
f, v
\rangle_\Gamma
+ \langle
i \kappa \cdot \int_\Gamma(
f(y) H_0^{(1)}(\kappa |x - y|)
)d\gamma(y), v
\rangle_\Sigma
- \langle
n(x) \cdot \nabla(
\int_\Gamma(
f(y) H_0^{(1)}(\kappa |x - y|)
)d\gamma(y)
), v
\rangle_\Sigma
"""
rhs_form = inner(inner(true_sol_grad_expr, FacetNormal(mesh)),
v) * ds(scatterer_bdy_id, metadata=metadata) \
+ inner(f_convoluted, v) * ds(outer_bdy_id) \
- inner(inner(f_grad_convoluted, FacetNormal(mesh)),
v) * ds(outer_bdy_id)
rhs = assemble(rhs_form)
# {{{ set up a solver:
solution = Function(fspace, name="Computed Solution")
# {{{ Used for preconditioning
if 'gamma' in solver_parameters or 'beta' in solver_parameters:
gamma = complex(solver_parameters.pop('gamma', 1.0))
import cmath
beta = complex(solver_parameters.pop('beta', cmath.sqrt(gamma)))
p = inner(grad(u), grad(v)) * dx \
- Constant(wave_number**2 * gamma) * inner(u, v) * dx \
- Constant(1j * wave_number * beta) * inner(u, v) * ds(outer_bdy_id)
P = assemble(p).M.handle
else:
P = A
# }}}
# Set up options to contain solver parameters:
ksp = PETSc.KSP().create()
if solver_parameters['pc_type'] == 'pyamg':
del solver_parameters['pc_type'] # We are using the AMG preconditioner
pyamg_tol = solver_parameters.get('pyamg_tol', None)
if pyamg_tol is not None:
pyamg_tol = float(pyamg_tol)
pyamg_maxiter = solver_parameters.get('pyamg_maxiter', None)
if pyamg_maxiter is not None:
pyamg_maxiter = int(pyamg_maxiter)
ksp.setOperators(B)
ksp.setUp()
pc = ksp.pc
pc.setType(pc.Type.PYTHON)
pc.setPythonContext(
AMGTransmissionPreconditioner(wave_number,
fspace,
A,
tol=pyamg_tol,
maxiter=pyamg_maxiter,
use_plane_waves=True))
# Otherwise use regular preconditioner
else:
ksp.setOperators(B, P)
options_manager = OptionsManager(solver_parameters, options_prefix)
options_manager.set_from_options(ksp)
import petsc4py.PETSc
petsc4py.PETSc.Sys.popErrorHandler()
with rhs.dat.vec_ro as b:
with solution.dat.vec as x:
ksp.solve(b, x)
# }}}
return ksp, solution
def main():
# cl.array.to_device(queue, numpy_array)
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(
FileSource("ellipsoid.step"),
2,
order=2,
other_options=["-string",
"Mesh.CharacteristicLengthMax = %g;" % h])
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=qbx_order + 10,
fmm_backend="fmmlib")
from pytential.symbolic.pde.maxwell import MuellerAugmentedMFIEOperator
pde_op = MuellerAugmentedMFIEOperator(
omega=0.4,
epss=[1.4, 1.0],
mus=[1.2, 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(0, 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)
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 0:
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=bvp_rhs, k=k)
fld_at_tgt = np.array([fi.get() for fi in fld_at_tgt])
print(fld_at_tgt)
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_tgt_tol = qbx.copy(target_association_tolerance=0.1)
from pytential.target import PointsTarget
from pytential.qbx import QBXTargetAssociationFailedException
rho_sym = sym.var("rho")
try:
fld_in_vol = bind((qbx_tgt_tol, 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 get_density_var(self, name):
"""
Returns a symbolic variable of length 2 corresponding to the density with
the given name.
"""
return sym.make_sym_vector(name, 2)
def test_pec_mfie_extinction(ctx_getter, case, visualize=False):
"""For (say) is_interior=False (the 'exterior' MFIE), this test verifies
extinction of the combined (incoming + scattered) field on the interior
of the scatterer.
"""
logging.basicConfig(level=logging.INFO)
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
np.random.seed(12)
knl_kwargs = {"k": case.k}
# {{{ come up with a solution to Maxwell's equations
j_sym = sym.make_sym_vector("j", 3)
jt_sym = sym.make_sym_vector("jt", 2)
rho_sym = sym.var("rho")
from pytential.symbolic.pde.maxwell import (
PECChargeCurrentMFIEOperator,
get_sym_maxwell_point_source,
get_sym_maxwell_plane_wave)
mfie = PECChargeCurrentMFIEOperator()
test_source = case.get_source(queue)
calc_patch = CalculusPatch(np.array([-3, 0, 0]), h=0.01)
calc_patch_tgt = PointsTarget(cl.array.to_device(queue, calc_patch.points))
rng = cl.clrandom.PhiloxGenerator(cl_ctx, seed=12)
src_j = rng.normal(queue, (3, test_source.nnodes), dtype=np.float64)
def eval_inc_field_at(tgt):
if 0:
# plane wave
return bind(
tgt,
get_sym_maxwell_plane_wave(
amplitude_vec=np.array([1, 1, 1]),
v=np.array([1, 0, 0]),
omega=case.k)
)(queue)
else:
# point source
return bind(
(test_source, tgt),
get_sym_maxwell_point_source(mfie.kernel, j_sym, mfie.k)
)(queue, j=src_j, k=case.k)
pde_test_inc = EHField(
vector_from_device(queue, eval_inc_field_at(calc_patch_tgt)))
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
# }}}
loc_sign = -1 if case.is_interior else +1
from pytools.convergence import EOCRecorder
eoc_rec_repr_maxwell = EOCRecorder()
eoc_pec_bc = EOCRecorder()
eoc_rec_e = EOCRecorder()
eoc_rec_h = EOCRecorder()
from pytential.qbx import QBXLayerPotentialSource
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
from sumpy.expansion.level_to_order import SimpleExpansionOrderFinder
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 = qbx.h_max
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, mfie.j_rhs(inc_xyz_sym.h))(
queue, inc_fld=inc_field_scat.field, **knl_kwargs)
gmres_settings = dict(
tol=case.gmres_tol,
progress=True,
hard_failure=True,
stall_iterations=50, no_progress_factor=1.05)
from pytential.solve import gmres
gmres_result = gmres(
bound_j_op.scipy_op(queue, "jt", np.complex128, **knl_kwargs),
j_rhs, **gmres_settings)
jt = gmres_result.solution
bound_rho_op = bind(qbx, mfie.rho_operator(loc_sign, rho_sym))
rho_rhs = bind(qbx, mfie.rho_rhs(jt_sym, inc_xyz_sym.e))(
queue, jt=jt, inc_fld=inc_field_scat.field, **knl_kwargs)
gmres_result = gmres(
bound_rho_op.scipy_op(queue, "rho", np.complex128, **knl_kwargs),
rho_rhs, **gmres_settings)
rho = gmres_result.solution
# }}}
jxyz = bind(qbx, sym.tangential_to_xyz(jt_sym))(queue, jt=jt)
# {{{ volume eval
sym_repr = mfie.scattered_volume_field(jt_sym, rho_sym)
def eval_repr_at(tgt, source=None):
if source is None:
source = qbx
return bind((source, tgt), sym_repr)(queue, jt=jt, rho=rho, **knl_kwargs)
pde_test_repr = EHField(
vector_from_device(queue, eval_repr_at(calc_patch_tgt)))
maxwell_residuals = [
calc_patch.norm(x, np.inf) / calc_patch.norm(pde_test_repr.e, np.inf)
for x in frequency_domain_maxwell(
calc_patch, pde_test_repr.e, pde_test_repr.h, case.k)]
print("Maxwell residuals:", maxwell_residuals)
eoc_rec_repr_maxwell.add_data_point(h_max, max(maxwell_residuals))
# }}}
# {{{ check PEC BC on total field
bc_repr = EHField(mfie.scattered_volume_field(
jt_sym, rho_sym, qbx_forced_limit=loc_sign))
pec_bc_e = sym.n_cross(bc_repr.e + inc_xyz_sym.e)
pec_bc_h = sym.normal(3).as_vector().dot(bc_repr.h + inc_xyz_sym.h)
eh_bc_values = bind(qbx, sym.join_fields(pec_bc_e, pec_bc_h))(
queue, jt=jt, rho=rho, inc_fld=inc_field_scat.field,
**knl_kwargs)
def scat_norm(f):
return norm(qbx, queue, f, p=np.inf)
e_bc_residual = scat_norm(eh_bc_values[:3]) / scat_norm(inc_field_scat.e)
h_bc_residual = scat_norm(eh_bc_values[3]) / scat_norm(inc_field_scat.h)
print("E/H PEC BC residuals:", h_max, e_bc_residual, h_bc_residual)
eoc_pec_bc.add_data_point(h_max, max(e_bc_residual, h_bc_residual))
# }}}
# {{{ visualization
if visualize:
from meshmode.discretization.visualization import make_visualizer
bdry_vis = make_visualizer(queue, scat_discr, case.target_order+3)
bdry_normals = bind(scat_discr, sym.normal(3))(queue)\
.as_vector(dtype=object)
bdry_vis.write_vtk_file("source-%s.vtu" % resolution, [
("j", jxyz),
("rho", rho),
("Einc", inc_field_scat.e),
("Hinc", inc_field_scat.h),
("bdry_normals", bdry_normals),
("e_bc_residual", eh_bc_values[:3]),
("h_bc_residual", eh_bc_values[3]),
])
fplot = make_field_plotter_from_bbox(
find_bounding_box(scat_discr.mesh), h=(0.05, 0.05, 0.3),
extend_factor=0.3)
from pytential.qbx import QBXTargetAssociationFailedException
qbx_tgt_tol = qbx.copy(target_association_tolerance=0.2)
fplot_tgt = PointsTarget(cl.array.to_device(queue, fplot.points))
try:
fplot_repr = eval_repr_at(fplot_tgt, source=qbx_tgt_tol)
except QBXTargetAssociationFailedException as e:
fplot.write_vtk_file(
"failed-targets.vts",
[
("failed_targets", e.failed_target_flags.get(queue))
])
raise
fplot_repr = EHField(vector_from_device(queue, fplot_repr))
fplot_inc = EHField(
vector_from_device(queue, eval_inc_field_at(fplot_tgt)))
fplot.write_vtk_file(
"potential-%s.vts" % resolution,
[
("E", fplot_repr.e),
("H", fplot_repr.h),
("Einc", fplot_inc.e),
("Hinc", fplot_inc.h),
]
)
# }}}
# {{{ error in E, H
obs_repr = EHField(eval_repr_at(obs_discr))
def obs_norm(f):
return norm(obs_discr, queue, f, p=np.inf)
rel_err_e = (obs_norm(inc_field_obs.e + obs_repr.e)
/ obs_norm(inc_field_obs.e))
rel_err_h = (obs_norm(inc_field_obs.h + obs_repr.h)
/ obs_norm(inc_field_obs.h))
# }}}
print("ERR", h_max, rel_err_h, rel_err_e)
eoc_rec_h.add_data_point(h_max, rel_err_h)
eoc_rec_e.add_data_point(h_max, rel_err_e)
print("--------------------------------------------------------")
print("is_interior=%s" % case.is_interior)
print("--------------------------------------------------------")
good = True
for which_eoc, eoc_rec, order_tol in [
("maxwell", eoc_rec_repr_maxwell, 1.5),
("PEC BC", eoc_pec_bc, 1.5),
("H", eoc_rec_h, 1.5),
("E", eoc_rec_e, 1.5)]:
print(which_eoc)
print(eoc_rec.pretty_print())
if len(eoc_rec.history) > 1:
if eoc_rec.order_estimate() < case.qbx_order - order_tol:
good = False
assert good
