]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Fix some comment. Wrap around a larger number of other comments, to
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Thu, 25 Jul 2002 14:37:55 +0000 (14:37 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Thu, 25 Jul 2002 14:37:55 +0000 (14:37 +0000)
make lines somewhat shorter.

git-svn-id: https://svn.dealii.org/trunk@6284 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/deal.II/include/grid/tria_accessor.h

index 1dced5daeac2db42de450d7de82e3d9c0f3e4ec5..8e68051e59e9d8098afdac534fd320f39549eaa8 100644 (file)
@@ -66,12 +66,13 @@ class TriaAccessor
 {
   protected:
                                     /**
-                                     * Declare the data type that this accessor
-                                     * class expects to get passed from the
-                                     * iterator classes. Since the pure
-                                     * triangulation iterators need no
-                                     * additional data, this data type is
-                                     * @p{void}.
+                                     * Declare the data type that
+                                     * this accessor class expects to
+                                     * get passed from the iterator
+                                     * classes. Since the pure
+                                     * triangulation iterators need
+                                     * no additional data, this data
+                                     * type is @p{void}.
                                      */
     typedef void AccessorData;
 
@@ -89,14 +90,15 @@ class TriaAccessor
                    tria (parent) {};
 
                                     /**
-                                     *  Copy operator. Since this is only
-                                     *  called from iterators, do not
-                                     *  return anything, since the
-                                     *  iterator will return itself.
+                                     *  Copy operator. Since this is
+                                     *  only called from iterators,
+                                     *  do not return anything, since
+                                     *  the iterator will return
+                                     *  itself.
                                      *
-                                     *  This method is protected, since it
-                                     *  is only to be called from the
-                                     *  iterator class.
+                                     *  This method is protected,
+                                     *  since it is only to be called
+                                     *  from the iterator class.
                                      */
     void copy_from (const TriaAccessor &);
 
@@ -132,15 +134,7 @@ class TriaAccessor
     bool operator == (const TriaAccessor &) const;
        
                                     /**
-                                     *  Compare for inequality.
-                                     *
-                                     * Note that at times, there is a problem
-                                     * with egcs 1.1 that makes it choose
-                                     * the global STL operator != (which
-                                     * does only !(a==b)) over this
-                                     * one, which then results in an
-                                     * error because the operator == is
-                                     * not made public. Strange...
+                                     * Compare for inequality.
                                      */
     bool operator != (const TriaAccessor &) const;
     
@@ -158,30 +152,33 @@ class TriaAccessor
                                      */
                                     /*@{*/
                                     /**
-                                     *  Returns the level the element
+                                     *  Return the level the element
                                      *  pointed to belongs to.
                                      */
     int level () const;
     
                                     /**
-                                     *  Returns the index of the element
-                                     *  presently pointed to on the
-                                     *  present level.
+                                     *  Return the index of the
+                                     *  element presently pointed to
+                                     *  on the present level.
                                      */
     int index () const;
     
                                     /**
-                                     *  Return the state of the iterator.
-                                     *  For the different states an accessor 
-                                     *  can be in, refer to the
-                                     *  @ref{TriaRawIterator} documentation.
+                                     *  Return the state of the
+                                     *  iterator.  For the different
+                                     *  states an accessor can be in,
+                                     *  refer to the
+                                     *  @ref{TriaRawIterator}
+                                     *  documentation.
                                      */
     IteratorState::IteratorStates state () const;
 
                                     /**
-                                     * Return a pointer to the triangulation
-                                     * which the object pointed to by this
-                                     * class belongs to.
+                                     * Return a pointer to the
+                                     * triangulation which the object
+                                     * pointed to by this class
+                                     * belongs to.
                                      */
     const Triangulation<dim> & get_triangulation () const;
     
@@ -245,21 +242,22 @@ class TriaAccessor
        
   protected:
                                     /**
-                                     *  Used to store the level presently
-                                     *  pointed to.
+                                     *  Used to store the level
+                                     *  presently pointed to.
                                      */
     int present_level;
     
                                     /**
-                                     *  Used to store the index of the
-                                     *  element presently pointed to on
-                                     *  the level presentl used.
+                                     *  Used to store the index of
+                                     *  the element presently pointed
+                                     *  to on the level presentl
+                                     *  used.
                                      */
     int present_index;
     
                                     /**
-                                     *  Pointer to the triangulation which
-                                     *  we act on.
+                                     *  Pointer to the triangulation
+                                     *  which we act on.
                                      */
     const Triangulation<dim> *tria;
 
@@ -271,12 +269,12 @@ class TriaAccessor
 
 
 /**
- * Common template for line, quad, hex accessors.
- * According to @p{celldim} objects of this class represent lines,
- * quadrilaterals, or hexahedra in @p{dim} space dimensions. Concrete implementations
- * are done for specialized @p{celldim} template parameter. For easier access,
- * we nevertheless document all functions of the specialized classes here as
- * well. However, they are not implemented.
+ * Common template for line, quad, hex accessors.  According to
+ * @p{celldim} objects of this class represent lines, quadrilaterals,
+ * or hexahedra in @p{dim} space dimensions. Concrete implementations
+ * are done for specialized @p{celldim} template parameter. For easier
+ * access, we nevertheless document all functions of the specialized
+ * classes here as well. However, they are not implemented.
  *
  * @author Wolfgang Bangerth, Guido Kanschat, 1999
  */
@@ -285,8 +283,8 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
 {
   public:
                                     /**
-                                     * Propagate typedef from BaseClass
-                                     * to this class.
+                                     * Propagate typedef from
+                                     * base class to this class.
                                      */
     typedef typename TriaAccessor<dim>::AccessorData AccessorData;
 
@@ -302,35 +300,40 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                    TriaAccessor<dim> (parent, level, index, local_data) {};
 
                                     /**
-                                     *  Copy the data of a line. Only
-                                     * implemented for @p{celldim==1}.
+                                     * Copy the data of a line. Only
+                                     * implemented for
+                                     * @p{celldim==1}.
                                      */
 
     void set (const Line&) const;
     
                                     /**
-                                     *  Copy the data of the given quad. Only
-                                     * implemented for @p{celldim==2}.
+                                     * Copy the data of the given
+                                     * quad. Only implemented for
+                                     * @p{celldim==2}.
                                      */
     void set (const Quad&) const;
     
                                     /**
-                                     *  Copy the data of the given hex. Only
-                                     * implemented for @p{celldim==3}.
+                                     * Copy the data of the given
+                                     * hex. Only implemented for
+                                     * @p{celldim==3}.
                                      */
     void set (const Hexahedron&) const;
     
                                     /**
-                                     *  Index of vertex. The convention regarding the
-                                     *  numbering of vertices is laid down
-                                     *  in the documentation of the
-                                     *  @ref{Triangulation} class.
+                                     *  Index of vertex. The
+                                     *  convention regarding the
+                                     *  numbering of vertices is laid
+                                     *  down in the documentation of
+                                     *  the @ref{Triangulation}
+                                     *  class.
                                      */ 
     int vertex_index (const unsigned int i) const;
 
                                     /**
-                                     *  Const reference (not an iterator!)
-                                     *  to the @p{i}th vertex.
+                                     *  Return a reference to the
+                                     *  @p{i}th vertex.
                                      */
     Point<dim> & vertex (const unsigned int i) const;
 
@@ -345,7 +348,8 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                     /**
                                      * Line index of the @p{i}th
                                      * line. The level is naturally
-                                     * the same as that of the object.
+                                     * the same as that of the
+                                     * object.
                                      *
                                      * Implemented only for @p{celldim>1}.
                                      */
@@ -375,27 +379,31 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      *  iterators that are either
                                      *  normal iterators or active
                                      *  iterators, only raw iterators
-                                     *  can return @p{false}. Since raw
-                                     *  iterators are only used in
-                                     *  the interiors of the library,
-                                     *  you will not usually need
-                                     *  this function.
+                                     *  can return @p{false}. Since
+                                     *  raw iterators are only used
+                                     *  in the interiors of the
+                                     *  library, you will not usually
+                                     *  need this function.
                                      */
     bool used () const;
 
                                     /**
-                                     *  Set the @p{used} flag. You should know
-                                     *  quite exactly what you are doing of you
-                                     *  touch this function. It is exclusively
-                                     *  for internal use in the library.
+                                     *  Set the @p{used} flag. You
+                                     *  should know quite exactly
+                                     *  what you are doing of you
+                                     *  touch this function. It is
+                                     *  exclusively for internal use
+                                     *  in the library.
                                      */
     void set_used_flag () const;
 
                                     /**
-                                     *  Clear the @p{used} flag. You should know
-                                     *  quite exactly what you are doing of you
-                                     *  touch this function. It is exclusively
-                                     *  for internal use in the library.
+                                     *  Clear the @p{used} flag. You
+                                     *  should know quite exactly
+                                     *  what you are doing of you
+                                     *  touch this function. It is
+                                     *  exclusively for internal use
+                                     *  in the library.
                                      */
     void clear_used_flag () const;
 
@@ -439,12 +447,15 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
     void clear_user_pointer () const;
 
                                     /**
-                                     * Access the value of the user pointer. It is in the
-                                     * responsibility of the user to make
-                                     * sure that the pointer points to
-                                     * something useful. You should use the
-                                     * new style cast operator to maintain
-                                     * a minimum of typesafety, e.g.
+                                     * Access the value of the user
+                                     * pointer. It is in the
+                                     * responsibility of the user to
+                                     * make sure that the pointer
+                                     * points to something
+                                     * useful. You should use the new
+                                     * style cast operator to
+                                     * maintain a minimum of
+                                     * typesafety, e.g.
                                      * @p{A *a=static_cast<A*>(cell->user_pointer());}.
                                      */
     void * user_pointer () const;
@@ -458,74 +469,85 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
 
                                     /**
                                      *  Index of the @p{i}th child.
-                                     *  The level of the child is one higher
-                                     *  than that of the present cell.
-                                     *  If the child does not exist, -1
-                                     *  is returned.
+                                     *  The level of the child is one
+                                     *  higher than that of the
+                                     *  present cell.  If the child
+                                     *  does not exist, -1 is
+                                     *  returned.
                                      */
     int child_index (const unsigned int i) const;
 
                                     /**
                                      *  Set the child field. Since we
-                                     *  only store the index of the first
-                                     *  child (the others follow directly)
-                                     *  only one child index is to be
-                                     *  given. The level of the child is
-                                     *  one level up of the level of the
-                                     *  cell to which this iterator points.
+                                     *  only store the index of the
+                                     *  first child (the others
+                                     *  follow directly) only one
+                                     *  child index is to be
+                                     *  given. The level of the child
+                                     *  is one level up of the level
+                                     *  of the cell to which this
+                                     *  iterator points.
                                      */
     void set_children (const int index) const;
        
                                     /**
-                                     *  Clear the child field, i.e. set
-                                     *  it to a value which indicates
-                                     *  that this cell has no children.
+                                     *  Clear the child field,
+                                     *  i.e. set it to a value which
+                                     *  indicates that this cell has
+                                     *  no children.
                                      */
     void clear_children () const;
     
                                     /**
-                                     *  Test whether the object has children.
+                                     *  Test whether the object has
+                                     *  children.
                                      */
     bool has_children () const;
 
                                     /**
                                      * Number of times that this
-                                     * object is refined. Note that not all
-                                     * its children are refined that often
-                                     * (which is why we prepend @p{max_}), 
-                                     * the returned number is rather the
-                                     * maximum number of refinement in
-                                     * any branch of children of this object.
+                                     * object is refined. Note that
+                                     * not all its children are
+                                     * refined that often (which is
+                                     * why we prepend @p{max_}), the
+                                     * returned number is rather the
+                                     * maximum number of refinement
+                                     * in any branch of children of
+                                     * this object.
                                      */
     unsigned int max_refinement_depth () const;    
     
                                     /**
                                      * Boundary indicator of this
-                                     * object.
-                                     * If the return value is 255, then this
-                                     * line is in the interior of the domain.
+                                     * object.  If the return value
+                                     * is 255, then this line is in
+                                     * the interior of the domain.
                                      *
-                                     * Since boundary data is only useful
-                                     * for structures with a dimension less
-                                     * than the dimension of a cell, this
-                                     * function issues an error if @p{dim<4}.
+                                     * Since boundary data is only
+                                     * useful for structures with a
+                                     * dimension less than the
+                                     * dimension of a cell, this
+                                     * function issues an error if
+                                     * @p{dim<4}.
                                      */
     unsigned char boundary_indicator () const;
 
                                     /**
                                      * Set the boundary indicator.
                                      * The same applies as for the
-                                     * @p{boundary_indicator()} function.
+                                     * @p{boundary_indicator()}
+                                     * function.
                                      *
                                      * Caution: Never set the
-                                     * boundary indicator to 255, unless
-                                     * you exactly know what you are doing!
-                                     * This value is reserved for
-                                     * another purpose and algorithms may
-                                     * not work if boundary cells have have
-                                     * this boundary indicator or if interior
-                                     * cells have boundary indicators other
-                                     * than 255.
+                                     * boundary indicator to 255,
+                                     * unless you exactly know what
+                                     * you are doing!  This value is
+                                     * reserved for another purpose
+                                     * and algorithms may not work if
+                                     * boundary cells have have this
+                                     * boundary indicator or if
+                                     * interior cells have boundary
+                                     * indicators other than 255.
                                      */
     void set_boundary_indicator (unsigned char) const;
 
@@ -633,25 +655,28 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                     /**@name Advancement of iterators*/
                                     /*@{*/
                                     /**
-                                     *  This operator advances the iterator to
-                                     *  the next element.
+                                     *  This operator advances the
+                                     *  iterator to the next element.
                                      *
-                                     *  The next element is next on this
-                                     *  level if there are more. If the
-                                     *  present element is the last on
-                                     *  this level, the first on the
-                                     *  next level is accessed.
+                                     *  The next element is next on
+                                     *  this level if there are
+                                     *  more. If the present element
+                                     *  is the last on this level,
+                                     *  the first on the next level
+                                     *  is accessed.
                                      */
     void operator ++ ();
 
                                     /**
-                                     *  This operator moves the iterator to
-                                     *  the previous element.
+                                     *  This operator moves the
+                                     *  iterator to the previous
+                                     *  element.
                                      *
-                                     *  The previous element is previous on
-                                     *  this level if @p{index>0}. If the
-                                     *  present element is the first on
-                                     *  this level, the last on the
+                                     *  The previous element is
+                                     *  previous on this level if
+                                     *  @p{index>0}. If the present
+                                     *  element is the first on this
+                                     *  level, the last on the
                                      *  previous level is accessed.
                                      */
     void operator -- ();
@@ -666,22 +691,23 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
 
 
 /**
- * Closure class to stop induction of classes. Should never be called and thus
- * produces an error when created.
+ * Closure class to stop induction of classes. Should never be called
+ * and thus produces an error when created.
  */
 template<int dim>
 class TriaObjectAccessor<0, dim> : public TriaAccessor<dim>
 {
   public:
                                     /**
-                                     * Propagate typedef from BaseClass
-                                     * to this class.
+                                     * Propagate typedef from
+                                     * base class to this class.
                                      */
     typedef typename TriaAccessor<dim>::AccessorData AccessorData;
 
                                     /**
-                                     * Constructor. Should never be called and
-                                     * thus produces an error.
+                                     * Constructor. Should never be
+                                     * called and thus produces an
+                                     * error.
                                      */
     TriaObjectAccessor (const Triangulation<dim> *parent     =  0,
                        const int                 level      = -1,
@@ -696,10 +722,11 @@ class TriaObjectAccessor<0, dim> : public TriaAccessor<dim>
 
 
 /**
- *   Accessor to dereference the data of lines. This accessor is used to
- *   point to lines in @p{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 other dimensions.
+ *   Accessor to dereference the data of lines. This accessor is used
+ *   to point to lines in @p{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 other
+ *   dimensions.
  *
  *   @author Wolfgang Bangerth, 1998
  */
@@ -708,8 +735,8 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
 {
   public:
                                     /**
-                                     * Propagate typedef from BaseClass
-                                     * to this class.
+                                     * Propagate typedef from
+                                     * base class to this class.
                                      */
     typedef typename TriaAccessor<dim>::AccessorData AccessorData;
 
@@ -723,19 +750,20 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                    TriaAccessor<dim> (parent, level, index, local_data) {};
 
                                     /**
-                                     *  Copy the data of the given line.
+                                     *  Copy the data of the given
+                                     *  line.
                                      */
     void set (const Line &l) const;
 
                                     /**
-                                     *  Return the index of vertex @p{i=0,1}
-                                     *  of a line.
+                                     *  Return the index of vertex
+                                     *  @p{i=0,1} of a line.
                                      */ 
     int vertex_index (const unsigned int i) const;
 
                                     /**
-                                     *  Return a reference (not an iterator!)
-                                     *  to the @p{i}th vertex.
+                                     *  Return a reference to the
+                                     *  @p{i}th vertex.
                                      */
     Point<dim> & vertex (const unsigned int i) const;
 
@@ -746,23 +774,25 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      *  iterators that are either
                                      *  normal iterators or active
                                      *  iterators, only raw iterators
-                                     *  can return @p{false}. Since raw
-                                     *  iterators are only used in
-                                     *  the interiors of the library,
-                                     *  you will not usually need
-                                     *  this function.
+                                     *  can return @p{false}. Since
+                                     *  raw iterators are only used
+                                     *  in the interiors of the
+                                     *  library, you will not usually
+                                     *  need this function.
                                      */
     bool used () const;
 
                                     /**
-                                     *  Set the @p{used} flag. Only for
-                                     *  internal use in the library.
+                                     *  Set the @p{used} flag. Only
+                                     *  for internal use in the
+                                     *  library.
                                      */
     void set_used_flag () const;
 
                                     /**
-                                     *  Clear the @p{used} flag. Only for
-                                     *  internal use in the library.
+                                     *  Clear the @p{used} flag. Only
+                                     *  for internal use in the
+                                     *  library.
                                      */
     void clear_used_flag () const;
 
@@ -783,120 +813,138 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
     void clear_user_flag () const;
 
                                     /**
-                                     *  set the user flag of this object
-                                     *  and of all its children and their
-                                     *  children, etc.
+                                     *  Set the user flag of this
+                                     *  object and of all its
+                                     *  children and their children,
+                                     *  etc.
                                      */
     void recursively_set_user_flag () const;
 
                                     /**
-                                     *  Clear the user flag of this object
-                                     *  and of all its children and their
-                                     *  children, etc.
+                                     *  Clear the user flag of this
+                                     *  object and of all its
+                                     *  children and their children,
+                                     *  etc.
                                      */
     void recursively_clear_user_flag () const;
 
                                     /**
-                                     * Set the user pointer of this line
-                                     * to @p{p}.
+                                     * Set the user pointer of this
+                                     * line to @p{p}.
                                      */
     void set_user_pointer (void *p) const;
 
                                     /**
-                                     * Reset the user pointer of this line
-                                     * to a @p{NULL} pointer.
+                                     * Reset the user pointer of this
+                                     * line to a @p{NULL} pointer.
                                      */
     void clear_user_pointer () const;
 
                                     /**
-                                     * Access the value of the user pointer
-                                     * of this line. It is in the
-                                     * responsibility of the user to make
-                                     * sure that the pointer points to
-                                     * something useful. You should use the
-                                     * new style cast operator to maintain
-                                     * a minimum of typesafety, e.g.
+                                     * Access the value of the user
+                                     * pointer of this line. It is in
+                                     * the responsibility of the user
+                                     * to make sure that the pointer
+                                     * points to something
+                                     * useful. You should use the new
+                                     * style cast operator to
+                                     * maintain a minimum of
+                                     * typesafety, e.g.
                                      * @p{A *a=static_cast<A*>(cell->user_pointer());}.
                                      */
     void * user_pointer () const;
     
                                     /**
-                                     *  Return a pointer to the @p{i}th
-                                     *  child.
+                                     *  Return a pointer to the
+                                     *  @p{i}th child.
                                      */
     TriaIterator<dim,TriaObjectAccessor<1, dim> >
     child (const unsigned int i) const;
 
                                     /**
-                                     *  Return the index of the @p{i}th child.
-                                     *  The level of the child is one higher
-                                     *  than that of the present cell.
-                                     *  If the child does not exist, -1
+                                     *  Return the index of the
+                                     *  @p{i}th child.  The level of
+                                     *  the child is one higher than
+                                     *  that of the present cell.  If
+                                     *  the child does not exist, -1
                                      *  is returned.
                                      */
     int child_index (const unsigned int i) const;
 
                                     /**
                                      *  Set the child field. Since we
-                                     *  only store the index of the first
-                                     *  child (the others follow directly)
-                                     *  only one child index is to be
-                                     *  given. The level of the child is
-                                     *  one level up of the level of the
-                                     *  cell to which this iterator points.
+                                     *  only store the index of the
+                                     *  first child (the others
+                                     *  follow directly) only one
+                                     *  child index is to be
+                                     *  given. The level of the child
+                                     *  is one level up of the level
+                                     *  of the cell to which this
+                                     *  iterator points.
                                      */
     void set_children (const int index) const;
        
                                     /**
-                                     *  Clear the child field, i.e. set
-                                     *  it to a value which indicates
-                                     *  that this cell has no children.
+                                     *  Clear the child field,
+                                     *  i.e. set it to a value which
+                                     *  indicates that this cell has
+                                     *  no children.
                                      */
     void clear_children () const;
 
                                     /**
-                                     *  Test whether the line has children.
+                                     *  Test whether the line has
+                                     *  children.
                                      */
     bool has_children () const;
 
                                     /**
-                                     * Return the number of times that this
-                                     * cell is refined. Note that not all
-                                     * its children are refined that often
-                                     * (which is why we prepend @p{max_}), 
-                                     * the returned number is rather the
-                                     * maximum number of refinement in
-                                     * any branch of children of this object.
+                                     * Return the number of times
+                                     * that this cell is
+                                     * refined. Note that not all its
+                                     * children are refined that
+                                     * often (which is why we prepend
+                                     * @p{max_}), the returned number
+                                     * is rather the maximum number
+                                     * of refinement in any branch of
+                                     * children of this object.
                                      */
     unsigned int max_refinement_depth () const;
     
                                     /**
-                                     * Return the boundary indicator of this
-                                     * line. Since boundary data is only useful
-                                     * for structures with a dimension less
-                                     * than the dimension of a cell, this
-                                     * function issues an error if @p{dim<2}.
+                                     * Return the boundary indicator
+                                     * of this line. Since boundary
+                                     * data is only useful for
+                                     * structures with a dimension
+                                     * less than the dimension of a
+                                     * cell, this function issues an
+                                     * error if @p{dim<2}.
                                      *
-                                     * If the return value is 255, then this
-                                     * line is in the interior of the domain.
+                                     * If the return value is 255,
+                                     * then this line is in the
+                                     * interior of the domain.
                                      */
     unsigned char boundary_indicator () const;
 
                                     /**
-                                     * Set the boundary indicator of this line.
-                                     * The same applies as for the
-                                     * @p{boundary_indicator()} function.
+                                     * Set the boundary indicator of
+                                     * this line.  The same applies
+                                     * as for the
+                                     * @p{boundary_indicator()}
+                                     * function.
                                      *
-                                     * You should be careful with this function
-                                     * and especially never try to set the
-                                     * boundary indicator to 255, unless
-                                     * you exactly know what you are doing,
-                                     * since this value is reserved for
-                                     * another purpose and algorithms may
-                                     * not work if boundary cells have
-                                     * this boundary indicator or if interior
-                                     * cells have boundary indicators other
-                                     * than 255.
+                                     * You should be careful with
+                                     * this function and especially
+                                     * never try to set the boundary
+                                     * indicator to 255, unless you
+                                     * exactly know what you are
+                                     * doing, since this value is
+                                     * reserved for another purpose
+                                     * and algorithms may not work if
+                                     * boundary cells have this
+                                     * boundary indicator or if
+                                     * interior cells have boundary
+                                     * indicators other than 255.
                                      */
     void set_boundary_indicator (unsigned char) const;
 
@@ -948,34 +996,39 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
     Point<dim> center () const;
 
                                     /**
-                                     * Return the barycenter of the line,
-                                     * which is the midpoint. The same
-                                     * applies as for the @p{center} function
-                                     * with regard to lines at the boundary.
+                                     * Return the barycenter of the
+                                     * line, which is the
+                                     * midpoint. The same applies as
+                                     * for the @p{center} function
+                                     * with regard to lines at the
+                                     * boundary.
                                      */
     Point<dim> barycenter () const;
     
                                     /**
                                      * Return the length of the line.
-                                     * The same
-                                     * applies as for the @p{center} function
-                                     * with regard to lines at the boundary.
+                                     * The same applies as for the
+                                     * @p{center} function with
+                                     * regard to lines at the
+                                     * boundary.
                                      */
     double measure () const;
 
                                     /**
-                                     * Compute and return the number of
-                                     * children of this line. Actually,
-                                     * this function only counts the number
-                                     * of active children, i.e. the number
-                                     * if lines which are not further
-                                     * refined. Thus, if both of the two
-                                     * children of a line are further
-                                     * refined exactly once, the returned
-                                     * number will be four, not six.
+                                     * Compute and return the number
+                                     * of children of this
+                                     * line. Actually, this function
+                                     * only counts the number of
+                                     * active children, i.e. the
+                                     * number if lines which are not
+                                     * further refined. Thus, if both
+                                     * of the two children of a line
+                                     * are further refined exactly
+                                     * once, the returned number will
+                                     * be four, not six.
                                      *
-                                     * If the present cell is not refined,
-                                     * one is returned.
+                                     * If the present cell is not
+                                     * refined, one is returned.
                                      */
     unsigned int number_of_children () const;
     
@@ -1005,25 +1058,28 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                     /**@name Advancement of iterators*/
                                     /*@{*/
                                     /**
-                                     *  This operator advances the iterator to
-                                     *  the next element.
+                                     *  This operator advances the
+                                     *  iterator to the next element.
                                      *
-                                     *  The next element is next on this
-                                     *  level if there are more. If the
-                                     *  present element is the last on
-                                     *  this level, the first on the
-                                     *  next level is accessed.
+                                     *  The next element is next on
+                                     *  this level if there are
+                                     *  more. If the present element
+                                     *  is the last on this level,
+                                     *  the first on the next level
+                                     *  is accessed.
                                      */
     void operator ++ ();
 
                                     /**
-                                     *  This operator moves the iterator to
-                                     *  the previous element.
+                                     *  This operator moves the
+                                     *  iterator to the previous
+                                     *  element.
                                      *
-                                     *  The previous element is previous on
-                                     *  this level if @p{index>0}. If the
-                                     *  present element is the first on
-                                     *  this level, the last on the
+                                     *  The previous element is
+                                     *  previous on this level if
+                                     *  @p{index>0}. If the present
+                                     *  element is the first on this
+                                     *  level, the last on the
                                      *  previous level is accessed.
                                      */
     void operator -- ();
@@ -1038,11 +1094,11 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
 
 
 /**
- *   Accessor to dereference the data of quads. This accessor is used to
- *   point to quads in @p{dim} space dimensions (only @p{dim>=2} seems reasonable
- *   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 other dimensions.
+ *   Accessor to dereference the data of quads. This accessor is used
+ *   to point to quads in @p{dim} space dimensions (only @p{dim>=2}
+ *   seems reasonable 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 other dimensions.
  *
  *   @author Wolfgang Bangerth, 1998
  */
@@ -1051,8 +1107,8 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
 {
   public:
                                     /**
-                                     * Propagate typedef from BaseClass
-                                     * to this class.
+                                     * Propagate typedef from base
+                                     * class to this class.
                                      */
     typedef typename TriaAccessor<dim>::AccessorData AccessorData;
 
@@ -1071,31 +1127,35 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
     void set (const Quad &q) const;
     
                                     /**
-                                     *  Return index of vertex @p{i=0 through 3} of
-                                     *  a quad. The @p{i}th vertex is the common
-                                     *  one of line @p{i} and @p{(i+3)%4}. See also
-                                     *  the introduced convention
+                                     *  Return index of vertex @p{i=0
+                                     *  through 3} of a quad. The
+                                     *  @p{i}th vertex is the common
+                                     *  one of line @p{i} and
+                                     *  @p{(i+3)%4}. See also the
+                                     *  introduced convention
                                      *  (@ref{Triangulation}).
                                      */ 
     int vertex_index (const unsigned int i) const;
 
                                     /**
-                                     *  Return a reference (not an iterator!)
-                                     *  to the @p{i}th vertex.
+                                     *  Return a reference to the
+                                     *  @p{i}th vertex.
                                      */
     Point<dim> & vertex (const unsigned int i) const;
 
                                     /**
-                                     *  Return a pointer to the @p{i}th line
-                                     *  bounding this @ref{Quad}.
+                                     *  Return a pointer to the
+                                     *  @p{i}th line bounding this
+                                     *  @ref{Quad}.
                                      */
     TriaIterator<dim,TriaObjectAccessor<1, dim> >
     line (const unsigned int i) const;
 
                                     /**
-                                     * Return the line index of the @p{i}th
-                                     * side (a line). The level is naturally
-                                     * the same as that of the quad.
+                                     * Return the line index of the
+                                     * @p{i}th side (a line). The
+                                     * level is naturally the same as
+                                     * that of the quad.
                                      */
     unsigned int line_index (const unsigned int i) const;
     
@@ -1106,27 +1166,31 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      *  iterators that are either
                                      *  normal iterators or active
                                      *  iterators, only raw iterators
-                                     *  can return @p{false}. Since raw
-                                     *  iterators are only used in
-                                     *  the interiors of the library,
-                                     *  you will not usually need
-                                     *  this function.
+                                     *  can return @p{false}. Since
+                                     *  raw iterators are only used
+                                     *  in the interiors of the
+                                     *  library, you will not usually
+                                     *  need this function.
                                      */
     bool used () const;
 
                                     /**
-                                     *  Set the @p{used} flag. You should know
-                                     *  quite exactly what you are doing of you
-                                     *  touch this function. It is exclusively
-                                     *  for internal use in the library.
+                                     *  Set the @p{used} flag. You
+                                     *  should know quite exactly
+                                     *  what you are doing of you
+                                     *  touch this function. It is
+                                     *  exclusively for internal use
+                                     *  in the library.
                                      */
     void set_used_flag () const;
 
                                     /**
-                                     *  Clear the @p{used} flag. You should know
-                                     *  quite exactly what you are doing of you
-                                     *  touch this function. It is exclusively
-                                     *  for internal use in the library.
+                                     *  Clear the @p{used} flag. You
+                                     *  should know quite exactly
+                                     *  what you are doing of you
+                                     *  touch this function. It is
+                                     *  exclusively for internal use
+                                     *  in the library.
                                      */
     void clear_used_flag () const;
 
@@ -1137,7 +1201,8 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
     bool user_flag_set () const;
 
                                     /**
-                                     *  Flag the user flag for this cell.
+                                     *  Flag the user flag for this
+                                     *  cell.
                                      */
     void set_user_flag () const;
 
@@ -1147,39 +1212,43 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
     void clear_user_flag () const;
 
                                     /**
-                                     *  set the user flag of this object
-                                     *  and of all its children and their
-                                     *  children, etc.
+                                     *  Set the user flag of this
+                                     *  object and of all its
+                                     *  children and their children,
+                                     *  etc.
                                      */
     void recursively_set_user_flag () const;
 
                                     /**
-                                     *  Clear the user flag of this object
-                                     *  and of all its children and their
-                                     *  children, etc.
+                                     *  Clear the user flag of this
+                                     *  object and of all its
+                                     *  children and their children,
+                                     *  etc.
                                      */
     void recursively_clear_user_flag () const;
 
                                     /**
-                                     * Set the user pointer of this quad
-                                     * to @p{p}.
+                                     * Set the user pointer of this
+                                     * quad to @p{p}.
                                      */
     void set_user_pointer (void *p) const;
 
                                     /**
-                                     * Reset the user pointer of this quad
-                                     * to a @p{NULL} pointer.
+                                     * Reset the user pointer of this
+                                     * quad to a @p{NULL} pointer.
                                      */
     void clear_user_pointer () const;
 
                                     /**
-                                     * Access the value of the user pointer
-                                     * of this quad. It is in the
-                                     * responsibility of the user to make
-                                     * sure that the pointer points to
-                                     * something useful. You should use the
-                                     * new style cast operator to maintain
-                                     * a minimum of typesafety, e.g.
+                                     * Access the value of the user
+                                     * pointer of this quad. It is in
+                                     * the responsibility of the user
+                                     * to make sure that the pointer
+                                     * points to something
+                                     * useful. You should use the new
+                                     * style cast operator to
+                                     * maintain a minimum of
+                                     * typesafety, e.g.
                                      * @p{A *a=static_cast<A*>(cell->user_pointer());}.
                                      */
     void * user_pointer () const;
@@ -1191,75 +1260,89 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
     TriaIterator<dim,TriaObjectAccessor<2, dim> > child (const unsigned int i) const;
 
                                     /**
-                                     *  Return the index of the @p{i}th child.
-                                     *  The level of the child is one higher
-                                     *  than that of the present cell.
-                                     *  If the child does not exist, -1
+                                     *  Return the index of the
+                                     *  @p{i}th child.  The level of
+                                     *  the child is one higher than
+                                     *  that of the present cell.  If
+                                     *  the child does not exist, -1
                                      *  is returned.
                                      */
     int child_index (const unsigned int i) const;
 
                                     /**
                                      *  Set the child field. Since we
-                                     *  only store the index of the first
-                                     *  child (the others follow directly)
-                                     *  only one child index is to be
-                                     *  given. The level of the child is
-                                     *  one level up of the level of the
-                                     *  cell to which this iterator points.
+                                     *  only store the index of the
+                                     *  first child (the others
+                                     *  follow directly) only one
+                                     *  child index is to be
+                                     *  given. The level of the child
+                                     *  is one level up of the level
+                                     *  of the cell to which this
+                                     *  iterator points.
                                      */
     void set_children (const int index) const;
        
                                     /**
-                                     *  Clear the child field, i.e. set
-                                     *  it to a value which indicates
-                                     *  that this cell has no children.
+                                     *  Clear the child field,
+                                     *  i.e. set it to a value which
+                                     *  indicates that this cell has
+                                     *  no children.
                                      */
     void clear_children () const;
     
                                     /**
-                                     *  Test whether the quad has children.
+                                     *  Test whether the quad has
+                                     *  children.
                                      */
     bool has_children () const;
 
                                     /**
-                                     * Return the number of times that this
-                                     * cell is refined. Note that not all
-                                     * its children are refined that often
-                                     * (which is why we prepend @p{max_}), 
-                                     * the returned number is rather the
-                                     * maximum number of refinement in
-                                     * any branch of children of this object.
+                                     * Return the number of times
+                                     * that this cell is
+                                     * refined. Note that not all its
+                                     * children are refined that
+                                     * often (which is why we prepend
+                                     * @p{max_}), the returned number
+                                     * is rather the maximum number
+                                     * of refinement in any branch of
+                                     * children of this object.
                                      */
     unsigned int max_refinement_depth () const;
     
                                     /**
-                                     * Return the boundary indicator of this
-                                     * quad. Since boundary data is only useful
-                                     * for structures with a dimension less
-                                     * than the dimension of a cell, this
-                                     * function issues an error if @p{dim<3}.
+                                     * Return the boundary indicator
+                                     * of this quad. Since boundary
+                                     * data is only useful for
+                                     * structures with a dimension
+                                     * less than the dimension of a
+                                     * cell, this function issues an
+                                     * error if @p{dim<3}.
                                      *
-                                     * If the return value is 255, then this
-                                     * quad is in the interior of the domain.
+                                     * If the return value is 255,
+                                     * then this quad is in the
+                                     * interior of the domain.
                                      */
     unsigned char boundary_indicator () const;
 
                                     /**
-                                     * Set the boundary indicator of this quad.
-                                     * The same applies as for the
-                                     * @p{boundary_indicator()} function.
+                                     * Set the boundary indicator of
+                                     * this quad.  The same applies
+                                     * as for the
+                                     * @p{boundary_indicator()}
+                                     * function.
                                      *
-                                     * You should be careful with this function
-                                     * and especially never try to set the
-                                     * boundary indicator to 255, unless
-                                     * you exactly know what you are doing,
-                                     * since this value is reserved for
-                                     * another purpose and algorithms may
-                                     * not work if boundary cells have have
-                                     * this boundary indicator or if interior
-                                     * cells have boundary indicators other
-                                     * than 255.
+                                     * You should be careful with
+                                     * this function and especially
+                                     * never try to set the boundary
+                                     * indicator to 255, unless you
+                                     * exactly know what you are
+                                     * doing, since this value is
+                                     * reserved for another purpose
+                                     * and algorithms may not work if
+                                     * boundary cells have have this
+                                     * boundary indicator or if
+                                     * interior cells have boundary
+                                     * indicators other than 255.
                                      */
     void set_boundary_indicator (unsigned char) const;
 
@@ -1282,99 +1365,117 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
     bool at_boundary () const;
     
                                     /**
-                                     * Return the diameter of the quad. If the
-                                     * quad describes part of the boundary
-                                     * (e.g. if it is face to a cell in 3D)
-                                     * and is not a plane one, ask the
-                                     * finite element class for the correct
-                                     * length!
+                                     * Return the diameter of the
+                                     * quad. If the quad describes
+                                     * part of the boundary (e.g. if
+                                     * it is face to a cell in 3D)
+                                     * and is not a plane one, ask
+                                     * the finite element class for
+                                     * the correct length!
                                      *
-                                     * The diameter of a quad is computed to
-                                     * be the larger of the two diagonals. You
-                                     * should absolutely be clear about the
-                                     * fact that this definitely is not the
-                                     * diameter of all quadrilaterals; however
-                                     * it may serve as an approximation and
-                                     * is exact in many cases, especially
-                                     * if the quadrilateral is not too much
+                                     * The diameter of a quad is
+                                     * computed to be the larger of
+                                     * the two diagonals. You should
+                                     * absolutely be clear about the
+                                     * fact that this definitely is
+                                     * not the diameter of all
+                                     * quadrilaterals; however it may
+                                     * serve as an approximation and
+                                     * is exact in many cases,
+                                     * especially if the
+                                     * quadrilateral is not too much
                                      * distorted.
                                      */
     double diameter () const;
 
                                     /**
-                                     * Return the center of the quad. The
-                                     * center of a quad is defined to be
-                                     * the average of the four vertices,
-                                     * which is also the point where the
-                                     * bilinear mapping places the midpoint
-                                     * of the unit quad in real space.
-                                     * However, this may not be the point
-                                     * of the barycenter of the quad.
+                                     * Return the center of the
+                                     * quad. The center of a quad is
+                                     * defined to be the average of
+                                     * the four vertices, which is
+                                     * also the point where the
+                                     * bilinear mapping places the
+                                     * midpoint of the unit quad in
+                                     * real space.  However, this may
+                                     * not be the point of the
+                                     * barycenter of the quad.
                                      *
                                      * Also note that if you use
-                                     * higher order mappings from the unit
-                                     * cell to the real cell (in more than
-                                     * two space dimension), the bounding
-                                     * quads may not necessarily be straight.
-                                     * In that case ask the finite element
-                                     * class for the correct place of the
-                                     * midpoint of the quad in real space.
+                                     * higher order mappings from the
+                                     * unit cell to the real cell (in
+                                     * more than two space
+                                     * dimension), the bounding quads
+                                     * may not necessarily be
+                                     * straight.  In that case ask
+                                     * the finite element class for
+                                     * the correct place of the
+                                     * midpoint of the quad in real
+                                     * space.
                                      */
     Point<dim> center () const;
 
                                     /**
-                                     * Return the barycenter of the qaud. The
-                                     * same applies as for the @p{center} function
-                                     * with regard to quads at the boundary.
+                                     * Return the barycenter of the
+                                     * qaud. The same applies as for
+                                     * the @p{center} function with
+                                     * regard to quads at the
+                                     * boundary.
                                      */
     Point<dim> barycenter () const;
 
                                     /**
-                                     * Return the area of the quad. With
-                                     * area, we mean the area included by
-                                     * the straight lines connecting the
-                                     * four vertices, i.e. no information
+                                     * Return the area of the
+                                     * quad. With area, we mean the
+                                     * area included by the straight
+                                     * lines connecting the four
+                                     * vertices, i.e. no information
                                      * about the boundary is used; if
                                      * you want other than bilinearly
-                                     * mapped unit quadrilaterals, ask the
-                                     * appropriate finite element class
-                                     * for the area of this quad.
+                                     * mapped unit quadrilaterals,
+                                     * ask the appropriate finite
+                                     * element class for the area of
+                                     * this quad.
                                      */
     double measure () const;
 
                                     /**
-                                     * Compute and return the number of
-                                     * children of this quad. Actually,
-                                     * this function only counts the number
-                                     * of active children, i.e. the number
-                                     * if quads which are not further
-                                     * refined. Thus, if all of the four
-                                     * children of a quad are further
-                                     * refined exactly once, the returned
-                                     * number will be 16, not 20.
+                                     * Compute and return the number
+                                     * of children of this
+                                     * quad. Actually, this function
+                                     * only counts the number of
+                                     * active children, i.e. the
+                                     * number if quads which are not
+                                     * further refined. Thus, if all
+                                     * of the four children of a quad
+                                     * are further refined exactly
+                                     * once, the returned number will
+                                     * be 16, not 20.
                                      *
-                                     * If the present cell is not refined,
-                                     * one is returned.
+                                     * If the present cell is not
+                                     * refined, one is returned.
                                      */
     unsigned int number_of_children () const;
 
   private:
                                     /**
-                                     *  Copy operator. This is normally
-                                     *  used in a context like
-                                     *  @p{iterator a,b;  *a=*b;}. Since
-                                     *  the meaning is to copy the object
-                                     *  pointed to by @p{b} to the object
+                                     *  Copy operator. This is
+                                     *  normally used in a context
+                                     *  like @p{iterator a,b;
+                                     *  *a=*b;}. Since the meaning is
+                                     *  to copy the object pointed to
+                                     *  by @p{b} to the object
                                      *  pointed to by @p{a} and since
                                      *  accessors are not real but
-                                     *  virtual objects, this operation
-                                     *  is not useful for iterators on
-                                     *  triangulations. We declare this
-                                     *  function here private, thus it may
-                                     *  not be used from outside.
-                                     *  Furthermore it is not implemented
-                                     *  and will give a linker error if
-                                     *  used anyway.
+                                     *  virtual objects, this
+                                     *  operation is not useful for
+                                     *  iterators on
+                                     *  triangulations. We declare
+                                     *  this function here private,
+                                     *  thus it may not be used from
+                                     *  outside.  Furthermore it is
+                                     *  not implemented and will give
+                                     *  a linker error if used
+                                     *  anyway.
                                      */
     void operator = (const TriaObjectAccessor<2, dim> &);
 
@@ -1382,25 +1483,28 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                     /**@name Advancement of iterators*/
                                     /*@{*/
                                     /**
-                                     *  This operator advances the iterator to
-                                     *  the next element.
+                                     *  This operator advances the
+                                     *  iterator to the next element.
                                      *
-                                     *  The next element is next on this
-                                     *  level if there are more. If the
-                                     *  present element is the last on
-                                     *  this level, the first on the
-                                     *  next level is accessed.
+                                     *  The next element is next on
+                                     *  this level if there are
+                                     *  more. If the present element
+                                     *  is the last on this level,
+                                     *  the first on the next level
+                                     *  is accessed.
                                      */
     void operator ++ ();
 
                                     /**
-                                     *  This operator moves the iterator to
-                                     *  the previous element.
+                                     *  This operator moves the
+                                     *  iterator to the previous
+                                     *  element.
                                      *
-                                     *  The previous element is previous on
-                                     *  this level if @p{index>0}. If the
-                                     *  present element is the first on
-                                     *  this level, the last on the
+                                     *  The previous element is
+                                     *  previous on this level if
+                                     *  @p{index>0}. If the present
+                                     *  element is the first on this
+                                     *  level, the last on the
                                      *  previous level is accessed.
                                      */
     void operator -- ();
@@ -1415,10 +1519,10 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
 
 
 /**
- *   Accessor to dereference the data of hexahedra. This accessor is used to
- *   point to hexs in @p{dim} space dimensions (only @p{dim>=3} seems reasonable
- *   to me). There is a derived class
- *   for hexs in three space dimension, in which case a hex is also a cell
+ *   Accessor to dereference the data of hexahedra. This accessor is
+ *   used to point to hexs in @p{dim} space dimensions (only
+ *   @p{dim>=3} seems reasonable to me). There is a derived class for
+ *   hexs in three space dimension, in which case a hex is also a cell
  *   and thus has much more functionality than in other dimensions.
  *
  *   @author Wolfgang Bangerth, 1998
@@ -1428,8 +1532,8 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
 {
   public:
                                     /**
-                                     * Propagate typedef from BaseClass
-                                     * to this class.
+                                     * Propagate typedef from base
+                                     * class to this class.
                                      */
     typedef typename TriaAccessor<dim>::AccessorData AccessorData;
 
@@ -1443,50 +1547,57 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                    TriaAccessor<dim> (parent, level, index, local_data) {};
 
                                     /**
-                                     *  Copy the data of the given hex.
+                                     *  Copy the data of the given
+                                     *  hex.
                                      */
     void set (const Hexahedron &h) const;
     
                                     /**
-                                     *  Return index of vertex @p{i=0 through 7} of
-                                     *  a hex. The convention regarding the
-                                     *  numbering of vertices is laid down
-                                     *  in the documentation of the
-                                     *  @ref{Triangulation} class.
+                                     *  Return index of vertex @p{i=0
+                                     *  through 7} of a hex. The
+                                     *  convention regarding the
+                                     *  numbering of vertices is laid
+                                     *  down in the documentation of
+                                     *  the @ref{Triangulation}
+                                     *  class.
                                      */ 
     int vertex_index (const unsigned int i) const;
 
                                     /**
-                                     *  Return a reference (not an iterator!)
-                                     *  to the @p{i}th vertex.
+                                     *  Return a reference to the
+                                     *  @p{i}th vertex.
                                      */
     Point<dim> & vertex (const unsigned int i) const;
 
                                     /**
-                                     *  Return a pointer to the @p{i}th line
-                                     *  bounding this @p{Hex}.
+                                     *  Return a pointer to the
+                                     *  @p{i}th line bounding this
+                                     *  @p{Hex}.
                                      */
     TriaIterator<dim,TriaObjectAccessor<1, dim> >
     line (const unsigned int i) const;
 
                                     /**
-                                     * Return the line index of the @p{i}th
-                                     * line. The level is naturally
-                                     * the same as that of the hex.
+                                     * Return the line index of the
+                                     * @p{i}th line. The level is
+                                     * naturally the same as that of
+                                     * the hex.
                                      */
     unsigned int line_index (const unsigned int i) const;
     
                                     /**
-                                     *  Return a pointer to the @p{i}th quad
-                                     *  bounding this @p{Hex}.
+                                     *  Return a pointer to the
+                                     *  @p{i}th quad bounding this
+                                     *  @p{Hex}.
                                      */
     TriaIterator<dim,TriaObjectAccessor<2, dim> >
     quad (const unsigned int i) const;
 
                                     /**
-                                     * Return the quad index of the @p{i}th
-                                     * side (a quad). The level is naturally
-                                     * the same as that of the hex.
+                                     * Return the quad index of the
+                                     * @p{i}th side (a quad). The
+                                     * level is naturally the same as
+                                     * that of the hex.
                                      */
     unsigned int quad_index (const unsigned int i) const;
 
@@ -1497,27 +1608,31 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      *  iterators that are either
                                      *  normal iterators or active
                                      *  iterators, only raw iterators
-                                     *  can return @p{false}. Since raw
-                                     *  iterators are only used in
-                                     *  the interiors of the library,
-                                     *  you will not usually need
-                                     *  this function.
+                                     *  can return @p{false}. Since
+                                     *  raw iterators are only used
+                                     *  in the interiors of the
+                                     *  library, you will not usually
+                                     *  need this function.
                                      */
     bool used () const;
 
                                     /**
-                                     *  Set the @p{used} flag. You should know
-                                     *  quite exactly what you are doing of you
-                                     *  touch this function. It is exclusively
-                                     *  for internal use in the library.
+                                     *  Set the @p{used} flag. You
+                                     *  should know quite exactly
+                                     *  what you are doing of you
+                                     *  touch this function. It is
+                                     *  exclusively for internal use
+                                     *  in the library.
                                      */
     void set_used_flag () const;
 
                                     /**
-                                     *  Clear the @p{used} flag. You should know
-                                     *  quite exactly what you are doing of you
-                                     *  touch this function. It is exclusively
-                                     *  for internal use in the library.
+                                     *  Clear the @p{used} flag. You
+                                     *  should know quite exactly
+                                     *  what you are doing of you
+                                     *  touch this function. It is
+                                     *  exclusively for internal use
+                                     *  in the library.
                                      */
     void clear_used_flag () const;
 
@@ -1528,7 +1643,8 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
     bool user_flag_set () const;
 
                                     /**
-                                     *  Flag the user flag for this cell.
+                                     *  Flag the user flag for this
+                                     *  cell.
                                      */
     void set_user_flag () const;
 
@@ -1538,120 +1654,138 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
     void clear_user_flag () const;
 
                                     /**
-                                     *  set the user flag of this object
-                                     *  and of all its children and their
-                                     *  children, etc.
+                                     *  Set the user flag of this
+                                     *  object and of all its
+                                     *  children and their children,
+                                     *  etc.
                                      */
     void recursively_set_user_flag () const;
 
                                     /**
-                                     *  Clear the user flag of this object
-                                     *  and of all its children and their
-                                     *  children, etc.
+                                     *  Clear the user flag of this
+                                     *  object and of all its
+                                     *  children and their children,
+                                     *  etc.
                                      */
     void recursively_clear_user_flag () const;
 
                                     /**
-                                     * Set the user pointer of this hex
-                                     * to @p{p}.
+                                     * Set the user pointer of this
+                                     * hex to @p{p}.
                                      */
     void set_user_pointer (void *p) const;
 
                                     /**
-                                     * Reset the user pointer of this hex
-                                     * to a @p{NULL} pointer.
+                                     * Reset the user pointer of this
+                                     * hex to a @p{NULL} pointer.
                                      */
     void clear_user_pointer () const;
 
                                     /**
-                                     * Access the value of the user pointer
-                                     * of this hex. It is in the
-                                     * responsibility of the user to make
-                                     * sure that the pointer points to
-                                     * something useful. You should use the
-                                     * new style cast operator to maintain
-                                     * a minimum of typesafety, e.g.
+                                     * Access the value of the user
+                                     * pointer of this hex. It is in
+                                     * the responsibility of the user
+                                     * to make sure that the pointer
+                                     * points to something
+                                     * useful. You should use the new
+                                     * style cast operator to
+                                     * maintain a minimum of
+                                     * typesafety, e.g.
                                      * @p{A *a=static_cast<A*>(cell->user_pointer());}.
                                      */
     void * user_pointer () const;
 
                                     /**
-                                     *  Return a pointer to the @p{i}th
-                                     *  child.
+                                     *  Return a pointer to the
+                                     *  @p{i}th child.
                                      */
     TriaIterator<dim,TriaObjectAccessor<3, dim> >
     child (const unsigned int i) const;
 
                                     /**
-                                     *  Return the index of the @p{i}th child.
-                                     *  The level of the child is one higher
-                                     *  than that of the present cell.
-                                     *  If the child does not exist, -1
+                                     *  Return the index of the
+                                     *  @p{i}th child.  The level of
+                                     *  the child is one higher than
+                                     *  that of the present cell.  If
+                                     *  the child does not exist, -1
                                      *  is returned.
                                      */
     int child_index (const unsigned int i) const;
 
                                     /**
                                      *  Set the child field. Since we
-                                     *  only store the index of the first
-                                     *  child (the others follow directly)
-                                     *  only one child index is to be
-                                     *  given. The level of the child is
-                                     *  one level up of the level of the
-                                     *  cell to which this iterator points.
+                                     *  only store the index of the
+                                     *  first child (the others
+                                     *  follow directly) only one
+                                     *  child index is to be
+                                     *  given. The level of the child
+                                     *  is one level up of the level
+                                     *  of the cell to which this
+                                     *  iterator points.
                                      */
     void set_children (const int index) const;
        
                                     /**
-                                     *  Clear the child field, i.e. set
-                                     *  it to a value which indicates
-                                     *  that this cell has no children.
+                                     *  Clear the child field,
+                                     *  i.e. set it to a value which
+                                     *  indicates that this cell has
+                                     *  no children.
                                      */
     void clear_children () const;
     
                                     /**
-                                     *  Test whether the hex has children.
+                                     *  Test whether the hex has
+                                     *  children.
                                      */
     bool has_children () const;
 
                                     /**
-                                     * Return the number of times that this
-                                     * cell is refined. Note that not all
-                                     * its children are refined that often
-                                     * (which is why we prepend @p{max_}), 
-                                     * the returned number is rather the
-                                     * maximum number of refinement in
-                                     * any branch of children of this object.
+                                     * Return the number of times
+                                     * that this cell is
+                                     * refined. Note that not all its
+                                     * children are refined that
+                                     * often (which is why we prepend
+                                     * @p{max_}), the returned number
+                                     * is rather the maximum number
+                                     * of refinement in any branch of
+                                     * children of this object.
                                      */
     unsigned int max_refinement_depth () const;    
     
                                     /**
-                                     * Return the boundary indicator of this
-                                     * hex. Since boundary data is only useful
-                                     * for structures with a dimension less
-                                     * than the dimension of a cell, this
-                                     * function issues an error if @p{dim<4}.
+                                     * Return the boundary indicator
+                                     * of this hex. Since boundary
+                                     * data is only useful for
+                                     * structures with a dimension
+                                     * less than the dimension of a
+                                     * cell, this function issues an
+                                     * error if @p{dim<4}.
                                      *
-                                     * If the return value is 255, then this
-                                     * line is in the interior of the domain.
+                                     * If the return value is 255,
+                                     * then this line is in the
+                                     * interior of the domain.
                                      */
     unsigned char boundary_indicator () const;
 
                                     /**
-                                     * Set the boundary indicator of this hex.
-                                     * The same applies as for the
-                                     * @p{boundary_indicator()} function.
+                                     * Set the boundary indicator of
+                                     * this hex.  The same applies as
+                                     * for the
+                                     * @p{boundary_indicator()}
+                                     * function.
                                      *
-                                     * You should be careful with this function
-                                     * and especially never try to set the
-                                     * boundary indicator to 255, unless
-                                     * you exactly know what you are doing,
-                                     * since this value is reserved for
-                                     * another purpose and algorithms may
-                                     * not work if boundary cells have have
-                                     * this boundary indicator or if interior
-                                     * cells have boundary indicators other
-                                     * than 255.
+                                     * You should be careful with
+                                     * this function and especially
+                                     * never try to set the boundary
+                                     * indicator to 255, unless you
+                                     * exactly know what you are
+                                     * doing, since this value is
+                                     * reserved for another purpose
+                                     * and algorithms may not work if
+                                     * boundary cells have have this
+                                     * boundary indicator or if
+                                     * interior cells have boundary
+                                     * indicators other than 255.
                                      */
     void set_boundary_indicator (unsigned char) const;
 
@@ -1691,51 +1825,59 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
     double diameter () const;
 
                                     /**
-                                     * Return the center of the hex. The
-                                     * center of a hex is defined to be
-                                     * the average of the vertices,
-                                     * which is also the point where the
-                                     * trilinear mapping places the midpoint
-                                     * of the unit hex in real space.
-                                     * However, this may not be the point
-                                     * of the barycenter of the hex.
+                                     * Return the center of the
+                                     * hex. The center of a hex is
+                                     * defined to be the average of
+                                     * the vertices, which is also
+                                     * the point where the trilinear
+                                     * mapping places the midpoint of
+                                     * the unit hex in real space.
+                                     * However, this may not be the
+                                     * point of the barycenter of the
+                                     * hex.
                                      */
     Point<dim> center () const;
 
                                     /**
-                                     * Return the barycenter of the hex.
+                                     * Return the barycenter of the
+                                     * hex.
                                      */
     Point<dim> barycenter () const;
 
                                     /**
-                                     * Return the volume of the hex. With
-                                     * volume, we mean the area included by
-                                     * the hexahedron if its faces are
-                                     * supposed to be derived by a trilinear
-                                     * mapping from the unit cell, only using
-                                     * the location of the vertices.
+                                     * Return the volume of the
+                                     * hex. With volume, we mean the
+                                     * area included by the
+                                     * hexahedron if its faces are
+                                     * supposed to be derived by a
+                                     * trilinear mapping from the
+                                     * unit cell, only using the
+                                     * location of the vertices.
                                      * Therefore, no information
                                      * about the boundary is used; if
-                                     * you want other than trilinearly
-                                     * mapped unit hexahedra, ask the
-                                     * appropriate finite element class
-                                     * for the volume.
+                                     * you want other than
+                                     * trilinearly mapped unit
+                                     * hexahedra, ask the appropriate
+                                     * finite element class for the
+                                     * volume.
                                      */
     double measure () const;
 
                                     /**
-                                     * Compute and return the number of
-                                     * children of this hex. Actually,
-                                     * this function only counts the number
-                                     * of active children, i.e. the number
-                                     * if hexs which are not further
-                                     * refined. Thus, if all of the eight
-                                     * children of a hex are further
-                                     * refined exactly once, the returned
-                                     * number will be 64, not 80.
+                                     * Compute and return the number
+                                     * of children of this
+                                     * hex. Actually, this function
+                                     * only counts the number of
+                                     * active children, i.e. the
+                                     * number if hexs which are not
+                                     * further refined. Thus, if all
+                                     * of the eight children of a hex
+                                     * are further refined exactly
+                                     * once, the returned number will
+                                     * be 64, not 80.
                                      *
-                                     * If the present cell is not refined,
-                                     * one is returned.
+                                     * If the present cell is not
+                                     * refined, one is returned.
                                      */
     unsigned int number_of_children () const;
 
@@ -1744,18 +1886,20 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      *  Copy operator. This is normally
                                      *  used in a context like
                                      *  @p{iterator a,b;  *a=*b;}. Since
-                                     *  the meaning is to copy the object
-                                     *  pointed to by @p{b} to the object
-                                     *  pointed to by @p{a} and since
-                                     *  accessors are not real but
-                                     *  virtual objects, this operation
-                                     *  is not useful for iterators on
-                                     *  triangulations. We declare this
-                                     *  function here private, thus it may
-                                     *  not be used from outside.
-                                     *  Furthermore it is not implemented
-                                     *  and will give a linker error if
-                                     *  used anyway.
+                                     *  the meaning is to copy the
+                                     *  object pointed to by @p{b} to
+                                     *  the object pointed to by
+                                     *  @p{a} and since accessors are
+                                     *  not real but virtual objects,
+                                     *  this operation is not useful
+                                     *  for iterators on
+                                     *  triangulations. We declare
+                                     *  this function here private,
+                                     *  thus it may not be used from
+                                     *  outside.  Furthermore it is
+                                     *  not implemented and will give
+                                     *  a linker error if used
+                                     *  anyway.
                                      */
     void operator = (const TriaObjectAccessor<3, dim> &);
 
@@ -1763,25 +1907,28 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                     /**@name Advancement of iterators*/
                                     /*@{*/
                                     /**
-                                     *  This operator advances the iterator to
-                                     *  the next element.
+                                     *  This operator advances the
+                                     *  iterator to the next element.
                                      *
-                                     *  The next element is next on this
-                                     *  level if there are more. If the
-                                     *  present element is the last on
-                                     *  this level, the first on the
-                                     *  next level is accessed.
+                                     *  The next element is next on
+                                     *  this level if there are
+                                     *  more. If the present element
+                                     *  is the last on this level,
+                                     *  the first on the next level
+                                     *  is accessed.
                                      */
     void operator ++ ();
 
                                     /**
-                                     *  This operator moves the iterator to
-                                     *  the previous element.
+                                     *  This operator moves the
+                                     *  iterator to the previous
+                                     *  element.
                                      *
-                                     *  The previous element is previous on
-                                     *  this level if @p{index>0}. If the
-                                     *  present element is the first on
-                                     *  this level, the last on the
+                                     *  The previous element is
+                                     *  previous on this level if
+                                     *  @p{index>0}. If the present
+                                     *  element is the first on this
+                                     *  level, the last on the
                                      *  previous level is accessed.
                                      */
     void operator -- ();
@@ -1801,11 +1948,11 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
  *
  * The following refers to any space dimension:
  * 
- * This class allows access to a @em{cell}, which is a line in 1D and a quad in
- * 2D. Cells have more functionality than lines or quads by themselves, for
- * 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.
+ * This class allows access to a @em{cell}, which is a line in 1D and
+ * a quad in 2D. Cells have more functionality than lines or quads by
+ * themselves, for 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, 1999, 2000
  */
@@ -1829,32 +1976,35 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                    TriaObjectAccessor<dim,dim> (parent, level, index, local_data) {};
 
                                     /**
-                                     *  Return a pointer to the @p{i}th
-                                     *  neighbor.
-                                     *  If the neighbor does not exist, an
+                                     *  Return a pointer to the
+                                     *  @p{i}th neighbor.  If the
+                                     *  neighbor does not exist, an
                                      *  invalid iterator is returned.
                                      */
     TriaIterator<dim,CellAccessor<dim> >
     neighbor (const unsigned int i) const;
 
                                     /**
-                                     *  Return the index of the @p{i}th neighbor.
-                                     *  If the neighbor does not exist, its
+                                     *  Return the index of the
+                                     *  @p{i}th neighbor.  If the
+                                     *  neighbor does not exist, its
                                      *  index is -1.
                                      */
     int neighbor_index (const unsigned int i) const;
 
                                     /**
-                                     *  Return the level of the @p{i}th neighbor.
-                                     *  If the neighbor does not exist, its
+                                     *  Return the level of the
+                                     *  @p{i}th neighbor.  If the
+                                     *  neighbor does not exist, its
                                      *  level is -1.
                                      */
     int neighbor_level (const unsigned int i) const;
 
                                     /**
-                                     *  Set the neighbor @p{i} of this cell
-                                     *  to the cell pointed to by @p{pointer}.
-                                     *  This line must be used.
+                                     *  Set the neighbor @p{i} of
+                                     *  this cell to the cell pointed
+                                     *  to by @p{pointer}.  This line
+                                     *  must be used.
                                      */
     void set_neighbor (const unsigned int i,
                       const TriaIterator<dim,CellAccessor<dim> > &pointer) const;
@@ -1946,15 +2096,16 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
     bool has_boundary_lines () const;
 
                                     /**
-                                     *  Return whether the refinement flag
-                                     *  is set or not.
+                                     *  Return whether the refinement
+                                     *  flag is set or not.
                                      */
     bool refine_flag_set () const;
 
                                     /**
                                      *  Flag the cell pointed to fo
-                                     *  refinement. This function is only
-                                     *  allowed for active cells.
+                                     *  refinement. This function is
+                                     *  only allowed for active
+                                     *  cells.
                                      */
     void set_refine_flag () const;
 
@@ -1972,8 +2123,9 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
 
                                     /**
                                      *  Flag the cell pointed to for
-                                     *  coarsening. This function is only
-                                     *  allowed for active cells.
+                                     *  coarsening. This function is
+                                     *  only allowed for active
+                                     *  cells.
                                      */
     void set_coarsen_flag () const;
 
@@ -1983,19 +2135,21 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
     void clear_coarsen_flag () const;
 
                                     /**
-                                     *  Return a pointer to the @p{i}th
-                                     *  child. Overloaded version which returns
-                                     *  a more reasonable iterator class.
+                                     *  Return a pointer to the
+                                     *  @p{i}th child. Overloaded
+                                     *  version which returns a more
+                                     *  reasonable iterator class.
                                      */
     TriaIterator<dim,CellAccessor<dim> >
     child (const unsigned int i) const;
 
                                     /**
-                                     * Return an iterator to the @p{i}th face
-                                     * of this cell.
+                                     * Return an iterator to the
+                                     * @p{i}th face of this cell.
                                      *
-                                     * This function is not implemented in 1D,
-                                     * and maps to QuadAccessor::line in 2D.
+                                     * This function is not
+                                     * implemented in 1D, and maps to
+                                     * QuadAccessor::line in 2D.
                                      */
     TriaIterator<dim,TriaObjectAccessor<dim-1, dim> >
     face (const unsigned int i) const;
@@ -2067,21 +2221,24 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
     
   private:
                                     /**
-                                     *  Copy operator. This is normally
-                                     *  used in a context like
-                                     *  @p{iterator a,b;  *a=*b;}. Since
-                                     *  the meaning is to copy the object
-                                     *  pointed to by @p{b} to the object
+                                     *  Copy operator. This is
+                                     *  normally used in a context
+                                     *  like @p{iterator a,b;
+                                     *  *a=*b;}. Since the meaning is
+                                     *  to copy the object pointed to
+                                     *  by @p{b} to the object
                                      *  pointed to by @p{a} and since
                                      *  accessors are not real but
-                                     *  virtual objects, this operation
-                                     *  is not useful for iterators on
-                                     *  triangulations. We declare this
-                                     *  function here private, thus it may
-                                     *  not be used from outside.
-                                     *  Furthermore it is not implemented
-                                     *  and will give a linker error if
-                                     *  used anyway.
+                                     *  virtual objects, this
+                                     *  operation is not useful for
+                                     *  iterators on
+                                     *  triangulations. We declare
+                                     *  this function here private,
+                                     *  thus it may not be used from
+                                     *  outside.  Furthermore it is
+                                     *  not implemented and will give
+                                     *  a linker error if used
+                                     *  anyway.
                                      */
     void operator = (const CellAccessor<dim> &);
 };

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.