GitLab

For higher order finite elements or e.g. DG1 discretizations, we need vector values unknowns on the discretized domain.

Currently this is implemented (but not tested and most likely not functional!) by template parameters (ValueType) that could theoretically be set to std::array or similar.

As an alternative, we could extend the indexing functions by another dimension that refers to the nth element of such a vector valued unknown.

Example: To get the three DG1 unknowns at position x, y on a macro-face an indexing function call could look like this:

real_t dg1_a = data[ index< Level >( x, y, DG_CENTER, 0 ) ];
real_t dg1_b = data[ index< Level >( x, y, DG_CENTER, 1 ) ];
real_t dg1_c = data[ index< Level >( x, y, DG_CENTER, 2 ) ];

(Such mappings of course must be documented (which would be true for the templated approach as well).)

The function memory is simply extended to the required size.

Further advantages:

• the ValueType template parameter can be removed would be restricted to either float or double
• the memory layout (AoS vs SoA) can be easily switched by exchanging the indexing function(!) - this would not be possible with the ValueType-template approach

Disadvantages:

• we would restrict the function classes to unknowns of type real_t^N float^N or double^N (for uint_t typed functions we then need extra classes (but maybe that's not that bad anyway?))
• https://i10git.cs.fau.de/terraneo/tinyhhg/issues/34 would be really hard to solve (but uncertain if we ever need that)