Rodin

Rodin is a lightweight and modular finite element framework which provides many of the associated functionalities that are needed when implementing shape and topology optimization algorithms. These functionalities range from refining and remeshing the underlying shape, to providing elegant mechanisms to specify and solve variational problems.

It is named after the French sculptor Auguste Rodin, considered the founder of modern sculpture.

The library is still in development. It is primarily maintained by Carlos Brito-Pacheco and was developed to generate examples for his ongoing PhD.

Any contributors are warmly encouraged and any help or comments are always appreciated!

Status

| Branch | Matrix | Tests | Code Coverage | Benchmarks | Documentation | |:-----------:|:--------:|:-----:|:-------------:|:----------:|:-------------:| | master | | | | | | | develop | | | | | |

Table of Contents

1. Building the project
2. Features
3. Third-Party integrations
4. Requirements
5. CMake options
6. Building the documentation

Building the project

git clone --recursive https://github.com/carlos-brito-pacheco/rodin cd rodin mkdir build && cd build cmake .. make -j4

Features

Embedded form language for FEM modelling

Rodin comes with a native C++20 form language for assembling and solving variational formulations.

For example, given a domain $\Omega$ with boundary $\Gamma := \partial \Omega$, the Poisson problem: math \left\{ \begin{aligned} -\Delta u &= f && \text{in } \Omega\\ u &= 0 && \text{on } \Gamma \ , \end{aligned} \right. has the associated weak formulation: math \text{Find} \ u \in H^1(\Omega) \quad \text{s.t.} \quad \forall v \in H^1_0(\Omega), \quad \int_\Omega \nabla u \cdot \nabla v \ dx = \int_\Omega f v \ dx, \quad \text{with } \quad H^1_0(\Omega) := \{ v \in H^1(\Omega) \mid v = 0 \text{ on } \Gamma \}

which can be quickly implemented via the following lines of code:

```c++

include

include

include

using namespace Rodin; using namespace Rodin::Geometry; using namespace Rodin::Variational;

int main(int, char**) { Mesh Omega; Omega = Omega.UniformGrid(Polytope::Type::Triangle, 16, 16); mesh.getConnectivity().compute(1, 2);

P1 Vh(Omega);

TrialFunction u(Vh); TestFunction v(Vh);

Solver::SparseLU solver;

Problem poisson(u, v); poisson = Integral(Grad(u), Grad(v)) - Integral(v) + DirichletBC(u, Zero()); poisson.solve(solver);

return 0; } ```

solution of the poisson equation.

Full high level mesh access and functionalities

Cell, Face, Vertex Iterators

The API offers full support for iteration over all polytopes of the mesh of some given dimension:

```c++ Mesh mesh; mesh = mesh.UniformGrid(Polytope::Type::Triangle, 16, 16); // 2D Mesh

for (auto it = mesh.getCell(); it; ++it) { // Access information about the cell }

for (auto it = mesh.getFace(); it; ++it) { // Access information about the face }

for (auto it = mesh.getVertex(); it; ++it) { // Access information about the vertex }

for (auto it = mesh.getPolytope(1); it; ++it) { // Access information about the face (face dimension in 2D is equal to 1) }

```

Full connectivity computation

Rodin is able to compute any connectivity information on the mesh. For example, the following computes the adjacency information from faces to cells:

```c++ Mesh mesh; mesh = mesh.UniformGrid(Polytope::Type::Triangle, 16, 16); // 2D Mesh

mesh.getConnectivity().compute(1, 2); ```

In general, this means that given a face, we are able to obtain the incident (neighboring) cells.

However, one can also compute any connectivity information on different dimensions. For example, for a mesh $\mathcal{T}_h \subset \mathbb{R}^d$, $d = 2$ of topological dimension $d$, we have:

```c++ // Compute connectivity between vertices and faces // i.e. Given a vertex, give me the incident edges mesh.getConnectivity().compute(0, 1);

// Compute connectivity between faces and cells // i.e. Given a vertex, give me the incident cells mesh.getConnectivity().compute(0, 2);

// Compute connectivity between faces // i.e. Given a face, give me the adjacent faces mesh.getConnectivity().compute(1, 1);

// Compute connectivity between cells // i.e. Given a cell, give me the adjacent cells mesh.getConnectivity().compute(2, 2);

// Compute connectivity between cells and faces // i.e. Given a cell, give me the adjacent faces mesh.getConnectivity().compute(2, 1);

// Etc. ```

Direct integration with Eigen solvers

Support for different finite elements

Support for different mesh and solution file formats

• MFEM
• MEDIT

Different quadrature formulae

Rodin supports different kinds of quadrature.

• Grundmann-Moeller

See here for the full list.

SubMesh support

Third-Party integrations

MMG

MMG is an open source software for bidimensional and tridimensional surface and volume remeshing.

• Loading the mesh: c++ MMG::Mesh Omega; Omega.load(meshFile, IO::FileFormat::MEDIT);

• Optimizing the mesh: c++ MMG::Optimizer().setHMax(hmax) // maximal edge size .setHMin(hmin) // minimal edge size .setGradation(hgrad) // ratio between two edges .setHausdorff(hausd) // curvature refinement .optimize(Omega);

Roadmap

List of features and modules that are in the works: - Discontinuous Galerkin methods - Rodin::Plot module - H1 - L2 - HDiv - HCurl - P2 - P0 - PETSc - METIS

Requirements

• CMake 3.16.0+
• Boost 1.74+

Any of these should be available for quick install from your standard package manager.

CMake options

| Option | Description | |------------------------|---------------------------------------------------| | RODINBUILDEXAMPLES | Builds the examples in the examples/ directory. | | RODINBUILDDOC | Builds the documentation using Doxygen | | RODINUSEMCSS | Builds the documentation using Doxygen and m.css | | RODINBUILDSRC | Build the Rodin source code | | RODINBUILDEXAMPLES | Build the Rodin examples | | RODINBUILDDOC | Build the Rodin documentation | | RODINUSEMCSS | Use m.css style documentation | | RODINWITHPLOT | Build the Rodin::Plot module | | RODINUSEMPI | Build with MPI support | | RODINUSEOPENMP | Build with OpenMP support | | RODINUSESUITESPARSE | Build with SuiteSparse support | | RODINSILENCEWARNINGS | Silence warnings outputted by Rodin | | RODINBUILDPY | Build Python bindings |

Building the documentation

See this page to see how to build the documentation.