def single_layer_and_hypersingular_pair(grid, parameters=None, spaces='linear', base_slp=None, return_base_slp=False, stabilization_factor=0): """Return a pair of hypersingular and single layer operator. This function creates a pair of a single-layer and a hypersingular operator, where both operators are instantiated using a common base single-layer operator. Hence, only one single-layer operator needs to be discretized to obtain both operators on the given grid. Parameters ---------- grid : bempp.api.grid.Grid The underlying grid for the multitrace operator parameters : bempp.api.common.ParameterList Parameters for the operator. If none given the default global parameter object `bempp.api.global_parameters` is used. spaces: string Choose 'linear' to assemble the operator with continuous linear function spaces for the Dirichlet and Neumann component (default). For a dual pairing of a linear space for the Dirichlet data and piecewise constant space for the Neumann data choose 'dual'. base_slp : None Specify a base single-layer operator to be used. If set to None, a base single-layer operator will be instantiated by the function. return_base_slp : bool If True also return the original large space single layer operator from which the hypersingular and slp operator are derived. Default is False stabilization_factor : double If not equal to zero add this factor times the rank one operator <w 1><v, 1> to the hypersingular, where w is in the domain space and v in the dual space of the hypersingular operator. This regularizes the hypersingular operator. Returns ------- A pair (slp, hyp) of a single-layer and hypersingular operator. If return_base_slp is true a triplet (slp, hyp, base_slp) is returned, where base_slp is the single-layer operator, from which slp and hyp are obtained via sparse transformations. """ from bempp.api.operators.boundary import _common ops = list(_common.slp_and_hyp_impl( grid, single_layer, hypersingular, parameters, spaces, base_slp, return_base_slp, laplace=True)) if stabilization_factor != 0: from bempp.api.assembly import RankOneBoundaryOperator ops[1] += stabilization_factor * RankOneBoundaryOperator( ops[1].domain, ops[1].range, ops[1].dual_to_range) return ops
def single_layer_and_hypersingular_pair(grid, wave_number, parameters=None, spaces='linear', base_slp=None, return_base_slp=False): """Return a pair of hypersingular and single layer operator. This function creates a pair of a single-layer and a hypersingular operator, where both operators are instantiated using a common base single-layer operator. Hence, only one single-layer operator needs to be discretized to obtain both operators on the given grid. Parameters ---------- grid : bempp.api.grid.Grid The underlying grid for the multitrace operator 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. spaces: string Choose 'linear' to assemble the operator with continuous linear function spaces for the Dirichlet and Neumann component (default). For a dual pairing of a linear space for the Dirichlet data and piecewise constant space for the Neumann data choose 'dual'. base_slp : None Specify a base single-layer operator to be used. If set to None, a base single-layer operator will be instantiated by the function. return_base_slp : bool If True also return the original large space single layer operator from which the hypersingular and slp operator are derived. Default is False Returns ------- A pair (slp, hyp) of a single-layer and hypersingular operator. If return_base_slp is true a triplet (slp, hyp, base_slp) is returned, where base_slp is the single-layer operator, from which slp and hyp are obtained via sparse transformations. """ from bempp.api.operators.boundary import _common def op(operator): """Partial lambda that removes wavenumber.""" if operator == hypersingular: def op_impl(domain, range_, dual_to_range, label="HYP", symmetry="no_symmetry", parameters=None, use_slp=False): """Implementation without wavenumber.""" return hypersingular(domain, range_, dual_to_range, wave_number, label, symmetry, parameters, use_slp) return op_impl else: import inspect #pylint: disable=deprecated-method defaults = inspect.getargspec(operator).defaults def op_impl(domain, range_, dual_to_range, label=defaults[0], symmetry=defaults[1], parameters=None): """Implementation without wavenumber.""" return operator(domain, range_, dual_to_range, wave_number, label, symmetry, parameters) return op_impl ops = _common.slp_and_hyp_impl(grid, op(single_layer), op(hypersingular), parameters, spaces, base_slp, return_base_slp, laplace=False) return ops
def single_layer_and_hypersingular_pair(grid, parameters=None, spaces='linear', base_slp=None, return_base_slp=False, stabilization_factor=0): """Return a pair of hypersingular and single layer operator. This function creates a pair of a single-layer and a hypersingular operator, where both operators are instantiated using a common base single-layer operator. Hence, only one single-layer operator needs to be discretized to obtain both operators on the given grid. Parameters ---------- grid : bempp.api.grid.Grid The underlying grid for the multitrace operator parameters : bempp.api.common.ParameterList Parameters for the operator. If none given the default global parameter object `bempp.api.global_parameters` is used. spaces: string Choose 'linear' to assemble the operator with continuous linear function spaces for the Dirichlet and Neumann component (default). For a dual pairing of a linear space for the Dirichlet data and piecewise constant space for the Neumann data choose 'dual'. base_slp : None Specify a base single-layer operator to be used. If set to None, a base single-layer operator will be instantiated by the function. return_base_slp : bool If True also return the original large space single layer operator from which the hypersingular and slp operator are derived. Default is False stabilization_factor : double If not equal to zero add this factor times the rank one operator <w 1><v, 1> to the hypersingular, where w is in the domain space and v in the dual space of the hypersingular operator. This regularizes the hypersingular operator. Returns ------- A pair (slp, hyp) of a single-layer and hypersingular operator. If return_base_slp is true a triplet (slp, hyp, base_slp) is returned, where base_slp is the single-layer operator, from which slp and hyp are obtained via sparse transformations. """ from bempp.api.operators.boundary import _common ops = list( _common.slp_and_hyp_impl(grid, single_layer, hypersingular, parameters, spaces, base_slp, return_base_slp, laplace=True)) if stabilization_factor != 0: from bempp.api.assembly import RankOneBoundaryOperator ops[1] += stabilization_factor * RankOneBoundaryOperator( ops[1].domain, ops[1].range, ops[1].dual_to_range) return ops
def single_layer_and_hypersingular_pair( grid, wave_number, parameters=None, spaces="linear", base_slp=None, return_base_slp=False ): """Return a pair of hypersingular and single layer operator. This function creates a pair of a single-layer and a hypersingular operator, where both operators are instantiated using a common base single-layer operator. Hence, only one single-layer operator needs to be discretized to obtain both operators on the given grid. Parameters ---------- grid : bempp.api.grid.Grid The underlying grid for the multitrace operator 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. spaces: string Choose 'linear' to assemble the operator with continuous linear function spaces for the Dirichlet and Neumann component (default). For a dual pairing of a linear space for the Dirichlet data and piecewise constant space for the Neumann data choose 'dual'. base_slp : None Specify a base single-layer operator to be used. If set to None, a base single-layer operator will be instantiated by the function. return_base_slp : bool If True also return the original large space single layer operator from which the hypersingular and slp operator are derived. Default is False Returns ------- A pair (slp, hyp) of a single-layer and hypersingular operator. If return_base_slp is true a triplet (slp, hyp, base_slp) is returned, where base_slp is the single-layer operator, from which slp and hyp are obtained via sparse transformations. """ from bempp.api.operators.boundary import _common def op(operator): if operator == hypersingular: def op_impl( domain, range_, dual_to_range, label="HYP", symmetry="no_symmetry", parameters=None, use_slp=False ): return hypersingular(domain, range_, dual_to_range, wave_number, label, symmetry, parameters, use_slp) return op_impl else: import inspect defaults = inspect.getargspec(operator).defaults def op_impl(domain, range_, dual_to_range, label=defaults[0], symmetry=defaults[1], parameters=None): return operator(domain, range_, dual_to_range, wave_number, label, symmetry, parameters) return op_impl ops = _common.slp_and_hyp_impl( grid, op(single_layer), op(hypersingular), parameters, spaces, base_slp, return_base_slp, laplace=False ) return ops