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 ]