Cosserat-Continuum-Nonplanar

@osander: Can you have a look here?

This MR cleans up the usage of MIXED_SPACE in cosserat-continuum.

Now all combinations of dim = dimworld or dim != dimworld and MIXED_SPACE = 0 or MIXED_SPACE = 1 at least compile.

Also, this MR points out the one combination that still can't be solved: Problems with dim != dimworld do not work for MIXED_SPACE = 1!

As soon as I need this for locking tests I will add this; I will have to change Nonplanarcosseratshellenergy so it can be assembled with the GFEMixedAssembler.

dune/gfe/geometries/moebiusstrip.hh

+#ifndef DUNE_GFE_MOEBIUSSTRIP_GRIDFUNCTION_HH
+#define DUNE_GFE_MOEBIUSSTRIP_GRIDFUNCTION_HH
+
+#include <cmath>
+
+#include <dune/common/fmatrix.hh>
+#include <dune/common/fvector.hh>
+#include <dune/curvedgrid/gridfunctions/analyticgridfunction.hh>
+
+namespace Dune {
+
+/// \brief Functor representing a Möbius strip in 3D, where the base circle is the circle in the x-y-plane with radius_ around 0,0,0
+template <class T = double>
+class MoebiusStripProjection
+{
+  static const int dim = 3;
+  using Domain = FieldVector<T,dim>;
+  using Jacobian = FieldMatrix<T,dim,dim>;
+
+  T radius_;
+
+public:
+  MoebiusStripProjection (T radius)
+    : radius_(radius)
+  {}
+
+  /// \brief Project the coordinate to the MS using closest point projection
+  Domain operator() (const Domain& x) const
+  {
+    double nrm = std::sqrt(x[0]*x[0] + x[1]*x[1]);
+    //center for the point x - it lies on the circle around (0,0,0) with radius radius_ in the x-y-plane
+    Domain center{x[0] * radius_/nrm, x[1] * radius_/nrm, 0}; 
+    double cosu = x[0]/nrm;
+    double sinu = x[1]/nrm;
+    double cosuhalf = std::sqrt((1+cosu)/2);
+    cosuhalf *= (sinu < 0) ? (-1) : 1 ; // u goes from 0 to 2*pi, so cosuhalf is negative if sinu < 0, we multiply that here
+    double sinuhalf = std::sqrt((1-cosu)/2); //u goes from 0 to 2*pi, so sinuhalf is always >= 0 
+
+    // now calculate line from center to the new point
+    // the direction is (cosuhalf*cosu,cosuhalf*sinu,sinuhalf), as can be seen from the formula to construct the MS, we normalize this vector
+    Domain centerToPointOnMS{cosuhalf*cosu,cosuhalf*sinu,sinuhalf};
+    centerToPointOnMS /= centerToPointOnMS.two_norm();
+
+    Domain centerToX = center - x;
+    // We need the length, let theta be the angle between the vector centerToX and center to centerToPointOnMS
+    // then cos(theta) = centerToX*centerToPointOnMS/(len(centerToX)*len(centerToPointOnMS))
+    // We want to project the point to MS, s.t. the angle between the MS and the projection is 90deg
+    // Then, length = cos(theta) * len(centerToX) = centerToX*centerToPointOnMS/len(centerToPointOnMS) = centerToX*centerToPointOnMS
+    double length = - centerToX * centerToPointOnMS;
+    centerToPointOnMS *= length;
+    return center + centerToPointOnMS;
+  }
+
+
+  /// \brief derivative of the projection to the MS
+  friend auto derivative (const MoebiusStripProjection& moebiusStrip)
+  {
+    DUNE_THROW(NotImplemented,"The derivative of the projection to the Möbius strip is not implemented yet!");
+    return [radius = moebiusStrip.radius_](const Domain& x)
+    {
+      Jacobian out;
+      return out;
+    };
+  }
+
+  /// \brief Normal Vector of the MS
+  Domain normal (const Domain& x) const
+  {
+    using std::sqrt;
+    Domain nVec = {x[0],x[1],0};
+    double nrm = std::sqrt(x[0]*x[0] + x[1]*x[1]);
+    double cosu = x[0]/nrm;
+    double sinu = x[1]/nrm;
+    double cosuhalf = std::sqrt((1+cosu)/2);
+    cosuhalf *= (sinu < 0) ? (-1) : 1 ; // u goes from 0 to 2*pi, so cosuhalf is negative if sinu < 0, we multiply that here
+    double sinuhalf = std::sqrt((1-cosu)/2);
+    nVec[2] = (-1)*cosuhalf*(cosu*x[0]+sinu*x[1])/sinuhalf;
+    nVec /= nVec.two_norm();
+    return nVec;
+  }
+
+  /// \brief The mean curvature of the MS
+  T mean_curvature (const Domain& /*x*/) const
+  {
+    DUNE_THROW(NotImplemented,"The mean curvature of the Möbius strip is not implemented yet!");
+    return 1;
+  }
+
+  /// \brief The area of the MS
+  T area () const
+  {
+    DUNE_THROW(NotImplemented,"The area of the Möbius strip is not implemented yet!");
+    return 1;
+  }
+};
+
+/// \brief construct a grid function representing the parametrization of a MS
+template <class Grid, class T>
+auto moebiusStripGridFunction (T radius)
+{
+  return analyticGridFunction<Grid>(MoebiusStripProjection<T>{radius});
+}
+
+} // end namespace Dune
+
+#endif // DUNE_GFE_MOEBIUSSTRIP_GRIDFUNCTION_HH