Skip to content

Latest commit

 

History

History
219 lines (176 loc) · 14.1 KB

README.md

File metadata and controls

219 lines (176 loc) · 14.1 KB
Raw

Bembel

License: GPL v3 GitHub release (latest by date) DOI CircleCI

Table of contents

  1. Introduction
  2. What is a Bembel?
  3. Features
  4. How to Run our Code
  5. Structure of the Repository
  6. Documentation
  7. Known Bugs and Upcoming Features
  8. Publications, Preprints, and how to cite
  9. Contributers
  10. About the People
  11. Funding

1. Introduction

Bembel is the Boundary Element Method Based Engineering Library written in C++ to solve boundary value problems governed by the Laplace, Helmholtz or electric wave equation within the isogeometric framework [3,4,5,6]. It was developed as part of a cooperation between the TU Darmstadt and the University of Basel, coordinated by H. Harbrecht, S. Kurz and S. Schöps. The code is based on the Laplace BEM of J. Dölz, H. Harbrecht, and M. Multerer, [2,7] as well as the spline and geometry framework of F. Wolf. The code was extended by J. Dölz and F. Wolf in early 2018 to cover electromagnetic applications [5,6]. A short introduction to the code has been written [3]. If you utilise our code as part of a publication, we would appreciate it if you cite it.

2. What is a Bembel?

A traditional German ceramic, as depicted in our logo. Quoting Wikipedia:

Most establishments also serve Apfelwein by the Bembel (a specific Apfelwein jug), much like how beer can be purchased by the pitcher in many countries. The paunchy Bembel (made from salt-glazed stoneware) usually has a basic grey colour with blue-painted detailing.

3. Features

Current key features include

  • Header-only implementation,
  • Already implemented Laplace, Helmholtz and Maxwell single layer operator, easily expendable to other operators,
  • Arbitrary parametric mappings for the geometry representation, by default realized as NURBS-mappings from files generated by the NURBS package,
  • Arbitrary-order B-Spline functions as Ansatz spaces, as in the framework of isogeometric analysis for electromagnetics [1,5],
  • An embedded interpolation-based fast multipole method for compression [2,5], equivalent to the H2 matrix format,
  • openMP parallelized matrix assembly,
  • Full compatibility with the Eigen linear algebra library. If you are not familiar with Eigen3, we emphasize that you can use it similarly to Matlab or Octave, see here.

4. How to Run our Code

You need to install the Eigen3 library, see Eigen's Documentation for help. We do not rely on any other external libraries, except for the standard template library. Thus, having installed Eigen, Bembel should run out of the box. If you want to use Bembel as part of your application, simply add the Bembel/ directory to your includes.

If you want to run the provided examples and tests, you can utilize the procided CMakeLists.txt. We recommend setting up a build/ directory in the root directory of the Bembel, to switch to it and then to call cmake .. and make debug or make release, respectively.

The CMake-File checks for installations of Eigen via the corresponding Eigen3Config.cmake. On Unix you may run apt install libeigen3-dev, or on Mac with Homebrew brew install eigen, and everything should work. Alternatively, you can delete the line find_package (Eigen3 3.3 REQUIRED NO_MODULE) and all lines of the type target_link_librarires(... Eigen3::Eigen) from CMakeLists.txt, and give a path to the eigen headers as an include directory manually.

Then, the examples and tests should compile without any issues. You may run all tests by calling make test from the build/ directory after a successful compilation.

The geometry files required to run the examples can be found in the geo/ folder.

5. Structure of the Repository

The general structure of the repository looks as follows.

  • The root directory contains some helpful shell scripts.
  • assets/ only contains things relevant for GitHub pages.
  • geo/ contains geometry files in the format of the octave NURBS package. They can be utilized for computations. Note that the normal vector must be outward directed on all patches!
    • geo/octave_example/ includes .m files that showcase how geometries can be constructed using the NURBS package of octave.
  • Bembel/ contains the library. In Bembel/, module files have been created analogously to the design of the Eigen library. If Bembel is used, only these module files should be included. These modules are the following:
    • AnsatzSpace contains the files whose routines manage the discrete space on the surface of the geometry. Specifically, this is realised through the four classes Superspace, Projector, Glue, and AnsatzSpace. Therein, the Superspace manages local polynomial bases on every element. Through a transformation matrix generated by the template class Projector which depends on the LinearOperator and its defined traits, the Superspace can be related to B-Spline bases on every patch. To build conforming spaces (in the case of DifferentialForm::DivergenceConforming through continuity of the normal component across patch interfaces, and in the case of DifferentialForm::Continuous through global C0-continuity), the template class Glue assembles another transformation matrix to identify degrees of freedom across edges. Then, a coefficient vector in the Superspace can be related to one of the smooth B-Spline basis, as explained in [4,5].
    • ClusterTree implements an element structure for refinement. Currently, only uniform refinement has been implemented. A ClusterTree object itself is comprised of a Geometry object and an ElementTree. The ElementTree provides routines for the extraction of topological information, refinement, as well as iterators to effortlessly loop over elements.
    • DuffyTrick provides quadrature routines for (nearly) singular integrals. Therein, quadrature routines for 4 cases are implemented: Separated elements, elements sharing a corner, elements sharing an edge, and identical elements.
    • DummyOperator provides a LinearOperator for testing.
    • Geometry implements the handling of the geometry.
    • H2Matrix handles the compression of the large, densely populated matrices. The algorithm was introduced in [2] and was generalized to the Maxwell case in [5].
    • Helmholtz provides the necessary specializations to solve Helmholtz problems.
    • IO provides input-output functionality, including routines for VTK file export, timing, and writing log files.
    • Laplace provides the necessary specializations to solve Laplace problems.
    • LinearForm implements trace operators, i.e., routines to generate the right hand side of the linear systems. Currently, only a Dirichlet trace and a rotated tangential trace are provided.
    • LinearOperator provides a framework to implement linear operators that can be used to solve PDEs. Therein, the kernel function, a routine for the evaluation, and certain traits (like the scalar type, the operator order, and the DifferentialForm, i.e., weather the basis must be discontinuous, vector-valued and divergence conforming, or globally continuous) required for discretization must be provided.
    • Maxwell provides the necessary specializations to solve Maxwell problems.
    • Potential provides routines for the evaluation of the Potential, i.e., the solution to the PDE via the solution of (non-singular) integrals based on the LinearOperators.
    • Quadrature
    • Spline provided basic routines related to spline function and local polynomials.

The Bembel/src/ directory leads to folders corresponding to these modules, which include the actual implementation. The folder examples/ contains short and well documented examples for Bembels functionality and tests/ contains the tests for Bembel.

6. Documentation

A good place to start are the examples in the examples/ folder, together with publication [3]. Apart from that, a Doxygen documentation is available.

7. Known Bugs and Upcoming Features

For a list of known bugs and upcoming features, please have a look at the issue tracker on github.

8. Publications, Preprints, and how to cite

The following articles and preprints influenced the development of Bembel. We appreciate a citation of [3] if you use it in one of your articles.

[1] A. Buffa, J. Dölz, S. Kurz, S. Schöps, R. Vázques, and F. Wolf. Multipatch approximation of the de Rham sequence and its traces in isogeometric analysis. In: Numer. Math., 144, 201-236, 2020. To the paper. To the preprint.

[2] J. Dölz, H. Harbrecht, and M. Peters. An interpolation-based fast multipole method for higher-order boundary elements on parametric surfaces. In: Int. J. Numer. Meth. Eng., 108(13):1705-1728, 2016. To the paper.

[3] J. Dölz, H. Harbrecht, S. Kurz, M. Multerer, S. Schöps, and F. Wolf. Bembel: The Fast Isogeometric Boundary Element C++ Library for Laplace, Helmholtz, and Electric Wave Equation. In: SoftwareX, 11, 10476. To the paper.

[4] J. Dölz, H. Harbrecht, S. Kurz, S. Schöps, and F. Wolf. A fast isogeometric BEM for the three dimensional Laplace- and Helmholtz problems. In: Comput. Methods Appl. Mech. Engrg., 330:83-101, 2018. To the paper. To the preprint.

[5] J. Dölz, S. Kurz, S. Schöps, and F. Wolf. Isogeometric Boundary Elements in Electromagnetism: Rigorous Analysis, Fast Methods, and Examples. In: SIAM J. Sci. Comput., 41(5), B983-B1010, 2019. To the paper. To the preprint.

[6] J. Dölz, S. Kurz, S. Schöps, and F. Wolf. A Numerical Comparison of an Isogeometric and a Parametric Higher Order Raviart–Thomas Approach to the Electric Field Integral Equation. In: IEEE Trans. Antenn. Prop., 68(1), 593–597, 2020. To the paper. To the preprint.

[7] H. Harbrecht and M. Peters. Comparison of fast boundary element methods on parametric surfaces. In: Comput. Methods Appl. Mech. Engrg., 261-262:39-55, 2013. To the paper.

9. Contributors

Contributors include (alphabetically):

10. About the People

11. Funding

Work on Bembel was conducted with the following financial support (alphabetically):

  • DFG Grant KU1553/4-1,
  • DFG Grant SCHO1562/3-1,
  • The Graduate School of Computational Engineering at TU Darmstadt and the Excellence Initiative of the German Federal and State Governments and the Graduate School of Computational Engineering at TU Darmstadt,
  • SNSF Grant 137669,
  • SNSF Grant 156101,
  • SNSF Grant 174987.