def __init__(self, kcomplex, eps, nlambda,
geofile='sphere-simple.script.geo', meshname='sphere.msh'):
self.ks = [kcomplex]
self.kExt = kcomplex
self.eps = eps
self.nlambda = nlambda
self.kInt = kcomplex * np.sqrt(eps)
self.geofile = geofile
self.meshname = meshname
with open('in.geo', 'w') as fp:
fp.write("k = {};".format(np.abs(self.kExt)))
fp.write("eps = {};".format(np.abs(self.eps)))
fp.write("nlambda = {};".format(np.abs(self.nlambda)))
with open('out.geo', 'w') as fp:
fp.write('\nSave "{}";\n'.format(meshname))
call(['gmsh', geofile, '-'])
self.grid = grid = bem.import_grid(meshname)
self.space = space = bem.function_space(grid, "P", 1)
self.shape = self.space.global_dof_count
self.collect()
self.weak_form()
def __init__(self,
kcomplex,
n,
geofile='sphere-simple.script.geo',
meshname='tmp.msh'):
self.ks = [kcomplex]
self.kExt = kcomplex
self.n = n
self.kInt = kcomplex * np.sqrt(n)
self.geofile = geofile
self.meshname = meshname
with open('in.geo', 'w') as fp:
fp.write("k = {};".format(np.abs(self.kInt)))
with open('out.geo', 'w') as fp:
fp.write('\nSave "{}";\n'.format(meshname))
call(['gmsh', geofile, '-'])
self.grid = grid = bem.import_grid(meshname)
self.space = space = bem.function_space(grid, "P", 1)
self.shape = self.space.global_dof_count
self.collect()
self.weak_form()
def __init__(self, kRef, meshname, doms, J_is='BlockedDiscrete'):
if isinstance(doms, list):
domains = Domains(doms)
elif isinstance(doms, Domains):
domains = doms
else:
raise TypeError(
'configuration needs to be a list or a Domains class')
self._collected = False
self._assembled = False
self._A_assembled = False
self._X_assembled = False
self._J_assembled = False
self._iJ_assembled = False
self._J_is = J_is
self.domains = domains
self.N = len(domains)
print('==Importing Grid/Mesh', end=' ', flush=True)
self.grid = grid = bem.import_grid(meshname)
print('done.', flush=True)
N = self.N
self.opA = bem.BlockedOperator(N, N)
self.opX = bem.BlockedOperator(N, N)
self.opI = bem.BlockedOperator(N, N)
if np.abs(kRef) <= 0.0:
kernel = 'lapl'
self.kRef = 0.0
dtype = np.float
else:
kernel = 'helm'
self.kRef = kRef #float(kRef)
dtype = np.complex
self.kernel = kernel
if dtype is None:
if kernel == 'helm':
dtype = np.complex
else:
dtype = np.float
self.dtype = dtype
if kernel == 'helm':
funEFIE = lambda trial, ran, test, k: bem.operators.boundary.maxwell.electric_field(
trial, ran, test, k)
funMFIE = lambda trial, ran, test, k: bem.operators.boundary.maxwell.magnetic_field(
trial, ran, test, k)
self._funEFIE = funEFIE
self._funMFIE = funMFIE
self._funI = bem.operators.boundary.sparse.maxwell_identity
def __init__(self, kRef, meshname, doms, J_is='BlockedDiscrete'):
if isinstance(doms, list):
domains = Domains(doms)
elif isinstance(doms, Domains):
domains = doms
else:
raise TypeError('configuration needs to be a list or a Domains class')
self._collected = False
self._assembled = False
self._A_assembled = False
self._X_assembled = False
self._J_assembled = False
self._iJ_assembled = False
self._J_is = J_is
self.domains = domains
self.N = len(domains)
print('==Importing Grid/Mesh', end=' ', flush=True)
self.grid = grid = bem.import_grid(meshname)
print('done.', flush=True)
N = self.N
self.opA = bem.BlockedOperator(N, N)
self.opX = bem.BlockedOperator(N, N)
self.opI = bem.BlockedOperator(N, N)
if np.abs(kRef) <= 0.0:
kernel = 'lapl'
self.kRef = 0.0
dtype = np.float
else:
kernel = 'helm'
self.kRef = kRef #float(kRef)
dtype = np.complex
self.kernel = kernel
if dtype is None:
if kernel == 'helm':
dtype = np.complex
else:
dtype = np.float
self.dtype = dtype
if kernel == 'helm':
funEFIE = lambda trial, ran, test, k: bem.operators.boundary.maxwell.electric_field(trial, ran, test, k)
funMFIE = lambda trial, ran, test, k: bem.operators.boundary.maxwell.magnetic_field(trial, ran, test, k)
self._funEFIE = funEFIE
self._funMFIE = funMFIE
self._funI = bem.operators.boundary.sparse.maxwell_identity
def __init__(self, kcomplex, n, geofile="sphere-simple.script.geo", meshname="tmp.msh"):
self.ks = [kcomplex]
self.kExt = kcomplex
self.n = n
self.kInt = kcomplex * np.sqrt(n)
self.geofile = geofile
self.meshname = meshname
with open("in.geo", "w") as fp:
fp.write("k = {};".format(np.abs(self.kInt)))
with open("out.geo", "w") as fp:
fp.write('\nSave "{}";\n'.format(meshname))
call(["gmsh", geofile, "-"])
self.grid = grid = bem.import_grid(meshname)
self.space = space = bem.function_space(grid, "P", 1)
self.shape = self.space.global_dof_count
self.collect()
self.weak_form()
def __init__(self,
kRef,
meshname,
doms,
J_is='BlockedDiscrete',
X_is='BlockedDiscrete',
use_slp=True):
if isinstance(doms, list):
domains = Domains(doms)
elif isinstance(doms, Domains):
domains = doms
else:
raise TypeError(
'configuration needs to be a list or a Domains class')
self._collected = False
self._assembled = False
self._A_assembled = False
self._X_assembled = False
self._J_assembled = False
self._iJ_assembled = False
if not J_is in ['BlockedDiscrete', 'CSC', 'Blocked']:
warnings.warn('{0} is not supported. Default used {1}'.format(
J_is, 'BlockedDiscrete'))
J_is = 'BlockedDiscrete'
self._J_is = J_is
if not X_is in ['BlockedDiscrete', 'Blocked']:
warnings.warn('{0} is not supported. Default used {1}'.format(
J_is, 'BlockedDiscrete'))
X_is = 'BlockedDiscrete'
self._X_is = X_is
self.use_slp = use_slp
print('==J_is: {0} , X_is: {1} , use_slp={2}'.format(
J_is, X_is, use_slp))
self.domains = domains
self.N = len(domains)
print('==Importing Grid/Mesh {}'.format(meshname), end=' ', flush=True)
self.grid = grid = bem.import_grid(meshname)
print('done.', flush=True)
N = self.N
self.opA = bem.BlockedOperator(N, N)
self.opX = bem.BlockedOperator(N, N)
self.opI = bem.BlockedOperator(N, N)
if np.abs(kRef) == 0.0:
kernel = 'lapl'
self.kRef = 0.0
dtype = np.float
else:
kernel = 'helm'
self.kRef = kRef #float(kRef)
dtype = np.complex
self.kernel = kernel
if not dtype is None:
if kernel == 'helm':
if dtype != np.complex:
warnings.warn('Helmholtz is complex. dtype={}'.format(
np.complex))
dtype = np.complex
else:
if dtype != np.float:
warnings.warn('Unsupported dtype. Converted to {}'.format(
np.float))
dtype = np.float
self.dtype = dtype
if kernel == 'helm':
funK = lambda trial, ran, test, k: bem.operators.boundary.helmholtz.double_layer(
trial, ran, test, k)
funV = lambda trial, ran, test, k: bem.operators.boundary.helmholtz.single_layer(
trial, ran, test, k)
funQ = lambda trial, ran, test, k: bem.operators.boundary.helmholtz.adjoint_double_layer(
trial, ran, test, k)
funW = lambda trial, ran, test, k: bem.operators.boundary.helmholtz.hypersingular(
trial, ran, test, k, use_slp=use_slp)
else:
funK = lambda trial, ran, test, k: bem.operators.boundary.laplace.double_layer(
trial, ran, test)
funV = lambda trial, ran, test, k: bem.operators.boundary.laplace.single_layer(
trial, ran, test)
funQ = lambda trial, ran, test, k: bem.operators.boundary.laplace.adjoint_double_layer(
trial, ran, test)
funW = lambda trial, ran, test, k: bem.operators.boundary.laplace.hypersingular(
trial, ran, test, use_slp=use_slp)
self._funK, self._funV = funK, funV
self._funW, self._funQ = funW, funQ
self._funI = bem.operators.boundary.sparse.identity
self.spaces = [(('test_d', 'trial_d'), ('test_n', 'trial_n'))
for d in domains]
# domains = Domains(dd)
if debug:
print('Debug: {}'.format(debug))
# ??
# bem.enable_console_logging()
# print('Dense')
# bem.global_parameters.assembly.boundary_operator_assembly_type = 'dense'
# bem.global_parameters.assembly.boundary_operator_assembly_type = 'hmat'
#pass
# bem.global_parameters.assembly.boundary_operator_assembly_type = 'dense'
print(bem.global_parameters.assembly.boundary_operator_assembly_type)
grid = bem.import_grid(meshname)
# opM = bem.BlockedOperator(len(domains), len(domains))
opA = bem.BlockedOperator(len(domains), len(domains))
opX = bem.BlockedOperator(len(domains), len(domains))
opI = bem.BlockedOperator(len(domains), len(domains))
opZ = bem.BlockedOperator(len(domains), len(domains))
opY = bem.BlockedOperator(len(domains), len(domains))
kind_d = ("P", 1)
kind_n = ("P", 1)
funK = bem.operators.boundary.helmholtz.double_layer
funV = bem.operators.boundary.helmholtz.single_layer
funQ = bem.operators.boundary.helmholtz.adjoint_double_layer
if debug:
print('Debug: {}'.format(debug))
# ??
# bem.enable_console_logging()
# print('Dense')
# bem.global_parameters.assembly.boundary_operator_assembly_type = 'dense'
# bem.global_parameters.assembly.boundary_operator_assembly_type = 'hmat'
#pass
# bem.global_parameters.assembly.boundary_operator_assembly_type = 'dense'
print(bem.global_parameters.assembly.boundary_operator_assembly_type)
grid = bem.import_grid(meshname)
# opM = bem.BlockedOperator(len(domains), len(domains))
opA = bem.BlockedOperator(len(domains), len(domains))
opX = bem.BlockedOperator(len(domains), len(domains))
opI = bem.BlockedOperator(len(domains), len(domains))
opY = bem.BlockedOperator(len(domains), len(domains))
opZ = bem.BlockedOperator(len(domains), len(domains))
# opR = bem.BlockedOperator(len(domains), len(domains))
opS = bem.BlockedOperator(len(domains), len(domains))
kind_d = ("P", 1)
kind_n = ("P", 1)
def __init__(self, kRef, meshname, doms,
J_is='BlockedDiscrete',
X_is='BlockedDiscrete',
use_slp=True):
if isinstance(doms, list):
domains = Domains(doms)
elif isinstance(doms, Domains):
domains = doms
else:
raise TypeError('configuration needs to be a list or a Domains class')
self._collected = False
self._assembled = False
self._A_assembled = False
self._X_assembled = False
self._J_assembled = False
self._iJ_assembled = False
if not J_is in ['BlockedDiscrete', 'CSC', 'Blocked']:
warnings.warn('{0} is not supported. Default used {1}'.format(J_is,
'BlockedDiscrete'))
J_is = 'BlockedDiscrete'
self._J_is = J_is
if not X_is in ['BlockedDiscrete', 'Blocked']:
warnings.warn('{0} is not supported. Default used {1}'.format(J_is,
'BlockedDiscrete'))
X_is = 'BlockedDiscrete'
self._X_is = X_is
self.use_slp = use_slp
print('==J_is: {0} , X_is: {1} , use_slp={2}'.format(J_is, X_is,
use_slp))
self.domains = domains
self.N = len(domains)
print('==Importing Grid/Mesh {}'.format(meshname), end=' ', flush=True)
self.grid = grid = bem.import_grid(meshname)
print('done.', flush=True)
N = self.N
self.opA = bem.BlockedOperator(N, N)
self.opX = bem.BlockedOperator(N, N)
self.opI = bem.BlockedOperator(N, N)
if np.abs(kRef) == 0.0:
kernel = 'lapl'
self.kRef = 0.0
dtype = np.float
else:
kernel = 'helm'
self.kRef = kRef #float(kRef)
dtype = np.complex
self.kernel = kernel
if not dtype is None:
if kernel == 'helm':
if dtype != np.complex:
warnings.warn('Helmholtz is complex. dtype={}'.format(np.complex))
dtype = np.complex
else:
if dtype != np.float:
warnings.warn('Unsupported dtype. Converted to {}'.format(np.float))
dtype = np.float
self.dtype = dtype
if kernel == 'helm':
funK = lambda trial, ran, test, k: bem.operators.boundary.helmholtz.double_layer(trial, ran, test, k)
funV = lambda trial, ran, test, k: bem.operators.boundary.helmholtz.single_layer(trial, ran, test, k)
funQ = lambda trial, ran, test, k: bem.operators.boundary.helmholtz.adjoint_double_layer(trial, ran, test, k)
funW = lambda trial, ran, test, k: bem.operators.boundary.helmholtz.hypersingular(trial, ran, test, k, use_slp=use_slp)
else:
funK = lambda trial, ran, test, k: bem.operators.boundary.laplace.double_layer(trial, ran, test)
funV = lambda trial, ran, test, k: bem.operators.boundary.laplace.single_layer(trial, ran, test)
funQ = lambda trial, ran, test, k: bem.operators.boundary.laplace.adjoint_double_layer(trial, ran, test)
funW = lambda trial, ran, test, k: bem.operators.boundary.laplace.hypersingular(trial, ran, test, use_slp=use_slp)
self._funK, self._funV = funK, funV
self._funW, self._funQ = funW, funQ
self._funI = bem.operators.boundary.sparse.identity
self.spaces = [ (
('test_d', 'trial_d'),
('test_n', 'trial_n')
) for d in domains ]
