* any dimension. Second order means that it integrates polynomials of
* third order exact. In general, a formula of order #n# exactly
* integrates polynomials of order #2n-1#.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class Quadrature {
* that every iterator which is once assigned to is a valid
* object. However, this assertion only holds in debug mode, when
* the #Assert# macro is switched on.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class DoFAccessor {
* multiple inheritance of #DoFLineAccessor# and #CellAccessor<1>#.
*
* The same concept is used with #DoFQuadAccessor# classes etc.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim, typename BaseClass>
class DoFLineAccessor : public DoFAccessor<dim>, public BaseClass {
* access to the neighbors and children as #DoFCellAccessor# objects
* rather than #CellAccessor# objects (the latter function was inherited
* from the #CellAccessor<dim># class).
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class DoFCellAccessor : public DoFSubstructAccessor<dim> {
* with two vectors, one working in-place. The operation of distribution undoes
* the condensation process in some sense, but it should be noted that it is not
* the inverse operation.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
class ConstraintMatrix {
public:
* function to the finite element space is applied. At present, only few
* places where this is used in the library come to mind to the author,
* namely the treating of boundary values in the #ProblemBase# class and
- * the interpolation in the #VectorCreator# collection. You should also
+ * the interpolation in the #VectorTools# collection. You should also
* look out for other places where explicit use of the ansatz points is
* made if you want to use elements of other classes. A hint may be the
* use of the #get_ansatz_points# and #get_face_ansatz_points# functions
* of this class.
*
+ * This also is used in some sense in the
+ * #DoFHandler::distribute_cell_to_dof_vector# where it is assumed that
+ * the degrees of freedom denote function values and not derivatives or
+ * the like.
+ *
* \item Vanishing of basis functions on faces: when projecting a function
* to the boundary, use if made of the assumption that all basis functions
* on a cell adjacent to the boundary vanish on the boundary except for those
* real space and $N_j(\vec \xi)$ is the value of the basis function associated
* with the $j$th corner point, on the unit cell at point $\vec \xi$. The sum
* over $j$ runs over all corner points.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class FELinear : public FiniteElement<dim> {
* gradient of a function be a #point# vector:
* #Point<dim> gradient_of_f (const Point<dim> &x)#. #Point#s have all
* functionality for this, e.g. scalar products, addition etc.
+ *
+ * @author Wolfgang Bangerth, 1997
*/
template <int dim>
class Point {
* certain fraction of the total error. If this fraction is 50 per cent,
* for example, the threshold is computed such that the cells with a
* criterion greater than the threshold together account for half of the
- * total error.
+ * total error. The definition of the fraction is a bit unintuitive, since
+ * the total error is the sum over all cells of the local contribution
+ * squared. We define that the fraction $\alpha$ be such that those
+ * elements with the greatest error are refined for which the condition
+ * $\sum \eta_K^2 \le \alpha\eta^2$ holds. Note that $\alpha$ is not
+ * squared. The sum runs over the mentioned
+ * cells, $\eta_K$ are the local error indicators and $\eta$ is the global
+ * indicator with $\eta^2 = \sum \eta_K^2$, with here the sum running over
+ * all cells.
*
* This strategy is more suited for singular functions and error
* functionals, but may lead to very slow convergence of the grid
* data members, offers comparison operators and the like), but has no
* functionality to actually dereference data. This is done in the derived
* classes.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class TriaAccessor {
/**
* Exception
*/
- DeclException0 (ExcRefineCellNotUsed);
- /**
- * Exception
- */
- DeclException0 (ExcRefineCellNotActive);
- /**
- * Exception
- */
DeclException1 (ExcInvalidNeighbor,
int,
<< "Neighbor indices must be between 0 and 2^dim-1, but "
* point to lines in #dim# space dimensions. There is a derived class
* for lines in one space dimension, in which case a line is also a cell
* and thus has much more functionality than in lower dimensions.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class LineAccessor : public TriaAccessor<dim> {
* to me). There is a derived class
* for quads in two space dimension, in which case a quad is also a cell
* and thus has much more functionality than in lower dimensions.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class QuadAccessor : public TriaAccessor<dim> {
* example they can be flagged for refinement, they have neighbors, they have
* the possibility to check whether they are at the boundary etc. This class
* offers access to all this data.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class CellAccessor : public TriaSubstructAccessor<dim> {
*/
bool active () const;
+ /**
+ * Exception
+ */
+ DeclException0 (ExcRefineCellNotActive);
+ /**
+ * Exception
+ */
+ DeclException0 (ExcCellFlaggedForRefinement);
+ /**
+ * Exception
+ */
+ DeclException0 (ExcCellFlaggedForCoarsening);
private:
/**
* Copy operator. This is normally
* the new point right into the middle of the given points, and
* #HyperBallBoundary<dim># creating a hyperball with given radius
* around a given center point.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class Boundary {
* \begin{itemize}
* \item It must have two members named #present_level# and #present_index#
* storing the address of the element in the triangulation presently
- *pointed to. Furthermore, the three #Tria{Raw| |Active}Iterator# classes
- *have to be friends to the accessor or these data members must be public.
+ * pointed to. Furthermore, the three #Tria{Raw| |Active}Iterator# classes
+ * have to be friends to the accessor or these data members must be public.
* \item It must have a constructor which takes 1. a #Triangulation<dim>*#,
* 2. and 3. and integer, denoting the initial level and index.
* \item For the #TriaIterator# and the #TriaActiveIterator# class, it must
* have a member function #bool used()#, for the latter a member function
- *#bool active()#.
+ * #bool active()#.
* \item It should not modify the #present_level# and #present_index# fields,
* since this is what the iterator classes do, but it should use them to
- *dereference the data it points to.
+ * dereference the data it points to.
* \item It must have void operators #++# and #--#.
* \end{itemize}
* Then the iterator is able to do what it is supposed to. All of the necessary
* the triangulation is concerned: the index in the level
* it belongs to. The level index is implicitely given by the position
* in the #lines.lines# list attached to the information of each level.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
class Line {
public:
* it belongs to. The level index is implicitely given by the position
* in the #quads.quads# list attached to the information of each level
* of the triangulation.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
class Quad {
public:
* Equation objects need only provide functions which set up the cell
* matrices and the cell right hand side. These are then automatically inserted
* into the global matrices and vectors.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class Equation {
/**
* An #Assembler# is a specialized version of a #DoFCellAccessor# which adds
* functionality to assemble global matrices and vectors from cell base ones.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class Assembler : public DoFCellAccessor<dim> {
* the boundary_values using the #MatrixTool::interpolate_boundary_values#
* function. See there for more information.
*
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class ProblemBase {
* backtracking nor whether it can be done with a stopping algorithm, if
* possible within polynomial time. This kind of numbering must be made
* upon construction of the coarse grid, unfortunately.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class DataIn {
* #set parametric# and #splot "filename" using 1:2:x# to get a 3d surface
* plot of the (#x-2#)th data set. For example, using #x=4# would mean to
* plot the second data set.
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class DataOut {
* once. If you only want to create a right hand side as above, there is
* a function in the #VectorCreator# class. The use of the latter may be
* useful if you want to create many right hand side vectors.
+ *
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class MatrixCreator {
* For the global $H_1$ norm and seminorm, the same rule applies as for the
* $L_2$ norm: compute the $l_2$ norm of the cell error vector.
* \end{itemize}
+ *
+ *
+ * @author Wolfgang Bangerth, 1998
*/
template <int dim>
class VectorTools {