Add generalized derivative and local-to-global adapter to handle the global derivatives uniformly

Summary

Cleanup of Gridfunctions, i.e. separate order, derivative and gridfunction concepts. Add generalized derivative with gradient, divergence and partial derivatives. Add a local-to-global adapter similar to the one found in dune-localfunctions.

Details

1. Cleanup of Gridfunctions: The GridFunctionConcepts is split into several parts, Order.hpp, Derivative.hpp and GridFunction.hpp for a cleaner structure. Thereby, the free functions order(), derivative() and localFunctions() now redirect to the corresponding member functions when those member functions are available.

2. Generalized derivatives: The function derivative() is extended by an argument characterizing the type of the derivative, i.e. tag::gradient, tag::divergence, or tag::partial where the last one accepts an argument for the component of the partial derivative. In order to determine the range type of the grid functions, a class DerivativeTraits is added, parametrized with the derivative type and the function signature. For the discrete function it is possible to calculate all three derivative types. This is tested in GradienTest finally.

3. Local-to-Global adapter: The calculation of global derivatives from local-basis and geometry Jacobians is abstracted and put into the new class LocalToGlobalBasisAdapter that performes cached evaluation of the local basis jacobians and geometry jacobians and the transforms those into global derivatives. This class can be used in the localoperators and is partially adapted already.

src/amdis/gridfunctions/DiscreteFunction.inc.hpp

@@ -367,41 +367,6 @@ public:
 
     return dy;
   }
-
-private:
-  template <class T, class J, class RG>
-  void test_partial(std::vector<T> const& partial, std::size_t comp, J const& jacobian, RG const& referenceGradients) const
-  {
-    for (std::size_t i = 0; i < referenceGradients.size(); ++i) { // J^(-T) * D[phi] -> grad^T
-      auto grad = jacobian * Dune::MatVec::as_vector(referenceGradients[i]);
-      auto grad_ = Dune::Functions::flatVectorView(grad);
-
-      if (std::abs(grad_[comp] - partial[i]) > 1.e-10) {
-        print_error(partial[i], comp, grad, jacobian, referenceGradients[i][0]);
-        error_exit("wrong partial derivatives");
-      }
-    }
-  }
-
-  template <class T, class G, class J, class RG>
-  void print_error(T const& partial_i, std::size_t comp, G const& grad_i, J const& jacobian, RG const& referenceGradient) const
-  {
-    msg(__PRETTY_FUNCTION__);
-    msg("jacobian = {}", jacobian);
-    auto&& jacobian_mat = Dune::MatVec::as_matrix(jacobian);
-    msg("jacobian_ = [");
-    for (std::size_t i = 0; i < jacobian_mat.N(); ++i) {
-      for (std::size_t j = 0; j < jacobian_mat.M(); ++j) {
-        msg_("{} ",jacobian_mat[i][j]);
-      }
-      msg(";");
-    }
-    msg("]");
-
-    msg("ref-grad = {}", referenceGradient);
-    auto grad_ = Dune::Functions::flatVectorView(grad_i);
-    msg("comp = {}, grad_ = ({}, {}), partial = {}", comp, grad_[0], grad_[1], partial_i);
-  }
 };