def tangent(self, where):
return sym.cse(
(sym.pseudoscalar(2, 1, where) / sym.area_element(2, 1, where)),
"tangent")
def run_dielectric_test(cl_ctx, queue, nelements, qbx_order,
op_class, mode,
k0=3, k1=2.9, mesh_order=10,
bdry_quad_order=None, bdry_ovsmp_quad_order=None,
use_l2_weighting=False,
fmm_order=None, visualize=False):
if fmm_order is None:
fmm_order = qbx_order * 2
if bdry_quad_order is None:
bdry_quad_order = mesh_order
if bdry_ovsmp_quad_order is None:
bdry_ovsmp_quad_order = 4*bdry_quad_order
from meshmode.mesh.generation import ellipse, make_curve_mesh
from functools import partial
mesh = make_curve_mesh(
partial(ellipse, 3),
np.linspace(0, 1, nelements+1),
mesh_order)
density_discr = Discretization(
cl_ctx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(bdry_quad_order))
logger.info("%d elements" % mesh.nelements)
# from meshmode.discretization.visualization import make_visualizer
# bdry_vis = make_visualizer(queue, density_discr, 20)
# {{{ solve bvp
from sumpy.kernel import HelmholtzKernel, AxisTargetDerivative
kernel = HelmholtzKernel(2)
beta = 2.5
K0 = np.sqrt(k0**2-beta**2) # noqa
K1 = np.sqrt(k1**2-beta**2) # noqa
pde_op = op_class(
mode,
k_vacuum=1,
interfaces=((0, 1, sym.DEFAULT_SOURCE),),
domain_k_exprs=(k0, k1),
beta=beta,
use_l2_weighting=use_l2_weighting)
op_unknown_sym = pde_op.make_unknown("unknown")
representation0_sym = pde_op.representation(op_unknown_sym, 0)
representation1_sym = pde_op.representation(op_unknown_sym, 1)
from pytential.qbx import QBXLayerPotentialSource
qbx = QBXLayerPotentialSource(
density_discr, fine_order=bdry_ovsmp_quad_order, qbx_order=qbx_order,
fmm_order=fmm_order
).with_refinement()
#print(sym.pretty(pde_op.operator(op_unknown_sym)))
#1/0
bound_pde_op = bind(qbx, pde_op.operator(op_unknown_sym))
e_factor = float(pde_op.ez_enabled)
h_factor = float(pde_op.hz_enabled)
e_sources_0 = make_obj_array(list(np.array([
[0.1, 0.2]
]).T.copy()))
e_strengths_0 = np.array([1*e_factor])
e_sources_1 = make_obj_array(list(np.array([
[4, 4]
]).T.copy()))
e_strengths_1 = np.array([1*e_factor])
h_sources_0 = make_obj_array(list(np.array([
[0.2, 0.1]
]).T.copy()))
h_strengths_0 = np.array([1*h_factor])
h_sources_1 = make_obj_array(list(np.array([
[4, 5]
]).T.copy()))
h_strengths_1 = np.array([1*h_factor])
kernel_grad = [
AxisTargetDerivative(i, kernel) for i in range(density_discr.ambient_dim)]
from sumpy.p2p import P2P
pot_p2p = P2P(cl_ctx, [kernel], exclude_self=False)
pot_p2p_grad = P2P(cl_ctx, kernel_grad, exclude_self=False)
normal = bind(density_discr, sym.normal())(queue).as_vector(np.object)
tangent = bind(
density_discr,
sym.pseudoscalar()/sym.area_element())(queue).as_vector(np.object)
_, (E0,) = pot_p2p(queue, density_discr.nodes(), e_sources_0, [e_strengths_0],
out_host=False, k=K0)
_, (E1,) = pot_p2p(queue, density_discr.nodes(), e_sources_1, [e_strengths_1],
out_host=False, k=K1)
_, (grad0_E0, grad1_E0) = pot_p2p_grad(
queue, density_discr.nodes(), e_sources_0, [e_strengths_0],
out_host=False, k=K0)
_, (grad0_E1, grad1_E1) = pot_p2p_grad(
queue, density_discr.nodes(), e_sources_1, [e_strengths_1],
out_host=False, k=K1)
_, (H0,) = pot_p2p(queue, density_discr.nodes(), h_sources_0, [h_strengths_0],
out_host=False, k=K0)
_, (H1,) = pot_p2p(queue, density_discr.nodes(), h_sources_1, [h_strengths_1],
out_host=False, k=K1)
_, (grad0_H0, grad1_H0) = pot_p2p_grad(
queue, density_discr.nodes(), h_sources_0, [h_strengths_0],
out_host=False, k=K0)
_, (grad0_H1, grad1_H1) = pot_p2p_grad(
queue, density_discr.nodes(), h_sources_1, [h_strengths_1],
out_host=False, k=K1)
E0_dntarget = (grad0_E0*normal[0] + grad1_E0*normal[1]) # noqa
E1_dntarget = (grad0_E1*normal[0] + grad1_E1*normal[1]) # noqa
H0_dntarget = (grad0_H0*normal[0] + grad1_H0*normal[1]) # noqa
H1_dntarget = (grad0_H1*normal[0] + grad1_H1*normal[1]) # noqa
E0_dttarget = (grad0_E0*tangent[0] + grad1_E0*tangent[1]) # noqa
E1_dttarget = (grad0_E1*tangent[0] + grad1_E1*tangent[1]) # noqa
H0_dttarget = (grad0_H0*tangent[0] + grad1_H0*tangent[1]) # noqa
H1_dttarget = (grad0_H1*tangent[0] + grad1_H1*tangent[1]) # noqa
sqrt_w = bind(density_discr, sym.sqrt_jac_q_weight())(queue)
bvp_rhs = np.zeros(len(pde_op.bcs), dtype=np.object)
for i_bc, terms in enumerate(pde_op.bcs):
for term in terms:
assert term.i_interface == 0
if term.field_kind == pde_op.field_kind_e:
if term.direction == pde_op.dir_none:
bvp_rhs[i_bc] += (
term.coeff_outer * E0
+ term.coeff_inner * E1)
elif term.direction == pde_op.dir_normal:
bvp_rhs[i_bc] += (
term.coeff_outer * E0_dntarget
+ term.coeff_inner * E1_dntarget)
elif term.direction == pde_op.dir_tangential:
bvp_rhs[i_bc] += (
term.coeff_outer * E0_dttarget
+ term.coeff_inner * E1_dttarget)
else:
raise NotImplementedError("direction spec in RHS")
elif term.field_kind == pde_op.field_kind_h:
if term.direction == pde_op.dir_none:
bvp_rhs[i_bc] += (
term.coeff_outer * H0
+ term.coeff_inner * H1)
elif term.direction == pde_op.dir_normal:
bvp_rhs[i_bc] += (
term.coeff_outer * H0_dntarget
+ term.coeff_inner * H1_dntarget)
elif term.direction == pde_op.dir_tangential:
bvp_rhs[i_bc] += (
term.coeff_outer * H0_dttarget
+ term.coeff_inner * H1_dttarget)
else:
raise NotImplementedError("direction spec in RHS")
if use_l2_weighting:
bvp_rhs[i_bc] *= sqrt_w
scipy_op = bound_pde_op.scipy_op(queue, "unknown",
domains=[sym.DEFAULT_TARGET]*len(pde_op.bcs), K0=K0, K1=K1,
dtype=np.complex128)
if mode == "tem" or op_class is SRep:
from sumpy.tools import vector_from_device, vector_to_device
from pytential.solve import lu
unknown = lu(scipy_op, vector_from_device(queue, bvp_rhs))
unknown = vector_to_device(queue, unknown)
else:
from pytential.solve import gmres
gmres_result = gmres(scipy_op,
bvp_rhs, tol=1e-14, progress=True,
hard_failure=True, stall_iterations=0)
unknown = gmres_result.solution
# }}}
targets_0 = make_obj_array(list(np.array([
[3.2 + t, -4]
for t in [0, 0.5, 1]
]).T.copy()))
targets_1 = make_obj_array(list(np.array([
[t*-0.3, t*-0.2]
for t in [0, 0.5, 1]
]).T.copy()))
from pytential.target import PointsTarget
from sumpy.tools import vector_from_device
F0_tgt = vector_from_device(queue, bind( # noqa
(qbx, PointsTarget(targets_0)),
representation0_sym)(queue, unknown=unknown, K0=K0, K1=K1))
F1_tgt = vector_from_device(queue, bind( # noqa
(qbx, PointsTarget(targets_1)),
representation1_sym)(queue, unknown=unknown, K0=K0, K1=K1))
_, (E0_tgt_true,) = pot_p2p(queue, targets_0, e_sources_0, [e_strengths_0],
out_host=True, k=K0)
_, (E1_tgt_true,) = pot_p2p(queue, targets_1, e_sources_1, [e_strengths_1],
out_host=True, k=K1)
_, (H0_tgt_true,) = pot_p2p(queue, targets_0, h_sources_0, [h_strengths_0],
out_host=True, k=K0)
_, (H1_tgt_true,) = pot_p2p(queue, targets_1, h_sources_1, [h_strengths_1],
out_host=True, k=K1)
err_F0_total = 0 # noqa
err_F1_total = 0 # noqa
i_field = 0
def vec_norm(ary):
return la.norm(ary.reshape(-1))
def field_kind_to_string(field_kind):
return {pde_op.field_kind_e: "E", pde_op.field_kind_h: "H"}[field_kind]
for field_kind in pde_op.field_kinds:
if not pde_op.is_field_present(field_kind):
continue
if field_kind == pde_op.field_kind_e:
F0_tgt_true = E0_tgt_true # noqa
F1_tgt_true = E1_tgt_true # noqa
elif field_kind == pde_op.field_kind_h:
F0_tgt_true = H0_tgt_true # noqa
F1_tgt_true = H1_tgt_true # noqa
else:
assert False
abs_err_F0 = vec_norm(F0_tgt[i_field] - F0_tgt_true) # noqa
abs_err_F1 = vec_norm(F1_tgt[i_field] - F1_tgt_true) # noqa
rel_err_F0 = abs_err_F0/vec_norm(F0_tgt_true) # noqa
rel_err_F1 = abs_err_F1/vec_norm(F1_tgt_true) # noqa
err_F0_total = max(rel_err_F0, err_F0_total) # noqa
err_F1_total = max(rel_err_F1, err_F1_total) # noqa
print("Abs Err %s0" % field_kind_to_string(field_kind), abs_err_F0)
print("Abs Err %s1" % field_kind_to_string(field_kind), abs_err_F1)
print("Rel Err %s0" % field_kind_to_string(field_kind), rel_err_F0)
print("Rel Err %s1" % field_kind_to_string(field_kind), rel_err_F1)
i_field += 1
if visualize:
from sumpy.visualization import FieldPlotter
fplot = FieldPlotter(np.zeros(2), extent=5, npoints=300)
from pytential.target import PointsTarget
fld0 = bind(
(qbx, PointsTarget(fplot.points)),
representation0_sym)(queue, unknown=unknown, K0=K0)
fld1 = bind(
(qbx, PointsTarget(fplot.points)),
representation1_sym)(queue, unknown=unknown, K1=K1)
comp_fields = []
i_field = 0
for field_kind in pde_op.field_kinds:
if not pde_op.is_field_present(field_kind):
continue
fld_str = field_kind_to_string(field_kind)
comp_fields.extend([
("%s_fld0" % fld_str, fld0[i_field].get()),
("%s_fld1" % fld_str, fld1[i_field].get()),
])
i_field += 0
low_order_qbx = QBXLayerPotentialSource(
density_discr, fine_order=bdry_ovsmp_quad_order, qbx_order=2,
fmm_order=3).with_refinement()
from sumpy.kernel import LaplaceKernel
from pytential.target import PointsTarget
ones = (cl.array.empty(queue, (density_discr.nnodes,), dtype=np.float64)
.fill(1))
ind_func = - bind((low_order_qbx, PointsTarget(fplot.points)),
sym.D(LaplaceKernel(2), sym.var("u")))(
queue, u=ones).get()
_, (e_fld0_true,) = pot_p2p(
queue, fplot.points, e_sources_0, [e_strengths_0],
out_host=True, k=K0)
_, (e_fld1_true,) = pot_p2p(
queue, fplot.points, e_sources_1, [e_strengths_1],
out_host=True, k=K1)
_, (h_fld0_true,) = pot_p2p(
queue, fplot.points, h_sources_0, [h_strengths_0],
out_host=True, k=K0)
_, (h_fld1_true,) = pot_p2p(
queue, fplot.points, h_sources_1, [h_strengths_1],
out_host=True, k=K1)
#fplot.show_scalar_in_mayavi(fld_in_vol.real, max_val=5)
fplot.write_vtk_file(
"potential-n%d.vts" % nelements,
[
("e_fld0_true", e_fld0_true),
("e_fld1_true", e_fld1_true),
("h_fld0_true", h_fld0_true),
("h_fld1_true", h_fld1_true),
("ind", ind_func),
] + comp_fields
)
return err_F0_total, err_F1_total
def run_int_eq_test(
cl_ctx, queue, curve_f, nelements, qbx_order, bc_type, loc_sign, k,
target_order, source_order):
mesh = make_curve_mesh(curve_f,
np.linspace(0, 1, nelements+1),
target_order)
if 0:
from pytential.visualization import show_mesh
show_mesh(mesh)
pt.gca().set_aspect("equal")
pt.show()
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))
if source_order is None:
source_order = 4*target_order
qbx = QBXLayerPotentialSource(
density_discr, fine_order=source_order, qbx_order=qbx_order,
# Don't use FMM for now
fmm_order=False)
# {{{ set up operator
from pytential.symbolic.pde.scalar import (
DirichletOperator,
NeumannOperator)
from sumpy.kernel import LaplaceKernel, HelmholtzKernel, AxisTargetDerivative
if k:
knl = HelmholtzKernel(2)
knl_kwargs = {"k": k}
else:
knl = LaplaceKernel(2)
knl_kwargs = {}
if knl.is_complex_valued:
dtype = np.complex128
else:
dtype = np.float64
if bc_type == "dirichlet":
op = DirichletOperator((knl, knl_kwargs), loc_sign, use_l2_weighting=True)
elif bc_type == "neumann":
op = NeumannOperator((knl, knl_kwargs), loc_sign, use_l2_weighting=True,
use_improved_operator=False)
else:
assert False
op_u = op.operator(sym.var("u"))
# }}}
# {{{ set up test data
inner_radius = 0.1
outer_radius = 2
if loc_sign < 0:
test_src_geo_radius = outer_radius
test_tgt_geo_radius = inner_radius
else:
test_src_geo_radius = inner_radius
test_tgt_geo_radius = outer_radius
point_sources = make_circular_point_group(10, test_src_geo_radius,
func=lambda x: x**1.5)
test_targets = make_circular_point_group(20, test_tgt_geo_radius)
np.random.seed(22)
source_charges = np.random.randn(point_sources.shape[1])
source_charges[-1] = -np.sum(source_charges[:-1])
source_charges = source_charges.astype(dtype)
assert np.sum(source_charges) < 1e-15
# }}}
if 0:
# show geometry, centers, normals
nodes_h = density_discr.nodes().get(queue=queue)
pt.plot(nodes_h[0], nodes_h[1], "x-")
normal = bind(density_discr, sym.normal())(queue).as_vector(np.object)
pt.quiver(nodes_h[0], nodes_h[1], normal[0].get(queue), normal[1].get(queue))
pt.gca().set_aspect("equal")
pt.show()
# {{{ establish BCs
from sumpy.p2p import P2P
pot_p2p = P2P(cl_ctx,
[knl], exclude_self=False, value_dtypes=dtype)
evt, (test_direct,) = pot_p2p(
queue, test_targets, point_sources, [source_charges],
out_host=False, **knl_kwargs)
nodes = density_discr.nodes()
evt, (src_pot,) = pot_p2p(
queue, nodes, point_sources, [source_charges],
**knl_kwargs)
grad_p2p = P2P(cl_ctx,
[AxisTargetDerivative(0, knl), AxisTargetDerivative(1, knl)],
exclude_self=False, value_dtypes=dtype)
evt, (src_grad0, src_grad1) = grad_p2p(
queue, nodes, point_sources, [source_charges],
**knl_kwargs)
if bc_type == "dirichlet":
bc = src_pot
elif bc_type == "neumann":
normal = bind(density_discr, sym.normal())(queue).as_vector(np.object)
bc = (src_grad0*normal[0] + src_grad1*normal[1])
# }}}
# {{{ solve
bound_op = bind(qbx, op_u)
rhs = bind(density_discr, op.prepare_rhs(sym.var("bc")))(queue, bc=bc)
from pytential.solve import gmres
gmres_result = gmres(
bound_op.scipy_op(queue, "u", k=k),
rhs, tol=1e-14, progress=True,
hard_failure=False)
u = gmres_result.solution
print("gmres state:", gmres_result.state)
if 0:
# {{{ build matrix for spectrum check
from sumpy.tools import build_matrix
mat = build_matrix(bound_op.scipy_op("u"))
w, v = la.eig(mat)
if 0:
pt.imshow(np.log10(1e-20+np.abs(mat)))
pt.colorbar()
pt.show()
#assert abs(s[-1]) < 1e-13, "h
#assert abs(s[-2]) > 1e-7
#from pudb import set_trace; set_trace()
# }}}
# }}}
# {{{ error check
from pytential.target import PointsTarget
bound_tgt_op = bind((qbx, PointsTarget(test_targets)),
op.representation(sym.var("u")))
test_via_bdry = bound_tgt_op(queue, u=u, k=k)
err = test_direct-test_via_bdry
err = err.get()
test_direct = test_direct.get()
test_via_bdry = test_via_bdry.get()
# {{{ remove effect of net source charge
if k == 0 and bc_type == "neumann" and loc_sign == -1:
# remove constant offset in interior Laplace Neumann error
tgt_ones = np.ones_like(test_direct)
tgt_ones = tgt_ones/la.norm(tgt_ones)
err = err - np.vdot(tgt_ones, err)*tgt_ones
# }}}
rel_err_2 = la.norm(err)/la.norm(test_direct)
rel_err_inf = la.norm(err, np.inf)/la.norm(test_direct, np.inf)
# }}}
print("rel_err_2: %g rel_err_inf: %g" % (rel_err_2, rel_err_inf))
# {{{ test tangential derivative
bound_t_deriv_op = bind(qbx,
op.representation(
sym.var("u"), map_potentials=sym.tangential_derivative,
qbx_forced_limit=loc_sign))
#print(bound_t_deriv_op.code)
tang_deriv_from_src = bound_t_deriv_op(queue, u=u).as_scalar().get()
tangent = bind(
density_discr,
sym.pseudoscalar()/sym.area_element())(queue).as_vector(np.object)
tang_deriv_ref = (src_grad0 * tangent[0] + src_grad1 * tangent[1]).get()
if 0:
pt.plot(tang_deriv_ref.real)
pt.plot(tang_deriv_from_src.real)
pt.show()
td_err = tang_deriv_from_src - tang_deriv_ref
rel_td_err_inf = la.norm(td_err, np.inf)/la.norm(tang_deriv_ref, np.inf)
print("rel_td_err_inf: %g" % rel_td_err_inf)
# }}}
# {{{ plotting
if 0:
fplot = FieldPlotter(np.zeros(2),
extent=1.25*2*max(test_src_geo_radius, test_tgt_geo_radius),
npoints=200)
#pt.plot(u)
#pt.show()
evt, (fld_from_src,) = pot_p2p(
queue, fplot.points, point_sources, [source_charges],
**knl_kwargs)
fld_from_bdry = bind(
(qbx, PointsTarget(fplot.points)),
op.representation(sym.var("u"))
)(queue, u=u, k=k)
fld_from_src = fld_from_src.get()
fld_from_bdry = fld_from_bdry.get()
nodes = density_discr.nodes().get(queue=queue)
def prep():
pt.plot(point_sources[0], point_sources[1], "o",
label="Monopole 'Point Charges'")
pt.plot(test_targets[0], test_targets[1], "v",
label="Observation Points")
pt.plot(nodes[0], nodes[1], "k-",
label=r"$\Gamma$")
from matplotlib.cm import get_cmap
cmap = get_cmap()
cmap._init()
if 0:
cmap._lut[(cmap.N*99)//100:, -1] = 0 # make last percent transparent?
prep()
if 1:
pt.subplot(131)
pt.title("Field error (loc_sign=%s)" % loc_sign)
log_err = np.log10(1e-20+np.abs(fld_from_src-fld_from_bdry))
log_err = np.minimum(-3, log_err)
fplot.show_scalar_in_matplotlib(log_err, cmap=cmap)
#from matplotlib.colors import Normalize
#im.set_norm(Normalize(vmin=-6, vmax=1))
cb = pt.colorbar(shrink=0.9)
cb.set_label(r"$\log_{10}(\mathdefault{Error})$")
if 1:
pt.subplot(132)
prep()
pt.title("Source Field")
fplot.show_scalar_in_matplotlib(
fld_from_src.real, max_val=3)
pt.colorbar(shrink=0.9)
if 1:
pt.subplot(133)
prep()
pt.title("Solved Field")
fplot.show_scalar_in_matplotlib(
fld_from_bdry.real, max_val=3)
pt.colorbar(shrink=0.9)
# total field
#fplot.show_scalar_in_matplotlib(
#fld_from_src.real+fld_from_bdry.real, max_val=0.1)
#pt.colorbar()
pt.legend(loc="best", prop=dict(size=15))
from matplotlib.ticker import NullFormatter
pt.gca().xaxis.set_major_formatter(NullFormatter())
pt.gca().yaxis.set_major_formatter(NullFormatter())
pt.gca().set_aspect("equal")
if 0:
border_factor_top = 0.9
border_factor = 0.3
xl, xh = pt.xlim()
xhsize = 0.5*(xh-xl)
pt.xlim(xl-border_factor*xhsize, xh+border_factor*xhsize)
yl, yh = pt.ylim()
yhsize = 0.5*(yh-yl)
pt.ylim(yl-border_factor_top*yhsize, yh+border_factor*yhsize)
#pt.savefig("helmholtz.pdf", dpi=600)
pt.show()
# }}}
class Result(Record):
pass
return Result(
rel_err_2=rel_err_2,
rel_err_inf=rel_err_inf,
rel_td_err_inf=rel_td_err_inf,
gmres_result=gmres_result)
def run_dielectric_test(cl_ctx,
queue,
nelements,
qbx_order,
op_class,
mode,
k0=3,
k1=2.9,
mesh_order=10,
bdry_quad_order=None,
bdry_ovsmp_quad_order=None,
use_l2_weighting=False,
fmm_order=None,
visualize=False):
if fmm_order is None:
fmm_order = qbx_order * 2
if bdry_quad_order is None:
bdry_quad_order = mesh_order
if bdry_ovsmp_quad_order is None:
bdry_ovsmp_quad_order = 4 * bdry_quad_order
from meshmode.mesh.generation import ellipse, make_curve_mesh
from functools import partial
mesh = make_curve_mesh(partial(ellipse, 3),
np.linspace(0, 1, nelements + 1), mesh_order)
density_discr = Discretization(
cl_ctx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(bdry_quad_order))
logger.info("%d elements" % mesh.nelements)
# from meshmode.discretization.visualization import make_visualizer
# bdry_vis = make_visualizer(queue, density_discr, 20)
# {{{ solve bvp
from sumpy.kernel import HelmholtzKernel, AxisTargetDerivative
kernel = HelmholtzKernel(2)
beta = 2.5
K0 = np.sqrt(k0**2 - beta**2) # noqa
K1 = np.sqrt(k1**2 - beta**2) # noqa
pde_op = op_class(mode,
k_vacuum=1,
interfaces=((0, 1, sym.DEFAULT_SOURCE), ),
domain_k_exprs=(k0, k1),
beta=beta,
use_l2_weighting=use_l2_weighting)
op_unknown_sym = pde_op.make_unknown("unknown")
representation0_sym = pde_op.representation(op_unknown_sym, 0)
representation1_sym = pde_op.representation(op_unknown_sym, 1)
from pytential.qbx import QBXLayerPotentialSource
qbx = QBXLayerPotentialSource(density_discr,
fine_order=bdry_ovsmp_quad_order,
qbx_order=qbx_order,
fmm_order=fmm_order).with_refinement()
#print(sym.pretty(pde_op.operator(op_unknown_sym)))
#1/0
bound_pde_op = bind(qbx, pde_op.operator(op_unknown_sym))
e_factor = float(pde_op.ez_enabled)
h_factor = float(pde_op.hz_enabled)
e_sources_0 = make_obj_array(list(np.array([[0.1, 0.2]]).T.copy()))
e_strengths_0 = np.array([1 * e_factor])
e_sources_1 = make_obj_array(list(np.array([[4, 4]]).T.copy()))
e_strengths_1 = np.array([1 * e_factor])
h_sources_0 = make_obj_array(list(np.array([[0.2, 0.1]]).T.copy()))
h_strengths_0 = np.array([1 * h_factor])
h_sources_1 = make_obj_array(list(np.array([[4, 5]]).T.copy()))
h_strengths_1 = np.array([1 * h_factor])
kernel_grad = [
AxisTargetDerivative(i, kernel)
for i in range(density_discr.ambient_dim)
]
from sumpy.p2p import P2P
pot_p2p = P2P(cl_ctx, [kernel], exclude_self=False)
pot_p2p_grad = P2P(cl_ctx, kernel_grad, exclude_self=False)
normal = bind(density_discr, sym.normal())(queue).as_vector(np.object)
tangent = bind(density_discr,
sym.pseudoscalar() / sym.area_element())(queue).as_vector(
np.object)
_, (E0, ) = pot_p2p(queue,
density_discr.nodes(),
e_sources_0, [e_strengths_0],
out_host=False,
k=K0)
_, (E1, ) = pot_p2p(queue,
density_discr.nodes(),
e_sources_1, [e_strengths_1],
out_host=False,
k=K1)
_, (grad0_E0, grad1_E0) = pot_p2p_grad(queue,
density_discr.nodes(),
e_sources_0, [e_strengths_0],
out_host=False,
k=K0)
_, (grad0_E1, grad1_E1) = pot_p2p_grad(queue,
density_discr.nodes(),
e_sources_1, [e_strengths_1],
out_host=False,
k=K1)
_, (H0, ) = pot_p2p(queue,
density_discr.nodes(),
h_sources_0, [h_strengths_0],
out_host=False,
k=K0)
_, (H1, ) = pot_p2p(queue,
density_discr.nodes(),
h_sources_1, [h_strengths_1],
out_host=False,
k=K1)
_, (grad0_H0, grad1_H0) = pot_p2p_grad(queue,
density_discr.nodes(),
h_sources_0, [h_strengths_0],
out_host=False,
k=K0)
_, (grad0_H1, grad1_H1) = pot_p2p_grad(queue,
density_discr.nodes(),
h_sources_1, [h_strengths_1],
out_host=False,
k=K1)
E0_dntarget = (grad0_E0 * normal[0] + grad1_E0 * normal[1]) # noqa
E1_dntarget = (grad0_E1 * normal[0] + grad1_E1 * normal[1]) # noqa
H0_dntarget = (grad0_H0 * normal[0] + grad1_H0 * normal[1]) # noqa
H1_dntarget = (grad0_H1 * normal[0] + grad1_H1 * normal[1]) # noqa
E0_dttarget = (grad0_E0 * tangent[0] + grad1_E0 * tangent[1]) # noqa
E1_dttarget = (grad0_E1 * tangent[0] + grad1_E1 * tangent[1]) # noqa
H0_dttarget = (grad0_H0 * tangent[0] + grad1_H0 * tangent[1]) # noqa
H1_dttarget = (grad0_H1 * tangent[0] + grad1_H1 * tangent[1]) # noqa
sqrt_w = bind(density_discr, sym.sqrt_jac_q_weight())(queue)
bvp_rhs = np.zeros(len(pde_op.bcs), dtype=np.object)
for i_bc, terms in enumerate(pde_op.bcs):
for term in terms:
assert term.i_interface == 0
if term.field_kind == pde_op.field_kind_e:
if term.direction == pde_op.dir_none:
bvp_rhs[i_bc] += (term.coeff_outer * E0 +
term.coeff_inner * E1)
elif term.direction == pde_op.dir_normal:
bvp_rhs[i_bc] += (term.coeff_outer * E0_dntarget +
term.coeff_inner * E1_dntarget)
elif term.direction == pde_op.dir_tangential:
bvp_rhs[i_bc] += (term.coeff_outer * E0_dttarget +
term.coeff_inner * E1_dttarget)
else:
raise NotImplementedError("direction spec in RHS")
elif term.field_kind == pde_op.field_kind_h:
if term.direction == pde_op.dir_none:
bvp_rhs[i_bc] += (term.coeff_outer * H0 +
term.coeff_inner * H1)
elif term.direction == pde_op.dir_normal:
bvp_rhs[i_bc] += (term.coeff_outer * H0_dntarget +
term.coeff_inner * H1_dntarget)
elif term.direction == pde_op.dir_tangential:
bvp_rhs[i_bc] += (term.coeff_outer * H0_dttarget +
term.coeff_inner * H1_dttarget)
else:
raise NotImplementedError("direction spec in RHS")
if use_l2_weighting:
bvp_rhs[i_bc] *= sqrt_w
scipy_op = bound_pde_op.scipy_op(queue,
"unknown",
domains=[sym.DEFAULT_TARGET] *
len(pde_op.bcs),
K0=K0,
K1=K1,
dtype=np.complex128)
if mode == "tem" or op_class is SRep:
from sumpy.tools import vector_from_device, vector_to_device
from pytential.solve import lu
unknown = lu(scipy_op, vector_from_device(queue, bvp_rhs))
unknown = vector_to_device(queue, unknown)
else:
from pytential.solve import gmres
gmres_result = gmres(scipy_op,
bvp_rhs,
tol=1e-14,
progress=True,
hard_failure=True,
stall_iterations=0)
unknown = gmres_result.solution
# }}}
targets_0 = make_obj_array(
list(np.array([[3.2 + t, -4] for t in [0, 0.5, 1]]).T.copy()))
targets_1 = make_obj_array(
list(np.array([[t * -0.3, t * -0.2] for t in [0, 0.5, 1]]).T.copy()))
from pytential.target import PointsTarget
from sumpy.tools import vector_from_device
F0_tgt = vector_from_device(
queue,
bind( # noqa
(qbx, PointsTarget(targets_0)),
representation0_sym)(queue, unknown=unknown, K0=K0, K1=K1))
F1_tgt = vector_from_device(
queue,
bind( # noqa
(qbx, PointsTarget(targets_1)),
representation1_sym)(queue, unknown=unknown, K0=K0, K1=K1))
_, (E0_tgt_true, ) = pot_p2p(queue,
targets_0,
e_sources_0, [e_strengths_0],
out_host=True,
k=K0)
_, (E1_tgt_true, ) = pot_p2p(queue,
targets_1,
e_sources_1, [e_strengths_1],
out_host=True,
k=K1)
_, (H0_tgt_true, ) = pot_p2p(queue,
targets_0,
h_sources_0, [h_strengths_0],
out_host=True,
k=K0)
_, (H1_tgt_true, ) = pot_p2p(queue,
targets_1,
h_sources_1, [h_strengths_1],
out_host=True,
k=K1)
err_F0_total = 0 # noqa
err_F1_total = 0 # noqa
i_field = 0
def vec_norm(ary):
return la.norm(ary.reshape(-1))
def field_kind_to_string(field_kind):
return {pde_op.field_kind_e: "E", pde_op.field_kind_h: "H"}[field_kind]
for field_kind in pde_op.field_kinds:
if not pde_op.is_field_present(field_kind):
continue
if field_kind == pde_op.field_kind_e:
F0_tgt_true = E0_tgt_true # noqa
F1_tgt_true = E1_tgt_true # noqa
elif field_kind == pde_op.field_kind_h:
F0_tgt_true = H0_tgt_true # noqa
F1_tgt_true = H1_tgt_true # noqa
else:
assert False
abs_err_F0 = vec_norm(F0_tgt[i_field] - F0_tgt_true) # noqa
abs_err_F1 = vec_norm(F1_tgt[i_field] - F1_tgt_true) # noqa
rel_err_F0 = abs_err_F0 / vec_norm(F0_tgt_true) # noqa
rel_err_F1 = abs_err_F1 / vec_norm(F1_tgt_true) # noqa
err_F0_total = max(rel_err_F0, err_F0_total) # noqa
err_F1_total = max(rel_err_F1, err_F1_total) # noqa
print("Abs Err %s0" % field_kind_to_string(field_kind), abs_err_F0)
print("Abs Err %s1" % field_kind_to_string(field_kind), abs_err_F1)
print("Rel Err %s0" % field_kind_to_string(field_kind), rel_err_F0)
print("Rel Err %s1" % field_kind_to_string(field_kind), rel_err_F1)
i_field += 1
if visualize:
from sumpy.visualization import FieldPlotter
fplot = FieldPlotter(np.zeros(2), extent=5, npoints=300)
from pytential.target import PointsTarget
fld0 = bind((qbx, PointsTarget(fplot.points)),
representation0_sym)(queue, unknown=unknown, K0=K0)
fld1 = bind((qbx, PointsTarget(fplot.points)),
representation1_sym)(queue, unknown=unknown, K1=K1)
comp_fields = []
i_field = 0
for field_kind in pde_op.field_kinds:
if not pde_op.is_field_present(field_kind):
continue
fld_str = field_kind_to_string(field_kind)
comp_fields.extend([
("%s_fld0" % fld_str, fld0[i_field].get()),
("%s_fld1" % fld_str, fld1[i_field].get()),
])
i_field += 0
low_order_qbx = QBXLayerPotentialSource(
density_discr,
fine_order=bdry_ovsmp_quad_order,
qbx_order=2,
fmm_order=3).with_refinement()
from sumpy.kernel import LaplaceKernel
from pytential.target import PointsTarget
ones = (cl.array.empty(queue, (density_discr.nnodes, ),
dtype=np.float64).fill(1))
ind_func = -bind(
(low_order_qbx, PointsTarget(fplot.points)),
sym.D(LaplaceKernel(2), sym.var("u")))(queue, u=ones).get()
_, (e_fld0_true, ) = pot_p2p(queue,
fplot.points,
e_sources_0, [e_strengths_0],
out_host=True,
k=K0)
_, (e_fld1_true, ) = pot_p2p(queue,
fplot.points,
e_sources_1, [e_strengths_1],
out_host=True,
k=K1)
_, (h_fld0_true, ) = pot_p2p(queue,
fplot.points,
h_sources_0, [h_strengths_0],
out_host=True,
k=K0)
_, (h_fld1_true, ) = pot_p2p(queue,
fplot.points,
h_sources_1, [h_strengths_1],
out_host=True,
k=K1)
#fplot.show_scalar_in_mayavi(fld_in_vol.real, max_val=5)
fplot.write_vtk_file("potential-n%d.vts" % nelements, [
("e_fld0_true", e_fld0_true),
("e_fld1_true", e_fld1_true),
("h_fld0_true", h_fld0_true),
("h_fld1_true", h_fld1_true),
("ind", ind_func),
] + comp_fields)
return err_F0_total, err_F1_total
def tangent(self, where):
return sym.cse(
(sym.pseudoscalar(2, 1, where)
/ sym.area_element(2, 1, where)),
"tangent")