Documentation: Added some more modules and summed them up in a mock file modules.hpp

include/ex/ex_dof_handler.hpp

@@ -27,7 +27,10 @@
 namespace betl2 {
   namespace fe {
     namespace ex {
-      /*! @brief Specialization of \ref DofHandler for \ref FESContinuity::Extended.
+      /*! @addtogroup dofhandlers
+       * @{
+       */
+      /*! @brief A class that distributes the degrees of freedom.
        *
        *  The degree of freedom handler creates and gives access to the finite element
        *  space. In addition it distributes the degree of freedoms using its member
@@ -184,6 +187,7 @@ namespace betl2 {
         //@}
 
       }; // end class DofHandler
+      /*! @} */
 
     } // end namespace ex
   } // end namespace fe

include/ex/ex_febasis.hpp

@@ -26,60 +26,6 @@
 #include "fe/fe_enumerators.hpp"
 #include "ex_data_set.hpp"
 
-// Definition of doxygen group
-/*! @defgroup febases Finite Element Basis
- *
- *  A finite element basis gives access to the number degrees of freedom for any entity.
- *  In addition, it needs to provide information about the type of basis (e.g.\ Lagrange).
- *  Finite element bases differentiate between two types:\ Fixed set of degrees of
- *  freedom and varying sets for entities with the same reference type.
- *
- *  In the former case any finite element basis needs to provide the following functions:
- *  @code
- *   // Approximation order of the basis functions
- *   static constexpr int approxOrder( );
- *
- *   // Type of finite element space
- *   static const betl2::fe::FEBasisType feBasisType( );
- *
- *   // Number of degrees of freedom associated 
- *   // with a reference type
- *   template< eth::base::RefElType RET >
- *   static constexpr size_type multiplicity( );
- *
- *   // Number of degrees of freedom associated 
- *   // with a reference type including its subentities
- *   template< eth::base::RefElType RET >
- *   static constexpr size_type numDofs( );
- *
- *   // Runtime support for multplicity
- *   static size_type multiplicity( const eth::base::RefElType );
- *   // Runtime support for numDofs
- *   static size_type numDofs( const eth::base::RefElType );
- *  @endcode
- *
- *  In the case of the extended implementation which allows for a varying set
- *  of degrees of freedom for entities with the same reference element type, any 
- *  finite element basis needs to provide the following functions:
- *  @code
- *   // A way to set the number of degrees of freedom
- *   template< int CODIM >
- *   void setMult( const entity_t<CODIM>&, size_type );
- *
- *   // Type of finite element space
- *   static const betl2::fe::FEBasisType feBasisType( );
- *
- *   // Number of degrees of freedom associated with an entity
- *   template< int CODIM >
- *   size_type multiplicity( const entity_t<CODIM>& ) const;
- * 
- *   // Total number of degrees of freedom associated with an element
- *   // (optionally implemented also for any entity)
- *   size_type numDofs( const element_t& ) const;
- *  @endcode
- *
- *  @sa \ref DofHandler, \ref FESpace, \ref FEBasisType, \ref ApproxOrder
- */
 
 namespace betl2 {
   namespace fe {

include/ex/ex_fespace.hpp

@@ -38,6 +38,10 @@
 namespace betl2 {
   namespace fe {
     namespace ex {
+
+      /*! @addtogroup fespaces
+       *  @{
+       */
       /*! @brief Class for a finite element space.
        *
        *  A finite element space class gives access to elements, indices
@@ -542,7 +546,8 @@ namespace betl2 {
                           );
           }
         };
-      }; // end struct FESpace
+      }; // end class FESpace
+      /*! @} */
 
 
       //==========================================================================

include/ex/modules.hpp

+// This file defines modules for doxygen. It has no use other than that.
+
+
+// -----------------------------------------------------------------------------
+// FINITE ELEMENT BASIS
+// -----------------------------------------------------------------------------
+
+/*! @defgroup febases Finite Element Basis
+ *
+ *  A finite element basis gives access to the number degrees of freedom for any entity.
+ *  In addition, it needs to provide information about the type of basis (e.g.\ Lagrange).
+ *  Finite element bases differentiate between two types:\ Fixed set of degrees of
+ *  freedom and varying sets for entities with the same reference type.
+ *
+ *  In the former case any finite element basis needs to provide the following functions:
+ *  @code
+ *   // Approximation order of the basis functions
+ *   static constexpr int approxOrder( );
+ *
+ *   // Type of finite element space
+ *   static const betl2::fe::FEBasisType feBasisType( );
+ *
+ *   // Number of degrees of freedom associated 
+ *   // with a reference type
+ *   template< eth::base::RefElType RET >
+ *   static constexpr size_type multiplicity( );
+ *
+ *   // Number of degrees of freedom associated 
+ *   // with a reference type including its subentities
+ *   template< eth::base::RefElType RET >
+ *   static constexpr size_type numDofs( );
+ *
+ *   // Runtime support for multplicity
+ *   static size_type multiplicity( const eth::base::RefElType );
+ *   // Runtime support for numDofs
+ *   static size_type numDofs( const eth::base::RefElType );
+ *  @endcode
+ *
+ *  In the case of the extended implementation which allows for a varying set
+ *  of degrees of freedom for entities with the same reference element type, any 
+ *  finite element basis needs to provide the following functions:
+ *  @code
+ *   // A way to set the number of degrees of freedom
+ *   template< int CODIM >
+ *   void setMult( const entity_t<CODIM>&, size_type );
+ *
+ *   // Type of finite element space
+ *   static const betl2::fe::FEBasisType feBasisType( );
+ *
+ *   // Number of degrees of freedom associated with an entity
+ *   template< int CODIM >
+ *   size_type multiplicity( const entity_t<CODIM>& ) const;
+ * 
+ *   // Total number of degrees of freedom associated with an element
+ *   // (optionally implemented also for any entity)
+ *   size_type numDofs( const element_t& ) const;
+ *  @endcode
+ *
+ *  @sa \ref dofhandlers, \ref fespaces,
+ *      \ref fe::FEBasisType, \ref fe::ApproxOrder
+ */
+
+
+// -----------------------------------------------------------------------------
+// DEGREE-OF-FREEDOM HANDLER
+// -----------------------------------------------------------------------------
+
+/*! @defgroup dofhandlers Degree-of-Freedom Handler
+ *
+ *  A Dof-Handler creates and gives access to a finite element space object
+ *  (\ref fespaces). It in addition distributes the degrees of freedom. The 
+ *  number of degrees of freedom is given by a finite element basis
+ *  (\ref febases).
+ *
+ *  @sa \ref fespaces, \ref febases
+ */
+
+
+// -----------------------------------------------------------------------------
+// FINITE ELEMENT SPACE
+// -----------------------------------------------------------------------------
+
+/*! @defgroup fespaces Finite Element Space
+ *
+ *  These classes provide access to elements, indices and degrees of freedom.
+ *  It also provides several functions for filtering both indices and degrees
+ *  of freedom from elements using an \ref Intersection.
+ *
+ *  In the case of varying number of degrees of freedom for the same reference
+ *  element type, a finite element space also gives access to the finite element
+ *  basis object.
+ *
+ *  @sa \ref dofhandlers, \ref febases
+ */
+