def map_call(self, expr):
arg, = expr.parameters
rec_arg = self.rec(arg)
if isinstance(rec_arg, np.ndarray) and self.is_kind_matrix(rec_arg):
raise RuntimeError("expression is nonlinear in variable")
from numbers import Number
if isinstance(rec_arg, Number):
return getattr(np, expr.function.name)(rec_arg)
else:
rec_arg = unflatten_from_numpy(self.array_context, None, rec_arg)
result = getattr(self.array_context.np,
expr.function.name)(rec_arg)
return flatten_to_numpy(self.array_context, result)
def map_interpolation(self, expr):
from pytential import sym
if expr.to_dd.discr_stage != sym.QBX_SOURCE_QUAD_STAGE2:
raise RuntimeError(
"can only interpolate to QBX_SOURCE_QUAD_STAGE2")
operand = self.rec(expr.operand)
actx = self.array_context
if isinstance(operand, (int, float, complex, np.number)):
return operand
elif isinstance(operand, np.ndarray) and operand.ndim == 1:
conn = self.places.get_connection(expr.from_dd, expr.to_dd)
discr = self.places.get_discretization(expr.from_dd.geometry,
expr.from_dd.discr_stage)
operand = unflatten_from_numpy(actx, discr, operand)
return flatten_to_numpy(actx, conn(operand))
elif isinstance(operand, np.ndarray) and operand.ndim == 2:
cache = self.places._get_cache("direct_resampler")
key = (expr.from_dd.geometry, expr.from_dd.discr_stage,
expr.to_dd.discr_stage)
try:
mat = cache[key]
except KeyError:
from meshmode.discretization.connection import \
flatten_chained_connection
conn = self.places.get_connection(expr.from_dd, expr.to_dd)
conn = flatten_chained_connection(actx, conn)
mat = actx.to_numpy(conn.full_resample_matrix(actx))
# FIXME: the resample matrix is slow to compute and very big
# to store, so caching it may not be the best idea
cache[key] = mat
return mat.dot(operand)
else:
raise RuntimeError("unknown operand type: {}".format(
type(operand)))
def map_num_reference_derivative(self, expr):
from pytential import bind, sym
rec_operand = self.rec(expr.operand)
assert isinstance(rec_operand, np.ndarray)
if self.is_kind_matrix(rec_operand):
raise NotImplementedError("derivatives")
dofdesc = expr.dofdesc
op = sym.NumReferenceDerivative(ref_axes=expr.ref_axes,
operand=sym.var("u"),
dofdesc=dofdesc)
discr = self.places.get_discretization(dofdesc.geometry,
dofdesc.discr_stage)
rec_operand = unflatten_from_numpy(self.array_context, discr,
rec_operand)
return flatten_to_numpy(
self.array_context,
bind(self.places, op)(self.array_context, u=rec_operand))
def test_build_matrix(ctx_factory, k, curve_fn, op_type, visualize=False):
"""Checks that the matrix built with `symbolic.execution.build_matrix`
gives the same (to tolerance) answer as a direct evaluation.
"""
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
# prevent cache 'splosion
from sympy.core.cache import clear_cache
clear_cache()
case = extra.CurveTestCase(name="curve",
knl_class_or_helmholtz_k=k,
curve_fn=curve_fn,
op_type=op_type,
target_order=7,
qbx_order=4,
resolutions=[30])
logger.info("\n%s", case)
# {{{ geometry
qbx = case.get_layer_potential(actx, case.resolutions[-1],
case.target_order)
from pytential.qbx.refinement import refine_geometry_collection
places = GeometryCollection(qbx, auto_where=case.name)
places = refine_geometry_collection(places,
kernel_length_scale=(5 /
k if k else None))
dd = places.auto_source.to_stage1()
density_discr = places.get_discretization(dd.geometry)
logger.info("nelements: %d", density_discr.mesh.nelements)
logger.info("ndofs: %d", density_discr.ndofs)
# }}}
# {{{ symbolic
sym_u, sym_op = case.get_operator(places.ambient_dim)
bound_op = bind(places, sym_op)
# }}}
# {{{ dense matrix
from pytential.symbolic.execution import build_matrix
mat = actx.to_numpy(
build_matrix(actx,
places,
sym_op,
sym_u,
context=case.knl_concrete_kwargs))
if visualize:
try:
import matplotlib.pyplot as pt
except ImportError:
visualize = False
if visualize:
from sumpy.tools import build_matrix as build_matrix_via_matvec
mat2 = bound_op.scipy_op(actx,
"u",
dtype=mat.dtype,
**case.knl_concrete_kwargs)
mat2 = build_matrix_via_matvec(mat2)
logger.info(
"real %.5e imag %.5e",
la.norm((mat - mat2).real, "fro") / la.norm(mat2.real, "fro"),
la.norm((mat - mat2).imag, "fro") / la.norm(mat2.imag, "fro"))
pt.subplot(121)
pt.imshow(np.log10(np.abs(1.0e-20 + (mat - mat2).real)))
pt.colorbar()
pt.subplot(122)
pt.imshow(np.log10(np.abs(1.0e-20 + (mat - mat2).imag)))
pt.colorbar()
pt.show()
pt.clf()
if visualize:
pt.subplot(121)
pt.imshow(mat.real)
pt.colorbar()
pt.subplot(122)
pt.imshow(mat.imag)
pt.colorbar()
pt.show()
pt.clf()
# }}}
# {{{ check
from pytential.utils import unflatten_from_numpy, flatten_to_numpy
np.random.seed(12)
for i in range(5):
if isinstance(sym_u, np.ndarray):
u = make_obj_array([
np.random.randn(density_discr.ndofs) for _ in range(len(sym_u))
])
else:
u = np.random.randn(density_discr.ndofs)
u_dev = unflatten_from_numpy(actx, density_discr, u)
res_matvec = np.hstack(
flatten_to_numpy(
actx, bound_op(actx, u=u_dev, **case.knl_concrete_kwargs)))
res_mat = mat.dot(np.hstack(u))
abs_err = la.norm(res_mat - res_matvec, np.inf)
rel_err = abs_err / la.norm(res_matvec, np.inf)
logger.info("AbsErr {:.5e} RelErr {:.5e}".format(abs_err, rel_err))
assert rel_err < 1.0e-13, 'iteration: {}'.format(i)
def run_exterior_stokes_2d(
ctx_factory,
nelements,
mesh_order=4,
target_order=4,
qbx_order=4,
fmm_order=False, # FIXME: FMM is slower than direct eval
mu=1,
circle_rad=1.5,
visualize=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)
actx = PyOpenCLArrayContext(queue)
ovsmp_target_order = 4 * target_order
# {{{ geometries
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(
actx, 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,
)
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])
from pytential.target import PointsTarget
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))
eval_points = outside_circle(eval_points, radius=circle_rad)
point_targets = PointsTarget(eval_points)
fplot = FieldPlotter(np.zeros(2), extent=6, npoints=100)
plot_targets = PointsTarget(outside_circle(fplot.points,
radius=circle_rad))
places = GeometryCollection({
sym.DEFAULT_SOURCE: qbx,
sym.DEFAULT_TARGET: qbx.density_discr,
"point_target": point_targets,
"plot_target": plot_targets,
})
density_discr = places.get_discretization(sym.DEFAULT_SOURCE)
normal = bind(places, sym.normal(2).as_vector())(actx)
path_length = bind(places, sym.integral(2, 1, 1))(actx)
# }}}
# {{{ 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(places, bdry_op_sym)
# {{{ fix rhs and solve
def fund_soln(x, y, loc, strength):
#with direction (1,0) for point source
r = actx.np.sqrt((x - loc[0])**2 + (y - loc[1])**2)
scaling = strength / (4 * np.pi * mu)
xcomp = (-actx.np.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 = actx.np.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 = actx.np.sqrt((x - loc[0])**2 + (y - loc[1])**2)
scaling = strength / (4 * np.pi * mu)
xcomp = ((-actx.np.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 make_obj_array([xcomp, ycomp])
from meshmode.dof_array import unflatten, flatten, thaw
nodes = flatten(thaw(actx, density_discr.nodes()))
fund_soln_loc = np.array([0.5, -0.2])
strength = 100.
bc = unflatten(
actx, density_discr,
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)
from pytential.utils import unflatten_from_numpy
omega = unflatten_from_numpy(
actx, density_discr,
make_obj_array([(strength / path_length) * np.ones(len(nodes[0])),
np.zeros(len(nodes[0]))]))
bvp_rhs = bind(places,
sym.make_sym_vector("bc", dim) + u_A_sym_bdry)(actx,
bc=bc,
mu=mu,
omega=omega)
gmres_result = gmres(bound_op.scipy_op(actx,
"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(places, sym.integral(2, 1, sigma_sym))(actx, 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)
where = (sym.DEFAULT_SOURCE, "point_target")
vel = bind(places, representation_sym,
auto_where=where)(actx,
sigma=sigma,
mu=mu,
normal=normal,
sigma_int_val=int_val,
omega=omega)
print("@@@@@@@@")
plot_vel = bind(places,
representation_sym,
auto_where=(sym.DEFAULT_SOURCE,
"plot_target"))(actx,
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(actx.from_numpy(eval_points[0]),
actx.from_numpy(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}"
.format(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 visualize:
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(places, sym.h_max(qbx.ambient_dim))(actx)
return h_max, l2_err
