def __init__(self,context,grid,
evaluation_options=None,
evaluation_quadrature_strategy=None,
gmres_tol=1E-10,
gmres_max_iter=1000,
use_aca_lu_preconditioner=True,
aca_lu_delta=1E-3,
operator_cache=False,
operator_cache_tol=1E-13):
super(MaxwellEfiePecIndirect,self).__init__()
if isinstance(grid,str):
self._grid = _bempplib.createGridFactory().importGmshGrid("triangular",grid)
else:
self._grid = grid
self._context = context
self._evaluation_options = evaluation_options
self._evaluation_quadrature_strategy = evaluation_quadrature_strategy
self._gmres_tol = gmres_tol
self._gmres_max_iter = gmres_max_iter
self._use_aca_lu_preconditioner = use_aca_lu_preconditioner
self._aca_lu_delta = aca_lu_delta
self._operator_cache = operator_cache
self._operator_cache_tol = operator_cache_tol
self._boundary_operator_cache = None
self._potential_operator_cache = None
self._evaluation_points = None
self._residuals = {}
self._space = None
def __init__(self,
mesh,
aca_epsilon=1E-5,
use_aca=True,
aca_lu_epsilon=1E-2,
gmres_tol = 1E-10,
gmres_max_iter = 1000,
relative_singular_quadrature_order=2,
relative_regular_quadrature_order=1,
operator_cache_tol=1E-13,
use_cache = False):
if isinstance(mesh,str):
self._mesh = _bempplib.createGridFactory().importGmshGrid("triangular",mesh)
else:
self._mesh = mesh
self._aca_epsilon = aca_epsilon
self._use_aca = use_aca
self._aca_lu_epsilon = aca_lu_epsilon
self._gmres_tol = gmres_tol
self._gmres_max_iter = gmres_max_iter
self._relative_singular_quadrature_order = relative_singular_quadrature_order
self._relative_regular_quadrature_order = relative_regular_quadrature_order
self._operator_cache_tol = operator_cache_tol
self._use_cache = use_cache
def __init__(self,context,grid,
eps_ext,eps_int,mu_ext,mu_int,
evaluation_options=None,
evaluation_quadrature_strategy=None,
gmres_tol=1E-8,
gmres_max_iter=1000,
use_aca_lu_preconditioner=True,
aca_lu_delta=1E-3,
operator_cache=False,
operator_cache_tol=1E-13):
super(MaxwellEfiePenetrable,self).__init__()
if isinstance(grid,str):
self._grid = _bempplib.createGridFactory().importGmshGrid("triangular",grid)
else:
self._grid = grid
self._mu_ext = mu_ext
self._mu_int = mu_int
self._eps_ext = eps_ext
self._eps_int = eps_int
self._context = context
self._evaluation_options = evaluation_options
self._evaluation_options.setVerbosityLevel('low')
self._evaluation_quadrature_strategy = evaluation_quadrature_strategy
self._gmres_tol = gmres_tol
self._gmres_max_iter = gmres_max_iter
self._use_aca_lu_preconditioner = use_aca_lu_preconditioner
self._aca_lu_delta = aca_lu_delta
self._operator_cache = operator_cache
self._operator_cache_tol = operator_cache_tol
self._boundary_operator_cache = None
self._potential_operator_cache = None
self._evaluation_points = None
self._residuals = {}
self._space = None
self._inside = None
self._outside = None
self._inc_dirichlet_traces = {}
self._inc_neumann_traces = {}
quadStrategy = lib.createNumericalQuadratureStrategy(
"float64", "complex128", accuracyOptions)
# Use ACA to accelerate the assembly
options = lib.createAssemblyOptions()
options.switchToAca(lib.createAcaOptions())
# The context object combines these settings
context = lib.createContext(quadStrategy, options)
# Load a grid approximating a unit sphere
grid_factory = lib.createGridFactory()
grid = grid_factory.importGmshGrid(
"triangular", "../../meshes/sphere-h-0.1.msh")
# Create a space of piecewise constant basis functions over the grid.
pwiseConstants = lib.createPiecewiseConstantScalarSpace(context, grid)
# We now initialize the boundary operators.
# A boundary operator always takes three space arguments: a domain space,
# a range space, and the test space (dual to the range).
# Here, we just use L^2 projections. Hence, all spaces are identical.
slpOp = lib.createHelmholtz3dSingleLayerBoundaryOperator(
context, pwiseConstants, pwiseConstants, pwiseConstants, k)
adlpOp = lib.createHelmholtz3dAdjointDoubleLayerBoundaryOperator(
sphere_def)
s3_geo_f.write("rad = " + str(r3) + ";\nlc = " + str(element_size) + ";\n" +
sphere_def)
s1_geo_f.close()
s2_geo_f.close()
s3_geo_f.close()
# Use Gmsh to create meshes
subprocess.check_call(gmsh_command + " -2 " + s1_geo_name, shell=True)
subprocess.check_call(gmsh_command + " -2 " + s2_geo_name, shell=True)
subprocess.check_call(gmsh_command + " -2 " + s3_geo_name, shell=True)
# Read the meshes into BEM++ Objects
sphere1 = blib.createGridFactory().importGmshGrid("triangular", s1_msh_name)
sphere2 = blib.createGridFactory().importGmshGrid("triangular", s2_msh_name)
sphere3 = blib.createGridFactory().importGmshGrid("triangular", s3_msh_name)
# Clean up the temporary files
os.remove(s1_geo_name)
os.remove(s2_geo_name)
os.remove(s3_geo_name)
os.remove(s1_msh_name)
os.remove(s2_msh_name)
os.remove(s3_msh_name)
# Create Context
accuracy_options = blib.createAccuracyOptions()
import numpy as np
import bempp.lib as lib
import scipy.special as sc
import numpy.polynomial.legendre as leg
import time
accuracyOptions = lib.createAccuracyOptions()
accuracyOptions.doubleRegular.setRelativeQuadratureOrder(2)
accuracyOptions.singleRegular.setRelativeQuadratureOrder(2)
quadStrategy = lib.createNumericalQuadratureStrategy("float64", "complex128", accuracyOptions)
options = lib.createAssemblyOptions()
options.switchToAca(lib.createAcaOptions())
context = lib.createContext(quadStrategy, options)
grid = lib.createGridFactory().importGmshGrid("triangular", "airplane.msh")
pconsts = lib.createPiecewiseConstantScalarSpace(context, grid)
k = 16
#k = 64; #16; #0.16
# ansatz: direction of incident plane wave: assume x here
lhsOp = lib.createHelmholtz3dSingleLayerBoundaryOperator(context, pconsts, pconsts, pconsts, k, "SLP")
# Create a grid function representing the Dirichlet trace of the incident wave
def uIncData(point):
x, y, z = point
return np.exp(1j * k * x)
def incident(point):
x, y, z = point
"float64", "complex128", accuracyOptions)
# Set assembly options -- switch to ACA
options = lib.createAssemblyOptions()
options.switchToAca(lib.createAcaOptions())
# Combine the quadrature strategy and assembly options into an assembly context
context = lib.createContext(quadStrategy, options)
# PART 3: Define the system of integral equations to be solved #################
# Import mesh
grid = lib.createGridFactory().importGmshGrid(
"triangular", "../../examples/meshes/sphere-h-0.1.msh")
# Create a function space
pconsts = lib.createPiecewiseConstantScalarSpace(context, grid)
# Define material and wave parameters
rhoInt = 2.
rhoExt = 1.
kInt = 1.
kExt = 5.
# Create boundary operators
slpOpInt = lib.createHelmholtz3dSingleLayerBoundaryOperator(
s1_geo_f.write("rad = "+str(r1)+";\nlc = "+str(element_size)+";\n"+sphere_def)
s2_geo_f.write("rad = "+str(r2)+";\nlc = "+str(element_size)+";\n"+sphere_def)
s3_geo_f.write("rad = "+str(r3)+";\nlc = "+str(element_size)+";\n"+sphere_def)
s1_geo_f.close()
s2_geo_f.close()
s3_geo_f.close()
# Use Gmsh to create meshes
subprocess.check_call(gmsh_command+" -2 "+s1_geo_name,shell=True)
subprocess.check_call(gmsh_command+" -2 "+s2_geo_name,shell=True)
subprocess.check_call(gmsh_command+" -2 "+s3_geo_name,shell=True)
# Read the meshes into BEM++ Objects
sphere1 = blib.createGridFactory().importGmshGrid("triangular",s1_msh_name)
sphere2 = blib.createGridFactory().importGmshGrid("triangular",s2_msh_name)
sphere3 = blib.createGridFactory().importGmshGrid("triangular",s3_msh_name)
# Clean up the temporary files
os.remove(s1_geo_name)
os.remove(s2_geo_name)
os.remove(s3_geo_name)
os.remove(s1_msh_name)
os.remove(s2_msh_name)
os.remove(s3_msh_name)
# Create Context
accuracy_options = blib.createAccuracyOptions()
def __generate_grid_from_string(geo_string,grid=True,msh_file=False,parallel=True):
"""Helper routine that implements the grid generation
"""
import os
import subprocess
def msh_from_string(geo_string):
gmsh_command = findGmsh(gmsh_exe)
f,geo_name,msh_name = getGmshFile()
f.write(geo_string)
f.close()
fnull = open(os.devnull,'w')
cmd = gmsh_command+" -2 "+geo_name
try:
print "Generating Gmsh grid..."
subprocess.check_call(cmd,shell=True,stdout=fnull,stderr=fnull)
except:
print "The following command failed: "+cmd
fnull.close()
raise
os.remove(geo_name)
fnull.close()
return msh_name
if parallel:
from PyTrilinos.Epetra import PyComm
comm = PyComm()
my_rank = comm.MyPID()
else:
my_rank = 0
if parallel:
if my_rank == 0:
rank0_msh_name = msh_from_string(geo_string)
nchar = np.array(len(rank0_msh_name),dtype='int')
comm.Broadcast(nchar,0)
msh_name_array=np.array(rank0_msh_name)
comm.Broadcast(msh_name_array,0)
else:
nchar=np.array([0],dtype='int')
comm.Broadcast(nchar,0)
msh_name_array=''
msh_name_array=np.array(msh_name_array.zfill(nchar))
comm.Broadcast(msh_name_array,0)
msh_name = msh_name_array.item()
else:
msh_name = msh_from_string(geo_string)
grid_obj = None
if grid:
from bempp.lib import createGridFactory
grid_obj = createGridFactory().importGmshGrid("triangular",msh_name)
comm.Barrier()
if not msh_file:
if parallel:
if my_rank==0:
os.remove(msh_name)
msh_name = None
else:
os.remove(msh_name)
msh_name = None
if grid and not msh_name:
return grid_obj
elif msh_file and not grid:
return msh_name
elif msh_file and grid:
return (grid_obj,msh_file)
else:
return None
import bempp.lib as lib
import scipy.special as sc
import numpy.polynomial.legendre as leg
import time
accuracyOptions = lib.createAccuracyOptions()
accuracyOptions.doubleRegular.setRelativeQuadratureOrder(2)
accuracyOptions.singleRegular.setRelativeQuadratureOrder(2)
quadStrategy = lib.createNumericalQuadratureStrategy("float64", "complex128",
accuracyOptions)
options = lib.createAssemblyOptions()
options.switchToAca(lib.createAcaOptions())
context = lib.createContext(quadStrategy, options)
grid = lib.createGridFactory().importGmshGrid("triangular", "airplane.msh")
pconsts = lib.createPiecewiseConstantScalarSpace(context, grid)
k = 16
#k = 64; #16; #0.16
# ansatz: direction of incident plane wave: assume x here
lhsOp = lib.createHelmholtz3dSingleLayerBoundaryOperator(
context, pconsts, pconsts, pconsts, k, "SLP")
# Create a grid function representing the Dirichlet trace of the incident wave
def uIncData(point):
x, y, z = point
return np.exp(1j * k * x)
quadStrategy = lib.createNumericalQuadratureStrategy(
"float64", "complex128", accuracyOptions)
# Use ACA to accelerate the assembly
options = lib.createAssemblyOptions()
options.switchToAca(lib.createAcaOptions())
# The context object combines these settings
context = lib.createContext(quadStrategy, options)
# Load a grid approximating a unit sphere
grid_factory = lib.createGridFactory()
grid = grid_factory.importGmshGrid(
"triangular", "../../examples/meshes/sphere-h-0.1.msh")
# Create a space of piecewise constant basis functions over the grid.
pwiseConstants = lib.createPiecewiseConstantScalarSpace(context, grid)
# We now initialize the boundary operators.
# A boundary operator always takes three space arguments: a domain space,
# a range space, and the test space (dual to the range).
# Here, we just use L^2 projections. Hence, all spaces are identical.
slpOp = lib.createHelmholtz3dSingleLayerBoundaryOperator(
context, pwiseConstants, pwiseConstants, pwiseConstants, k)
adlpOp = lib.createHelmholtz3dAdjointDoubleLayerBoundaryOperator(
def __generate_grid_from_string(geo_string,
grid=True,
msh_file=False,
parallel=True):
"""Helper routine that implements the grid generation
"""
import os
import subprocess
def msh_from_string(geo_string):
gmsh_command = findGmsh(gmsh_exe)
f, geo_name, msh_name = getGmshFile()
f.write(geo_string)
f.close()
fnull = open(os.devnull, 'w')
cmd = gmsh_command + " -2 " + geo_name
try:
print "Generating Gmsh grid..."
subprocess.check_call(cmd, shell=True, stdout=fnull, stderr=fnull)
except:
print "The following command failed: " + cmd
fnull.close()
raise
os.remove(geo_name)
fnull.close()
return msh_name
if parallel:
from PyTrilinos.Epetra import PyComm
comm = PyComm()
my_rank = comm.MyPID()
else:
my_rank = 0
if parallel:
if my_rank == 0:
rank0_msh_name = msh_from_string(geo_string)
nchar = np.array(len(rank0_msh_name), dtype='int')
comm.Broadcast(nchar, 0)
msh_name_array = np.array(rank0_msh_name)
comm.Broadcast(msh_name_array, 0)
else:
nchar = np.array([0], dtype='int')
comm.Broadcast(nchar, 0)
msh_name_array = ''
msh_name_array = np.array(msh_name_array.zfill(nchar))
comm.Broadcast(msh_name_array, 0)
msh_name = msh_name_array.item()
else:
msh_name = msh_from_string(geo_string)
grid_obj = None
if grid:
from bempp.lib import createGridFactory
grid_obj = createGridFactory().importGmshGrid("triangular", msh_name)
comm.Barrier()
if not msh_file:
if parallel:
if my_rank == 0:
os.remove(msh_name)
msh_name = None
else:
os.remove(msh_name)
msh_name = None
if grid and not msh_name:
return grid_obj
elif msh_file and not grid:
return msh_name
elif msh_file and grid:
return (grid_obj, msh_file)
else:
return None
"float64", "complex128", accuracyOptions)
# Set assembly options -- switch to ACA
options = lib.createAssemblyOptions()
options.switchToAca(lib.createAcaOptions())
# Combine the quadrature strategy and assembly options into an assembly context
context = lib.createContext(quadStrategy, options)
# PART 3: Define the system of integral equations to be solved #################
# Import mesh
grid = lib.createGridFactory().importGmshGrid(
"triangular", "../../examples/meshes/sphere-h-0.1.msh")
# Create a function space
pconsts = lib.createPiecewiseConstantScalarSpace(context, grid)
# Define material and wave parameters
rhoInt = 2.
rhoExt = 1.
kInt = 1.
kExt = 5.
# Create boundary operators
slpOpInt = lib.createHelmholtz3dSingleLayerBoundaryOperator(
