def __init__( self, grid, order, domains=None, closed=True, reference_point_on_segment=True, element_on_segment=False, comp_key=None): from bempp.core.space.space import function_space as _function_space from bempp.api.assembly.functors import scalar_function_value_functor super( DiscontinuousPolynomialSpace, self).__init__( _function_space( grid._impl, "DP", order, domains, closed, False, reference_point_on_segment, element_on_segment), comp_key=comp_key) self._order = order self._has_non_barycentric_space = True self._non_barycentric_space = self self._discontinuous_space = self self._super_space = self self._evaluation_functor = scalar_function_value_functor() self._is_barycentric = False self._grid = grid
def __init__(self, grid, comp_key=None): from bempp.core.space.space import function_space as _function_space from bempp.api.assembly.functors import scalar_function_value_functor super(DualSpace, self).__init__( _function_space(grid._impl, "DUAL", 0), comp_key) self._order = 0 self._has_non_barycentric_space = False self._non_barycentric_space = None self._discontinuous_space = function_space( grid.barycentric_grid(), "DP", 0) self._super_space = self._discontinuous_space self._evaluation_functor = scalar_function_value_functor() self._is_barycentric = True self._grid = grid.barycentric_grid()
def __init__(self, grid, order, comp_key=None): from bempp.core.space.space import function_space as _function_space from bempp.api.assembly.functors import scalar_function_value_functor super(BarycentricContinuousPolynomialSpace, self).__init__( _function_space(grid._impl, "B-P", order), comp_key) self._order = order self._has_non_barycentric_space = True self._non_barycentric_space = function_space(grid, "P", order) self._discontinuous_space = function_space( grid.barycentric_grid(), "DP", order) self._super_space = self._discontinuous_space self._evaluation_functor = scalar_function_value_functor() self._is_barycentric = True self._grid = grid.barycentric_grid()
def hypersingular(domain, range_, dual_to_range, label="HYP", symmetry='no_symmetry', parameters=None, use_slp=False, use_projection_spaces=True, assemble_only_singular_part=False): """Return the Laplace hypersingular boundary operator. Parameters ---------- domain : bempp.api.space.Space Domain space. range_ : bempp.api.space.Space Range space. dual_to_range : bempp.api.space.Space Dual space to the range space. label : string Label for the operator. symmetry : string Symmetry mode. Possible values are: 'no_symmetry', 'symmetric', 'hermitian'. parameters : bempp.api.common.ParameterList Parameters for the operator. If none given the default global parameter object `bempp.api.global_parameters` is used. use_projection_spaces : bool Represent operator by projection from higher dimensional space if available. This parameter can speed up fast assembly routines, such as H-Matrices or FMM (default true). use_slp : True/False or boundary operator object The hypersingular operator can be represented as a sparse transformation of a single-layer operator. If `use_slp=True` this representation is used. If `use_slp=op` for a single-layer boundary operator assembled on a suitable space this operator is used to assemble the hypersingular operator. Note that if `use_slp=op` is used no checks are performed if the slp operator is correctly defined for representing the hypersingular operator. Hence, if no care is taken this option can lead to a wrong operator. Also, `use_slp=True` or `use_slp=op` is only valid if the `domain` and `dual_to_range` spaces are identical. assemble_only_singular_part : bool When assembled the operator will only contain components for adjacent or overlapping test and trial functions (default false). Note. This option is only used if `use_slp` is not specified. """ import bempp.api from bempp.api.assembly.boundary_operator import BoundaryOperator if parameters is None: parameters = bempp.api.global_parameters if domain != dual_to_range and use_slp: use_slp = False if not use_slp: from bempp.api.operators.boundary._common import \ get_operator_with_space_preprocessing return get_operator_with_space_preprocessing( _hypersingular_impl, domain, range_, dual_to_range, label, symmetry, parameters, use_projection_spaces=use_projection_spaces, assemble_only_singular_part=assemble_only_singular_part) else: if domain != dual_to_range: raise ValueError( "domain and dual_to_range spaces must be identical " + "if use_slp=True") if not isinstance(use_slp, BoundaryOperator): disc_space = domain.discontinuous_space slp = single_layer(disc_space, range_, disc_space, parameters=parameters) else: slp = use_slp from bempp.api.assembly.functors import vector_surface_curl_functor from bempp.api.assembly.functors import scalar_function_value_functor from bempp.api.assembly.functors import \ single_component_test_trial_integrand_functor from bempp.api.space.projection import rewrite_operator_spaces compound_op = bempp.api.ZeroBoundaryOperator(domain, slp.range, dual_to_range) for i in range(3): curl_value_op = \ bempp.api.operators.boundary.sparse.operator_from_functors( domain, slp.domain, slp.domain, scalar_function_value_functor(), vector_surface_curl_functor(), single_component_test_trial_integrand_functor(0, i), label="CURL_OP[{0}]".format(i), parameters=parameters) compound_op += curl_value_op.dual_product(slp) * curl_value_op # Now generate the compound operator return rewrite_operator_spaces(compound_op, domain=domain, range_=range_, dual_to_range=dual_to_range)