def single_layer( domain, range_, dual_to_range, omega, parameters=None, assembler="default_nonlocal", device_interface=None, precision=None, ): """Assemble the mod. Helmholtz single-layer boundary operator.""" return _common.create_operator( "modified_helmholtz_real_single_layer_boundary", domain, range_, dual_to_range, parameters, assembler, { "KERNEL_FUNCTION": "modified_helmholtz_real_single_layer", "OMEGA": 1.0 * omega, }, "default_scalar", device_interface, precision, )
def hypersingular( domain, range_, dual_to_range, omega, parameters=None, assembler="default_nonlocal", device_interface=None, precision=None, ): """Assemble the mod. Helmholtz hypersingular boundary op.""" return _common.create_operator( "helmholtz_hypersingular_boundary", domain, range_, dual_to_range, parameters, assembler, { "KERNEL_FUNCTION": "modified_helmholtz_real_single_layer", "OMEGA": 1.0 * omega, }, "helmholtz_hypersingular", device_interface, precision, ) # Ensure that variable is float type
def adjoint_double_layer( domain, range_, dual_to_range, omega, parameters=None, assembler="default_nonlocal", device_interface=None, precision=None, ): """Assemble the mod. Helmholtz adj. double-layer boundary op.""" if _np.imag(omega) != 0: raise ValueError("'omega' must be real.") return _common.create_operator( "modified_helmholtz_adjoint_double_layer_boundary", domain, range_, dual_to_range, parameters, assembler, [omega], "modified_helmholtz_adjoint_double_layer", "default_scalar", device_interface, precision, False, )
def _rwg0_snc0_identity( domain, range_, dual_to_range, parameters=None, device_interface=None, precision=None, ): """Assemble the SNC/RWG identiy operator.""" if not (domain.identifier == "snc0" and dual_to_range.identifier == "rwg0"): raise ValueError( "Operator only defined for domain = 'snc' and 'dual_to_range = 'rwg" ) return _common.create_operator( "rwg0_snc0_identity", domain, range_, dual_to_range, parameters, "sparse", {}, "default_sparse", device_interface, precision, )
def hypersingular( domain, range_, dual_to_range, omega, parameters=None, assembler="default_nonlocal", device_interface=None, precision=None, ): """Assemble the mod. Helmholtz hypersingular boundary op.""" if domain.shapeset.identifier != "p1_discontinuous": raise ValueError("Domain shapeset must be of type 'p1_discontinuous'.") if dual_to_range.shapeset.identifier != "p1_discontinuous": raise ValueError( "Dual to range shapeset must be of type 'p1_discontinuous'.") if _np.imag(omega) != 0: raise ValueError("'omega' must be real.") return _common.create_operator( "modified_helmholtz_hypersingular_boundary", domain, range_, dual_to_range, parameters, assembler, [omega], "modified_helmholtz_single_layer", "modified_helmholtz_hypersingular", device_interface, precision, False, )
def hypersingular( domain, range_, dual_to_range, parameters=None, assembler="default_nonlocal", device_interface=None, precision=None, ): """Assemble the Laplace hypersingular boundary operator.""" if domain.shapeset.identifier != "p1_discontinuous": raise ValueError("Domain shapeset must be of type 'p1_discontinuous'.") if dual_to_range.shapeset.identifier != "p1_discontinuous": raise ValueError("Dual to range shapeset must be of type 'p1_discontinuous'.") return _common.create_operator( "laplace_hypersingular_boundary", domain, range_, dual_to_range, parameters, assembler, [], "laplace_single_layer", "laplace_hypersingular", device_interface, precision, False, )
def electric_field( domain, range_, dual_to_range, wavenumber, parameters=None, assembler="default_nonlocal", device_interface=None, precision=None, ): """Assemble the electric field boundary operator.""" from bempp.api.operators import _add_wavenumber if not (domain.identifier == "rwg0" and dual_to_range.identifier == "snc0"): raise ValueError( "Operator only defined for domain = 'rwg' and 'dual_to_range = 'snc" ) options = {"KERNEL_FUNCTION": "helmholtz_single_layer", "COMPLEX_KERNEL": None} _add_wavenumber(options, wavenumber) return _common.create_operator( "maxwell_electric_field_boundary", domain, range_, dual_to_range, parameters, assembler, options, "maxwell_electric_field", device_interface, precision, )
def electric_field( domain, range_, dual_to_range, wavenumber, parameters=None, assembler="default_nonlocal", device_interface=None, precision=None, ): """Assemble the electric field boundary operator.""" if domain.identifier != "rwg0": raise ValueError("Domain space must be an RWG type function space.") if dual_to_range.identifier != "snc0": raise ValueError( "Dual to range space must be an SNC type function space.") return _common.create_operator( "maxwell_electric_field_boundary", domain, range_, dual_to_range, parameters, assembler, [_np.real(wavenumber), _np.imag(wavenumber)], "helmholtz_single_layer", "maxwell_electric_field", device_interface, precision, True, )
def identity( domain, range_, dual_to_range, parameters=None, device_interface=None, precision=None, ): # BC spaces use same code as RWG spaces. # RBC spaces use same code as SNC spaces. maxwell_modifier = { "bc": "rwg0", "rwg0": "rwg0", "rbc": "snc0", "snc0": "snc0" } identity_dispatch = { ("snc0", "rwg0"): _snc0_rwg0_identity, ("rwg0", "snc0"): _rwg0_snc0_identity, ("rwg0", "rwg0"): _rwg0_rwg0_identity, ("snc0", "snc0"): _snc0_snc0_identity, } domain_identifier = domain.identifier dual_to_range_identifier = dual_to_range.identifier if domain_identifier in maxwell_modifier.keys(): domain_identifier = maxwell_modifier[domain_identifier] if dual_to_range_identifier in maxwell_modifier.keys(): dual_to_range_identifier = maxwell_modifier[dual_to_range_identifier] if (dual_to_range_identifier, domain_identifier) in identity_dispatch.keys(): return identity_dispatch[(dual_to_range_identifier, domain_identifier)](domain, range_, dual_to_range, parameters, device_interface, precision) if not (domain.codomain_dimension == 1 and dual_to_range.codomain_dimension == 1): raise ValueError("domain and codomain must be scalar spaces.") """Assemble the L^2 identiy operator.""" return _common.create_operator( "scalar_identity", domain, range_, dual_to_range, parameters, "sparse", {}, "default_sparse", device_interface, precision, )
def adjoint_double_layer( domain, range_, dual_to_range, wavenumber, parameters=None, assembler="default_nonlocal", device_interface=None, precision=None, ): """Assemble the Helmholtz adj. double-layer boundary operator.""" from bempp.api.operators import _add_wavenumber from .modified_helmholtz import ( adjoint_double_layer as _modified_adjoint_double_layer, ) if _np.real(wavenumber) == 0: return _modified_adjoint_double_layer( domain, range_, dual_to_range, _np.imag(wavenumber), parameters, assembler, device_interface, precision, ) options = { "KERNEL_FUNCTION": "helmholtz_adjoint_double_layer", "COMPLEX_KERNEL": None, } _add_wavenumber(options, wavenumber) return _common.create_operator( "helmholtz_adjoint_double_layer_boundary", domain, range_, dual_to_range, parameters, assembler, options, "default_scalar", device_interface, precision, )
def hypersingular( domain, range_, dual_to_range, wavenumber, parameters=None, assembler="default_nonlocal", device_interface=None, precision=None, ): """Assemble the Helmholtz hypersingular boundary operator.""" from .modified_helmholtz import hypersingular as _hypersingular if domain.shapeset.identifier != "p1_discontinuous": raise ValueError("Domain shapeset must be of type 'p1_discontinuous'.") if dual_to_range.shapeset.identifier != "p1_discontinuous": raise ValueError( "Dual to range shapeset must be of type 'p1_discontinuous'.") if _np.real(wavenumber) == 0: return _hypersingular( domain, range_, dual_to_range, _np.imag(wavenumber), parameters, assembler, device_interface, precision, ) return _common.create_operator( "helmholtz_hypersingular_boundary", domain, range_, dual_to_range, parameters, assembler, [_np.real(wavenumber), _np.imag(wavenumber)], "helmholtz_single_layer", "helmholtz_hypersingular", device_interface, precision, True, )
def adjoint_double_layer( domain, range_, dual_to_range, wavenumber, parameters=None, assembler="default_nonlocal", device_interface=None, precision=None, ): """Assemble the Helmholtz adj. double-layer boundary operator.""" from .modified_helmholtz import ( adjoint_double_layer as _modified_adjoint_double_layer, ) if _np.real(wavenumber) == 0: return _modified_adjoint_double_layer( domain, range_, dual_to_range, _np.imag(wavenumber), parameters, assembler, device_interface, precision, ) return _common.create_operator( "helmholtz_adjoint_double_layer_boundary", domain, range_, dual_to_range, parameters, assembler, [_np.real(wavenumber), _np.imag(wavenumber)], "helmholtz_adjoint_double_layer", "default_scalar", device_interface, precision, True, )
def hypersingular( domain, range_, dual_to_range, parameters=None, assembler="default_nonlocal", device_interface=None, precision=None, ): """Assemble the Laplace hypersingular boundary operator.""" return _common.create_operator( "laplace_hypersingular_boundary", domain, range_, dual_to_range, parameters, assembler, {"KERNEL_FUNCTION": "laplace_single_layer"}, "laplace_hypersingular", device_interface, precision, )
def identity( domain, range_, dual_to_range, parameters=None, device_interface=None, precision=None, ): """Assemble the L^2 identity operator.""" return _common.create_operator( "l2_identity", domain, range_, dual_to_range, parameters, "sparse", [], "l2_identity", "default_sparse", device_interface, precision, False, )
def adjoint_double_layer( domain, range_, dual_to_range, parameters=None, assembler="default_nonlocal", device_interface=None, precision=None, ): """Assemble the Laplace adjoint double-layer boundary operator.""" return _common.create_operator( "laplace_adjoint_double_layer_boundary", domain, range_, dual_to_range, parameters, assembler, [], "laplace_adjoint_double_layer", "default_scalar", device_interface, precision, False, )