bem3d.h

Go to the documentation of this file.

/* ------------------------------------------------------------
 * This is the file "bem3d.h" of the H2Lib package.
 * All rights reserved, Sven Christophersen 2011
 * ------------------------------------------------------------ */

#ifndef BEM3D_H_
#define BEM3D_H_

/* C STD LIBRARY */
#include <stdio.h>
#ifdef USE_OPENMP
#include <omp.h>
#endif
/* CORE 0 */
#ifdef USE_SIMD
#include "simd.h"
#endif
#include "basic.h"
/* CORE 1 */
#include "amatrix.h"
#include "gaussquad.h"
#include "factorizations.h"
#include "krylov.h"
#include "sparsematrix.h"
/* CORE 2 */
#include "cluster.h"
#include "clustergeometry.h"
#include "block.h"
#include "hmatrix.h"
#include "clusterbasis.h"
#include "h2matrix.h"
#include "dcluster.h"
#include "dblock.h"
#include "dclusterbasis.h"
#include "dh2matrix.h"
#include "krylovsolvers.h"
/* CORE 3 */
#include "hcoarsen.h"
#include "h2update.h"
#include "aca.h"
/* SIMPLE */
/* BEM */
#include "macrosurface3d.h"
#include "surface3d.h"
#include "singquad2d.h"

/* ------------------------------------------------------------
 * Type definitions
 * ------------------------------------------------------------ */

typedef struct _bem3d bem3d;
typedef bem3d *pbem3d;
typedef const bem3d* pcbem3d;

typedef struct _aprxbem3d aprxbem3d;
typedef aprxbem3d *paprxbem3d;
typedef const aprxbem3d *pcaprxbem3d;

typedef struct _parbem3d parbem3d;
typedef parbem3d *pparbem3d;
typedef const parbem3d *pcparbem3d;

typedef struct _kernelbem3d kernelbem3d;

typedef kernelbem3d *pkernelbem3d;

typedef const kernelbem3d *pckernelbem3d;

typedef void (*quadpoints3d)(pcbem3d bem, const real bmin[3],
    const real bmax[3], const real delta, real (**Z)[3], real (**N)[3]);

enum _basisfunctionbem3d {
  BASIS_NONE_BEM3D = 0,
  BASIS_CONSTANT_BEM3D = 'c',
  BASIS_LINEAR_BEM3D = 'l'
};

typedef enum _basisfunctionbem3d basisfunctionbem3d;

typedef field (*boundary_func3d)(const real *x, const real *n, void *data);

typedef field (*kernel_func3d)(const real *x, const real *y, const real *nx,
    const real *ny, void *data);

typedef field (*kernel_wave_func3d)(const real *x, const real *y,
    const real *nx, const real *ny, pcreal dir, void *data);

#ifdef USE_SIMD
typedef void (*kernel_simd_func3d)(const vreal *x, const vreal *y,
    const vreal *nx, const vreal *ny, void *data, vreal *res_re, vreal *res_im);

typedef void (*kernel_simd_wave_func3d)(const vreal *x, const vreal *y,
    const vreal *nx, const vreal *ny, pcreal dir, void *data, vreal *res_re,
    vreal *res_im);
#endif

typedef struct _listnode listnode;

typedef listnode *plistnode;

typedef struct _tri_list tri_list;

typedef tri_list *ptri_list;

typedef struct _vert_list vert_list;

typedef vert_list *pvert_list;

struct _bem3d {
  pcsurface3d gr;

  psingquad2d sq;

  basisfunctionbem3d row_basis;

  basisfunctionbem3d col_basis;

  real *mass;

  field alpha;


  field k;

  field kernel_const;

  plistnode *v2t;

  void (*nearfield)(const uint *ridx, const uint *cidx, pcbem3d bem,
      bool ntrans, pamatrix N);

  void (*nearfield_far)(const uint *ridx, const uint *cidx, pcbem3d bem,
      bool ntrans, pamatrix N);

  void (*farfield_rk)(pccluster rc, uint rname, pccluster cc, uint cname,
      pcbem3d bem, prkmatrix R);

  void (*farfield_u)(uint rname, uint cname, uint bname, pcbem3d bem);

  void (*farfield_wave_u)(uint rname, uint cname, uint bname, pcbem3d bem);

  void (*leaf_row)(uint rname, pcbem3d bem);

  void (*leaf_wave_row)(uint rname, pcbem3d bem);

  void (*leaf_col)(uint cname, pcbem3d bem);

  void (*leaf_wave_col)(uint cname, pcbem3d bem);

  void (*transfer_row)(uint rname, pcbem3d bem);

  void (*transfer_wave_row)(uint rname, pcbem3d bem);

  void (*transfer_wave_wave_row)(uint rname, pcbem3d bem);

  void (*transfer_col)(uint cname, pcbem3d bem);

  void (*transfer_wave_col)(uint cname, pcbem3d bem);

  void (*transfer_wave_wave_col)(uint cname, pcbem3d bem);

  paprxbem3d aprx;

  pparbem3d par;

  pkernelbem3d kernels;
};

struct _kernelbem3d {
  void (*fundamental)(pcbem3d bem, const real (*X)[3], const real (*Y)[3],
      pamatrix V);

  void (*fundamental_wave)(pcbem3d bem, const real (*X)[3], const real (*Y)[3],
      pcreal dir, pamatrix V);

  void (*dny_fundamental)(pcbem3d bem, const real (*X)[3], const real (*Y)[3],
      const real (*NY)[3], pamatrix V);

  void (*dnx_dny_fundamental)(pcbem3d bem, const real (*X)[3],
      const real (*NX)[3], const real (*Y)[3], const real (*NY)[3], pamatrix V);

  void (*kernel_row)(const uint *idx, const real (*Z)[3], pcbem3d bem,
      pamatrix A);

  void (*kernel_col)(const uint *idx, const real (*Z)[3], pcbem3d bem,
      pamatrix B);

  void (*dnz_kernel_row)(const uint *idx, const real (*Z)[3],
      const real (*NZ)[3], pcbem3d bem, pamatrix A);

  void (*dnz_kernel_col)(const uint *idx, const real (*Z)[3],
      const real (*NZ)[3], pcbem3d bem, pamatrix B);

  void (*fundamental_row)(const uint *idx, const real (*Z)[3], pcbem3d bem,
      pamatrix A);

  void (*fundamental_col)(const uint *idx, const real (*Z)[3], pcbem3d bem,
      pamatrix B);

  void (*dnz_fundamental_row)(const uint *idx, const real (*Z)[3],
      const real (*NZ)[3], pcbem3d bem, pamatrix A);

  void (*dnz_fundamental_col)(const uint *idx, const real (*Z)[3],
      const real (*NZ)[3], pcbem3d bem, pamatrix B);

  void (*lagrange_row)(const uint *idx, pcrealavector px, pcrealavector py,
      pcrealavector pz, pcbem3d bem, pamatrix V);

  void (*lagrange_wave_row)(const uint *idx, pcrealavector px, pcrealavector py,
      pcrealavector pz, pcreal dir, pcbem3d bem, pamatrix V);

  void (*lagrange_col)(const uint *idx, pcrealavector px, pcrealavector py,
      pcrealavector pz, pcbem3d bem, pamatrix W);

  void (*lagrange_wave_col)(const uint *idx, pcrealavector px, pcrealavector py,
      pcrealavector pz, pcreal dir, pcbem3d bem, pamatrix W);
};

struct _listnode {
  uint data;
  plistnode next;
};

struct _tri_list {
  uint t;
  pvert_list vl;
  ptri_list next;
};

struct _vert_list {
  uint v;
  pvert_list next;
};

/* ------------------------------------------------------------
 * Constructors and destructors
 * ------------------------------------------------------------ */

HEADER_PREFIX pvert_list
new_vert_list(pvert_list next);

HEADER_PREFIX void
del_vert_list(pvert_list vl);

HEADER_PREFIX ptri_list
new_tri_list(ptri_list next);

HEADER_PREFIX void
del_tri_list(ptri_list tl);

HEADER_PREFIX pbem3d
new_bem3d(pcsurface3d gr, basisfunctionbem3d row_basis,
    basisfunctionbem3d col_basis);

HEADER_PREFIX void
del_bem3d(pbem3d bem);

/* ------------------------------------------------------------
 * Methods to build clustertrees
 * ------------------------------------------------------------ */

HEADER_PREFIX pclustergeometry
build_bem3d_const_clustergeometry(pcbem3d bem, uint **idx);

HEADER_PREFIX pclustergeometry
build_bem3d_linear_clustergeometry(pcbem3d bem, uint **idx);

HEADER_PREFIX pclustergeometry
build_bem3d_clustergeometry(pcbem3d bem, uint **idx, basisfunctionbem3d basis);

HEADER_PREFIX pcluster
build_bem3d_cluster(pcbem3d bem, uint clf, basisfunctionbem3d basis);

/* ------------------------------------------------------------
 * Nearfield quadrature routines
 * ------------------------------------------------------------ */

HEADER_PREFIX void
assemble_cc_near_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_func3d kernel);
#ifdef USE_SIMD
HEADER_PREFIX void
assemble_cc_simd_near_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_simd_func3d kernel);
#endif

HEADER_PREFIX void
assemble_cc_far_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_func3d kernel);
#ifdef USE_SIMD
HEADER_PREFIX void
assemble_cc_simd_far_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_simd_func3d kernel);
#endif

HEADER_PREFIX void
assemble_cl_near_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_func3d kernel);
#ifdef USE_SIMD
HEADER_PREFIX void
assemble_cl_simd_near_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_simd_func3d kernel);
#endif

HEADER_PREFIX void
assemble_cl_far_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_func3d kernel);
#ifdef USE_SIMD
HEADER_PREFIX void
assemble_cl_simd_far_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_simd_func3d kernel);
#endif

HEADER_PREFIX void
assemble_lc_near_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_func3d kernel);
#ifdef USE_SIMD
HEADER_PREFIX void
assemble_lc_simd_near_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_simd_func3d kernel);
#endif

HEADER_PREFIX void
assemble_lc_far_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_func3d kernel);
#ifdef USE_SIMD
HEADER_PREFIX void
assemble_lc_simd_far_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_simd_func3d kernel);
#endif

HEADER_PREFIX void
assemble_ll_near_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_func3d kernel);
#ifdef USE_SIMD
HEADER_PREFIX void
assemble_ll_simd_near_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_simd_func3d kernel);
#endif

HEADER_PREFIX void
assemble_ll_far_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_func3d kernel);
#ifdef USE_SIMD
HEADER_PREFIX void
assemble_ll_simd_far_bem3d(const uint * ridx, const uint * cidx, pcbem3d bem,
    bool ntrans, pamatrix N, kernel_simd_func3d kernel);
#endif

/* ------------------------------------------------------------
 * Evaluate kernel function at given points
 * ------------------------------------------------------------ */

HEADER_PREFIX void
fill_bem3d(pcbem3d bem, const real (*X)[3], const real (*Y)[3],
    const real (*NX)[3], const real (*NY)[3], pamatrix V, kernel_func3d kernel);

HEADER_PREFIX void
fill_wave_bem3d(pcbem3d bem, const real (*X)[3], const real (*Y)[3],
    const real (*NX)[3], const real (*NY)[3], pamatrix V, pcreal dir,
    kernel_wave_func3d kernel);

/* ------------------------------------------------------------
 * Compute single integrals with kernel functions
 * ------------------------------------------------------------ */

HEADER_PREFIX void
fill_row_c_bem3d(const uint * idx, const real (*Z)[3], pcbem3d bem, pamatrix V,
    kernel_func3d kernel);
#ifdef USE_SIMD
HEADER_PREFIX void
fill_row_simd_c_bem3d(const uint * idx, const real (*Z)[3], pcbem3d bem,
    pamatrix V, kernel_simd_func3d kernel);
#endif

HEADER_PREFIX void
fill_col_c_bem3d(const uint * idx, const real (*Z)[3], pcbem3d bem, pamatrix V,
    kernel_func3d kernel);
#ifdef USE_SIMD
HEADER_PREFIX void
fill_col_simd_c_bem3d(const uint * idx, const real (*Z)[3], pcbem3d bem,
    pamatrix V, kernel_simd_func3d kernel);
#endif

HEADER_PREFIX void
fill_row_l_bem3d(const uint * idx, const real (*Z)[3], pcbem3d bem, pamatrix V,
    kernel_func3d kernel);

HEADER_PREFIX void
fill_col_l_bem3d(const uint * idx, const real (*Z)[3], pcbem3d bem, pamatrix V,
    kernel_func3d kernel);

HEADER_PREFIX void
fill_dnz_row_c_bem3d(const uint * idx, const real (*Z)[3], const real (*N)[3],
    pcbem3d bem, pamatrix V, kernel_func3d kernel);
#ifdef USE_SIMD
HEADER_PREFIX void
fill_dnz_row_simd_c_bem3d(const uint * idx, const real (*Z)[3],
    const real (*N)[3], pcbem3d bem, pamatrix V, kernel_simd_func3d kernel);
#endif

HEADER_PREFIX void
fill_dnz_col_c_bem3d(const uint * idx, const real (*Z)[3], const real (*N)[3],
    pcbem3d bem, pamatrix V, kernel_func3d kernel);
#ifdef USE_SIMD
HEADER_PREFIX void
fill_dnz_col_simd_c_bem3d(const uint * idx, const real (*Z)[3],
    const real (*N)[3], pcbem3d bem, pamatrix V, kernel_simd_func3d kernel);
#endif

HEADER_PREFIX void
fill_dnz_row_l_bem3d(const uint * idx, const real (*Z)[3], const real (*N)[3],
    pcbem3d bem, pamatrix V, kernel_func3d kernel);

HEADER_PREFIX void
fill_dnz_col_l_bem3d(const uint * idx, const real (*Z)[3], const real (*N)[3],
    pcbem3d bem, pamatrix V, kernel_func3d kernel);

/* ------------------------------------------------------------
 * Initializer functions for h-matrix approximations
 * ------------------------------------------------------------ */

HEADER_PREFIX void
setup_hmatrix_recomp_bem3d(pbem3d bem, bool recomp, real accur_recomp,
    bool coarsen, real accur_coarsen);

/* ------------------------------------------------------------
 * Interpolation
 * ------------------------------------------------------------ */

HEADER_PREFIX void
setup_hmatrix_aprx_inter_row_bem3d(pbem3d bem, pccluster rc, pccluster cc,
    pcblock tree, uint m);

HEADER_PREFIX void
setup_hmatrix_aprx_inter_col_bem3d(pbem3d bem, pccluster rc, pccluster cc,
    pcblock tree, uint m);

HEADER_PREFIX void
setup_hmatrix_aprx_inter_mixed_bem3d(pbem3d bem, pccluster rc, pccluster cc,
    pcblock tree, uint m);

/* ------------------------------------------------------------
 * Green
 * ------------------------------------------------------------ */

HEADER_PREFIX void
setup_hmatrix_aprx_green_row_bem3d(pbem3d bem, pccluster rc, pccluster cc,
    pcblock tree, uint m, uint l, real delta, quadpoints3d quadpoints);

HEADER_PREFIX void
setup_hmatrix_aprx_green_col_bem3d(pbem3d bem, pccluster rc, pccluster cc,
    pcblock tree, uint m, uint l, real delta, quadpoints3d quadpoints);

HEADER_PREFIX void
setup_hmatrix_aprx_green_mixed_bem3d(pbem3d bem, pccluster rc, pccluster cc,
    pcblock tree, uint m, uint l, real delta, quadpoints3d quadpoints);

/* ------------------------------------------------------------
 * Greenhybrid
 * ------------------------------------------------------------ */

HEADER_PREFIX void
setup_hmatrix_aprx_greenhybrid_row_bem3d(pbem3d bem, pccluster rc, pccluster cc,
    pcblock tree, uint m, uint l, real delta, real accur,
    quadpoints3d quadpoints);

HEADER_PREFIX void
setup_hmatrix_aprx_greenhybrid_col_bem3d(pbem3d bem, pccluster rc, pccluster cc,
    pcblock tree, uint m, uint l, real delta, real accur,
    quadpoints3d quadpoints);

HEADER_PREFIX void
setup_hmatrix_aprx_greenhybrid_mixed_bem3d(pbem3d bem, pccluster rc,
    pccluster cc, pcblock tree, uint m, uint l, real delta, real accur,
    quadpoints3d quadpoints);

/* ------------------------------------------------------------
 * ACA
 * ------------------------------------------------------------ */

HEADER_PREFIX void
setup_hmatrix_aprx_aca_bem3d(pbem3d bem, pccluster rc, pccluster cc,
    pcblock tree, real accur);

HEADER_PREFIX void
setup_hmatrix_aprx_paca_bem3d(pbem3d bem, pccluster rc, pccluster cc,
    pcblock tree, real accur);

/* ------------------------------------------------------------
 * HCA
 * ------------------------------------------------------------ */

HEADER_PREFIX void
setup_hmatrix_aprx_hca_bem3d(pbem3d bem, pccluster rc, pccluster cc,
    pcblock tree, uint m, real accur);

/* ------------------------------------------------------------
 * Initializer functions for H2-matrix approximations
 * ------------------------------------------------------------ */

HEADER_PREFIX void
setup_h2matrix_recomp_bem3d(pbem3d bem, bool hiercomp, real accur_hiercomp);

HEADER_PREFIX void
setup_h2matrix_aprx_inter_bem3d(pbem3d bem, pcclusterbasis rb,
    pcclusterbasis cb, pcblock tree, uint m);

HEADER_PREFIX void
setup_h2matrix_aprx_greenhybrid_bem3d(pbem3d bem, pcclusterbasis rb,
    pcclusterbasis cb, pcblock tree, uint m, uint l, real delta, real accur,
    quadpoints3d quadpoints);

HEADER_PREFIX void
setup_h2matrix_aprx_greenhybrid_ortho_bem3d(pbem3d bem, pcclusterbasis rb,
    pcclusterbasis cb, pcblock tree, uint m, uint l, real delta, real accur,
    quadpoints3d quadpoints);

/* ------------------------------------------------------------
 * Initializer functions for DH2-matrix approximations
 * ------------------------------------------------------------ */

HEADER_PREFIX void
setup_dh2matrix_aprx_inter_bem3d(pbem3d bem, pcdclusterbasis rb,
    pcdclusterbasis cb, pcdblock tree, uint m);

HEADER_PREFIX void
setup_dh2matrix_aprx_inter_ortho_bem3d(pbem3d bem, pcdclusterbasis rb,
    pcdclusterbasis cb, pcdblock tree, uint m);

HEADER_PREFIX void
setup_dh2matrix_aprx_inter_recomp_bem3d(pbem3d bem, pcdclusterbasis rb,
    pcdclusterbasis cb, pcdblock tree, uint m, ptruncmode tm, real eps);

/* ------------------------------------------------------------
 * Fill amatrix
 * ------------------------------------------------------------ */

HEADER_PREFIX void
assemble_bem3d_amatrix(pbem3d bem, pamatrix G);

/* ------------------------------------------------------------
 * Fill hmatrix
 * ------------------------------------------------------------ */

HEADER_PREFIX void
assemble_bem3d_hmatrix(pbem3d bem, pblock b, phmatrix G);

HEADER_PREFIX void
assemblecoarsen_bem3d_hmatrix(pbem3d bem, pblock b, phmatrix G);

HEADER_PREFIX void
assemble_bem3d_nearfield_hmatrix(pbem3d bem, pblock b, phmatrix G);

HEADER_PREFIX void
assemble_bem3d_farfield_hmatrix(pbem3d bem, pblock b, phmatrix G);

/* ------------------------------------------------------------
 * Fill H2-matrix
 * ------------------------------------------------------------ */

HEADER_PREFIX void
assemble_bem3d_h2matrix_row_clusterbasis(pcbem3d bem, pclusterbasis rb);

HEADER_PREFIX void
assemble_bem3d_h2matrix_col_clusterbasis(pcbem3d bem, pclusterbasis cb);

HEADER_PREFIX void
assemble_bem3d_h2matrix(pbem3d bem, ph2matrix G);

HEADER_PREFIX void
assemble_bem3d_nearfield_h2matrix(pbem3d bem, ph2matrix G);

HEADER_PREFIX void
assemble_bem3d_farfield_h2matrix(pbem3d bem, ph2matrix G);

HEADER_PREFIX void
assemblehiercomp_bem3d_h2matrix(pbem3d bem, pblock b, ph2matrix G);

HEADER_PREFIX void
assemble_bem3d_dh2matrix_row_dclusterbasis(pcbem3d bem, pdclusterbasis rb);

HEADER_PREFIX void
assemble_bem3d_dh2matrix_col_dclusterbasis(pcbem3d bem, pdclusterbasis cb);

HEADER_PREFIX void
assemble_bem3d_dh2matrix_ortho_row_dclusterbasis(pcbem3d bem, pdclusterbasis rb,
    pdclusteroperator ro);

HEADER_PREFIX void
assemble_bem3d_dh2matrix_ortho_col_dclusterbasis(pcbem3d bem, pdclusterbasis cb,
    pdclusteroperator co);

HEADER_PREFIX void
assemble_bem3d_dh2matrix_recomp_both_dclusterbasis(pcbem3d bem,
    pdclusterbasis rb, pdclusteroperator bro, pdclusterbasis cb,
    pdclusteroperator bco, pcdblock broot);

HEADER_PREFIX void
assemble_bem3d_dh2matrix(pbem3d bem, pdh2matrix G);

HEADER_PREFIX void
assemble_bem3d_nearfield_dh2matrix(pbem3d bem, pdh2matrix G);

HEADER_PREFIX void
assemble_bem3d_farfield_dh2matrix(pbem3d bem, pdh2matrix G);

/* ------------------------------------------------------------
 * Lagrange polynomials
 * ------------------------------------------------------------ */

HEADER_PREFIX void
assemble_bem3d_lagrange_c_amatrix(const uint *idx, pcrealavector px,
    pcrealavector py, pcrealavector pz, pcbem3d bem, pamatrix V);

HEADER_PREFIX void
assemble_bem3d_lagrange_wave_c_amatrix(const uint *idx, pcrealavector px,
    pcrealavector py, pcrealavector pz, pcreal dir, pcbem3d bem, pamatrix V);

HEADER_PREFIX void
assemble_bem3d_lagrange_l_amatrix(const uint *idx, pcrealavector px,
    pcrealavector py, pcrealavector pz, pcbem3d bem, pamatrix V);

HEADER_PREFIX void
assemble_bem3d_lagrange_wave_l_amatrix(const uint *idx, pcrealavector px,
    pcrealavector py, pcrealavector pz, pcreal dir, pcbem3d bem, pamatrix V);

HEADER_PREFIX void
assemble_bem3d_dn_lagrange_c_amatrix(const uint *idx, pcrealavector px,
    pcrealavector py, pcrealavector pz, pcbem3d bem, pamatrix V);

HEADER_PREFIX void
assemble_bem3d_dn_lagrange_wave_c_amatrix(const uint * idx, pcrealavector px,
    pcrealavector py, pcrealavector pz, pcreal dir, pcbem3d bem, pamatrix V);

HEADER_PREFIX void
assemble_bem3d_dn_lagrange_l_amatrix(const uint *idx, pcrealavector px,
    pcrealavector py, pcrealavector pz, pcbem3d bem, pamatrix V);

HEADER_PREFIX void
assemble_bem3d_dn_lagrange_wave_l_amatrix(const uint *idx, pcrealavector px,
    pcrealavector py, pcrealavector pz, pcreal dir, pcbem3d bem, pamatrix V);

HEADER_PREFIX void
assemble_bem3d_lagrange_amatrix(const real (*X)[3], pcrealavector px,
    pcrealavector py, pcrealavector pz, pcbem3d bem, pamatrix V);

HEADER_PREFIX void
assemble_bem3d_lagrange_wave_amatrix(const real (*X)[3], pcrealavector px,
    pcrealavector py, pcrealavector pz, pcreal dir, pcbem3d bem, pamatrix V);

/* ------------------------------------------------------------
 * Some useful functions
 * ------------------------------------------------------------ */

HEADER_PREFIX real
normL2_bem3d(pbem3d bem, boundary_func3d f, void *data);

HEADER_PREFIX real
normL2_c_bem3d(pbem3d bem, pavector x);

HEADER_PREFIX real
normL2diff_c_bem3d(pbem3d bem, pavector x, boundary_func3d f, void *data);

HEADER_PREFIX real
normL2_l_bem3d(pbem3d bem, pavector x);

HEADER_PREFIX real
normL2diff_l_bem3d(pbem3d bem, pavector x, boundary_func3d f, void *data);

HEADER_PREFIX void
integrate_bem3d_c_avector(pbem3d bem, boundary_func3d f, pavector w, void *data);

HEADER_PREFIX void
integrate_bem3d_l_avector(pbem3d bem, boundary_func3d f, pavector w, void *data);

HEADER_PREFIX void
projectL2_bem3d_c_avector(pbem3d bem, boundary_func3d f, pavector w, void *data);

HEADER_PREFIX void
projectL2_bem3d_l_avector(pbem3d bem, boundary_func3d f, pavector w, void *data);

HEADER_PREFIX void
setup_vertex_to_triangle_map_bem3d(pbem3d bem);

HEADER_PREFIX
void build_bem3d_cube_quadpoints(pcbem3d bem, const real a[3], const real b[3],
    const real delta, real (**Z)[3], real (**N)[3]);

HEADER_PREFIX prkmatrix
build_bem3d_rkmatrix(pccluster row, pccluster col, void* data);

HEADER_PREFIX pamatrix
build_bem3d_amatrix(pccluster row, pccluster col, void* data);

HEADER_PREFIX void
build_bem3d_curl_sparsematrix(pcbem3d bem, psparsematrix *C0, psparsematrix *C1,
    psparsematrix *C2);

#endif /* BEM3D_H_ */