def single_layer( space, points, wavenumber, parameters=None, device_interface=None, precision=None ): """Return a Helmholtz single-layer potential operator.""" from bempp.core.dense_potential_assembler import DensePotentialAssembler from bempp.api.operators import OperatorDescriptor from bempp.api.operators import _add_wavenumber from bempp.api.assembly.potential_operator import PotentialOperator options = {"KERNEL_FUNCTION": "helmholtz_single_layer"} _add_wavenumber(options, wavenumber) return PotentialOperator( DensePotentialAssembler( space, OperatorDescriptor( "helmholtz_single_layer_potential", options, "default_dense" ), points, 1, True, device_interface, precision, parameters=parameters, ) )
def electric_field(space, evaluation_points, wave_number, parameters=None): """Return the Maxwell electric field potential operator Parameters ---------- space : bempp.api.space.Space The function space over which to assemble the potential. evaluation_points : numpy.ndarray A (3 x N) array of N evaluation points, where each column corresponds to the coordinates of one evaluation point. wave_number : complex Wavenumber of the operator. parameters : bempp.api.common.ParameterList Parameters for the operator. If none given the default global parameter object `bempp.api.global_parameters` is used. """ import bempp from bempp.api.assembly.potential_operator import PotentialOperator from bempp.api.assembly.discrete_boundary_operator import \ GeneralNonlocalDiscreteBoundaryOperator from bempp.core.operators.potential.maxwell import electric_field_ext if space.has_non_barycentric_space: space = space.non_barycentric_space if parameters is None: parameters = bempp.api.global_parameters return PotentialOperator( GeneralNonlocalDiscreteBoundaryOperator( electric_field_ext(space._impl, evaluation_points, wave_number, parameters)), 3, space, evaluation_points)
def electric_field( space, points, wavenumber, parameters=None, assembler="dense", device_interface=None, precision=None, ): """Return a Maxwell electric far-field potential operator.""" import bempp.api from bempp.api.operators import OperatorDescriptor from bempp.api.assembly.potential_operator import PotentialOperator from bempp.api.assembly.assembler import PotentialAssembler if precision is None: precision = bempp.api.DEFAULT_PRECISION operator_descriptor = OperatorDescriptor( "maxwell_far_field_electric_field_potential", # Identifier [_np.real(wavenumber), _np.imag(wavenumber)], # Options "helmholtz_far_field_single_layer", # Kernel type "maxwell_electric_far_field", # Assembly type precision, # Precision True, # Is complex None, # Singular part 3, # Kernel dimension ) return PotentialOperator( PotentialAssembler(space, points, operator_descriptor, device_interface, assembler, parameters))
def single_layer_gradient(space, evaluation_points, parameters=None): """Return the Laplace single-layer gradient potential operator Parameters ---------- space : bempp.api.space.Space The function space over which to assemble the potential. evaluation_points : numpy.ndarray A (3 x N) array of N evaluation points, where each column corresponds to the coordinates of one evaluation point. parameters : bempp.api.common.ParameterList Parameters for the operator. If none given the default global parameter object `bempp.api.global_parameters` is used. """ import bempp from bempp.api.assembly.potential_operator import PotentialOperator from bempp.api.assembly.discrete_boundary_operator import \ GeneralNonlocalDiscreteBoundaryOperator #pylint: disable=no-name-in-module from bempp.core.operators.potential.laplace import single_layer_gradient_ext if space.has_non_barycentric_space: space = space.non_barycentric_space if parameters is None: parameters = bempp.api.global_parameters return PotentialOperator( GeneralNonlocalDiscreteBoundaryOperator( single_layer_gradient_ext(space._impl, evaluation_points, parameters)), 3, space, evaluation_points)
def double_layer( space, points, parameters=None, assembler="dense", device_interface=None, precision=None, ): """Return a Laplace single-layer potential operator.""" import bempp.api from bempp.api.operators import OperatorDescriptor from bempp.api.assembly.potential_operator import PotentialOperator from bempp.api.assembly.assembler import PotentialAssembler if precision is None: precision = bempp.api.DEFAULT_PRECISION operator_descriptor = OperatorDescriptor( "laplace_double_layer_potential", # Identifier [], # Options "laplace_double_layer", # Kernel type "default_scalar", # Assembly type precision, # Precision False, # Is complex None, # Singular part 1, # Kernel dimension ) return PotentialOperator( PotentialAssembler(space, points, operator_descriptor, device_interface, assembler, parameters))
def magnetic_field(space, points, wavenumber, parameters=None, device_interface=None, precision=None): """Return a Maxwell magnetic far-field potential operator.""" from bempp.core.dense_potential_assembler import DensePotentialAssembler from bempp.api.operators import OperatorDescriptor from bempp.api.operators import _add_wavenumber from bempp.api.assembly.potential_operator import PotentialOperator options = {} _add_wavenumber(options, wavenumber) return PotentialOperator( DensePotentialAssembler( space, OperatorDescriptor("maxwell_magnetic_far_field", options, "maxwell_magnetic_far_field"), points, 3, True, device_interface, precision, parameters=parameters, ))
def single_layer(space, evaluation_points, wave_number, parameters=None): """Return the Helmholtz single-layer far field operator. Parameters ---------- space : bempp.api.space.Space The function space over which to assemble the potential. evaluation_points : numpy.ndarray A (3 x N) array of N evaluation points, where each column corresponds to the coordinates of one evaluation point. For the far field the points should lie on the unit sphere. parameters : bempp.api.common.ParameterList Parameters for the operator. If none given the default global parameter object `bempp.api.global_parameters` is used. """ import bempp from bempp.api.assembly.potential_operator import PotentialOperator from bempp.api.assembly.discrete_boundary_operator import \ GeneralNonlocalDiscreteBoundaryOperator from bempp.core.operators.far_field.helmholtz import single_layer_ext if space.has_non_barycentric_space: space = space.non_barycentric_space if parameters is None: parameters = bempp.api.global_parameters return PotentialOperator( GeneralNonlocalDiscreteBoundaryOperator( single_layer_ext(space._impl, evaluation_points, wave_number, parameters)), 1, space, evaluation_points)
def double_layer( space, points, wavenumber, parameters=None, assembler="dense", device_interface=None, precision=None, ): """Return a Helmholtz double-layer potential operator.""" import bempp.api from bempp.api.operators import OperatorDescriptor from bempp.api.assembly.potential_operator import PotentialOperator from bempp.api.assembly.assembler import PotentialAssembler from .modified_helmholtz import double_layer as modified_double_layer if _np.real(wavenumber) == 0: return modified_double_layer( space, points, wavenumber, parameters, assembler, device_interface, precision, ) if precision is None: precision = bempp.api.DEFAULT_PRECISION operator_descriptor = OperatorDescriptor( "helmholtz_double_layer_potential", # Identifier [_np.real(wavenumber), _np.imag(wavenumber)], # Options "helmholtz_double_layer", # Kernel type "default_scalar", # Assembly type precision, # Precision True, # Is complex None, # Singular part 1, # Kernel dimension ) return PotentialOperator( PotentialAssembler(space, points, operator_descriptor, device_interface, assembler, parameters))
def double_layer( space, points, omega, parameters=None, assembler="dense", device_interface=None, precision=None, ): """Return a modified Helmholtz double-layer potential operator.""" import bempp.api from bempp.api.operators import OperatorDescriptor from bempp.api.assembly.potential_operator import PotentialOperator from bempp.api.assembly.assembler import PotentialAssembler if _np.imag(omega) != 0: raise ValueError("'omega' must be real.") if precision is None: precision = bempp.api.DEFAULT_PRECISION operator_descriptor = OperatorDescriptor( "modified_helmholtz_double_layer_potential", # Identifier [omega], # Options "modified_helmholtz_double_layer", # Kernel type "default_scalar", # Assembly type precision, # Precision False, # Is complex None, # Singular part 1, # Kernel dimension ) return PotentialOperator( PotentialAssembler( space, points, operator_descriptor, device_interface, assembler, parameters ) )
def magnetic_field( space, points, wavenumber, parameters=None, assembler="dense", device_interface=None, precision=None, ): """Return a Maxwell magnetic field potential operator.""" from bempp.api.operators import OperatorDescriptor from bempp.api.assembly.potential_operator import PotentialOperator from bempp.api.assembly.assembler import PotentialAssembler import bempp.api if space.identifier != "rwg0": raise ValueError("Space must be an RWG type function space.") if precision is None: precision = bempp.api.DEFAULT_PRECISION operator_descriptor = OperatorDescriptor( "maxwell_magnetic_field_potential", # Identifier [_np.real(wavenumber), _np.imag(wavenumber)], # Options "helmholtz_single_layer", # Kernel type "maxwell_magnetic_field", # Assembly type precision, # Precision True, # Is complex None, # Singular part 3, # Kernel dimension ) return PotentialOperator( PotentialAssembler( space, points, operator_descriptor, device_interface, assembler, parameters ) )