template <int dim> class FESubfaceValues;
template <int dim> class FESystem;
+/*!@addtogroup febase */
+/*@{*/
/**
* Common interface of all finite elements. Here, the functions to
friend class FESystem<dim>;
};
+/*@}*/
#endif
template<int dim> class FESystem;
+/*!@addtogroup febase */
+/*@{*/
/**
*/
friend class InternalDataBase;
};
-
+/*@}*/
template <int dim>
inline
template <int dim> class MappingQ;
+/*!@addtogroup fe */
+/*@{*/
+
/**
* Discontinuous finite elements based on Legendre polynomials.
*
template <int dim1> friend class FE_DGP;
/**
- * Allows @p{MappingQ} class to
+ * Allows @p{MappingQ} class
* access to build_renumbering
* function.
*/
friend class MappingQ<dim>;
};
+/*@}*/
// declaration of explicit specializations of member variables, if the
// compiler allows us to do that (the standard says we must)
template <int dim> class MappingQ;
+/*!@addtogroup fe */
+/*@{*/
+
/**
* Discontinuous finite elements evaluated at the mapped quadrature points.
*
friend class MappingQ<dim>;
};
+/*@}*/
// declaration of explicit specializations of member variables, if the
// compiler allows us to do that (the standard says we must)
template <int dim> class MappingQ;
+/*!@addtogroup fe */
+/*@{*/
+
/**
* Discontinuous tensor product elements based on equidistant support points.
*
template <int dim1> friend class MappingQ;
};
+/*@}*/
// declaration of explicit specializations of member variables, if the
// compiler allows us to do that (the standard says we must)
template <int dim> class MappingQ;
+/*!@addtogroup fe */
+/*@{*/
/**
* Implementation of continuous Nedelec elements for the space
template <int dim1> friend class FE_Nedelec;
};
+/*@}*/
/* -------------- declaration of explicit specializations ------------- */
template <int dim> class MappingQ;
+/*!@addtogroup fe */
+/*@{*/
/**
* Implementation of Lagrange finite elements @p{Qp} that yield the
template <int dim1> friend class FE_Q;
};
+/*@}*/
/* -------------- declaration of explicit specializations ------------- */
template <int dim> class MappingQ;
+/*!@addtogroup fe */
+/*@{*/
/**
* Implementation of Hierarchical finite elements @p{Qp} that yield the
template <int dim1> friend class FE_Q_Hierarchical;
};
+/*@}*/
/* -------------- declaration of explicit specializations ------------- */
template <int dim> class MappingQ;
+/*!@addtogroup fe */
+/*@{*/
/**
* Implementation of continuous Raviart-Thomas elements for the space
template <int dim1> friend class FE_RaviartThomas;
};
+/*@}*/
/* -------------- declaration of explicit specializations ------------- */
#include <utility>
+/*!@addtogroup febase */
+/*@{*/
+
/**
* This class provides an interface to group several elements together
* into one. To the outside world, the resulting object looks just
};
};
+/*@}*/
/* -------------- declaration of explicit specializations ------------- */
#include <vector>
#include <string>
+/*!@addtogroup febase */
+/*@{*/
+
/**
* This class performs interpolations and extrapolations of discrete
* functions of one @p{FiniteElement} @p{fe1} to another @p{FiniteElement}
get_fe_from_name_aux (const std::string &name);
};
-
+/*@}*/
/*---------------------------- fe_tools.h ---------------------------*/
/* end of #ifndef __deal2__fe_tools_H */
#include <base/config.h>
+/*!@addtogroup febase */
+/*@{*/
+
/**
* Provide a set of flags which tells the @p{FEValues<>::reinit}
* function, which fields are to be updated for each cell. E.g. if you
return result;
}
+/*@}*/
+
#endif
template <int dim> class Quadrature;
+/*!@addtogroup febase */
+/*@{*/
/**
* Contains all data vectors for @p{FEValues}.
void initialize (const UpdateFlags update_flags);
};
-
+/*@}*/
/*------------------------ Inline functions: FEValuesBase ------------------------*/
template <int dim> class FESubfaceValues;
+/*!@addtogroup febase */
+/*@{*/
+
/**
* Abstract base class for mapping classes.
*
friend class FESubfaceValues<dim>;
};
+/*@}*/
/* -------------- declaration of explicit specializations ------------- */
#include <fe/mapping_q.h>
+/*!@addtogroup fe */
+/*@{*/
+
/**
* Mapping class that uses C1 (continuously differentiable) cubic
* mappings of the boundary. This class is built atop of
std::vector<Point<dim> > &a) const;
};
+/*@}*/
/* -------------- declaration of explicit specializations ------------- */
#include <fe/mapping.h>
+/*!@addtogroup fe */
+/*@{*/
+
/**
* Mapping of an axis-parallel cell.
*
static const unsigned int invalid_face_number = static_cast<unsigned int>(-1);
};
-
+/*@}*/
/* -------------- declaration of explicit specializations ------------- */
template <int dim> class TensorProductPolynomials;
+/*!@addtogroup fe */
+/*@{*/
/**
* Mapping class that uses Qp-mappings on boundary cells. The mapping
static const bool use_mapping_q_on_all_cells = false;
};
+/*@}*/
/* -------------- declaration of explicit specializations ------------- */
#include <fe/mapping.h>
+/*!@addtogroup fe */
+/*@{*/
+
/**
* Mapping of general quadrilateral/hexahedra by d-linear shape
* functions.
static const unsigned int n_shape_functions = GeometryInfo<dim>::vertices_per_cell;
};
+/*@}*/
+
/*----------------------------------------------------------------------*/
template<int dim>
#include <fe/mapping_q1.h>
+/*!@addtogroup fe */
+/*@{*/
+
/**
* Eulerian mapping of general unit cells by d-linear shape
* functions. Each cell is thus shifted in space by values given to
};
+/*@}*/
#endif
{
public:
typedef TriaRawIterator<1,CellAccessor<1> > raw_line_iterator;
+ /**
+ * Iterator for lines.
+ */
typedef TriaIterator<1,CellAccessor<1> > line_iterator;
+ /**
+ * Iterator for active lines.
+ */
typedef TriaActiveIterator<1,CellAccessor<1> > active_line_iterator;
-
+
typedef void * raw_quad_iterator;
+ /**
+ * Iterator for quads. Void in 1D.
+ */
typedef void * quad_iterator;
+ /**
+ * Iterator for active quads. Void in 1D.
+ */
typedef void * active_quad_iterator;
typedef void * raw_hex_iterator;
+ /**
+ * Iterator for hexahedra. Void in 1D.
+ */
typedef void * hex_iterator;
+ /**
+ * Iterator for active hexahedra. Void in 1D.
+ */
typedef void * active_hex_iterator;
typedef raw_line_iterator raw_cell_iterator;
+ /**
+ * Iterator for cells.
+ */
typedef line_iterator cell_iterator;
+ /**
+ * Iterator active for cells.
+ */
typedef active_line_iterator active_cell_iterator;
typedef void * raw_face_iterator;
+ /**
+ * Iterator for faces. Void in 1D.
+ */
typedef void * face_iterator;
+ /**
+ * Iterator for active faces. Void in 1D.
+ */
typedef void * active_face_iterator;
};
{
public:
typedef TriaRawIterator<2,TriaObjectAccessor<1, 2> > raw_line_iterator;
+ /**
+ * Iterator for lines.
+ */
typedef TriaIterator<2,TriaObjectAccessor<1, 2> > line_iterator;
+ /**
+ * Iterator for active lines.
+ */
typedef TriaActiveIterator<2,TriaObjectAccessor<1, 2> > active_line_iterator;
typedef TriaRawIterator<2,CellAccessor<2> > raw_quad_iterator;
+ /**
+ * Iterator for quadrilaterals.
+ */
typedef TriaIterator<2,CellAccessor<2> > quad_iterator;
+ /**
+ * Iterator for active quadrilaterals.
+ */
typedef TriaActiveIterator<2,CellAccessor<2> > active_quad_iterator;
typedef void * raw_hex_iterator;
+ /**
+ * Iterator for hexahedra. Void in 2D.
+ */
typedef void * hex_iterator;
+ /**
+ * Iterator for active hexahedra. Void in 2D.
+ */
typedef void * active_hex_iterator;
typedef raw_quad_iterator raw_cell_iterator;
+ /**
+ * Iterator for cells.
+ */
typedef quad_iterator cell_iterator;
+ /**
+ * Iterator for active cells.
+ */
typedef active_quad_iterator active_cell_iterator;
typedef raw_line_iterator raw_face_iterator;
+ /**
+ * Iterator for faces.
+ */
typedef line_iterator face_iterator;
+ /**
+ * Iterator for active faces.
+ */
typedef active_line_iterator active_face_iterator;
};
{
public:
typedef TriaRawIterator<3,TriaObjectAccessor<1, 3> > raw_line_iterator;
+ /**
+ * Iterator for lines.
+ */
typedef TriaIterator<3,TriaObjectAccessor<1, 3> > line_iterator;
+ /**
+ * Iterator for active lines.
+ */
typedef TriaActiveIterator<3,TriaObjectAccessor<1, 3> > active_line_iterator;
typedef TriaRawIterator<3,TriaObjectAccessor<2, 3> > raw_quad_iterator;
+ /**
+ * Iterator for quadrilaterals.
+ */
typedef TriaIterator<3,TriaObjectAccessor<2, 3> > quad_iterator;
+ /**
+ * Iterator for active quadrilaterals.
+ */
typedef TriaActiveIterator<3,TriaObjectAccessor<2, 3> > active_quad_iterator;
typedef TriaRawIterator<3,CellAccessor<3> > raw_hex_iterator;
+ /**
+ * Iterator for hexahedra.
+ */
typedef TriaIterator<3,CellAccessor<3> > hex_iterator;
+ /**
+ * Iterator for active hexahedra.
+ */
typedef TriaActiveIterator<3,CellAccessor<3> > active_hex_iterator;
typedef raw_hex_iterator raw_cell_iterator;
+ /**
+ * Iterator for cells.
+ */
typedef hex_iterator cell_iterator;
+ /**
+ * Iterator for active cells.
+ */
typedef active_hex_iterator active_cell_iterator;
typedef raw_quad_iterator raw_face_iterator;
+ /**
+ * Iterator for faces.
+ */
typedef quad_iterator face_iterator;
+ /**
+ * Iterator for active faces.
+ */
typedef active_quad_iterator active_face_iterator;
};
//
//-------------------------------------------------------------------------
+/**
+ * @defgroup grid Grid Handling
+ */
+
+/**
+ * @defgroup dofs Handling of degrees of freedom
+ */
+
+/**
+ * @defgroup febase Finite element access classes
+ */
+
+/**
+ * @defgroup fe Finite element shape functions
+ */
+
+/**
+ * @defgroup mg Multilevel support
+ */
+
+
//
//-------------------------------------------------------------------------
-/**
- * @defgroup LAC The Linear Algebra Classes
- * @brief All the classes for linear algebra
- * Bla bla bla
- * @{
- */
-
/**
* @defgroup Solvers Linear Solver classes
*
/**
* @defgroup Matrices Matrix classes
* @{
+ *
+ * All matrices in this library have a common minimal interface,
+ * defined through MATRIX. This interface consists of functions for
+ * multiplication with appropriate vectors.
+ *
*/
/**
* @defgroup Matrix1 Basic matrices
- */
+ *
+ * These are the actual matrix classes provided by deal.II. They all
+ * provide some interface for allocating memory and entering values.
+*/
/**
* @defgroup Preconditioners Preconditioners
* @}
*/
-
-
-/**
- * @}
- */