:py:mod:`bempp.api.operators.boundary.sparse`
=============================================

.. py:module:: bempp.api.operators.boundary.sparse

.. autoapi-nested-parse::

   Interfaces to Laplace operators.



Module Contents
---------------


Functions
~~~~~~~~~

.. autoapisummary::

   bempp.api.operators.boundary.sparse.identity
   bempp.api.operators.boundary.sparse._vector_grad_product
   bempp.api.operators.boundary.sparse._curl_curl_product
   bempp.api.operators.boundary.sparse.multitrace_identity
   bempp.api.operators.boundary.sparse.mte_operators
   bempp.api.operators.boundary.sparse.lambda_1
   bempp.api.operators.boundary.sparse.lambda_2
   bempp.api.operators.boundary.sparse.sigma_identity
   bempp.api.operators.boundary.sparse.laplace_beltrami



.. py:function:: identity(domain, range_, dual_to_range, parameters=None, device_interface=None, precision=None)

   Assemble the L^2 identity operator.


.. py:function:: _vector_grad_product(domain, range_, dual_to_range, parameters=None, device_interface=None, precision=None)

   Assemble the inner product between a vector field and grad of a P1 basis function.


.. py:function:: _curl_curl_product(domain, range_, dual_to_range, parameters=None, device_interface=None, precision=None)

   Assemble inner product between the surface curl of 2 SNC basis functions.


.. py:function:: multitrace_identity(multitrace_operator, parameters=None, device_interface=None, precision=None)

   Create a multitrace identity operator.

   Parameters
   ----------
   multitrace_operator : Bempp Operator
       A 2 x 2 multitrace operator object whose spaces are used to define
       the identity operator.

   Output
   ------
   A block-diagonal multitrace identity operator.



.. py:function:: mte_operators(domains_, ranges_, dual_to_ranges_, kappa)

   Create basic sparse operators to assemble Pade approximate MtE operators.

   Parameters
   ----------
   domains_
       Domain spaces
   ranges_
       Range spaces
   dual_to_ranges_
       Dual spaces

   Output
   ------
   Basic sparse operators to assemble Pade approximate MtE operators.

   IP
       Identity operator built with piecewise linear basis functions
   IC
       Identity operator built with Hcurl conforming basis functions
   N
       Scaled curlcurl operator
   L
       Grad u dot v operator
   LT
       Transpose of L



.. py:function:: lambda_1(mte_operators, beta, kappa_eps)

   Create and return block Pade approximate operator to Lambda1 = (I+Delta)^(1/2).

   Parameters
   ----------
   mte_operators
       Basic sparse Pade approximate MtE operators.
   beta
       Array containing the division between Pade coefficients: A_j/B_j
   kappa
       Damped wavenumber kappa_eps = kappa + i eps

   Output
   ------
   Block operator that approximates (I+Delta)^(1/2)


.. py:function:: lambda_2(mte_operators)

   Create and return Lambda2 = (I-curlcurl) operator.

   Parameters
   ----------
   mte_operators

   Output
   ------
   IC-N = (I-curlcurl)



.. py:function:: sigma_identity(domain, range_, dual_to_range, parameters=None, device_interface=None, precision=None)

   Evaluate the sigma identity operator.

   For Galerkin methods this operator is equivalent to .5 * identity. For
   collocation methods the value may differ from .5 on piecewise smooth
   domains.


.. py:function:: laplace_beltrami(domain, range_, dual_to_range, parameters=None, device_interface=None, precision=None)

   Assemble the negative Laplace-Beltrami operator.