def get_mesh(self, resolution, target_order):
from meshmode.mesh.io import generate_gmsh, FileSource
base_mesh = generate_gmsh(
FileSource("ellipsoid.step"), 2, order=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" % resolution])
from meshmode.mesh.processing import perform_flips
# Flip elements--gmsh generates inside-out geometry.
base_mesh = perform_flips(base_mesh, np.ones(base_mesh.nelements))
from meshmode.mesh.processing import affine_map, merge_disjoint_meshes
from meshmode.mesh.tools import rand_rotation_matrix
pitch = 10
meshes = [
affine_map(
base_mesh,
A=rand_rotation_matrix(3),
b=pitch*np.array([
(ix-self.nx//2),
(iy-self.ny//2),
(iz-self.ny//2)]))
for ix in range(self.nx)
for iy in range(self.ny)
for iz in range(self.nz)
]
mesh = merge_disjoint_meshes(meshes, single_group=True)
return mesh
def test_element_orientation():
from meshmode.mesh.io import generate_gmsh, FileSource
mesh_order = 3
mesh = generate_gmsh(
FileSource("blob-2d.step"),
2,
order=mesh_order,
force_ambient_dim=2,
other_options=["-string", "Mesh.CharacteristicLengthMax = 0.02;"])
from meshmode.mesh.processing import (perform_flips,
find_volume_mesh_element_orientations
)
mesh_orient = find_volume_mesh_element_orientations(mesh)
assert (mesh_orient > 0).all()
from random import randrange
flippy = np.zeros(mesh.nelements, np.int8)
for i in range(int(0.3 * mesh.nelements)):
flippy[randrange(0, mesh.nelements)] = 1
mesh = perform_flips(mesh, flippy, skip_tests=True)
mesh_orient = find_volume_mesh_element_orientations(mesh)
assert ((mesh_orient < 0) == (flippy > 0)).all()
def test_element_orientation():
from meshmode.mesh.io import generate_gmsh, FileSource
mesh_order = 3
mesh = generate_gmsh(
FileSource("blob-2d.step"), 2, order=mesh_order,
force_ambient_dim=2,
other_options=["-string", "Mesh.CharacteristicLengthMax = 0.02;"]
)
from meshmode.mesh.processing import (perform_flips,
find_volume_mesh_element_orientations)
mesh_orient = find_volume_mesh_element_orientations(mesh)
assert (mesh_orient > 0).all()
from random import randrange
flippy = np.zeros(mesh.nelements, np.int8)
for i in range(int(0.3*mesh.nelements)):
flippy[randrange(0, mesh.nelements)] = 1
mesh = perform_flips(mesh, flippy, skip_tests=True)
mesh_orient = find_volume_mesh_element_orientations(mesh)
assert ((mesh_orient < 0) == (flippy > 0)).all()
def get_mesh(self, resolution, target_order):
from meshmode.mesh.io import generate_gmsh, FileSource
base_mesh = generate_gmsh(FileSource("ellipsoid.step"),
2,
order=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" %
resolution
])
from meshmode.mesh.processing import perform_flips
# Flip elements--gmsh generates inside-out geometry.
base_mesh = perform_flips(base_mesh, np.ones(base_mesh.nelements))
from meshmode.mesh.processing import affine_map, merge_disjoint_meshes
from meshmode.mesh.tools import rand_rotation_matrix
pitch = 10
meshes = [
affine_map(base_mesh,
A=rand_rotation_matrix(3),
b=pitch * np.array([(ix - self.nx // 2),
(iy - self.ny // 2),
(iz - self.ny // 2)]))
for ix in range(self.nx) for iy in range(self.ny)
for iz in range(self.nz)
]
mesh = merge_disjoint_meshes(meshes, single_group=True)
return mesh
def get_mesh(self, resolution, target_order):
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(
FileSource("ellipsoid.step"), 2, order=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" % resolution])
from meshmode.mesh.processing import perform_flips
# Flip elements--gmsh generates inside-out geometry.
return perform_flips(mesh, np.ones(mesh.nelements))
def get_mesh(self, resolution, target_order):
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(FileSource("ellipsoid.step"),
2,
order=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" %
resolution
])
from meshmode.mesh.processing import perform_flips
# Flip elements--gmsh generates inside-out geometry.
return perform_flips(mesh, np.ones(mesh.nelements))
def get_mesh(self, resolution, target_order):
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(
FileSource("rounded-cube.step"), 2, order=3,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" % resolution])
from meshmode.mesh.processing import perform_flips, affine_map
mesh = affine_map(mesh, b=np.array([-0.5, -0.5, -0.5]))
mesh = affine_map(mesh, A=np.eye(3)*2)
# now centered at origin and extends to -1,1
# Flip elements--gmsh generates inside-out geometry.
return perform_flips(mesh, np.ones(mesh.nelements))
def get_mesh(self, resolution, target_order):
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(
FileSource("rounded-cube.step"), 2, order=3,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" % resolution])
from meshmode.mesh.processing import perform_flips, affine_map
mesh = affine_map(mesh, b=np.array([-0.5, -0.5, -0.5]))
mesh = affine_map(mesh, A=np.eye(3)*2)
# now centered at origin and extends to -1,1
# Flip elements--gmsh generates inside-out geometry.
return perform_flips(mesh, np.ones(mesh.nelements))
def get_mesh(self, resolution, target_order):
from pytools import download_from_web_if_not_present
download_from_web_if_not_present(
"https://raw.githubusercontent.com/inducer/geometries/master/"
"surface-3d/elliptiplane.brep")
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(
FileSource("elliptiplane.brep"), 2, order=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" % resolution])
# now centered at origin and extends to -1,1
# Flip elements--gmsh generates inside-out geometry.
from meshmode.mesh.processing import perform_flips
return perform_flips(mesh, np.ones(mesh.nelements))
def get_mesh(self, resolution, target_order):
from pytools import download_from_web_if_not_present
download_from_web_if_not_present(
"https://raw.githubusercontent.com/inducer/geometries/master/"
"surface-3d/elliptiplane.brep")
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(
FileSource("elliptiplane.brep"), 2, order=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %g;" % resolution])
# now centered at origin and extends to -1,1
# Flip elements--gmsh generates inside-out geometry.
from meshmode.mesh.processing import perform_flips
return perform_flips(mesh, np.ones(mesh.nelements))
def get_mesh(self, resolution, mesh_order):
from meshmode.mesh.io import ScriptSource
source = ScriptSource(
"""
SetFactory("OpenCASCADE");
Sphere(1) = {{0, 0, 0, {r}}};
Dilate {{ {{0, 0, 0}}, {{ {r}, {r}, {rr} }} }} {{ Volume{{1}}; }}
""".format(r=self.diameter, rr=self.aspect_ratio * self.diameter),
"geo")
from meshmode.mesh.io import generate_gmsh
mesh = generate_gmsh(source,
2,
order=mesh_order,
other_options=[
"-optimize_ho", "-string",
"Mesh.CharacteristicLengthMax = %g;" %
resolution
],
target_unit="MM")
from meshmode.mesh.processing import perform_flips
return perform_flips(mesh, np.ones(mesh.nelements))
def main():
import logging
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.WARNING) # INFO for more progress info
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(
FileSource(cad_file_name), 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))
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 + 3,
target_association_tolerance=0.15).with_refinement()
nodes = density_discr.nodes().with_queue(queue)
angle = cl.clmath.atan2(nodes[1], nodes[0])
from pytential import bind, sym
#op = sym.d_dx(sym.S(kernel, sym.var("sigma"), qbx_forced_limit=None))
op = sym.D(kernel, sym.var("sigma"), qbx_forced_limit=None)
#op = sym.S(kernel, sym.var("sigma"), qbx_forced_limit=None)
sigma = cl.clmath.cos(mode_nr*angle)
if 0:
sigma = 0*angle
from random import randrange
for i in range(5):
sigma[randrange(len(sigma))] = 1
if isinstance(kernel, HelmholtzKernel):
sigma = sigma.astype(np.complex128)
fplot = FieldPlotter(bbox_center, extent=3.5*bbox_size, npoints=150)
from pytential.target import PointsTarget
fld_in_vol = bind(
(qbx, PointsTarget(fplot.points)),
op)(queue, sigma=sigma, k=k).get()
#fplot.show_scalar_in_mayavi(fld_in_vol.real, max_val=5)
fplot.write_vtk_file(
"potential-3d.vts",
[
("potential", fld_in_vol)
]
)
bdry_normals = bind(
density_discr,
sym.normal(density_discr.ambient_dim))(queue).as_vector(dtype=object)
from meshmode.discretization.visualization import make_visualizer
bdry_vis = make_visualizer(queue, density_discr, target_order)
bdry_vis.write_vtk_file("source-3d.vtu", [
("sigma", sigma),
("bdry_normals", bdry_normals),
])
def get_mesh(self, resolution, target_order):
from pytools import download_from_web_if_not_present
download_from_web_if_not_present(
"https://raw.githubusercontent.com/inducer/geometries/a869fc3/"
"surface-3d/betterplane.brep")
from meshmode.mesh.io import generate_gmsh, ScriptWithFilesSource
mesh = generate_gmsh(
ScriptWithFilesSource("""
Merge "betterplane.brep";
Mesh.CharacteristicLengthMax = %(lcmax)f;
Mesh.ElementOrder = 2;
Mesh.CharacteristicLengthExtendFromBoundary = 0;
// 2D mesh optimization
// Mesh.Lloyd = 1;
l_superfine() = Unique(Abs(Boundary{ Surface{
27, 25, 17, 13, 18 }; }));
l_fine() = Unique(Abs(Boundary{ Surface{ 2, 6, 7}; }));
l_coarse() = Unique(Abs(Boundary{ Surface{ 14, 16 }; }));
// p() = Unique(Abs(Boundary{ Line{l_fine()}; }));
// Characteristic Length{p()} = 0.05;
Field[1] = Attractor;
Field[1].NNodesByEdge = 100;
Field[1].EdgesList = {l_superfine()};
Field[2] = Threshold;
Field[2].IField = 1;
Field[2].LcMin = 0.075;
Field[2].LcMax = %(lcmax)f;
Field[2].DistMin = 0.1;
Field[2].DistMax = 0.4;
Field[3] = Attractor;
Field[3].NNodesByEdge = 100;
Field[3].EdgesList = {l_fine()};
Field[4] = Threshold;
Field[4].IField = 3;
Field[4].LcMin = 0.1;
Field[4].LcMax = %(lcmax)f;
Field[4].DistMin = 0.15;
Field[4].DistMax = 0.4;
Field[5] = Attractor;
Field[5].NNodesByEdge = 100;
Field[5].EdgesList = {l_coarse()};
Field[6] = Threshold;
Field[6].IField = 5;
Field[6].LcMin = 0.15;
Field[6].LcMax = %(lcmax)f;
Field[6].DistMin = 0.2;
Field[6].DistMax = 0.4;
Field[7] = Min;
Field[7].FieldsList = {2, 4, 6};
Background Field = 7;
""" % {
"lcmax": resolution,
}, ["betterplane.brep"]), 2)
# Flip elements--gmsh generates inside-out geometry.
from meshmode.mesh.processing import perform_flips
return perform_flips(mesh, np.ones(mesh.nelements))
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 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 main(mesh_name="ellipsoid"):
import logging
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.WARNING) # INFO for more progress info
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
if mesh_name == "ellipsoid":
cad_file_name = "geometries/ellipsoid.step"
h = 0.6
elif mesh_name == "two-cylinders":
cad_file_name = "geometries/two-cylinders-smooth.step"
h = 0.4
else:
raise ValueError("unknown mesh name: %s" % mesh_name)
from meshmode.mesh.io import generate_gmsh, FileSource
mesh = generate_gmsh(
FileSource(cad_file_name),
2,
order=2,
other_options=["-string",
"Mesh.CharacteristicLengthMax = %g;" % h],
target_unit="MM")
from meshmode.mesh.processing import perform_flips
# Flip elements--gmsh generates inside-out geometry.
mesh = perform_flips(mesh, np.ones(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(
actx, mesh, InterpolatoryQuadratureSimplexGroupFactory(target_order))
qbx = QBXLayerPotentialSource(density_discr,
4 * target_order,
qbx_order,
fmm_order=qbx_order + 3,
target_association_tolerance=0.15)
from pytential.target import PointsTarget
fplot = FieldPlotter(bbox_center, extent=3.5 * bbox_size, npoints=150)
from pytential import GeometryCollection
places = GeometryCollection(
{
"qbx": qbx,
"targets": PointsTarget(fplot.points)
}, auto_where="qbx")
density_discr = places.get_discretization("qbx")
nodes = thaw(actx, density_discr.nodes())
angle = actx.np.arctan2(nodes[1], nodes[0])
if k:
kernel = HelmholtzKernel(3)
else:
kernel = LaplaceKernel(3)
#op = sym.d_dx(sym.S(kernel, sym.var("sigma"), qbx_forced_limit=None))
op = sym.D(kernel, sym.var("sigma"), qbx_forced_limit=None)
#op = sym.S(kernel, sym.var("sigma"), qbx_forced_limit=None)
sigma = actx.np.cos(mode_nr * angle)
if 0:
from meshmode.dof_array import flatten, unflatten
sigma = flatten(0 * angle)
from random import randrange
for i in range(5):
sigma[randrange(len(sigma))] = 1
sigma = unflatten(actx, density_discr, sigma)
if isinstance(kernel, HelmholtzKernel):
for i, elem in np.ndenumerate(sigma):
sigma[i] = elem.astype(np.complex128)
fld_in_vol = actx.to_numpy(
bind(places, op, auto_where=("qbx", "targets"))(actx, sigma=sigma,
k=k))
#fplot.show_scalar_in_mayavi(fld_in_vol.real, max_val=5)
fplot.write_vtk_file("layerpot-3d-potential.vts",
[("potential", fld_in_vol)])
bdry_normals = bind(places, sym.normal(
density_discr.ambient_dim))(actx).as_vector(dtype=object)
from meshmode.discretization.visualization import make_visualizer
bdry_vis = make_visualizer(actx, density_discr, target_order)
bdry_vis.write_vtk_file("layerpot-3d-density.vtu", [
("sigma", sigma),
("bdry_normals", bdry_normals),
])
def get_mesh(self, resolution, target_order):
from pytools import download_from_web_if_not_present
download_from_web_if_not_present(
"https://raw.githubusercontent.com/inducer/geometries/a869fc3/"
"surface-3d/betterplane.brep")
from meshmode.mesh.io import generate_gmsh, ScriptWithFilesSource
mesh = generate_gmsh(
ScriptWithFilesSource(
"""
Merge "betterplane.brep";
Mesh.CharacteristicLengthMax = %(lcmax)f;
Mesh.ElementOrder = 2;
Mesh.CharacteristicLengthExtendFromBoundary = 0;
// 2D mesh optimization
// Mesh.Lloyd = 1;
l_superfine() = Unique(Abs(Boundary{ Surface{
27, 25, 17, 13, 18 }; }));
l_fine() = Unique(Abs(Boundary{ Surface{ 2, 6, 7}; }));
l_coarse() = Unique(Abs(Boundary{ Surface{ 14, 16 }; }));
// p() = Unique(Abs(Boundary{ Line{l_fine()}; }));
// Characteristic Length{p()} = 0.05;
Field[1] = Attractor;
Field[1].NNodesByEdge = 100;
Field[1].EdgesList = {l_superfine()};
Field[2] = Threshold;
Field[2].IField = 1;
Field[2].LcMin = 0.075;
Field[2].LcMax = %(lcmax)f;
Field[2].DistMin = 0.1;
Field[2].DistMax = 0.4;
Field[3] = Attractor;
Field[3].NNodesByEdge = 100;
Field[3].EdgesList = {l_fine()};
Field[4] = Threshold;
Field[4].IField = 3;
Field[4].LcMin = 0.1;
Field[4].LcMax = %(lcmax)f;
Field[4].DistMin = 0.15;
Field[4].DistMax = 0.4;
Field[5] = Attractor;
Field[5].NNodesByEdge = 100;
Field[5].EdgesList = {l_coarse()};
Field[6] = Threshold;
Field[6].IField = 5;
Field[6].LcMin = 0.15;
Field[6].LcMax = %(lcmax)f;
Field[6].DistMin = 0.2;
Field[6].DistMax = 0.4;
Field[7] = Min;
Field[7].FieldsList = {2, 4, 6};
Background Field = 7;
""" % {
"lcmax": resolution,
}, ["betterplane.brep"]), 2)
# Flip elements--gmsh generates inside-out geometry.
from meshmode.mesh.processing import perform_flips
return perform_flips(mesh, np.ones(mesh.nelements))
