Many Comments, constructor without tangentials

argyrisTransformationMatrix.py

@@ -34,23 +34,23 @@ def writeBCRS(mat, path="argyrisTransformationMethods.txt"):
 
 E = SparseMatrix(21, 24, {(0, 0): eye(19), (19, 20): 1, (20, 22): 1})
 pprint(E)
-J_0 = Matrix(MatrixSymbol('J_0', 2, 2))
-J_1 = Matrix(MatrixSymbol('J_1', 2, 2))
-J_2 = Matrix(MatrixSymbol('J_2', 2, 2))
-Dir_0 = Matrix(MatrixSymbol('dir_0',2,2))
-Dir_1 = Matrix(MatrixSymbol('dir_1',2,2))
-Dir_2 = Matrix(MatrixSymbol('dir_2',2,2))
-ThetaDir_0 = Matrix(MatrixSymbol('thetaDir_0',3,3))
-ThetaDir_1 = Matrix(MatrixSymbol('thetaDir_1',3,3))
-ThetaDir_2 = Matrix(MatrixSymbol('thetaDir_2',3,3))
-
-
-Theta_0 = Matrix(MatrixSymbol('theta_0', 3, 3))
-Theta_1 = Matrix(MatrixSymbol('theta_1', 3, 3))
-Theta_2 = Matrix(MatrixSymbol('theta_2', 3, 3))
-B1 = Matrix(MatrixSymbol('b_0', 2, 2))
-B2 = Matrix(MatrixSymbol('b_1', 2, 2))
-B3 = Matrix(MatrixSymbol('b_2', 2, 2))
+J_0 = Matrix(MatrixSymbol('J^0', 2, 2))
+J_1 = Matrix(MatrixSymbol('J^1', 2, 2))
+J_2 = Matrix(MatrixSymbol('J^2', 2, 2))
+Dir_0 = Matrix(MatrixSymbol('dir^0',2,2))
+Dir_1 = Matrix(MatrixSymbol('dir^1',2,2))
+Dir_2 = Matrix(MatrixSymbol('dir^2',2,2))
+ThetaDir_0 = Matrix(MatrixSymbol('thetaDir^0',3,3))
+ThetaDir_1 = Matrix(MatrixSymbol('thetaDir^1',3,3))
+ThetaDir_2 = Matrix(MatrixSymbol('thetaDir^2',3,3))
+
+
+Theta_0 = Matrix(MatrixSymbol('theta^0', 3, 3))
+Theta_1 = Matrix(MatrixSymbol('theta^1', 3, 3))
+Theta_2 = Matrix(MatrixSymbol('theta^2', 3, 3))
+B1 = Matrix(MatrixSymbol('b^0', 2, 2))
+B2 = Matrix(MatrixSymbol('b^1', 2, 2))
+B3 = Matrix(MatrixSymbol('b^2', 2, 2))
 
 Dir = SparseMatrix(21, 21, {(0, 0): 1, (1, 1): Dir_0.T, (3, 3): ThetaDir_0, (6, 6): 1, (7, 7): Dir_1.T, (
     9, 9): ThetaDir_1, (12, 12): 1, (13, 13): Dir_2.T, (15, 15): ThetaDir_2, (18, 18): eye(3)})
@@ -90,4 +90,4 @@ print("==============================================================")
 print("start writing file")
 writeBCRS(V)
 #with open("argyrisMatrix.tex", 'w') as f:
-  #f.write(latex(V))
+ # f.write(latex(D.T*VC*E.T))

dune/functions/functionspacebases/c1_interpolate.hh

@@ -117,7 +117,6 @@ namespace Dune
 
             FiniteElementRange operator()(const LocalDomain &x) const
             {
-              // TODO deduce range of localF_
               const auto &y = visitor_ptr_->localF_(x);
               return FiniteElementRange(
                   flatVectorView(visitor_ptr_->nodeToRangeEntry_(node_, treePath_, y))[j_]);
@@ -166,7 +165,8 @@ namespace Dune
               // etc. But as far as I know, there are no fufem-classes using derivative
               // interpolation. This code should work if j_ == 0.
               // also assuming y has size dim (worldDimension)... necessary because y.size() returns
-              // 1 for FieldMatrix<F,1,dim> TODO solve this better ..
+              // 1 for FieldMatrix<F,1,dim>
+              //TODO Make this viable for Jacobians of other form ..
               for (std::size_t i = 0; i < dim; ++i)
                 ret[0][i] = flatVectorView(
                     visitor_ptr_->nodeToRangeEntry_(node_, treePath_, y))[j_ * dim + i];
@@ -259,6 +259,7 @@ namespace Dune
             auto interpolationCoefficients = std::vector<FiniteElementRangeField>();
             auto &&fe = node.finiteElement();
 
+            // TODO Test if this compatibility is still maintained
             // backward compatibility: for scalar basis functions and possibly vector valued
             // coefficients
             //                         (like used in dune-fufem for power bases) loop over the
@@ -269,14 +270,8 @@ namespace Dune
               // the selected component later on by modifying j. Maybe we
               // should avoid this naughty statefull lambda hack in favor
               // of a separate helper class.
-              // This is now implemented as CallableWithNTRE
+              // This is now implemented as CallableWithNTRE.
               std::size_t j = 0;
-              // TODO remove
-              //  auto localFj = [&](const LocalDomain& x){
-              //    const auto& y = localF_(x);
-              //    return FiniteElementRange(flatVectorView(nodeToRangeEntry_(node, treePath,
-              //    y))[j]);
-              //  };
 
               auto localFj = CallableWithNTRE(node, treePath, j, this);
 
@@ -303,8 +298,9 @@ namespace Dune
             }
             else // ( FiniteElement::Traits::LocalBasisType::Traits::dimRange != 1 )
             {
-              // for all other finite elements: use the FiniteElementRange directly for the
-              // interpolation
+              // TODO adapt this too, such that someone could implement hermite type FEs with
+              // dimRange != 1 for all other finite elements: use the FiniteElementRange directly
+              // for the interpolation
               auto localF = [&](const LocalDomain &x)
               {
                 const auto &y = localF_(x);

dune/functions/functionspacebases/hermitebasis.hh

@@ -28,15 +28,15 @@ namespace Dune
       /**
        * \brief Implements a transformation from pullbacks of reference basis functions to global
        * basisfunctions for Hermite elements. For more information, see
-       * dune-functions/dune/functions/functionspacebases/globalvaluedlocalfiniteelement.hh
+       * dune-functions/dune/functions/functionspacebases/globalvaluedlocalfiniteelement.hh and
+       * c1element/dune/functions/functionspacebases/lineartransformedlocalfinitelement.hh
        * Primary Template uses a sparse Matrix approach and the class
        * LinearTransformedLocalFiniteElement and is valid for all dimensions. Spezialized template
        * for dim == 1 and dim == 2 perform the transformation "by hand" using the class
-       * GlobalValuedLocalFiniteElementand are approx 1.4 times faster than primary template (for
-       * average evaluation time of shapefunction and local gradients with usual quad rule).
-       * \tparam dim dimension of the underlying grid
-       * \tparam useSpezialization whether to use the spezialized versions for dim 1 and 2. Ignored
-       * if dim == 3
+       * GlobalValuedLocalFiniteElementand. They are approx 1.4 times faster than primary template
+       * (for average binding + evaluation time of shapefunction and local gradients with usual quad
+       * rule). \tparam dim dimension of the underlying grid \tparam useSpezialization whether to
+       * use the spezialized versions for dim 1 and 2. Ignored if dim == 3
        */
 
       template <unsigned int dim, bool useSpecialization, class R = double>
@@ -47,6 +47,8 @@ namespace Dune
          *  Stores information that specify the directions of derivative dofs of an element
          *  Also stores, if those directions are modified (i.e. not the coordinate axes) and if they
          * are to be used for dirichlet interpolation (i.e. tangential)
+         * // TODO include a check, whether strong enforcement of Dirichlet conditions is possible
+         * and throw Error on call to isDirichlet if not
          */
         template <class Element>
         class ElementInformation
@@ -75,9 +77,9 @@ namespace Dune
           }
 
           /**
-           * @brief return whether the some direction of vertex"th vertex was modified
-           * @param vertex
-           * @return bool
+           * \brief return whether the some direction of vertex"th vertex was modified
+           * \param vertex
+           * \return bool
            * */
           bool isModified(std::size_t vertex) const
           {
@@ -87,11 +89,11 @@ namespace Dune
             return ret;
           }
           /**
-           * @brief return whether the "direction"th direction of vertex"th vertex is a Dirichlet
+           * \brief return whether the "direction"th direction of vertex"th vertex is a Dirichlet
            * dof (i.e. is a tangential)
-           * @param vertex
-           * @param direction
-           * @return bool
+           * \param vertex
+           * \param direction
+           * \return bool
            */
           bool isDirichlet(std::size_t vertex, std::size_t direction) const
           {
@@ -101,11 +103,11 @@ namespace Dune
           }
 
           /**
-           * @brief return the dof corresponding to localKey is a Dirichlet
+           * \brief return the dof corresponding to localKey is a Dirichlet
            * dof (i.e. is a tangential)
-           * @param localKey
+           * \param localKey
            *
-           * @return bool
+           * \return bool
            */
           bool isDirichlet(LocalKey localKey) const
           {
@@ -122,10 +124,10 @@ namespace Dune
             DUNE_THROW(NotImplemented, "Invalid LocalKey");
           }
           /**
-           * @brief Get the Derivative Directions object, and array storing the directions of
+           * \brief Get the Derivative Directions object, and array storing the directions of
            * derivative dofs as rows of a fieldmatrix for each vertex
            *
-           * @return std::array<FieldMatrix<ctype, dim, dim>, dim + 1> const&
+           * \return std::array<FieldMatrix<ctype, dim, dim>, dim + 1> const&
            */
           std::array<FieldMatrix<ctype, dim, dim>, dim + 1> const &getDerivativeDirections() const
           {
@@ -191,11 +193,11 @@ namespace Dune
         }
 
         /**
-         * @brief Create the transformationmatrix m
+         * \brief Create the transformationmatrix m
          *
-         * @tparam Geometry
-         * @param geometry
-         * @return BCRSMatrix with size nDofs x nDofs
+         * \tparam Geometry
+         * \param geometry
+         * \return BCRSMatrix with size nDofs x nDofs
          *
          *      |1          0|} repeat
          *      |   J        |} dim + 1 times
@@ -239,6 +241,13 @@ namespace Dune
 
       public:
         static constexpr bool globalInterpolation = true;
+        /**
+         * \brief Class that evaluates the push forwards of the global nodes of a LocalFunction.
+         *        It stretches the LocalInterpolation interface, because we evaluate the derivatives
+         * of f
+         * \tparam LocalBasis Basis of the reference element, to get the Domain and RangeFieldType
+         * \tparam Element
+         */
         template <class LocalBasis, class Element>
         class GlobalInterpolation
         {
@@ -257,7 +266,6 @@ namespace Dune
           void bind(const LocalInterpolation &dummyForCompability, const Element &element,
                     const ElementInformation<Element> &elementInfo)
           {
-            element_ = &element;
             elementInfo_ = elementInfo;
           }
 
@@ -315,9 +323,10 @@ namespace Dune
           }
 
         protected:
-          const Element *element_; // TODO remove
           ElementInformation<Element> elementInfo_;
         };
+
+        // TODO remove this class, because it is not used anymore
         template <class Function, class LocalCoordinate, class Element>
         class LocalValuedFunction
         {
@@ -480,9 +489,20 @@ namespace Dune
         };
       };
 
+      // primary template
       template <typename GV, int dim, typename R>
-      class HermiteElementInformationMap
+      class HermiteElementInformationMap;
+      // specialization for dim == 2
+      /**
+       * \brief Class that creates a Mapping from Elements of a GridView to their ElementInformation
+       *
+       * \tparam GV GridView
+       * \tparam R Rangetype of the finite element
+       */
+      template <typename GV, typename R>
+      class HermiteElementInformationMap<GV, 2, R>
       {
+        static constexpr int dim = 2;
         using D = typename GV::ctype;
         using Element = typename GV::template Codim<0>::Entity;
         static_assert(GV::dimension == dim);
@@ -492,22 +512,28 @@ namespace Dune
         using IndexType = typename GV::IndexSet::IndexType;
 
       public:
-        HermiteElementInformationMap(GV const &gv)
-            : elementMapper_(gv, mcmgElementLayout()), elementInformation_(gv.size(0))
+        HermiteElementInformationMap(GV const &gv, bool useTangentials = true)
+            : elementMapper_(gv, mcmgElementLayout()), elementInformation_(),
+              useTangentials_(useTangentials)
         {
+          elementInformation_.resize(gv.size(0));
+          if (useTangentials_)
           fill(gv);
         }
 
         template <class Function>
         HermiteElementInformationMap(GV const &gv, Function const &f)
             : elementMapper_(gv, mcmgElementLayout()), elementInformation_(gv.size(0)),
-              tangentialMap(f)
+              tangentialMap_(f)
         {
           fill(gv);
+          useTangentials_ = true;
         }
 
         void update(GV const &gv)
         {
+          if (!useTangentials_)
+            return;
           elementInformation_.resize(gv.size(0));
           elementMapper_.update(gv);
           fill(gv);
@@ -516,10 +542,14 @@ namespace Dune
         template <class Element>
         const auto &find(const Element &element) const
         {
+          if (useTangentials_)
           return elementInformation_[elementMapper_.index(element)];
+          else
+            return defaultInfo_;
         }
 
       private:
+
         void fill(const GV &gv, std::enable_if_t<dim == 2, int> = 0)
         {
 
@@ -548,12 +578,12 @@ namespace Dune
                 auto startIndex = indexSet.subIndex(facet, 0, dim);
                 auto endIndex = indexSet.subIndex(facet, 1, dim);
 
-                if (tangentialMap)
+                if (tangentialMap_)
                 {
                   setVertexData(directionPerVertex[startIndex],
-                                tangentialMap(facet.geometry().corner(0)));
+                                tangentialMap_(facet.geometry().corner(0)));
                   setVertexData(directionPerVertex[endIndex],
-                                tangentialMap(facet.geometry().corner(1)));
+                                tangentialMap_(facet.geometry().corner(1)));
                 }
                 else
                 {
@@ -602,7 +632,11 @@ namespace Dune
 
         Dune::MultipleCodimMultipleGeomTypeMapper<GV> elementMapper_;
         std::vector<ElementInformation> elementInformation_;
-        std::function<GlobalCoordinate(GlobalCoordinate)> tangentialMap;
+        std::function<GlobalCoordinate(GlobalCoordinate)> tangentialMap_;
+        ElementInformation defaultInfo_;
+        bool useTangentials_;
+
+        // helper functions
         bool linearIndependent(Dune::FieldVector<D, 2> a, Dune::FieldVector<D, 2> b)
         { // write formula explicitly
           return std::abs(a.dot(Dune::FieldVector<D, dim>{-b[1], b[0]})) > 1e-14;
@@ -657,7 +691,7 @@ namespace Dune
         using IndexType = typename GV::IndexSet::IndexType;
 
       public:
-        HermiteElementInformationMap(GV const &gv)
+        HermiteElementInformationMap(GV const &gv, bool dummy)
         {
           std::array<Dune::FieldMatrix<D, 1, 1>, 2> dir;
           std::array<std::bitset<2>, 2> b;
@@ -691,7 +725,7 @@ namespace Dune
         using IndexType = typename GV::IndexSet::IndexType;
 
       public:
-        HermiteElementInformationMap(GV const &gv)
+        HermiteElementInformationMap(GV const &gv, bool dummy)
         {
           std::array<FieldMatrix<D, 3, 3>, 4> data;
           std::array<std::bitset<6>, 4> b;
@@ -784,7 +818,6 @@ namespace Dune
       using FiniteElement
           = Impl::LinearTransformedLocalFiniteElement<Impl::HermiteTransformator<dim, false, R>,
                                                       LocalValuedFE, Element>;
-      // TODO remove shared_ptr
       HermiteNode(const ElementInformationMap *elementInformationMap)
           : localValuedFiniteElement_(std::make_shared<LocalValuedFE>()),
             finiteElement_(std::make_shared<FiniteElement>()),
@@ -866,7 +899,8 @@ namespace Dune
 
     public:
       //! Constructor for a given grid view object
-      HermitePreBasis(const GV &gv) : gridView_(gv), elementInformationMap_(gv)
+      HermitePreBasis(const GV &gv, bool useTangential)
+          : gridView_(gv), elementInformationMap_(gv, useTangential), useDirections_(useTangential)
       {
         if (dim > 3)
           DUNE_THROW(Dune::NotImplemented, "HermitePreBasis only implemented for dim <= 3");
@@ -876,7 +910,7 @@ namespace Dune
       //! vertices
       template <class Function>
       HermitePreBasis(const GV &gv, Function const &f)
-          : gridView_(gv), elementInformationMap_(gv, f)
+          : gridView_(gv), elementInformationMap_(gv, f), useDirections_(true)
       {
         if (dim > 3)
           DUNE_THROW(Dune::NotImplemented, "HermitePreBasis only implemented for dim <= 3");
@@ -971,6 +1005,7 @@ namespace Dune
     protected:
       GridView gridView_;
       ElementInformationMap elementInformationMap_;
+      bool useDirections_ = true;
 
     }; // class HermitePreBasis
 
@@ -978,18 +1013,19 @@ namespace Dune
     {
 
       template <typename R = double, bool useSpecialization = false>
-      auto hermite()
+      auto hermite(bool useTangentials = true)
       {
-        return [](const auto &gridView)
+        return [=](const auto &gridView)
         {
-          return HermitePreBasis<std::decay_t<decltype(gridView)>, R, useSpecialization>(gridView);
+          return HermitePreBasis<std::decay_t<decltype(gridView)>, R, useSpecialization>(
+              gridView, useTangentials);
         };
       }
 
       template <class F, typename R = double, bool useSpecialization = false>
       auto hermite(F const &f)
       {
-        return [&](const auto &gridView) {
+        return [=](const auto &gridView) {
           return HermitePreBasis<std::decay_t<decltype(gridView)>, R, useSpecialization>(gridView,
                                                                                          f);
         };

dune/functions/functionspacebases/lineartransformedlocalfiniteelement.hh

@@ -73,7 +73,7 @@ namespace Dune
     /** \brief Example of LinearTransformation Interface
      *  \tparam F Field type
      *  \tparam size number of basisfunctions
-     *  TODO add ElementInformation, GlobalInterpolation
+     *  TODO add  GlobalInterpolation
      */
     template <class F, unsigned int size>
     struct IdentityTransformation
@@ -128,7 +128,8 @@ namespace Dune
       ScaledIdentityMatrix<F, size> m_;
     };
 
-    /** \brief Implementation of a dune-localfunctions LocalBasis that applies a transformation
+    /** \brief Implementation of a dune-localfunctions LocalBasis that applies a linear
+     * transformation
      *
      * \tparam Transformator The transformation that is to be applied
      * \tparam LocalValuedLocalBasis The local-valued LocalBasis that is getting transformed
@@ -142,7 +143,6 @@ namespace Dune
     public:
       using Traits = typename LocalValuedLocalBasis::Traits;
 
-      // LinearTransformedLocalBasis() : elementInformation_(), transformator_() {}
       /** \brief Bind the local basis to a particular grid element
        */
       void bind(const LocalValuedLocalBasis &localValuedLocalBasis, const Element &element,
@@ -253,6 +253,7 @@ namespace Dune
       const ElementInformation *elementInformation_;
     };
 
+    // SFINAE structure to enable two approaches for interpolation
     template <class LinearTransformator, class LocalValuedLFE, class Element, class Enable = void>
     struct LinearTransformedInterpolation
     {
@@ -276,20 +277,51 @@ namespace Dune
           LinearTransformator, typename LocalValuedLFE::Traits::LocalInterpolationType, Element>;
     };
 
+    /**
+     * @brief Class representing Linear transformed coefficients. This class mainly forwards the
+     * LocalCoefficient class of the reference finite element. Technically this is wrong! A linear
+     * transformation might change the Location of a degree of freedom! This class extends the
+     * LocalCoefficient interface by providing a binding methods, such that it can access the
+     * ElementInformation object, and provides methods to determine whether the ith degree of
+     * freedom is to be used when strongly incorporation Dirichlet or Clamped boundary conditions.
+     * This information is obtained from the ElementInformation object.
+     * @tparam LocalCoefficients
+     * @tparam ElementInformation
+     */
     template <class LocalCoefficients, class ElementInformation>
     class LinearTransformedLocalCoefficients: public LocalCoefficients
     {
 
     public:
-      LinearTransformedLocalCoefficients() : LocalCoefficients(), elementInfo_(nullptr) {}
       // TODO maybe variadic forward constructor
+      LinearTransformedLocalCoefficients() : LocalCoefficients(), elementInfo_(nullptr) {}
       void bind(ElementInformation const &elementInfo) { elementInfo_ = &elementInfo; }
 
+      /**
+       * @brief Wheter or not to use the ith dof when strongly incorporating Dirichlet Conditions.
+       * If the ElementInformation class does not implement a corresponding methods, this method
+       * will always return true. Also note that this methods will wrongly return true on inner
+       * dofs, too.
+       *
+       * @param i
+       * @return true
+       * @return false
+       */
       bool isDirichlet(std::size_t i) const
       {
         return isDirichletImpl(*elementInfo_, i, PriorityTag<42>());
       }
 
+      /**
+       * @brief Wheter or not to use the ith dof when strongly incorporating Clamped Conditions. If
+       * the ElementInformation class does not implement a corresponding methods, this method will
+       * always return true. Also note that this methods will wrongly return true on inner dofs,
+       * too.
+       *
+       * @param i
+       * @return true
+       * @return false
+       */
       bool isClamped(std::size_t i) const
       {
         return isClampedImpl(*elementInfo_, i, PriorityTag<42>());
@@ -337,7 +369,7 @@ namespace Dune
      * \tparam Transformator Class implementing linear transformations
      *  \tparam LocalValuedLFE LocalFiniteElement implementation whose values are to be
      * transformed
-     * \tparam Element Element where to transform the FE values to
+     * \tparam Element Element onto which the FE is transformed
      */
     template <class LinearTransformator, class LocalValuedLFE, class Element>
     class LinearTransformedLocalFiniteElement
@@ -359,6 +391,14 @@ namespace Dune
 
       LinearTransformedLocalFiniteElement() {}
 
+      /**
+       * @brief Binding routine. This binds all other objects of the LocalFiniteElement interface,
+       * as well as the Transformator.
+       *
+       * @param localValuedLFE
+       * @param element
+       * @param elementInfo
+       */
       void bind(const LocalValuedLFE &localValuedLFE, const Element &element,
                 const ElementInformation &elementInfo)
       {

dune/functions/functionspacebases/morleybasis.hh

@@ -19,12 +19,15 @@ namespace Dune
   {
     namespace Impl
     {
-      /** please doc me */
+      /** \brief Linear transformation that maps the reference basis onto the pull-backs of physical
+       * nodal basis for the Morley element \tparam R RangeFieldType of finite element
+       */
       template <class R>
       class MorleyTransformator
       {
       public:
-        /**please doc me
+        /** \brief class holding the orientation of normal derivatives
+         * \tparam Element Element type for compability
          */
         template <class Element>
         class ElementInformation
@@ -40,11 +43,11 @@ namespace Dune
           }
           std::array<R, 3> const &getEdgeOrientation() const { return edgeOrientation_; }
           /**
-           * @brief return the dof corresponding to localKey is a Dirichlet
+           * \brief return the dof corresponding to localKey is a Dirichlet
            * dof (i.e. is a tangential)
-           * @param localKey
+           * \param localKey
            *
-           * @return bool
+           * \return bool
            */
           bool isDirichlet(LocalKey localKey) const
           {
@@ -64,6 +67,14 @@ namespace Dune
 
         MorleyTransformator() : mat_(6, 6, BCRSMatrix<R>::random) { setupMatrix(); }
 
+        /**
+         * \brief binds the transformation to an element and its elementinformation
+         *        Fills the transformation Matrix.
+         *
+         * \tparam Element
+         * \param element
+         * \param elementInformation
+         */
         template <class Element>
         void bind(Element const &element, ElementInformation<Element> elementInformation)
         {
@@ -73,7 +84,16 @@ namespace Dune
               elementInformation.getEdgeOrientation()); // barycenter, because we need some value.
         }
 
-        // TODO remove unneccessary template parameters
+        /**
+         * \brief Apply the transformation to some Vector of Shapevalues, Jacobians or Hessians
+         *
+         * \tparam Values Vector
+         * \tparam LocalCoordinate Coordinate type in the reference element
+         * \tparam Geometry Affine Mapping
+         * \param values
+         * \param x
+         * \param geometry
+         */
         template <class Values, class LocalCoordinate, class Geometry>
         void apply(Values &values, LocalCoordinate const &x, Geometry const &geometry) const
         {
@@ -117,7 +137,6 @@ namespace Dune
           // from the global normals/tangents normalize
 
           // get local and global Tangents
-          // TODO maybe it is possible to move this to a function that is called on bind()
           auto refElement = Dune::referenceElement<double, 2>(geometry.type());
           for (std::size_t i = 0; i < 3; ++i)
           {
@@ -168,7 +187,7 @@ namespace Dune
         BCRSMatrix<R> mat_;
 
       public:
-        // TODO find a better name
+        // TODO remove, this class is not used anymore
         /** \brief Wrapper that is evaluated by LocalInterpolation as if it was evaluated by
          * GlobalInterpolation */
         template <class Function, class LocalCoordinate, class Element>
@@ -235,6 +254,13 @@ namespace Dune
           }
         }; // LocalValuedFunction
 
+        /**
+         * \brief Class that evaluates the push forwards of the global nodes of a LocalFunction.
+         *        It stretches the LocalInterpolation interface, because we evaluate the derivatives
+         * of f
+         * \tparam LocalBasis Basis of the reference element, to get the Domain and RangeFieldType
+         * \tparam Element
+         */
         static constexpr bool globalInterpolation = true;
         template <class LocalBasis, class Element>
         class GlobalInterpolation

dune/functions/functionspacebases/test/argyristest.cc

@@ -164,7 +164,7 @@ int main(int argc, char *argv[])
     auto gridView = grid->leafGridView();
     std::cout << "Grid has " << gridView.size(0) << " elementes and " << gridView.size(1)
               << " facettes and " << gridView.size(2) << " vertices" << std::endl;
-    using GridView = decltype(gridView);
+    // using GridView = decltype(gridView);
     {
       using namespace Dune::Functions::BasisFactory;
       auto basis = makeBasis(gridView, argyris());

dune/functions/utility/printbasis.hh

@@ -298,7 +298,7 @@ namespace Dune
         else if (key.codim() == dim - 1) // suppose this is normal derivative dof //TODO this is not
                                          // valid for the vast majority of finite elements
         {
-          // TODO
+          // TODO implement some printing of the normal dofs
         }
       }
       for (int i = 0; i < geo.corners(); ++i)

dune/localfunctions/hermite.hh

@@ -31,7 +31,6 @@ namespace Dune
        \tparam R Type to represent the field in the range
        \tparam dim Dimension of the domain simplex
     */
-    // TODO Singleton pattern for matrix, change to PolynomialBasis
     template <class D, class R, unsigned int dim>
     class HermiteLocalBasis:
         public PolynomialBasisWithMatrix<StandardEvaluator<VirtualMonomialBasis<dim, D>>,
@@ -213,7 +212,6 @@ namespace Dune
 
     protected:
       // TODO make this viable for general matrices
-      // TODO maybe make this part of a baseclass that also can be used by Argyris
       template <class DerivativeType, class FieldType>
       FieldType getPartialDerivative(DerivativeType const &df,
                                      std::size_t i) const

dune/localfunctions/morley.hh

@@ -83,8 +83,6 @@ namespace Dune
         edgeOrientation_ = other.edgeOrientation_;
       }
 
-      // TODO copy assignment, move?
-
       static unsigned int size() { return coeffSize; }
 
       /** \brief Evaluate values of all shape functions at a given point