From 8d4cfe44288a2b6b147c2e8b3f7865e5bd3aca8e Mon Sep 17 00:00:00 2001 From: wolf Date: Thu, 25 Jul 2002 14:37:55 +0000 Subject: [PATCH] Fix some comment. Wrap around a larger number of other comments, to 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 | 1369 ++++++++++-------- 1 file changed, 763 insertions(+), 606 deletions(-) diff --git a/deal.II/deal.II/include/grid/tria_accessor.h b/deal.II/deal.II/include/grid/tria_accessor.h index 1dced5daea..8e68051e59 100644 --- a/deal.II/deal.II/include/grid/tria_accessor.h +++ b/deal.II/deal.II/include/grid/tria_accessor.h @@ -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 & 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 *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 { public: /** - * Propagate typedef from BaseClass - * to this class. + * Propagate typedef from + * base class to this class. */ typedef typename TriaAccessor::AccessorData AccessorData; @@ -302,35 +300,40 @@ class TriaObjectAccessor : public TriaAccessor TriaAccessor (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 & vertex (const unsigned int i) const; @@ -345,7 +348,8 @@ class TriaObjectAccessor : public TriaAccessor /** * 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 * 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 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(cell->user_pointer());}. */ void * user_pointer () const; @@ -458,74 +469,85 @@ class TriaObjectAccessor : public TriaAccessor /** * 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 /**@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 /** - * 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 class TriaObjectAccessor<0, dim> : public TriaAccessor { public: /** - * Propagate typedef from BaseClass - * to this class. + * Propagate typedef from + * base class to this class. */ typedef typename TriaAccessor::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 *parent = 0, const int level = -1, @@ -696,10 +722,11 @@ class TriaObjectAccessor<0, dim> : public TriaAccessor /** - * 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 { public: /** - * Propagate typedef from BaseClass - * to this class. + * Propagate typedef from + * base class to this class. */ typedef typename TriaAccessor::AccessorData AccessorData; @@ -723,19 +750,20 @@ class TriaObjectAccessor<1, dim> : public TriaAccessor TriaAccessor (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 & vertex (const unsigned int i) const; @@ -746,23 +774,25 @@ class TriaObjectAccessor<1, dim> : public TriaAccessor * 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 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(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 > 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 Point 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 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 /**@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 /** - * 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 { public: /** - * Propagate typedef from BaseClass - * to this class. + * Propagate typedef from base + * class to this class. */ typedef typename TriaAccessor::AccessorData AccessorData; @@ -1071,31 +1127,35 @@ class TriaObjectAccessor<2, dim> : public TriaAccessor 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 & 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 > 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 * 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 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 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(cell->user_pointer());}. */ void * user_pointer () const; @@ -1191,75 +1260,89 @@ class TriaObjectAccessor<2, dim> : public TriaAccessor TriaIterator > 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 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 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 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 /**@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 /** - * 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 { public: /** - * Propagate typedef from BaseClass - * to this class. + * Propagate typedef from base + * class to this class. */ typedef typename TriaAccessor::AccessorData AccessorData; @@ -1443,50 +1547,57 @@ class TriaObjectAccessor<3, dim> : public TriaAccessor TriaAccessor (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 & 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 > 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 > 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 * 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 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 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(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 > 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 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 center () const; /** - * Return the barycenter of the hex. + * Return the barycenter of the + * hex. */ Point 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 * 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 /**@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 * * 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 TriaObjectAccessor (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 > 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 > &pointer) const; @@ -1946,15 +2096,16 @@ class CellAccessor : public TriaObjectAccessor 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 /** * 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 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 > 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 > face (const unsigned int i) const; @@ -2067,21 +2221,24 @@ class CellAccessor : public TriaObjectAccessor 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 &); }; -- 2.39.5