From: Matthias Maier Date: Mon, 15 Dec 2014 21:47:01 +0000 (+0100) Subject: reindent dof_handler.h, doxygen fixups X-Git-Tag: v8.2.0-rc1~14^2~3 X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=6e8d589cc0adf501dd152f48c9b20197ab55be33;p=dealii.git reindent dof_handler.h, doxygen fixups --- diff --git a/include/deal.II/dofs/dof_handler.h b/include/deal.II/dofs/dof_handler.h index b3816e5f18..6a7ce85d73 100644 --- a/include/deal.II/dofs/dof_handler.h +++ b/include/deal.II/dofs/dof_handler.h @@ -70,32 +70,34 @@ namespace internal * @ref GlossMeshAsAContainer "Meshes as containers". It is first used in the * step-2 tutorial program. * - * For each vertex, line, quad, etc, this class stores a list of the indices of degrees - * of freedom living on this object. These indices refer to the unconstrained - * degrees of freedom, i.e. constrained degrees of freedom are numbered in the - * same way as unconstrained ones, and are only later eliminated. This leads - * to the fact that indices in global vectors and matrices also refer to all - * degrees of freedom and some kind of condensation is needed to restrict the - * systems of equations to the unconstrained degrees of freedom only. The - * actual layout of storage of the indices is described in the dealii::internal::DoFHandler::DoFLevel class - * documentation. + * For each vertex, line, quad, etc, this class stores a list of the + * indices of degrees of freedom living on this object. These indices refer + * to the unconstrained degrees of freedom, i.e. constrained degrees of + * freedom are numbered in the same way as unconstrained ones, and are only + * later eliminated. This leads to the fact that indices in global vectors + * and matrices also refer to all degrees of freedom and some kind of + * condensation is needed to restrict the systems of equations to the + * unconstrained degrees of freedom only. The actual layout of storage of + * the indices is described in the dealii::internal::DoFHandler::DoFLevel + * class documentation. * - * The class offers iterators to traverse all cells, in much the same way as - * the Triangulation class does. Using the begin() and end() functions (and - * companions, like begin_active()), one can obtain iterators to walk over cells, and - * query the degree of freedom structures as well as the triangulation data. - * These iterators are built on top of those of the Triangulation class, but - * offer the additional information on degrees of freedom functionality compared to - * pure triangulation iterators. The order in which dof iterators are - * presented by the ++ and -- operators is the same as that - * for the corresponding iterators traversing the triangulation on which this - * DoFHandler is constructed. + * The class offers iterators to traverse all cells, in much the same way + * as the Triangulation class does. Using the begin() and end() functions + * (and companions, like begin_active()), one can obtain iterators to walk + * over cells, and query the degree of freedom structures as well as the + * triangulation data. These iterators are built on top of those of the + * Triangulation class, but offer the additional information on degrees of + * freedom functionality compared to pure triangulation iterators. The + * order in which dof iterators are presented by the ++ and + * -- operators is the same as that for the corresponding + * iterators traversing the triangulation on which this DoFHandler is + * constructed. * - * The spacedim parameter has to be used if one wants to - * solve problems on surfaces. If not specified, this parameter takes - * the default value =dim implying that we want to solve - * problems in a domain whose dimension equals the dimension of the - * space in which it is embedded. + * The spacedim parameter has to be used if one wants to solve + * problems on surfaces. If not specified, this parameter takes the default + * value =dim implying that we want to solve problems in a domain + * whose dimension equals the dimension of the space in which it is + * embedded. * * *

Distribution of indices for degrees of freedom

@@ -108,46 +110,47 @@ namespace internal * are considered. Active cells are defined to be those cells which have no * children, i.e. they are the most refined ones. * - * Since the triangulation is traversed starting with the cells of the coarsest - * active level and going to more refined levels, the lowest numbers for dofs - * are given to the largest cells as well as their bounding lines and vertices, - * with the dofs of more refined cells getting higher numbers. + * Since the triangulation is traversed starting with the cells of the + * coarsest active level and going to more refined levels, the lowest + * numbers for dofs are given to the largest cells as well as their + * bounding lines and vertices, with the dofs of more refined cells getting + * higher numbers. * - * This numbering implies very large bandwiths of the resulting matrices and - * is thus vastly suboptimal for some solution algorithms. For this reason, - * the DoFRenumbering class offers several algorithms to reorder the dof - * numbering according. See there for a discussion of the implemented - * algorithms. + * This numbering implies very large bandwiths of the resulting matrices + * and is thus vastly suboptimal for some solution algorithms. For this + * reason, the DoFRenumbering class offers several algorithms to reorder + * the dof numbering according. See there for a discussion of the + * implemented algorithms. * * *

Interaction with distributed meshes

* * Upon construction, this class takes a reference to a triangulation - * object. In most cases, this will be a reference to an object of - * type Triangulation, i.e. the class that represents triangulations - * that entirely reside on a single processor. However, it can also be - * of type parallel::distributed::Triangulation (see, for example, - * step-32, step-40 and in particular the @ref distributed module) in - * which case the DoFHandler object will proceed to only manage - * degrees of freedom on locally owned and ghost cells. This process - * is entirely transparent to the used. + * object. In most cases, this will be a reference to an object of type + * Triangulation, i.e. the class that represents triangulations that + * entirely reside on a single processor. However, it can also be of type + * parallel::distributed::Triangulation (see, for example, step-32, step-40 + * and in particular the @ref distributed module) in which case the + * DoFHandler object will proceed to only manage degrees of freedom on + * locally owned and ghost cells. This process is entirely transparent to + * the used. * * *

User defined renumbering schemes

* * The DoFRenumbering class offers a number of renumbering schemes like the - * Cuthill-McKey scheme. Basically, the function sets up an array in which for - * each degree of freedom we store the new index this DoF should have after - * renumbering. Using this array, the renumber_dofs() function of the present - * class is called, which actually performs the change from old DoF indices to - * the ones given in the array. In some cases, however, a user may want to - * compute her own renumbering order; in this case, one can allocate an array - * with one element per degree of freedom and fill it with the number that the - * respective degree of freedom shall be assigned. This number may, for - * example, be obtained by sorting the support points of the degrees of - * freedom in downwind direction. Then call the - * renumber_dofs(vector) function with the array, which - * converts old into new degree of freedom indices. + * Cuthill-McKey scheme. Basically, the function sets up an array in which + * for each degree of freedom we store the new index this DoF should have + * after renumbering. Using this array, the renumber_dofs() function of the + * present class is called, which actually performs the change from old DoF + * indices to the ones given in the array. In some cases, however, a user + * may want to compute her own renumbering order; in this case, one can + * allocate an array with one element per degree of freedom and fill it + * with the number that the respective degree of freedom shall be assigned. + * This number may, for example, be obtained by sorting the support points + * of the degrees of freedom in downwind direction. Then call the + * renumber_dofs(vector) function with + * the array, which converts old into new degree of freedom indices. * * *

Serializing (loading or storing) DoFHandler objects

@@ -199,50 +202,49 @@ public: /** * A typedef that is used to to identify - * @ref GlossActive "active cell iterators". The - * concept of iterators is discussed at length in the + * @ref GlossActive "active cell iterators". + * The concept of iterators is discussed at length in the * @ref Iterators "iterators documentation module". * * The current typedef identifies active cells in a DoFHandler object. - * While the actual data type of the typedef is hidden behind a few layers - * of (unfortunately necessary) indirections, it is in essence - * TriaActiveIterator. The TriaActiveIterator - * class works like a pointer to active objects that when you - * dereference it yields an object of type DoFCellAccessor. - * DoFCellAccessor is a class that identifies properties that - * are specific to cells in a DoFHandler, but it is derived - * (and consequently inherits) from both DoFAccessor, TriaCellAccessor - * and TriaAccessor that describe - * what you can ask of more general objects (lines, faces, as - * well as cells) in a triangulation and DoFHandler objects. + * While the actual data type of the typedef is hidden behind a few + * layers of (unfortunately necessary) indirections, it is in essence + * TriaActiveIterator. The TriaActiveIterator class + * works like a pointer to active objects that when you dereference it + * yields an object of type DoFCellAccessor. DoFCellAccessor is a class + * that identifies properties that are specific to cells in a DoFHandler, + * but it is derived (and consequently inherits) from both DoFAccessor, + * TriaCellAccessor and TriaAccessor that describe what you can ask of + * more general objects (lines, faces, as well as cells) in a + * triangulation and DoFHandler objects. * * @ingroup Iterators */ typedef typename ActiveSelector::active_cell_iterator active_cell_iterator; /** - * A typedef that is used to to identify cell iterators. The - * concept of iterators is discussed at length in the + * A typedef that is used to to identify cell iterators. The concept of + * iterators is discussed at length in the * @ref Iterators "iterators documentation module". * - * The current typedef identifies cells in a DoFHandler object. Some - * of these cells may in fact be active (see @ref GlossActive "active cell iterators") + * The current typedef identifies cells in a DoFHandler object. Some of + * these cells may in fact be active (see + * @ref GlossActive "active cell iterators") * in which case they can in fact be asked for the degrees of freedom - * that live on them. On the other hand, if the cell is not active, - * any such query will result in an error. Note that this is what distinguishes - * this typedef from the level_cell_iterator typedef. + * that live on them. On the other hand, if the cell is not active, any + * such query will result in an error. Note that this is what + * distinguishes this typedef from the level_cell_iterator typedef. * - * While the actual data type of the typedef is hidden behind a few layers - * of (unfortunately necessary) indirections, it is in essence - * TriaIterator. The TriaIterator - * class works like a pointer to objects that when you - * dereference it yields an object of type DoFCellAccessor. - * DoFCellAccessor is a class that identifies properties that - * are specific to cells in a DoFHandler, but it is derived - * (and consequently inherits) from both DoFAccessor, TriaCellAccessor - * and TriaAccessor that describe - * what you can ask of more general objects (lines, faces, as - * well as cells) in a triangulation and DoFHandler objects. + * While the actual data type of the typedef is hidden behind a few + * layers of (unfortunately necessary) indirections, it is in essence + * TriaIterator. The TriaIterator class works like a + * pointer to objects that when you dereference it yields an object of + * type DoFCellAccessor. DoFCellAccessor is a class that identifies + * properties that are specific to cells in a DoFHandler, but it is + * derived (and consequently inherits) from both DoFAccessor, + * TriaCellAccessor and TriaAccessor that describe what you can ask of + * more general objects (lines, faces, as well as cells) in a + * triangulation and DoFHandler objects. * * @ingroup Iterators */ @@ -259,75 +261,52 @@ public: /** - * Alias the @p FunctionMap type - * declared elsewhere. + * Alias the @p FunctionMap type declared elsewhere. */ typedef typename dealii::FunctionMap::type FunctionMap; /** - * Make the dimension available - * in function templates. + * Make the dimension available in function templates. */ static const unsigned int dimension = dim; /** - * Make the space dimension available - * in function templates. + * Make the space dimension available in function templates. */ static const unsigned int space_dimension = spacedim; /** - * When the arrays holding the - * DoF indices are set up, but - * before they are filled with - * actual values, they are set to - * an invalid value, in order to - * monitor possible - * problems. This invalid value - * is the constant defined here. + * When the arrays holding the DoF indices are set up, but before they + * are filled with actual values, they are set to an invalid value, in + * order to monitor possible problems. This invalid value is the constant + * defined here. * - * Please note that you should - * not rely on it having a - * certain value, but rather take - * its symbolic name. + * Please note that you should not rely on it having a certain value, but + * rather take its symbolic name. */ static const types::global_dof_index invalid_dof_index = numbers::invalid_dof_index; /** - * The default index of the - * finite element to be used on a - * given cell. Since the present - * class only supports the same - * finite element to be used on - * all cells, the index of the - * finite element needs to be the - * same on all cells anyway, and - * by convention we pick zero for - * this value. The situation is - * different for hp objects - * (i.e. the hp::DoFHandler - * class) where different finite - * element indices may be used on - * different cells, and the - * default index there - * corresponds to an invalid - * value. + * The default index of the finite element to be used on a given cell. + * Since the present class only supports the same finite element to be + * used on all cells, the index of the finite element needs to be the + * same on all cells anyway, and by convention we pick zero for this + * value. The situation is different for hp objects (i.e. the + * hp::DoFHandler class) where different finite element indices may be + * used on different cells, and the default index there corresponds to an + * invalid value. */ static const unsigned int default_fe_index = 0; /** - * Standard constructor, not - * initializing any data. After - * constructing an object with - * this constructor, use - * initialize() to make a valid + * Standard constructor, not initializing any data. After constructing an + * object with this constructor, use initialize() to make a valid * DoFHandler. */ DoFHandler (); /** - * Constructor. Take @p tria as the - * triangulation to work on. + * Constructor. Take @p tria as the triangulation to work on. */ DoFHandler ( const Triangulation &tria); @@ -337,231 +316,156 @@ public: virtual ~DoFHandler (); /** - * Assign a Triangulation and a - * FiniteElement to the - * DoFHandler and compute the - * distribution of degrees of - * freedom over the mesh. + * Assign a Triangulation and a FiniteElement to the DoFHandler and + * compute the distribution of degrees of freedom over the mesh. */ void initialize(const Triangulation &tria, const FiniteElement &fe); /** - * Go through the triangulation and "distribute" the degrees of - * freedoms needed for the given finite element. "Distributing" - * degrees of freedom involved allocating memory to store the - * information that describes it (e.g., whether it is located on a - * vertex, edge, face, etc) and to sequentially enumerate all - * degrees of freedom. In other words, while the mesh and the finite - * element object by themselves simply define a finite element space - * $V_h$, the process of distributing degrees of freedom makes sure - * that there is a basis for this space and that the shape functions - * of this basis are enumerated in an indexable, predictable way. + * Go through the triangulation and "distribute" the degrees of freedoms + * needed for the given finite element. "Distributing" degrees of freedom + * involved allocating memory to store the information that describes it + * (e.g., whether it is located on a vertex, edge, face, etc) and to + * sequentially enumerate all degrees of freedom. In other words, while + * the mesh and the finite element object by themselves simply define a + * finite element space $V_h$, the process of distributing degrees of + * freedom makes sure that there is a basis for this space and that the + * shape functions of this basis are enumerated in an indexable, + * predictable way. * - * The purpose of this function - * is first discussed in the introduction - * to the step-2 tutorial program. + * The purpose of this function is first discussed in the introduction to + * the step-2 tutorial program. * - * @note A pointer of the finite element given as argument is - * stored. Therefore, the lifetime of the finite element object - * shall be longer than that of this object. If you don't want this - * behavior, you may want to call the @p clear member function which - * also releases the lock of this object to the finite element. + * @note A pointer of the finite element given as argument is stored. + * Therefore, the lifetime of the finite element object shall be longer + * than that of this object. If you don't want this behavior, you may + * want to call the @p clear member function which also releases the lock + * of this object to the finite element. */ virtual void distribute_dofs (const FiniteElement &fe); /** * Distribute level degrees of freedom on each level for geometric - * multigrid. The active DoFs need to be distributed using distribute_dofs() - * before calling this function and the @p fe needs to be identical to the - * finite element passed to distribute_dofs(). + * multigrid. The active DoFs need to be distributed using + * distribute_dofs() before calling this function and the @p fe needs to + * be identical to the finite element passed to distribute_dofs(). * * This replaces the functionality of the old MGDoFHandler. */ virtual void distribute_mg_dofs (const FiniteElement &fe); /** - * This function returns whether - * this DoFHandler has DoFs - * distributed on each multigrid - * level or in other words if - * distribute_mg_dofs() has been - * called. + * This function returns whether this DoFHandler has DoFs distributed on + * each multigrid level or in other words if distribute_mg_dofs() has + * been called. */ bool has_level_dofs() const; /** - * This function returns whether this DoFHandler has active - * DoFs. This is equivalent to asking whether (i) distribute_dofs() - * has been called and (ii) the finite element for which degrees of - * freedom have been distributed actually has degrees of freedom - * (which is not the case for FE_Nothing, for example). + * This function returns whether this DoFHandler has active DoFs. This is + * equivalent to asking whether (i) distribute_dofs() has been called and + * (ii) the finite element for which degrees of freedom have been + * distributed actually has degrees of freedom (which is not the case for + * FE_Nothing, for example). * - * If this object is based on a - * parallel::distributed::Triangulation, then the current function - * returns true if any partition of the parallel DoFHandler - * object has any degrees of freedom. In other words, the function - * returns true even if the Triangulation does not own any active - * cells on the current MPI process, but at least one process owns + * If this object is based on a parallel::distributed::Triangulation, + * then the current function returns true if any partition of the + * parallel DoFHandler object has any degrees of freedom. In other words, + * the function returns true even if the Triangulation does not own any + * active cells on the current MPI process, but at least one process owns * cells and at least this one process has any degrees of freedom * associated with it. */ bool has_active_dofs() const; /** - * After distribute_dofs() with - * an FESystem element, the block - * structure of global and level - * vectors is stored in a - * BlockInfo object accessible - * with block_info(). This - * function initializes the local - * block structure on each cell - * in the same object. + * After distribute_dofs() with an FESystem element, the block structure + * of global and level vectors is stored in a BlockInfo object accessible + * with block_info(). This function initializes the local block structure + * on each cell in the same object. */ void initialize_local_block_info(); /** - * Clear all data of this object and - * especially delete the lock this object - * has to the finite element used the last - * time when @p distribute_dofs was called. + * Clear all data of this object and especially delete the lock this + * object has to the finite element used the last time when + * @p distribute_dofs was called. */ virtual void clear (); /** - * Renumber degrees of freedom based on - * a list of new dof numbers for all the - * dofs. + * Renumber degrees of freedom based on a list of new dof numbers for all + * the dofs. * - * This function is called by - * the functions in - * DoFRenumbering function - * after computing the ordering - * of the degrees of freedom. - * This function is called, for - * example, by the functions in - * the DoFRenumbering - * namespace, but it can of - * course also be called from - * user code. + * This function is called by the functions in DoFRenumbering function + * after computing the ordering of the degrees of freedom. This function + * is called, for example, by the functions in the DoFRenumbering + * namespace, but it can of course also be called from user code. * - * @arg new_number This array - * must have a size equal to - * the number of degrees of - * freedom owned by the current - * processor, i.e. the size - * must be equal to what - * n_locally_owned_dofs() - * returns. If only one - * processor participates in - * storing the current mesh, - * then this equals the total - * number of degrees of - * freedom, i.e. the result of - * n_dofs(). The contents of - * this array are the new - * global indices for each - * freedom listed in the - * IndexSet returned by - * locally_owned_dofs(). In the - * case of a sequential mesh - * this means that the array is - * a list of new indices for - * each of the degrees of - * freedom on the current - * mesh. In the case that we - * have a - * parallel::distributed::Triangulation - * underlying this DoFHandler - * object, the array is a list - * of new indices for all the - * locally owned degrees of - * freedom, enumerated in the - * same order as the currently - * locally owned DoFs. In other - * words, assume that degree of - * freedom i is - * currently locally owned, - * then + * @arg new_number This array must have a size equal to the number of + * degrees of freedom owned by the current processor, i.e. the size must + * be equal to what n_locally_owned_dofs() returns. If only one processor + * participates in storing the current mesh, then this equals the total + * number of degrees of freedom, i.e. the result of n_dofs(). The + * contents of this array are the new global indices for each freedom + * listed in the IndexSet returned by locally_owned_dofs(). In the case + * of a sequential mesh this means that the array is a list of new + * indices for each of the degrees of freedom on the current mesh. In the + * case that we have a parallel::distributed::Triangulation underlying + * this DoFHandler object, the array is a list of new indices for all the + * locally owned degrees of freedom, enumerated in the same order as the + * currently locally owned DoFs. In other words, assume that degree of + * freedom i is currently locally owned, then * new_numbers[locally_owned_dofs().index_within_set(i)] - * returns the new global DoF - * index of - * i. Since the - * IndexSet of - * locally_owned_dofs() is - * complete in the sequential - * case, the latter convention - * for the content of the array - * reduces to the former in the - * case that only one processor - * participates in the mesh. + * returns the new global DoF index of i. Since the IndexSet + * of locally_owned_dofs() is complete in the sequential case, the latter + * convention for the content of the array reduces to the former in the + * case that only one processor participates in the mesh. */ void renumber_dofs (const std::vector &new_numbers); /** - * The same function as above, but - * renumber the degrees of freedom of a + * The same function as above, but renumber the degrees of freedom of a * single level of a multigrid hierarchy. */ void renumber_dofs (const unsigned int level, const std::vector &new_numbers); /** - * Return the maximum number of - * degrees of freedom a degree of freedom - * in the given triangulation with the - * given finite element may couple with. - * This is the maximum number of entries - * per line in the system matrix; this - * information can therefore be used upon - * construction of the SparsityPattern - * object. + * Return the maximum number of degrees of freedom a degree of freedom in + * the given triangulation with the given finite element may couple with. + * This is the maximum number of entries per line in the system matrix; + * this information can therefore be used upon construction of the + * SparsityPattern object. * - * The returned number is not really the - * maximum number but an estimate based - * on the finite element and the maximum - * number of cells meeting at a vertex. - * The number holds for the constrained - * matrix as well. + * The returned number is not really the maximum number but an estimate + * based on the finite element and the maximum number of cells meeting at + * a vertex. The number holds for the constrained matrix as well. * - * The determination of the number of - * couplings can be done by simple - * picture drawing. An example can be - * found in the implementation of this + * The determination of the number of couplings can be done by simple + * picture drawing. An example can be found in the implementation of this * function. * - * @note This function is most often - * used to determine the maximal row - * length for sparsity - * patterns. Unfortunately, while the - * estimates returned by this function - * are rather accurate in 1d and 2d, they - * are often significantly too high in - * 3d, leading the SparsityPattern class - * to allocate much too much memory in - * some cases. Unless someone comes - * around to improving the present - * function for 3d, there is not very - * much one can do about these cases. The - * typical way to work around this - * problem is to use an intermediate - * compressed sparsity pattern that only - * allocates memory on demand. Refer to - * the step-2 and step-11 example - * programs on how to do this. The problem - * is also discussed in the documentation - * of the module on @ref Sparsity. + * @note This function is most often used to determine the maximal row + * length for sparsity patterns. Unfortunately, while the estimates + * returned by this function are rather accurate in 1d and 2d, they are + * often significantly too high in 3d, leading the SparsityPattern class + * to allocate much too much memory in some cases. Unless someone comes + * around to improving the present function for 3d, there is not very + * much one can do about these cases. The typical way to work around this + * problem is to use an intermediate compressed sparsity pattern that + * only allocates memory on demand. Refer to the step-2 and step-11 + * example programs on how to do this. The problem is also discussed in + * the documentation of the module on @ref Sparsity. */ unsigned int max_couplings_between_dofs () const; /** - * Return the number of degrees of freedom - * located on the boundary another dof on - * the boundary can couple with. + * Return the number of degrees of freedom located on the boundary + * another dof on the boundary can couple with. * - * The number is the same as for - * max_couplings_between_dofs() in one + * The number is the same as for max_couplings_between_dofs() in one * dimension less. * * @note The same applies to this function as to max_couplings_per_dofs() @@ -573,12 +477,15 @@ public: /*--------------------------------------*/ /** - * @name Cell iterator functions + * @name Cell iterator functions + */ + + /* + * @{ */ - /*@{*/ + /** - * Iterator to the first used - * cell on level @p level. + * Iterator to the first used cell on level @p level. */ cell_iterator begin (const unsigned int level = 0) const; @@ -597,64 +504,54 @@ public: active_cell_iterator begin_active(const unsigned int level = 0) const; /** - * Iterator past the end; this - * iterator serves for - * comparisons of iterators with - * past-the-end or - * before-the-beginning states. + * Iterator past the end; this iterator serves for comparisons of + * iterators with past-the-end or before-the-beginning states. */ cell_iterator end () const; /** - * Return an iterator which is the first - * iterator not on the given level. If @p level is - * the last level, then this returns - * end(). + * Return an iterator which is the first iterator not on the given level. + * If @p level is the last level, then this returns end(). */ cell_iterator end (const unsigned int level) const; /** - * Return an active iterator which is the first active iterator not - * on the given level. If @p level is the last level, then this - * returns end(). + * Return an active iterator which is the first active iterator not on + * the given level. If @p level is the last level, then this returns + * end(). */ active_cell_iterator end_active (const unsigned int level) const; /** - * Iterator to the first used - * cell on level @p level. This returns a level_cell_iterator - * that returns level dofs when dof_indices() is called. + * Iterator to the first used cell on level @p level. This returns a + * level_cell_iterator that returns level dofs when dof_indices() is + * called. */ level_cell_iterator begin_mg (const unsigned int level = 0) const; /** - * Iterator past the last - * cell on level @p level. This returns a level_cell_iterator - * that returns level dofs when dof_indices() is called. + * Iterator past the last cell on level @p level. This returns a + * level_cell_iterator that returns level dofs when dof_indices() is + * called. */ level_cell_iterator end_mg (const unsigned int level) const; /** - * Iterator past the end; this - * iterator serves for - * comparisons of iterators with - * past-the-end or - * before-the-beginning states. + * Iterator past the end; this iterator serves for comparisons of + * iterators with past-the-end or before-the-beginning states. */ level_cell_iterator end_mg () const; - /*@}*/ - /** * @name Cell iterator functions returning ranges of iterators */ /** - * Return an iterator range that contains all cells (active or not) - * that make up this DoFHandler. Such a range is useful to - * initialize range-based for loops as supported by C++11. See the - * example in the documentation of active_cell_iterators(). + * Return an iterator range that contains all cells (active or not) that + * make up this DoFHandler. Such a range is useful to initialize + * range-based for loops as supported by C++11. See the example in the + * documentation of active_cell_iterators(). * * @return The half open range [this->begin(), this->end()) * @@ -705,10 +602,10 @@ public: IteratorRange active_cell_iterators () const; /** - * Return an iterator range that contains all cells (active or not) - * that make up this DoFHandler in their level-cell form. Such a range is useful to - * initialize range-based for loops as supported by C++11. See the - * example in the documentation of active_cell_iterators(). + * Return an iterator range that contains all cells (active or not) that + * make up this DoFHandler in their level-cell form. Such a range is + * useful to initialize range-based for loops as supported by C++11. See + * the example in the documentation of active_cell_iterators(). * * @return The half open range [this->begin_mg(), this->end_mg()) * @@ -724,7 +621,8 @@ public: * * @param[in] level A given level in the refinement hierarchy of this * triangulation. - * @return The half open range [this->begin(level), this->end(level)) + * @return The half open range [this->begin(level), + * this->end(level)) * * @pre level must be less than this->n_levels(). * @@ -733,8 +631,8 @@ public: IteratorRange cell_iterators_on_level (const unsigned int level) const; /** - * Return an iterator range that contains all active cells - * that make up the given level of this DoFHandler. Such a range is useful to + * Return an iterator range that contains all active cells that make up + * the given level of this DoFHandler. Such a range is useful to * initialize range-based for loops as supported by C++11. See the * example in the documentation of active_cell_iterators(). * @@ -749,11 +647,11 @@ public: IteratorRange active_cell_iterators_on_level (const unsigned int level) const; /** - * Return an iterator range that contains all cells (active or not) - * that make up the given level of this DoFHandler in their level-cell form. - * Such a range is useful to - * initialize range-based for loops as supported by C++11. See the - * example in the documentation of active_cell_iterators(). + * Return an iterator range that contains all cells (active or not) that + * make up the given level of this DoFHandler in their level-cell form. + * Such a range is useful to initialize range-based for loops as + * supported by C++11. See the example in the documentation of + * active_cell_iterators(). * * @param[in] level A given level in the refinement hierarchy of this * triangulation. @@ -762,187 +660,121 @@ public: * @pre level must be less than this->n_levels(). * * @ingroup CPP11 + * */ IteratorRange mg_cell_iterators_on_level (const unsigned int level) const; - //@} + + /* + * @} + */ + /*---------------------------------------*/ /** - * Return the global number of - * degrees of freedom. If the - * current object handles all - * degrees of freedom itself - * (even if you may intend to - * solve your linear system in - * parallel, such as in step-17 - * or step-18), then this number - * equals the number of locally - * owned degrees of freedom since - * this object doesn't know - * anything about what you want - * to do with it and believes - * that it owns every degree of - * freedom it knows about. + * Return the global number of degrees of freedom. If the current object + * handles all degrees of freedom itself (even if you may intend to solve + * your linear system in parallel, such as in step-17 or step-18), then + * this number equals the number of locally owned degrees of freedom + * since this object doesn't know anything about what you want to do with + * it and believes that it owns every degree of freedom it knows about. * - * On the other hand, if this - * object operates on a - * parallel::distributed::Triangulation - * object, then this function - * returns the global number of - * degrees of freedom, - * accumulated over all + * On the other hand, if this object operates on a + * parallel::distributed::Triangulation object, then this function + * returns the global number of degrees of freedom, accumulated over all * processors. * - * In either case, included in - * the returned number are those - * DoFs which are constrained by - * hanging nodes, see @ref constraints. + * In either case, included in the returned number are those DoFs which + * are constrained by hanging nodes, see @ref constraints. */ types::global_dof_index n_dofs () const; /** - * The (global) number of multilevel - * degrees of freedom on a - * given level. + * The (global) number of multilevel degrees of freedom on a given level. * - * If no level degrees of - * freedom have been assigned - * to this level, returns - * numbers::invalid_dof_index. Else - * returns the number of - * degrees of freedom on this level. + * If no level degrees of freedom have been assigned to this level, + * returns numbers::invalid_dof_index. Else returns the number of degrees + * of freedom on this level. */ types::global_dof_index n_dofs (const unsigned int level) const; /** - * Return the number of degrees of freedom - * located on the boundary. + * Return the number of degrees of freedom located on the boundary. */ types::global_dof_index n_boundary_dofs () const; /** - * Return the number of degrees - * of freedom located on those - * parts of the boundary which - * have a boundary indicator - * listed in the given set. The - * reason that a @p map rather - * than a @p set is used is the - * same as described in the - * section on the - * @p make_boundary_sparsity_pattern + * Return the number of degrees of freedom located on those parts of the + * boundary which have a boundary indicator listed in the given set. The + * reason that a @p map rather than a @p set is used is the same as + * described in the section on the @p make_boundary_sparsity_pattern * function. */ types::global_dof_index n_boundary_dofs (const FunctionMap &boundary_indicators) const; /** - * Same function, but with - * different data type of the - * argument, which is here simply - * a list of the boundary - * indicators under - * consideration. + * Same function, but with different data type of the argument, which is + * here simply a list of the boundary indicators under consideration. */ types::global_dof_index n_boundary_dofs (const std::set &boundary_indicators) const; /** - * Access to an object informing - * of the block structure of the - * dof handler. + * Access to an object informing of the block structure of the dof + * handler. * - * If an FESystem is used in - * distribute_dofs(), degrees of - * freedom naturally split into - * several @ref GlossBlock - * "blocks". For each base element - * as many blocks appear as its - * multiplicity. + * If an FESystem is used in distribute_dofs(), degrees of freedom + * naturally split into several @ref GlossBlock "blocks". For each base + * element as many blocks appear as its multiplicity. * - * At the end of - * distribute_dofs(), the number - * of degrees of freedom in each - * block is counted, and stored - * in a BlockInfo object, which - * can be accessed here. In an - * MGDoFHandler, the same is done - * on each level. Additionally, - * the block structure on each - * cell can be generated in this - * object by calling - * initialize_local_block_info(). + * At the end of distribute_dofs(), the number of degrees of freedom in + * each block is counted, and stored in a BlockInfo object, which can be + * accessed here. In an MGDoFHandler, the same is done on each level. + * Additionally, the block structure on each cell can be generated in + * this object by calling initialize_local_block_info(). */ const BlockInfo &block_info() const; /** - * Return the number of - * degrees of freedom that - * belong to this - * process. + * Return the number of degrees of freedom that belong to this process. * - * If this is a sequential job, - * then the result equals that - * produced by n_dofs(). On the - * other hand, if we are - * operating on a - * parallel::distributed::Triangulation, - * then it includes only the - * degrees of freedom that the - * current processor owns. Note - * that in this case this does - * not include all degrees of - * freedom that have been - * distributed on the current - * processor's image of the mesh: - * in particular, some of the - * degrees of freedom on the - * interface between the cells - * owned by this processor and - * cells owned by other - * processors may be theirs, and - * degrees of freedom on ghost - * cells are also not necessarily - * included. + * If this is a sequential job, then the result equals that produced by + * n_dofs(). On the other hand, if we are operating on a + * parallel::distributed::Triangulation, then it includes only the + * degrees of freedom that the current processor owns. Note that in this + * case this does not include all degrees of freedom that have been + * distributed on the current processor's image of the mesh: in + * particular, some of the degrees of freedom on the interface between + * the cells owned by this processor and cells owned by other processors + * may be theirs, and degrees of freedom on ghost cells are also not + * necessarily included. */ unsigned int n_locally_owned_dofs() const; /** - * Return an IndexSet describing - * the set of locally owned DoFs - * as a subset of - * 0..n_dofs(). The number of - * elements of this set equals + * Return an IndexSet describing the set of locally owned DoFs as a + * subset of 0..n_dofs(). The number of elements of this set equals * n_locally_owned_dofs(). */ const IndexSet &locally_owned_dofs() const; /** - * Returns an IndexSet describing the set of locally - * owned DoFs used for the given multigrid level as - * a subset of 0..n_dofs(level). + * Returns an IndexSet describing the set of locally owned DoFs used for + * the given multigrid level as a subset of 0..n_dofs(level). */ const IndexSet &locally_owned_mg_dofs(const unsigned int level) const; /** - * Returns a vector that - * stores the locally owned - * DoFs of each processor. If - * you are only interested in - * the number of elements - * each processor owns then - * n_locally_owned_dofs_per_processor() is - * a better choice. + * Returns a vector that stores the locally owned DoFs of each processor. + * If you are only interested in the number of elements each processor + * owns then n_locally_owned_dofs_per_processor() is a better choice. * - * If this is a sequential job, - * then the vector has a single - * element that equals the - * IndexSet representing the - * entire range [0,n_dofs()]. + * If this is a sequential job, then the vector has a single element that + * equals the IndexSet representing the entire range [0,n_dofs()]. */ const std::vector & locally_owned_dofs_per_processor () const; @@ -951,73 +783,51 @@ public: locally_owned_mg_dofs_per_processor (const unsigned int level) const; /** - * Return a vector that - * stores the number of - * degrees of freedom each - * processor that - * participates in this - * triangulation owns - * locally. The sum of all - * these numbers equals the - * number of degrees of - * freedom that exist - * globally, i.e. what - * n_dofs() returns. + * Return a vector that stores the number of degrees of freedom each + * processor that participates in this triangulation owns locally. The + * sum of all these numbers equals the number of degrees of freedom that + * exist globally, i.e. what n_dofs() returns. * - * Each element of the vector - * returned by this function - * equals the number of - * elements of the - * corresponding sets - * returned by + * Each element of the vector returned by this function equals the number + * of elements of the corresponding sets returned by * global_dof_indices(). * - * If this is a sequential job, - * then the vector has a single - * element equal to n_dofs(). + * If this is a sequential job, then the vector has a single element + * equal to n_dofs(). */ const std::vector & n_locally_owned_dofs_per_processor () const; /** - * Return a constant reference to - * the selected finite element - * object. + * Return a constant reference to the selected finite element object. */ const FiniteElement &get_fe () const; /** - * Return a constant reference to - * the triangulation underlying - * this object. + * Return a constant reference to the triangulation underlying this + * object. */ const Triangulation &get_tria () const; /** - * Determine an estimate for the - * memory consumption (in bytes) - * of this object. + * Determine an estimate for the memory consumption (in bytes) of this + * object. * - * This function is made virtual, - * since a dof handler object - * might be accessed through a - * pointers to this base class, - * although the actual object - * might be a derived class. + * This function is made virtual, since a dof handler object might be + * accessed through a pointers to this base class, although the actual + * object might be a derived class. */ virtual std::size_t memory_consumption () const; /** - * Write the data of this object to a - * stream for the purpose of + * Write the data of this object to a stream for the purpose of * serialization. */ template void save (Archive &ar, const unsigned int version) const; /** - * Read the data of this object from a - * stream for the purpose of + * Read the data of this object from a stream for the purpose of * serialization. */ template @@ -1026,10 +836,8 @@ public: BOOST_SERIALIZATION_SPLIT_MEMBER() /** - * We are trying to renumber the - * degrees of freedom, but - * somehow did not count - * correctly. + * We are trying to renumber the degrees of freedom, but somehow did not + * count correctly. * * @ingroup Exceptions */ @@ -1053,7 +861,7 @@ public: << "The given list of new dof indices is not consecutive: " << "the index " << arg1 << " does not exist."); /** - * Exception + * Exception * @ingroup Exceptions */ DeclException1 (ExcInvalidLevel, @@ -1078,73 +886,56 @@ public: private: /** - * Copy constructor. I can see no reason - * why someone might want to use it, so - * I don't provide it. Since this class - * has pointer members, making it private - * prevents the compiler to provide it's - * own, incorrect one if anyone chose to - * copy such an object. + * Copy constructor. I can see no reason why someone might want to use + * it, so I don't provide it. Since this class has pointer members, + * making it private prevents the compiler to provide it's own, incorrect + * one if anyone chose to copy such an object. */ DoFHandler (const DoFHandler &); /** - * Copy operator. I can see no reason - * why someone might want to use it, so - * I don't provide it. Since this class - * has pointer members, making it private - * prevents the compiler to provide it's - * own, incorrect one if anyone chose to - * copy such an object. + * Copy operator. I can see no reason why someone might want to use it, + * so I don't provide it. Since this class has pointer members, making it + * private prevents the compiler to provide it's own, incorrect one if + * anyone chose to copy such an object. */ DoFHandler &operator = (const DoFHandler &); /** - * An object containing - * information on the block structure. + * An object containing information on the block structure. */ BlockInfo block_info_object; /** - * Address of the triangulation to - * work on. + * Address of the triangulation to work on. */ SmartPointer,DoFHandler > tria; /** - * Store a pointer to the finite element - * given latest for the distribution of - * dofs. In order to avoid destruction of - * the object before the lifetime of - * the DoF handler, we subscribe to - * the finite element object. To unlock - * the FE before the end of the lifetime - * of this DoF handler, use the clear() - * function (this clears all data of - * this object as well, though). + * Store a pointer to the finite element given latest for the + * distribution of dofs. In order to avoid destruction of the object + * before the lifetime of the DoF handler, we subscribe to the finite + * element object. To unlock the FE before the end of the lifetime of + * this DoF handler, use the clear() function (this clears all + * data of this object as well, though). */ SmartPointer,DoFHandler > selected_fe; /** - * An object that describes how degrees - * of freedom should be distributed and - * renumbered. + * An object that describes how degrees of freedom should be distributed + * and renumbered. */ std_cxx11::shared_ptr > policy; /** - * A structure that contains all - * sorts of numbers that - * characterize the degrees of - * freedom this object works on. + * A structure that contains all sorts of numbers that characterize the + * degrees of freedom this object works on. * - * For most members of this - * structure, there is an - * accessor function in this - * class that returns its value. + * For most members of this structure, there is an accessor function in + * this class that returns its value. */ dealii::internal::DoFHandler::NumberCache number_cache; @@ -1157,8 +948,7 @@ private: * A data structure that is used to store the DoF indices associated with * a particular vertex. Unlike cells, vertices live on several levels of * a multigrid hierarchy; consequently, we need to store DoF indices for - * each vertex for each of the levels it lives on. This class does - * this. + * each vertex for each of the levels it lives on. This class does this. */ class MGVertexDoFs { @@ -1183,29 +973,26 @@ private: const unsigned int dofs_per_vertex); /** - * Return the coarsest level for which this structure - * stores data. + * Return the coarsest level for which this structure stores data. */ unsigned int get_coarsest_level () const; /** - * Return the finest level for which this structure - * stores data. + * Return the finest level for which this structure stores data. */ unsigned int get_finest_level () const; /** - * Return the index of the dof_numberth degree of - * freedom for the given level stored for the current vertex. + * Return the index of the dof_numberth degree of freedom + * for the given level stored for the current vertex. */ types::global_dof_index get_index (const unsigned int level, const unsigned int dof_number) const; /** - * Set the index of the dof_numberth degree of - * freedom for the given level stored for the current vertex - * to index. + * Set the index of the dof_numberth degree of freedom for + * the given level stored for the current vertex to index. */ void set_index (const unsigned int level, const unsigned int dof_number, @@ -1228,16 +1015,15 @@ private: unsigned int finest_level; /** - * A pointer to an array where we store the indices of the - * DoFs that live on the various levels this vertex exists - * on. + * A pointer to an array where we store the indices of the DoFs that + * live on the various levels this vertex exists on. */ types::global_dof_index *indices; /** - * This array stores, for each level starting with coarsest_level, - * the offset in the indices array where the DoF - * indices for each level are stored. + * This array stores, for each level starting with coarsest_level, the + * offset in the indices array where the DoF indices for + * each level are stored. */ types::global_dof_index *indices_offset; }; @@ -1252,42 +1038,41 @@ private: void reserve_space (); template - types::global_dof_index get_dof_index (const unsigned int obj_level, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index) const; + types::global_dof_index get_dof_index (const unsigned int obj_level, + const unsigned int obj_index, + const unsigned int fe_index, + const unsigned int local_index) const; template - void set_dof_index (const unsigned int obj_level, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index) const; + void set_dof_index (const unsigned int obj_level, + const unsigned int obj_index, + const unsigned int fe_index, + const unsigned int local_index, + const types::global_dof_index global_index) const; /** - * Array to store the indices for - * degrees of freedom located at - * vertices. + * Array to store the indices for degrees of freedom located at vertices. */ std::vector vertex_dofs; /** - * An array to store the indices for level degrees of freedom located - * at vertices. + * An array to store the indices for level degrees of freedom located at + * vertices. */ std::vector mg_vertex_dofs; /** - * Space to store the DoF numbers - * for the different - * levels. Analogous to the - * levels[] tree of the - * Triangulation objects. + * Space to store the DoF numbers for the different levels. Analogous to + * the levels[] tree of the Triangulation objects. */ std::vector*> levels; std::vector*> mg_levels; /** - * Space to store DoF numbers of - * faces. They are not stored in - * levels since faces - * are not organized - * hierarchically, but in a flat - * array. + * Space to store DoF numbers of faces. They are not stored in + * levels since faces are not organized hierarchically, but in a + * flat array. */ dealii::internal::DoFHandler::DoFFaces *faces; @@ -1437,9 +1222,9 @@ DoFHandler::block_info () const namespace internal { /** - * returns a string representing the dynamic type of the given argument. This is - * basically the same what typeid(...).name() does, but it turns out this is broken - * on Intel 13+. + * returns a string representing the dynamic type of the given argument. + * This is basically the same what typeid(...).name() does, but it turns + * out this is broken on Intel 13+. * * Defined in dof_handler.cc. */ @@ -1460,8 +1245,8 @@ void DoFHandler::save (Archive &ar, ar &levels; ar &faces; - // write out the number of triangulation cells and later check - // during loading that this number is indeed correct; same with something that + // write out the number of triangulation cells and later check during + // loading that this number is indeed correct; same with something that // identifies the FE and the policy unsigned int n_cells = tria->n_cells(); std::string fe_name = selected_fe->get_name(); @@ -1481,9 +1266,9 @@ void DoFHandler::load (Archive &ar, ar &number_cache; // boost::serialization can restore pointers just fine, but if the - // pointer object still points to something useful, that object is - // not destroyed and we end up with a memory leak. consequently, - // first delete previous content before re-loading stuff + // pointer object still points to something useful, that object is not + // destroyed and we end up with a memory leak. consequently, first delete + // previous content before re-loading stuff for (unsigned int i=0; i::load (Archive &ar, ar &levels; ar &faces; - // these are the checks that correspond to the last block in the save() function + // these are the checks that correspond to the last block in the save() + // function unsigned int n_cells; std::string fe_name; std::string policy_name; diff --git a/include/deal.II/dofs/dof_tools.h b/include/deal.II/dofs/dof_tools.h index 59fbc8e32e..40495100c0 100644 --- a/include/deal.II/dofs/dof_tools.h +++ b/include/deal.II/dofs/dof_tools.h @@ -651,6 +651,7 @@ namespace DoFTools /** * @} */ + /** * @name Hanging nodes and other constraints * @{ @@ -802,7 +803,9 @@ namespace DoFTools const InterGridMap > &coarse_to_fine_grid_map, std::vector > &transfer_representation); - //@} + /** + * @} + */ /** @@ -1150,9 +1153,6 @@ namespace DoFTools const ComponentMask &component_mask = ComponentMask()) DEAL_II_DEPRECATED; - //@} - - /** * Take a vector of values which live on cells (e.g. an error per * cell) and distribute it to the dofs in such a way that a finite @@ -1194,6 +1194,7 @@ namespace DoFTools /** * @} */ + /** * @name Identifying subsets of degrees of freedom with particular properties * @{ diff --git a/include/deal.II/grid/grid_generator.h b/include/deal.II/grid/grid_generator.h index dcb647d981..ee15401d7e 100644 --- a/include/deal.II/grid/grid_generator.h +++ b/include/deal.II/grid/grid_generator.h @@ -53,9 +53,9 @@ template class SparseMatrix; namespace GridGenerator { /** - * @name Creating meshes for basic geometries + * @name Creating meshes for basic geometries + * @{ */ - /*@{*/ /** * Initialize the given triangulation with a hypercube (line in 1D, @@ -655,13 +655,12 @@ namespace GridGenerator const double R, const double r); - /** + /* * @} */ + /** - * @name Creating meshes from other meshes - */ - /** + * @name Creating meshes from other meshes * @{ */ @@ -802,14 +801,14 @@ namespace GridGenerator void flatten_triangulation(const Triangulation &in_tria, Triangulation &out_tria); - /** + /* * @} */ /** - * @name Creating lower-dimensional meshes from parts of higher-dimensional meshes + * @name Creating lower-dimensional meshes from parts of higher-dimensional meshes + * @{ */ - /*@{*/ #ifdef _MSC_VER @@ -922,12 +921,12 @@ namespace GridGenerator const std::set &boundary_ids = std::set()); - /*@}*/ - - /** - * @name Deprecated functions + /* + * @} */ + /** + * @name Deprecated functions * @{ */ @@ -959,13 +958,12 @@ namespace GridGenerator const std::map > &new_points, const Function *coefficient = 0) DEAL_II_DEPRECATED; - /** + /* * @} */ + /** - * @name Exceptions - */ - /** + * @name Exceptions * @{ */ @@ -987,6 +985,10 @@ namespace GridGenerator int, << "The vector of repetitions must have " << arg1 <<" elements."); + + /* + * @} + */ } diff --git a/include/deal.II/grid/tria.h b/include/deal.II/grid/tria.h index bb218fa3f3..2f0a5ed09f 100644 --- a/include/deal.II/grid/tria.h +++ b/include/deal.II/grid/tria.h @@ -2051,11 +2051,11 @@ public: void distort_random (const double factor, const bool keep_boundary=true) DEAL_II_DEPRECATED; - /** - * @name Mesh refinement + * @name Mesh refinement + * @{ */ - /*@{*/ + /** * Flag all active cells for refinement. This will refine all * cells of all levels which are not already refined (i.e. only @@ -2148,12 +2148,15 @@ public: * need them afterwards. */ bool prepare_coarsening_and_refinement (); - /** @} */ + + /* + * @} + */ /** - * @name Keeping up with what happens to a triangulation + * @name Keeping up with what happens to a triangulation + * @{ */ - /** @{ */ /** * Add a RefinementListener. Adding listeners to the Triangulation @@ -2204,12 +2207,15 @@ public: */ mutable Signals signals; - /*@}*/ + /* + * @} + */ /** - * @name History of a triangulation + * @name History of a triangulation + * @{ */ - /*@{*/ + /** * Save the addresses of the cells which are flagged for refinement * to @p out. For usage, read the general documentation for this @@ -2259,13 +2265,16 @@ public: * (as opposed to only isotropic) refinement. */ bool get_anisotropic_refinement_flag() const; - /*@}*/ + /* + * @} + */ /** - * @name User data + * @name User data + * @{ */ - /*@{*/ + /** * Clear all user flags. See also @ref GlossUserFlags . */ @@ -2492,13 +2501,16 @@ public: * GlossUserData . */ void load_user_pointers_hex (const std::vector &v); - /*@}*/ + /* + * @} + */ /** - * @name Cell iterator functions + * @name Cell iterator functions + * @{ */ - /*@{*/ + /** * Iterator to the first used cell on level @p level. */ @@ -2547,7 +2559,6 @@ public: * Return an iterator pointing to the last active cell. */ active_cell_iterator last_active () const; - /*@}*/ /** * @name Cell iterator functions returning ranges of iterators @@ -2635,15 +2646,18 @@ public: */ IteratorRange active_cell_iterators_on_level (const unsigned int level) const; - /*@}*/ + /* + * @} + */ /*---------------------------------------*/ /*---------------------------------------*/ /** - * @name Face iterator functions + * @name Face iterator functions + * @{ */ - /*@{*/ + /** * Iterator to the first used face. */ @@ -2659,15 +2673,15 @@ public: * iterators with past-the-end or before-the-beginning states. */ face_iterator end_face () const; - /*@}*/ - - /*---------------------------------------*/ + /* + * @} + */ /** * @name Information about the triangulation + * @{ */ - /*@{*/ /** * In the following, most functions are provided in two versions, @@ -2923,12 +2937,15 @@ public: * those cells that are owned by the current processor. */ virtual types::subdomain_id locally_owned_subdomain () const; - /*@}*/ + + /* + * @} + */ /** - * @name Internal information about the number of objects + * @name Internal information about the number of objects + * @{ */ - /*@{*/ /** * Total number of lines, used or unused. @@ -3083,7 +3100,9 @@ public: */ unsigned int n_raw_faces () const; - /*@}*/ + /* + * @} + */ /** * Determine an estimate for the memory consumption (in bytes) of @@ -3131,9 +3150,10 @@ public: BOOST_SERIALIZATION_SPLIT_MEMBER() /** - * @name Exceptions + * @name Exceptions + * @{ */ - /*@{*/ + /** * Exception @ingroup Exceptions */ @@ -3172,7 +3192,11 @@ public: * Exception @ingroup Exceptions */ DeclException0 (ExcNonOrientableTriangulation); - /*@}*/ + + /* + * @} + */ + protected: /** * Do some smoothing in the process of refining the @@ -3212,9 +3236,10 @@ protected: private: /** - * @name Cell iterator functions for internal use + * @name Cell iterator functions for internal use + * @{ */ - /*@{*/ + /** * Declare a number of iterator types for raw iterators, i.e., * iterators that also iterate over holes in the list of cells left @@ -3242,14 +3267,15 @@ private: * end(). */ raw_cell_iterator end_raw (const unsigned int level) const; - /*@}*/ - /*---------------------------------------*/ + /* + * @} + */ /** - * @name Line iterator functions for internal use + * @name Line iterator functions for internal use + * @{ */ - /*@{*/ /** * Iterator to the first line, used or not, on level @p level. If a @@ -3278,15 +3304,16 @@ private: * iterators with past-the-end or before-the-beginning states. */ line_iterator end_line () const; - /*@}*/ - /*---------------------------------------*/ + /* + * @} + */ /** - * @name Quad iterator functions for internal use - */ - /*@{ + * @name Quad iterator functions for internal use + * @{ */ + /** * Iterator to the first quad, used or not, on the given level. If * a level has no quads, a past-the-end iterator is returned. If @@ -3315,15 +3342,16 @@ private: */ quad_iterator end_quad () const; - /*@}*/ - /*---------------------------------------*/ + /* + * @} + */ /** - * @name Hex iterator functions for internal use - */ - /*@{ + * @name Hex iterator functions for internal use + * @{ */ + /** * Iterator to the first hex, used or not, on level @p level. If a * level has no hexs, a past-the-end iterator is returned. @@ -3349,7 +3377,10 @@ private: */ hex_iterator end_hex () const; - /*@}*/ + + /* + * @} + */ /** diff --git a/include/deal.II/hp/dof_handler.h b/include/deal.II/hp/dof_handler.h index 70d1696871..5bc7ada7b5 100644 --- a/include/deal.II/hp/dof_handler.h +++ b/include/deal.II/hp/dof_handler.h @@ -440,8 +440,6 @@ namespace hp */ active_cell_iterator end_active (const unsigned int level) const; - /*@}*/ - /** * @name Cell iterator functions returning ranges of iterators */ @@ -532,7 +530,9 @@ namespace hp */ IteratorRange active_cell_iterators_on_level (const unsigned int level) const; - /*@}*/ + /* + * @} + */ /*---------------------------------------*/