Dune-CurvedSurfaceGrid - A Dune module for surface parametrization

This Dune module provides a meta-grid for wrapping other grid implementations and providing a curved geometry on each element, parametrized by a Dune-CurvedGeometry class.

For an overview about the CurvedSurfaceGrid and the CurvedGeometry, see also the presentation Dune-CurvedSurfaceGrid - A Dune module for surface parametrization.

Initial Example

(See example1.cc)

// 1. Construct a reference grid
auto refGrid = GmshReader< FoamGrid<2,3> >::read("sphere.msh");

// 2. Define the geometry mapping
auto sphere = [](const auto& x) { return x / x.two_norm(); };
auto sphereGF = analyticDiscreteFunction(sphere, *refGrid, order);

// 3. Wrap the reference grid to build a curved grid
CurvedSurfaceGrid grid{*refGrid, sphereGF};

At first, we have to create a reference grid that acts as a parametrization domain for the target curved grid. In the example, we use Dune-FoamGrid and read a piece-wise flat grid from a GMsh file sphere.msh.

In a second step, we describe the parametrization of the curved surface by a closest-point projection to the sphere with radius 1. This projection is given by a callable sphere and the wrapped into a grid-function by a call to analyticDiscreteFunction. This grid-function wrapper associated the lambda-expression with a grid and a polynomial order for the local interpolation of the projection into a Lagrange basis. This interpolation allows to obtain values and derivatives of the geometry mapping.

Finally, the reference grid and the parametrization together build the curved grid. This meta-grid CurvedSurfaceGrid implements the Dune grid interface and can thus be used as replacement for, e.g., the reference grid.

Two Different Geometry Mappings

The Dune-CurvedGeometry module provides two different geometry implementations that differ in the input and in the representation of the parametrization.

Parametrized-Geometry

The first one, ParametrizedGeometry, provides a geometry that locally interpolates a given projection function into a (Lagrange) basis on the reference element. This requires from the projection mapping just that it allows to map local coordinates in the reference element to global coordinates on the surface.

The CurvedSurfaceGrid constructs on request of the element geometry a LocalFiniteElement of Lagrange basis functions for the internal parametrization of the geometry. The ParametrizedGeometry is constructed, if the grid gets a polynomial order k > 0.

(See example2.cc)

// Construct a reference grid
auto refGrid = GmshReader< FoamGrid<2,3> >::read("sphere.msh");

// Define the geometry mapping
auto sphere = [](const auto& x) { return x / x.two_norm(); };

template <int order>
using Order_t = std::integral_constant<int,order>;

// Wrap the reference grid to build a curved grid
CurvedSurfaceGrid grid{*refGrid, sphere, Order_t<k>{}};

LocalFunction-Geometry

In case the projection is given as a differentiable mapping f, i.e., there exists a function derivative(f) returning a callable that gives the Jacobian of the mapping, the grid constructs a LocalFunctionGeometry on each element. This geometry is exactly parametrized with the mapping and its derivative, i.e., no additional interpolation is performed.

(See example3.cc)

auto gv = refGrid->leafGridView();

// Define a discrete grid-function on the reference grid
// with dim(range) = 3 and polynomial order k
auto f = discreteGridViewFunction<3>(gv, k);

// Interpolate the parametrization into the grid-function
Functions::interpolate(f.basis(), f.coefficients(), sphere);

// Wrap the reference grid and the grid-function
CurvedSurfaceGrid grid{*refGrid, f};