def all_refine(num_mesh, depth, fname):
from meshmode.mesh.generation import ( # noqa
generate_icosphere, generate_icosahedron,
generate_torus, generate_regular_rect_mesh,
generate_box_mesh)
import timeit
nelements = []
runtimes = []
for el_fact in range(2, num_mesh+2):
mesh = generate_box_mesh(3*(np.linspace(0, 1, el_fact),))
r = Refiner(mesh)
for time in range(depth):
flags = np.ones(len(mesh.groups[0].vertex_indices))
if time < depth-1:
mesh = r.refine(flags)
else:
start = timeit.default_timer()
mesh = r.refine(flags)
stop = timeit.default_timer()
nelements.append(mesh.nelements)
runtimes.append(stop-start)
check_nodal_adj_against_geometry(mesh)
import matplotlib.pyplot as pt
pt.plot(nelements, runtimes, "o")
pt.savefig(fname)
pt.clf()
def all_refine(num_mesh, depth, fname):
from meshmode.mesh.generation import ( # noqa
generate_icosphere, generate_icosahedron, generate_torus,
generate_regular_rect_mesh, generate_box_mesh)
import timeit
nelements = []
runtimes = []
for el_fact in range(2, num_mesh + 2):
mesh = generate_box_mesh(3 * (np.linspace(0, 1, el_fact), ))
r = Refiner(mesh)
for time in range(depth):
flags = np.ones(len(mesh.groups[0].vertex_indices))
if time < depth - 1:
mesh = r.refine(flags)
else:
start = timeit.default_timer()
mesh = r.refine(flags)
stop = timeit.default_timer()
nelements.append(mesh.nelements)
runtimes.append(stop - start)
check_nodal_adj_against_geometry(mesh)
import matplotlib.pyplot as pt
pt.plot(nelements, runtimes, "o")
pt.savefig(fname)
pt.clf()
def get_sphere_mesh(refinement_increment, target_order):
from meshmode.mesh.generation import generate_icosphere
mesh = generate_icosphere(1, target_order)
from meshmode.mesh.refinement import Refiner
refiner = Refiner(mesh)
for i in range(refinement_increment):
flags = np.ones(mesh.nelements, dtype=bool)
refiner.refine(flags)
mesh = refiner.get_current_mesh()
return mesh
def get_sphere_mesh(refinement_increment, target_order):
from meshmode.mesh.generation import generate_icosphere
mesh = generate_icosphere(1, target_order)
from meshmode.mesh.refinement import Refiner
refiner = Refiner(mesh)
for i in range(refinement_increment):
flags = np.ones(mesh.nelements, dtype=bool)
refiner.refine(flags)
mesh = refiner.get_current_mesh()
return mesh
def test_refinement(case_name, mesh_gen, flag_gen, num_generations):
from random import seed
seed(13)
mesh = mesh_gen()
r = Refiner(mesh)
for _ in range(num_generations):
flags = flag_gen(mesh)
mesh = r.refine(flags)
check_nodal_adj_against_geometry(mesh)
def test_refinement(case_name, mesh_gen, flag_gen, num_generations):
from random import seed
seed(13)
mesh = mesh_gen()
r = Refiner(mesh)
for _ in range(num_generations):
flags = flag_gen(mesh)
mesh = r.refine(flags)
check_nodal_adj_against_geometry(mesh)
def uniform_refine(num_mesh, fract, depth, fname):
from meshmode.mesh.generation import ( # noqa
generate_icosphere, generate_icosahedron,
generate_torus, generate_regular_rect_mesh,
generate_box_mesh)
import timeit
nelements = []
runtimes = []
for el_fact in range(2, num_mesh+2):
mesh = generate_box_mesh(3*(np.linspace(0, 1, el_fact),))
r = Refiner(mesh)
all_els = list(range(mesh.nelements))
for time in range(depth):
print("EL_FACT", el_fact, "TIME", time)
flags = np.zeros(mesh.nelements)
from random import shuffle, seed
seed(1)
shuffle(all_els)
nels_this_round = 0
for i in range(len(all_els)):
if i / len(flags) > fract:
break
flags[all_els[i]] = 1
nels_this_round += 1
if time < depth-1:
mesh = r.refine(flags)
else:
start = timeit.default_timer()
mesh = r.refine(flags)
stop = timeit.default_timer()
nelements.append(mesh.nelements)
runtimes.append(stop-start)
all_els = []
for i in range(len(flags)):
if flags[i]:
all_els.append(i)
for i in range(len(flags), mesh.nelements):
all_els.append(i)
check_nodal_adj_against_geometry(mesh)
import matplotlib.pyplot as pt
pt.plot(nelements, runtimes, "o")
pt.savefig(fname)
pt.clf()
def uniform_refine(num_mesh, fract, depth, fname):
from meshmode.mesh.generation import ( # noqa
generate_icosphere, generate_icosahedron,
generate_torus, generate_regular_rect_mesh,
generate_box_mesh)
import timeit
nelements = []
runtimes = []
for el_fact in range(2, num_mesh+2):
mesh = generate_box_mesh(3*(np.linspace(0, 1, el_fact),))
r = Refiner(mesh)
all_els = list(range(mesh.nelements))
for time in range(depth):
print("EL_FACT", el_fact, "TIME", time)
flags = np.zeros(mesh.nelements)
from random import shuffle, seed
seed(1)
shuffle(all_els)
nels_this_round = 0
for i in range(len(all_els)):
if i / len(flags) > fract:
break
flags[all_els[i]] = 1
nels_this_round += 1
if time < depth-1:
mesh = r.refine(flags)
else:
start = timeit.default_timer()
mesh = r.refine(flags)
stop = timeit.default_timer()
nelements.append(mesh.nelements)
runtimes.append(stop-start)
all_els = []
for i in range(len(flags)):
if flags[i]:
all_els.append(i)
for i in range(len(flags), mesh.nelements):
all_els.append(i)
check_nodal_adj_against_geometry(mesh)
import matplotlib.pyplot as pt
pt.plot(nelements, runtimes, "o")
pt.savefig(fname)
pt.clf()
def main():
# cl.array.to_device(queue, numpy_array)
from meshmode.mesh.io import generate_gmsh, FileSource
from meshmode.mesh.generation import generate_icosphere
from meshmode.mesh.refinement import Refiner
mesh = generate_icosphere(1, target_order)
refinement_increment = 1
refiner = Refiner(mesh)
for i in range(refinement_increment):
flags = np.ones(mesh.nelements, dtype=bool)
refiner.refine(flags)
mesh = refiner.get_current_mesh()
from meshmode.mesh.processing import perform_flips
# Flip elements--gmsh generates inside-out geometry.
mesh = perform_flips(mesh, np.ones(mesh.nelements))
print("%d elements" % mesh.nelements)
from meshmode.mesh.processing import find_bounding_box
bbox_min, bbox_max = find_bounding_box(mesh)
bbox_center = 0.5 * (bbox_min + bbox_max)
bbox_size = max(bbox_max - bbox_min) / 2
logger.info("%d elements" % mesh.nelements)
from pytential.qbx import QBXLayerPotentialSource
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
density_discr = Discretization(
cl_ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order))
qbx = QBXLayerPotentialSource(density_discr,
4 * target_order,
qbx_order,
fmm_order=False,
fmm_backend="fmmlib")
from pytential.symbolic.pde.maxwell import MuellerAugmentedMFIEOperator
pde_op = MuellerAugmentedMFIEOperator(
omega=1.0,
epss=[1.0, 1.0],
mus=[1.0, 1.0],
)
from pytential import bind, sym
unk = pde_op.make_unknown("sigma")
sym_operator = pde_op.operator(unk)
sym_rhs = pde_op.rhs(sym.make_sym_vector("Einc", 3),
sym.make_sym_vector("Hinc", 3))
sym_repr = pde_op.representation(1, unk)
if 1:
expr = sym_repr
print(sym.pretty(expr))
print("#" * 80)
from pytential.target import PointsTarget
tgt_points = np.zeros((3, 1))
tgt_points[0, 0] = 100
tgt_points[1, 0] = -200
tgt_points[2, 0] = 300
bound_op = bind((qbx, PointsTarget(tgt_points)), expr)
print(bound_op.code)
if 1:
def green3e(x, y, z, source, strength, k):
# electric field corresponding to dyadic green's function
# due to monochromatic electric dipole located at "source".
# "strength" is the the intensity of the dipole.
# E = (I + Hess)(exp(ikr)/r) dot (strength)
#
dx = x - source[0]
dy = y - source[1]
dz = z - source[2]
rr = np.sqrt(dx**2 + dy**2 + dz**2)
fout = np.exp(1j * k * rr) / rr
evec = fout * strength
qmat = np.zeros((3, 3), dtype=np.complex128)
qmat[0, 0] = (2 * dx**2 - dy**2 - dz**2) * (1 - 1j * k * rr)
qmat[1, 1] = (2 * dy**2 - dz**2 - dx**2) * (1 - 1j * k * rr)
qmat[2, 2] = (2 * dz**2 - dx**2 - dy**2) * (1 - 1j * k * rr)
qmat[0, 0] = qmat[0, 0] + (-k**2 * dx**2 * rr**2)
qmat[1, 1] = qmat[1, 1] + (-k**2 * dy**2 * rr**2)
qmat[2, 2] = qmat[2, 2] + (-k**2 * dz**2 * rr**2)
qmat[0, 1] = (3 - k**2 * rr**2 - 3 * 1j * k * rr) * (dx * dy)
qmat[1, 2] = (3 - k**2 * rr**2 - 3 * 1j * k * rr) * (dy * dz)
qmat[2, 0] = (3 - k**2 * rr**2 - 3 * 1j * k * rr) * (dz * dx)
qmat[1, 0] = qmat[0, 1]
qmat[2, 1] = qmat[1, 2]
qmat[0, 2] = qmat[2, 0]
fout = np.exp(1j * k * rr) / rr**5 / k**2
fvec = fout * np.dot(qmat, strength)
evec = evec + fvec
return evec
def green3m(x, y, z, source, strength, k):
# magnetic field corresponding to dyadic green's function
# due to monochromatic electric dipole located at "source".
# "strength" is the the intensity of the dipole.
# H = curl((I + Hess)(exp(ikr)/r) dot (strength)) =
# strength \cross \grad (exp(ikr)/r)
#
dx = x - source[0]
dy = y - source[1]
dz = z - source[2]
rr = np.sqrt(dx**2 + dy**2 + dz**2)
fout = (1 - 1j * k * rr) * np.exp(1j * k * rr) / rr**3
fvec = np.zeros(3, dtype=np.complex128)
fvec[0] = fout * dx
fvec[1] = fout * dy
fvec[2] = fout * dz
hvec = np.cross(strength, fvec)
return hvec
def dipole3e(x, y, z, source, strength, k):
#
# evalaute electric and magnetic field due
# to monochromatic electric dipole located at "source"
# with intensity "strength"
evec = green3e(x, y, z, source, strength, k)
evec = evec * 1j * k
hvec = green3m(x, y, z, source, strength, k)
# print(hvec)
# print(strength)
return evec, hvec
def dipole3m(x, y, z, source, strength, k):
#
# evalaute electric and magnetic field due
# to monochromatic magnetic dipole located at "source"
# with intensity "strength"
evec = green3m(x, y, z, source, strength, k)
hvec = green3e(x, y, z, source, strength, k)
hvec = -hvec * 1j * k
return evec, hvec
def dipole3eall(x, y, z, sources, strengths, k):
ns = len(strengths)
evec = np.zeros(3, dtype=np.complex128)
hvec = np.zeros(3, dtype=np.complex128)
for i in range(ns):
evect, hvect = dipole3e(x, y, z, sources[i], strengths[i], k)
evec = evec + evect
hvec = hvec + hvect
nodes = density_discr.nodes().with_queue(queue).get()
source = [0.01, -0.03, 0.02]
# source = cl.array.to_device(queue,np.zeros(3))
# source[0] = 0.01
# source[1] =-0.03
# source[2] = 0.02
strength = np.ones(3)
# evec = cl.array.to_device(queue,np.zeros((3,len(nodes[0])),dtype=np.complex128))
# hvec = cl.array.to_device(queue,np.zeros((3,len(nodes[0])),dtype=np.complex128))
evec = np.zeros((3, len(nodes[0])), dtype=np.complex128)
hvec = np.zeros((3, len(nodes[0])), dtype=np.complex128)
for i in range(len(nodes[0])):
evec[:, i], hvec[:, i] = dipole3e(nodes[0][i], nodes[1][i],
nodes[2][i], source, strength, k)
print(np.shape(hvec))
print(type(evec))
print(type(hvec))
evec = cl.array.to_device(queue, evec)
hvec = cl.array.to_device(queue, hvec)
bvp_rhs = bind(qbx, sym_rhs)(queue, Einc=evec, Hinc=hvec)
print(np.shape(bvp_rhs))
print(type(bvp_rhs))
# print(bvp_rhs)
1 / -1
bound_op = bind(qbx, sym_operator)
from pytential.solve import gmres
if 1:
gmres_result = gmres(bound_op.scipy_op(queue,
"sigma",
dtype=np.complex128,
k=k),
bvp_rhs,
tol=1e-8,
progress=True,
stall_iterations=0,
hard_failure=True)
sigma = gmres_result.solution
fld_at_tgt = bind((qbx, PointsTarget(tgt_points)),
sym_repr)(queue, sigma=sigma, k=k)
fld_at_tgt = np.array([fi.get() for fi in fld_at_tgt])
print(fld_at_tgt)
fld_exact_e, fld_exact_h = dipole3e(tgt_points[0, 0], tgt_points[1, 0],
tgt_points[2,
0], source, strength, k)
print(fld_exact_e)
print(fld_exact_h)
1 / 0
# }}}
#mlab.figure(bgcolor=(1, 1, 1))
if 1:
from meshmode.discretization.visualization import make_visualizer
bdry_vis = make_visualizer(queue, density_discr, target_order)
bdry_normals = bind(density_discr, sym.normal(3))(queue)\
.as_vector(dtype=object)
bdry_vis.write_vtk_file("source.vtu", [
("sigma", sigma),
("bdry_normals", bdry_normals),
])
fplot = FieldPlotter(bbox_center,
extent=2 * bbox_size,
npoints=(150, 150, 1))
qbx_stick_out = qbx.copy(target_stick_out_factor=0.1)
from pytential.target import PointsTarget
from pytential.qbx import QBXTargetAssociationFailedException
rho_sym = sym.var("rho")
try:
fld_in_vol = bind((qbx_stick_out, PointsTarget(fplot.points)),
sym.make_obj_array([
sym.S(pde_op.kernel,
rho_sym,
k=sym.var("k"),
qbx_forced_limit=None),
sym.d_dx(
3,
sym.S(pde_op.kernel,
rho_sym,
k=sym.var("k"),
qbx_forced_limit=None)),
sym.d_dy(
3,
sym.S(pde_op.kernel,
rho_sym,
k=sym.var("k"),
qbx_forced_limit=None)),
sym.d_dz(
3,
sym.S(pde_op.kernel,
rho_sym,
k=sym.var("k"),
qbx_forced_limit=None)),
]))(queue, jt=jt, rho=rho, k=k)
except QBXTargetAssociationFailedException as e:
fplot.write_vtk_file(
"failed-targets.vts",
[("failed_targets", e.failed_target_flags.get(queue))])
raise
fld_in_vol = sym.make_obj_array([fiv.get() for fiv in fld_in_vol])
#fplot.show_scalar_in_mayavi(fld_in_vol.real, max_val=5)
fplot.write_vtk_file("potential.vts", [
("potential", fld_in_vol[0]),
("grad", fld_in_vol[1:]),
])
def test_refinement_connection(ctx_getter,
group_factory,
mesh_name,
dim,
mesh_pars,
mesh_order,
refine_flags,
plot_mesh=False):
from random import seed
seed(13)
# Discretization order
order = 5
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
from meshmode.discretization import Discretization
from meshmode.discretization.connection import (make_refinement_connection,
check_connection)
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
def f(x):
from six.moves import reduce
return 0.1 * reduce(lambda x, y: x * cl.clmath.sin(5 * y), x)
for mesh_par in mesh_pars:
# {{{ get mesh
if mesh_name == "circle":
assert dim == 1
h = 1 / mesh_par
mesh = make_curve_mesh(partial(ellipse, 1),
np.linspace(0, 1, mesh_par + 1),
order=mesh_order)
elif mesh_name == "blob":
if mesh_order == 5:
pytest.xfail(
"https://gitlab.tiker.net/inducer/meshmode/issues/2")
assert dim == 2
h = mesh_par
mesh = gen_blob_mesh(h, mesh_order)
elif mesh_name == "warp":
from meshmode.mesh.generation import generate_warped_rect_mesh
mesh = generate_warped_rect_mesh(dim, order=mesh_order, n=mesh_par)
h = 1 / mesh_par
else:
raise ValueError("mesh_name not recognized")
# }}}
discr = Discretization(cl_ctx, mesh, group_factory(order))
refiner = Refiner(mesh)
flags = refine_flags(mesh)
refiner.refine(flags)
connection = make_refinement_connection(refiner, discr,
group_factory(order))
check_connection(connection)
fine_discr = connection.to_discr
x = discr.nodes().with_queue(queue)
x_fine = fine_discr.nodes().with_queue(queue)
f_coarse = f(x)
f_interp = connection(queue, f_coarse).with_queue(queue)
f_true = f(x_fine).with_queue(queue)
if plot_mesh:
import matplotlib.pyplot as plt
x = x.get(queue)
err = np.array(np.log10(1e-16 +
np.abs((f_interp - f_true).get(queue))),
dtype=float)
import matplotlib.cm as cm
cmap = cm.ScalarMappable(cmap=cm.jet)
cmap.set_array(err)
plt.scatter(x[0], x[1], c=cmap.to_rgba(err), s=20, cmap=cmap)
plt.colorbar(cmap)
plt.show()
import numpy.linalg as la
err = la.norm((f_interp - f_true).get(queue), np.inf)
eoc_rec.add_data_point(h, err)
print(eoc_rec)
assert (eoc_rec.order_estimate() >= order - 0.5
or eoc_rec.max_error() < 1e-14)
def warp_and_refine_until_resolved(
unwarped_mesh_or_refiner, warp_callable, est_rel_interp_tolerance):
"""Given an original ("un-warped") :class:`meshmode.mesh.Mesh` and a
warping function *warp_callable* that takes and returns a mesh and a
tolerance to which the mesh should be resolved by the mapping polynomials,
this function will iteratively refine the *unwarped_mesh* until relative
interpolation error estimates on the warped version are smaller than
*est_rel_interp_tolerance* on each element.
:returns: The refined, un-warped mesh.
.. versionadded:: 2018.1
"""
from modepy.modes import simplex_onb
from modepy.matrices import vandermonde
from modepy.modal_decay import simplex_interp_error_coefficient_estimator_matrix
from meshmode.mesh.refinement import Refiner, RefinerWithoutAdjacency
if isinstance(unwarped_mesh_or_refiner, (Refiner, RefinerWithoutAdjacency)):
refiner = unwarped_mesh_or_refiner
unwarped_mesh = refiner.get_current_mesh()
else:
unwarped_mesh = unwarped_mesh_or_refiner
refiner = Refiner(unwarped_mesh)
iteration = 0
while True:
refine_flags = np.zeros(unwarped_mesh.nelements, dtype=np.bool)
warped_mesh = warp_callable(unwarped_mesh)
# test whether there are invalid values in warped mesh
if not np.isfinite(warped_mesh.vertices).all():
raise FloatingPointError("Warped mesh contains non-finite vertices "
"(NaN or Inf)")
for group in warped_mesh.groups:
if not np.isfinite(group.nodes).all():
raise FloatingPointError("Warped mesh contains non-finite nodes "
"(NaN or Inf)")
for egrp in warped_mesh.groups:
dim, nunit_nodes = egrp.unit_nodes.shape
interp_err_est_mat = simplex_interp_error_coefficient_estimator_matrix(
egrp.unit_nodes, egrp.order,
n_tail_orders=1 if warped_mesh.dim > 1 else 2)
vdm_inv = la.inv(
vandermonde(simplex_onb(dim, egrp.order), egrp.unit_nodes))
mapping_coeffs = np.einsum("ij,dej->dei", vdm_inv, egrp.nodes)
mapping_norm_2 = np.sqrt(np.sum(mapping_coeffs**2, axis=-1))
interp_error_coeffs = np.einsum(
"ij,dej->dei", interp_err_est_mat, egrp.nodes)
interp_error_norm_2 = np.sqrt(np.sum(interp_error_coeffs**2, axis=-1))
# max over dimensions
est_rel_interp_error = np.max(interp_error_norm_2/mapping_norm_2, axis=0)
refine_flags[
egrp.element_nr_base:
egrp.element_nr_base+egrp.nelements] = \
est_rel_interp_error > est_rel_interp_tolerance
nrefined_elements = np.sum(refine_flags.astype(np.int32))
if nrefined_elements == 0:
break
logger.info("warp_and_refine_until_resolved: "
"iteration %d -> splitting %d/%d elements",
iteration, nrefined_elements, unwarped_mesh.nelements)
unwarped_mesh = refiner.refine(refine_flags)
iteration += 1
return unwarped_mesh
def main():
# cl.array.to_device(queue, numpy_array)
from meshmode.mesh.io import generate_gmsh, FileSource
from meshmode.mesh.generation import generate_icosphere
from meshmode.mesh.refinement import Refiner
mesh = generate_icosphere(1,target_order)
refinement_increment = 1
refiner = Refiner(mesh)
for i in range(refinement_increment):
flags = np.ones(mesh.nelements, dtype=bool)
refiner.refine(flags)
mesh = refiner.get_current_mesh()
from meshmode.mesh.processing import perform_flips
# Flip elements--gmsh generates inside-out geometry.
mesh = perform_flips(mesh, np.ones(mesh.nelements))
print("%d elements" % mesh.nelements)
from meshmode.mesh.processing import find_bounding_box
bbox_min, bbox_max = find_bounding_box(mesh)
bbox_center = 0.5*(bbox_min+bbox_max)
bbox_size = max(bbox_max-bbox_min) / 2
logger.info("%d elements" % mesh.nelements)
from pytential.qbx import QBXLayerPotentialSource
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
density_discr = Discretization(
cl_ctx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order))
qbx = QBXLayerPotentialSource(density_discr, 4*target_order, qbx_order,
fmm_order=False, fmm_backend="fmmlib")
from pytential.symbolic.pde.maxwell import MuellerAugmentedMFIEOperator
pde_op = MuellerAugmentedMFIEOperator(
omega=1.0,
epss=[1.0, 1.0],
mus=[1.0, 1.0],
)
from pytential import bind, sym
unk = pde_op.make_unknown("sigma")
sym_operator = pde_op.operator(unk)
sym_rhs = pde_op.rhs(
sym.make_sym_vector("Einc", 3),
sym.make_sym_vector("Hinc", 3))
sym_repr = pde_op.representation(1, unk)
if 1:
expr = sym_repr
print(sym.pretty(expr))
print("#"*80)
from pytential.target import PointsTarget
tgt_points=np.zeros((3,1))
tgt_points[0,0] = 100
tgt_points[1,0] = -200
tgt_points[2,0] = 300
bound_op = bind((qbx, PointsTarget(tgt_points)), expr)
print(bound_op.code)
if 1:
def green3e(x,y,z,source,strength,k):
# electric field corresponding to dyadic green's function
# due to monochromatic electric dipole located at "source".
# "strength" is the the intensity of the dipole.
# E = (I + Hess)(exp(ikr)/r) dot (strength)
#
dx = x - source[0]
dy = y - source[1]
dz = z - source[2]
rr = np.sqrt(dx**2 + dy**2 + dz**2)
fout = np.exp(1j*k*rr)/rr
evec = fout*strength
qmat = np.zeros((3,3),dtype=np.complex128)
qmat[0,0]=(2*dx**2-dy**2-dz**2)*(1-1j*k*rr)
qmat[1,1]=(2*dy**2-dz**2-dx**2)*(1-1j*k*rr)
qmat[2,2]=(2*dz**2-dx**2-dy**2)*(1-1j*k*rr)
qmat[0,0]=qmat[0,0]+(-k**2*dx**2*rr**2)
qmat[1,1]=qmat[1,1]+(-k**2*dy**2*rr**2)
qmat[2,2]=qmat[2,2]+(-k**2*dz**2*rr**2)
qmat[0,1]=(3-k**2*rr**2-3*1j*k*rr)*(dx*dy)
qmat[1,2]=(3-k**2*rr**2-3*1j*k*rr)*(dy*dz)
qmat[2,0]=(3-k**2*rr**2-3*1j*k*rr)*(dz*dx)
qmat[1,0]=qmat[0,1]
qmat[2,1]=qmat[1,2]
qmat[0,2]=qmat[2,0]
fout=np.exp(1j*k*rr)/rr**5/k**2
fvec = fout*np.dot(qmat,strength)
evec = evec + fvec
return evec
def green3m(x,y,z,source,strength,k):
# magnetic field corresponding to dyadic green's function
# due to monochromatic electric dipole located at "source".
# "strength" is the the intensity of the dipole.
# H = curl((I + Hess)(exp(ikr)/r) dot (strength)) =
# strength \cross \grad (exp(ikr)/r)
#
dx = x - source[0]
dy = y - source[1]
dz = z - source[2]
rr = np.sqrt(dx**2 + dy**2 + dz**2)
fout=(1-1j*k*rr)*np.exp(1j*k*rr)/rr**3
fvec = np.zeros(3,dtype=np.complex128)
fvec[0] = fout*dx
fvec[1] = fout*dy
fvec[2] = fout*dz
hvec = np.cross(strength,fvec)
return hvec
def dipole3e(x,y,z,source,strength,k):
#
# evalaute electric and magnetic field due
# to monochromatic electric dipole located at "source"
# with intensity "strength"
evec = green3e(x,y,z,source,strength,k)
evec = evec*1j*k
hvec = green3m(x,y,z,source,strength,k)
# print(hvec)
# print(strength)
return evec,hvec
def dipole3m(x,y,z,source,strength,k):
#
# evalaute electric and magnetic field due
# to monochromatic magnetic dipole located at "source"
# with intensity "strength"
evec = green3m(x,y,z,source,strength,k)
hvec = green3e(x,y,z,source,strength,k)
hvec = -hvec*1j*k
return evec,hvec
def dipole3eall(x,y,z,sources,strengths,k):
ns = len(strengths)
evec = np.zeros(3,dtype=np.complex128)
hvec = np.zeros(3,dtype=np.complex128)
for i in range(ns):
evect,hvect = dipole3e(x,y,z,sources[i],strengths[i],k)
evec = evec + evect
hvec = hvec + hvect
nodes = density_discr.nodes().with_queue(queue).get()
source = [0.01,-0.03,0.02]
# source = cl.array.to_device(queue,np.zeros(3))
# source[0] = 0.01
# source[1] =-0.03
# source[2] = 0.02
strength = np.ones(3)
# evec = cl.array.to_device(queue,np.zeros((3,len(nodes[0])),dtype=np.complex128))
# hvec = cl.array.to_device(queue,np.zeros((3,len(nodes[0])),dtype=np.complex128))
evec = np.zeros((3,len(nodes[0])),dtype=np.complex128)
hvec = np.zeros((3,len(nodes[0])),dtype=np.complex128)
for i in range(len(nodes[0])):
evec[:,i],hvec[:,i] = dipole3e(nodes[0][i],nodes[1][i],nodes[2][i],source,strength,k)
print(np.shape(hvec))
print(type(evec))
print(type(hvec))
evec = cl.array.to_device(queue,evec)
hvec = cl.array.to_device(queue,hvec)
bvp_rhs = bind(qbx, sym_rhs)(queue,Einc=evec,Hinc=hvec)
print(np.shape(bvp_rhs))
print(type(bvp_rhs))
# print(bvp_rhs)
1/-1
bound_op = bind(qbx, sym_operator)
from pytential.solve import gmres
if 1:
gmres_result = gmres(
bound_op.scipy_op(queue, "sigma", dtype=np.complex128, k=k),
bvp_rhs, tol=1e-8, progress=True,
stall_iterations=0,
hard_failure=True)
sigma = gmres_result.solution
fld_at_tgt = bind((qbx, PointsTarget(tgt_points)), sym_repr)(queue,
sigma=sigma,k=k)
fld_at_tgt = np.array([
fi.get() for fi in fld_at_tgt
])
print(fld_at_tgt)
fld_exact_e,fld_exact_h = dipole3e(tgt_points[0,0],tgt_points[1,0],tgt_points[2,0],source,strength,k)
print(fld_exact_e)
print(fld_exact_h)
1/0
# }}}
#mlab.figure(bgcolor=(1, 1, 1))
if 1:
from meshmode.discretization.visualization import make_visualizer
bdry_vis = make_visualizer(queue, density_discr, target_order)
bdry_normals = bind(density_discr, sym.normal(3))(queue)\
.as_vector(dtype=object)
bdry_vis.write_vtk_file("source.vtu", [
("sigma", sigma),
("bdry_normals", bdry_normals),
])
fplot = FieldPlotter(bbox_center, extent=2*bbox_size, npoints=(150, 150, 1))
qbx_stick_out = qbx.copy(target_stick_out_factor=0.1)
from pytential.target import PointsTarget
from pytential.qbx import QBXTargetAssociationFailedException
rho_sym = sym.var("rho")
try:
fld_in_vol = bind(
(qbx_stick_out, PointsTarget(fplot.points)),
sym.make_obj_array([
sym.S(pde_op.kernel, rho_sym, k=sym.var("k"),
qbx_forced_limit=None),
sym.d_dx(3, sym.S(pde_op.kernel, rho_sym, k=sym.var("k"),
qbx_forced_limit=None)),
sym.d_dy(3, sym.S(pde_op.kernel, rho_sym, k=sym.var("k"),
qbx_forced_limit=None)),
sym.d_dz(3, sym.S(pde_op.kernel, rho_sym, k=sym.var("k"),
qbx_forced_limit=None)),
])
)(queue, jt=jt, rho=rho, k=k)
except QBXTargetAssociationFailedException as e:
fplot.write_vtk_file(
"failed-targets.vts",
[
("failed_targets", e.failed_target_flags.get(queue))
])
raise
fld_in_vol = sym.make_obj_array(
[fiv.get() for fiv in fld_in_vol])
#fplot.show_scalar_in_mayavi(fld_in_vol.real, max_val=5)
fplot.write_vtk_file(
"potential.vts",
[
("potential", fld_in_vol[0]),
("grad", fld_in_vol[1:]),
]
)
def refine_and_generate_chart_function(mesh, filename, function):
from time import clock
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
print("NELEMENTS: ", mesh.nelements)
#print mesh
for i in range(len(mesh.groups[0].vertex_indices[0])):
for k in range(len(mesh.vertices)):
print(mesh.vertices[k, i])
#check_nodal_adj_against_geometry(mesh);
r = Refiner(mesh)
#random.seed(0)
#times = 3
num_elements = []
time_t = []
#nelements = mesh.nelements
while True:
print("NELS:", mesh.nelements)
#flags = get_corner_flags(mesh)
flags = get_function_flags(mesh, function)
nels = 0
for i in flags:
if i:
nels += 1
if nels == 0:
break
print("LKJASLFKJALKASF:", nels)
num_elements.append(nels)
#flags = get_corner_flags(mesh)
beg = clock()
mesh = r.refine(flags)
end = clock()
time_taken = end - beg
time_t.append(time_taken)
#if nelements == mesh.nelements:
#break
#nelements = mesh.nelements
#from meshmode.mesh.visualization import draw_2d_mesh
#draw_2d_mesh(mesh, True, True, True, fill=None)
#import matplotlib.pyplot as pt
#pt.show()
#poss_flags = np.zeros(len(mesh.groups[0].vertex_indices))
#for i in range(0, len(flags)):
# poss_flags[i] = flags[i]
#for i in range(len(flags), len(poss_flags)):
# poss_flags[i] = 1
import matplotlib.pyplot as pt
pt.xlabel('Number of elements being refined')
pt.ylabel('Time taken')
pt.plot(num_elements, time_t, "o")
pt.savefig(filename, format='pdf')
pt.clf()
print('DONE REFINING')
'''
flags = np.zeros(len(mesh.groups[0].vertex_indices))
flags[0] = 1
flags[1] = 1
mesh = r.refine(flags)
flags = np.zeros(len(mesh.groups[0].vertex_indices))
flags[0] = 1
flags[1] = 1
flags[2] = 1
mesh = r.refine(flags)
'''
#check_nodal_adj_against_geometry(mesh)
#r.print_rays(70)
#r.print_rays(117)
#r.print_hanging_elements(10)
#r.print_hanging_elements(117)
#r.print_hanging_elements(757)
#from meshmode.mesh.visualization import draw_2d_mesh
#draw_2d_mesh(mesh, False, False, False, fill=None)
#import matplotlib.pyplot as pt
#pt.show()
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
PolynomialWarpAndBlendGroupFactory
discr = Discretization(cl_ctx, mesh,
PolynomialWarpAndBlendGroupFactory(order))
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(queue, discr, order)
remove_if_exists("connectivity2.vtu")
remove_if_exists("geometry2.vtu")
vis.write_vtk_file("geometry2.vtu", [
("f", discr.nodes()[0]),
])
from meshmode.discretization.visualization import \
write_nodal_adjacency_vtk_file
write_nodal_adjacency_vtk_file("connectivity2.vtu", mesh)
def test_sphere_eigenvalues(ctx_getter, mode_m, mode_n, qbx_order,
fmm_backend):
logging.basicConfig(level=logging.INFO)
special = pytest.importorskip("scipy.special")
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
target_order = 8
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
from pytential.qbx import QBXLayerPotentialSource
from pytools.convergence import EOCRecorder
s_eoc_rec = EOCRecorder()
d_eoc_rec = EOCRecorder()
sp_eoc_rec = EOCRecorder()
dp_eoc_rec = EOCRecorder()
def rel_err(comp, ref):
return (
norm(density_discr, queue, comp - ref)
/ norm(density_discr, queue, ref))
for nrefinements in [0, 1]:
from meshmode.mesh.generation import generate_icosphere
mesh = generate_icosphere(1, target_order)
from meshmode.mesh.refinement import Refiner
refiner = Refiner(mesh)
for i in range(nrefinements):
flags = np.ones(mesh.nelements, dtype=bool)
refiner.refine(flags)
mesh = refiner.get_current_mesh()
pre_density_discr = Discretization(
cl_ctx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(target_order))
qbx, _ = QBXLayerPotentialSource(
pre_density_discr, 4*target_order,
qbx_order, fmm_order=6,
fmm_backend=fmm_backend,
).with_refinement()
density_discr = qbx.density_discr
nodes = density_discr.nodes().with_queue(queue)
r = cl.clmath.sqrt(nodes[0]**2 + nodes[1]**2 + nodes[2]**2)
phi = cl.clmath.acos(nodes[2]/r)
theta = cl.clmath.atan2(nodes[0], nodes[1])
ymn = cl.array.to_device(queue,
special.sph_harm(mode_m, mode_n, theta.get(), phi.get()))
from sumpy.kernel import LaplaceKernel
lap_knl = LaplaceKernel(3)
# {{{ single layer
s_sigma_op = bind(qbx, sym.S(lap_knl, sym.var("sigma")))
s_sigma = s_sigma_op(queue=queue, sigma=ymn)
s_eigval = 1/(2*mode_n + 1)
s_eoc_rec.add_data_point(qbx.h_max, rel_err(s_sigma, s_eigval*ymn))
# }}}
# {{{ double layer
d_sigma_op = bind(qbx, sym.D(lap_knl, sym.var("sigma")))
d_sigma = d_sigma_op(queue=queue, sigma=ymn)
d_eigval = -1/(2*(2*mode_n + 1))
d_eoc_rec.add_data_point(qbx.h_max, rel_err(d_sigma, d_eigval*ymn))
# }}}
# {{{ S'
sp_sigma_op = bind(qbx, sym.Sp(lap_knl, sym.var("sigma")))
sp_sigma = sp_sigma_op(queue=queue, sigma=ymn)
sp_eigval = -1/(2*(2*mode_n + 1))
sp_eoc_rec.add_data_point(qbx.h_max, rel_err(sp_sigma, sp_eigval*ymn))
# }}}
# {{{ D'
dp_sigma_op = bind(qbx, sym.Dp(lap_knl, sym.var("sigma")))
dp_sigma = dp_sigma_op(queue=queue, sigma=ymn)
dp_eigval = -(mode_n*(mode_n+1))/(2*mode_n + 1)
dp_eoc_rec.add_data_point(qbx.h_max, rel_err(dp_sigma, dp_eigval*ymn))
# }}}
print("Errors for S:")
print(s_eoc_rec)
required_order = qbx_order + 1
assert s_eoc_rec.order_estimate() > required_order - 1.5
print("Errors for D:")
print(d_eoc_rec)
required_order = qbx_order
assert d_eoc_rec.order_estimate() > required_order - 0.5
print("Errors for S':")
print(sp_eoc_rec)
required_order = qbx_order
assert sp_eoc_rec.order_estimate() > required_order - 1.5
print("Errors for D':")
print(dp_eoc_rec)
required_order = qbx_order
assert dp_eoc_rec.order_estimate() > required_order - 1.5
def test_sphere_eigenvalues(ctx_factory, mode_m, mode_n, qbx_order,
fmm_backend):
logging.basicConfig(level=logging.INFO)
special = pytest.importorskip("scipy.special")
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
target_order = 8
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
InterpolatoryQuadratureSimplexGroupFactory
from pytential.qbx import QBXLayerPotentialSource
from pytools.convergence import EOCRecorder
s_eoc_rec = EOCRecorder()
d_eoc_rec = EOCRecorder()
sp_eoc_rec = EOCRecorder()
dp_eoc_rec = EOCRecorder()
def rel_err(comp, ref):
return (norm(density_discr, comp - ref) / norm(density_discr, ref))
for nrefinements in [0, 1]:
from meshmode.mesh.generation import generate_icosphere
mesh = generate_icosphere(1, target_order)
from meshmode.mesh.refinement import Refiner
refiner = Refiner(mesh)
for i in range(nrefinements):
flags = np.ones(mesh.nelements, dtype=bool)
refiner.refine(flags)
mesh = refiner.get_current_mesh()
pre_density_discr = Discretization(
actx, mesh,
InterpolatoryQuadratureSimplexGroupFactory(target_order))
qbx = QBXLayerPotentialSource(
pre_density_discr,
4 * target_order,
qbx_order,
fmm_order=6,
fmm_backend=fmm_backend,
)
places = GeometryCollection(qbx)
from meshmode.dof_array import flatten, unflatten, thaw
density_discr = places.get_discretization(places.auto_source.geometry)
nodes = thaw(actx, density_discr.nodes())
r = actx.np.sqrt(nodes[0] * nodes[0] + nodes[1] * nodes[1] +
nodes[2] * nodes[2])
phi = actx.np.arccos(nodes[2] / r)
theta = actx.np.arctan2(nodes[0], nodes[1])
ymn = unflatten(
actx, density_discr,
actx.from_numpy(
special.sph_harm(mode_m, mode_n, actx.to_numpy(flatten(theta)),
actx.to_numpy(flatten(phi)))))
from sumpy.kernel import LaplaceKernel
lap_knl = LaplaceKernel(3)
# {{{ single layer
s_sigma_op = bind(
places, sym.S(lap_knl, sym.var("sigma"), qbx_forced_limit=+1))
s_sigma = s_sigma_op(actx, sigma=ymn)
s_eigval = 1 / (2 * mode_n + 1)
h_max = bind(places, sym.h_max(qbx.ambient_dim))(actx)
s_eoc_rec.add_data_point(h_max, rel_err(s_sigma, s_eigval * ymn))
# }}}
# {{{ double layer
d_sigma_op = bind(
places, sym.D(lap_knl, sym.var("sigma"), qbx_forced_limit="avg"))
d_sigma = d_sigma_op(actx, sigma=ymn)
d_eigval = -1 / (2 * (2 * mode_n + 1))
d_eoc_rec.add_data_point(h_max, rel_err(d_sigma, d_eigval * ymn))
# }}}
# {{{ S'
sp_sigma_op = bind(
places, sym.Sp(lap_knl, sym.var("sigma"), qbx_forced_limit="avg"))
sp_sigma = sp_sigma_op(actx, sigma=ymn)
sp_eigval = -1 / (2 * (2 * mode_n + 1))
sp_eoc_rec.add_data_point(h_max, rel_err(sp_sigma, sp_eigval * ymn))
# }}}
# {{{ D'
dp_sigma_op = bind(
places, sym.Dp(lap_knl, sym.var("sigma"), qbx_forced_limit="avg"))
dp_sigma = dp_sigma_op(actx, sigma=ymn)
dp_eigval = -(mode_n * (mode_n + 1)) / (2 * mode_n + 1)
dp_eoc_rec.add_data_point(h_max, rel_err(dp_sigma, dp_eigval * ymn))
# }}}
print("Errors for S:")
print(s_eoc_rec)
required_order = qbx_order + 1
assert s_eoc_rec.order_estimate() > required_order - 1.5
print("Errors for D:")
print(d_eoc_rec)
required_order = qbx_order
assert d_eoc_rec.order_estimate() > required_order - 0.5
print("Errors for S':")
print(sp_eoc_rec)
required_order = qbx_order
assert sp_eoc_rec.order_estimate() > required_order - 1.5
print("Errors for D':")
print(dp_eoc_rec)
required_order = qbx_order
assert dp_eoc_rec.order_estimate() > required_order - 1.5
def warp_and_refine_until_resolved(unwarped_mesh_or_refiner, warp_callable,
est_rel_interp_tolerance):
"""Given an original ("unwarped") :class:`meshmode.mesh.Mesh` and a
warping function *warp_callable* that takes and returns a mesh and a
tolerance to which the mesh should be resolved by the mapping polynomials,
this function will iteratively refine the *unwarped_mesh* until relative
interpolation error estimates on the warped version are smaller than
*est_rel_interp_tolerance* on each element.
:returns: The refined, unwarped mesh.
.. versionadded:: 2018.1
"""
from modepy.modes import simplex_onb
from modepy.matrices import vandermonde
from modepy.modal_decay import simplex_interp_error_coefficient_estimator_matrix
from meshmode.mesh.refinement import Refiner, RefinerWithoutAdjacency
if isinstance(unwarped_mesh_or_refiner,
(Refiner, RefinerWithoutAdjacency)):
refiner = unwarped_mesh_or_refiner
unwarped_mesh = refiner.get_current_mesh()
else:
unwarped_mesh = unwarped_mesh_or_refiner
refiner = Refiner(unwarped_mesh)
iteration = 0
while True:
refine_flags = np.zeros(unwarped_mesh.nelements, dtype=bool)
warped_mesh = warp_callable(unwarped_mesh)
# test whether there are invalid values in warped mesh
if not np.isfinite(warped_mesh.vertices).all():
raise FloatingPointError(
"Warped mesh contains non-finite vertices "
"(NaN or Inf)")
for group in warped_mesh.groups:
if not np.isfinite(group.nodes).all():
raise FloatingPointError(
"Warped mesh contains non-finite nodes "
"(NaN or Inf)")
for egrp in warped_mesh.groups:
dim, nunit_nodes = egrp.unit_nodes.shape
interp_err_est_mat = simplex_interp_error_coefficient_estimator_matrix(
egrp.unit_nodes,
egrp.order,
n_tail_orders=1 if warped_mesh.dim > 1 else 2)
vdm_inv = la.inv(
vandermonde(simplex_onb(dim, egrp.order), egrp.unit_nodes))
mapping_coeffs = np.einsum("ij,dej->dei", vdm_inv, egrp.nodes)
mapping_norm_2 = np.sqrt(np.sum(mapping_coeffs**2, axis=-1))
interp_error_coeffs = np.einsum("ij,dej->dei", interp_err_est_mat,
egrp.nodes)
interp_error_norm_2 = np.sqrt(
np.sum(interp_error_coeffs**2, axis=-1))
# max over dimensions
est_rel_interp_error = np.max(interp_error_norm_2 / mapping_norm_2,
axis=0)
refine_flags[
egrp.element_nr_base:
egrp.element_nr_base+egrp.nelements] = \
est_rel_interp_error > est_rel_interp_tolerance
nrefined_elements = np.sum(refine_flags.astype(np.int32))
if nrefined_elements == 0:
break
logger.info(
"warp_and_refine_until_resolved: "
"iteration %d -> splitting %d/%d elements", iteration,
nrefined_elements, unwarped_mesh.nelements)
unwarped_mesh = refiner.refine(refine_flags)
iteration += 1
return unwarped_mesh
def refine_and_generate_chart_function(mesh, filename, function):
from time import clock
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
print("NELEMENTS: ", mesh.nelements)
#print mesh
for i in range(len(mesh.groups[0].vertex_indices[0])):
for k in range(len(mesh.vertices)):
print(mesh.vertices[k, i])
#check_nodal_adj_against_geometry(mesh);
r = Refiner(mesh)
#random.seed(0)
#times = 3
num_elements = []
time_t = []
#nelements = mesh.nelements
while True:
print("NELS:", mesh.nelements)
#flags = get_corner_flags(mesh)
flags = get_function_flags(mesh, function)
nels = 0
for i in flags:
if i:
nels += 1
if nels == 0:
break
print("LKJASLFKJALKASF:", nels)
num_elements.append(nels)
#flags = get_corner_flags(mesh)
beg = clock()
mesh = r.refine(flags)
end = clock()
time_taken = end - beg
time_t.append(time_taken)
#if nelements == mesh.nelements:
#break
#nelements = mesh.nelements
#from meshmode.mesh.visualization import draw_2d_mesh
#draw_2d_mesh(mesh, True, True, True, fill=None)
#import matplotlib.pyplot as pt
#pt.show()
#poss_flags = np.zeros(len(mesh.groups[0].vertex_indices))
#for i in range(0, len(flags)):
# poss_flags[i] = flags[i]
#for i in range(len(flags), len(poss_flags)):
# poss_flags[i] = 1
import matplotlib.pyplot as pt
pt.xlabel('Number of elements being refined')
pt.ylabel('Time taken')
pt.plot(num_elements, time_t, "o")
pt.savefig(filename, format='pdf')
pt.clf()
print('DONE REFINING')
'''
flags = np.zeros(len(mesh.groups[0].vertex_indices))
flags[0] = 1
flags[1] = 1
mesh = r.refine(flags)
flags = np.zeros(len(mesh.groups[0].vertex_indices))
flags[0] = 1
flags[1] = 1
flags[2] = 1
mesh = r.refine(flags)
'''
#check_nodal_adj_against_geometry(mesh)
#r.print_rays(70)
#r.print_rays(117)
#r.print_hanging_elements(10)
#r.print_hanging_elements(117)
#r.print_hanging_elements(757)
#from meshmode.mesh.visualization import draw_2d_mesh
#draw_2d_mesh(mesh, False, False, False, fill=None)
#import matplotlib.pyplot as pt
#pt.show()
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
PolynomialWarpAndBlendGroupFactory
discr = Discretization(
cl_ctx, mesh, PolynomialWarpAndBlendGroupFactory(order))
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(queue, discr, order)
remove_if_exists("connectivity2.vtu")
remove_if_exists("geometry2.vtu")
vis.write_vtk_file("geometry2.vtu", [
("f", discr.nodes()[0]),
])
from meshmode.discretization.visualization import \
write_nodal_adjacency_vtk_file
write_nodal_adjacency_vtk_file("connectivity2.vtu",
mesh)