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,
)
