From d9f44302ca3fa880177184a55fa109d4d07b5baf Mon Sep 17 00:00:00 2001 From: heister Date: Fri, 21 Dec 2012 02:05:48 +0000 Subject: [PATCH] document function and revert whitespace changes git-svn-id: https://svn.dealii.org/branches/branch_merge_mg_into_dof_handler@27842 0785d39b-7218-0410-832d-ea1e28bc413d --- deal.II/include/deal.II/dofs/dof_handler.h | 992 +++++++++++---------- 1 file changed, 499 insertions(+), 493 deletions(-) diff --git a/deal.II/include/deal.II/dofs/dof_handler.h b/deal.II/include/deal.II/dofs/dof_handler.h index baf45648b2..abd7be86c6 100644 --- a/deal.II/include/deal.II/dofs/dof_handler.h +++ b/deal.II/include/deal.II/dofs/dof_handler.h @@ -200,114 +200,114 @@ public: typedef typename ActiveSelector::cell_iterator cell_iterator; /** - * 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. - * - * Please note that you should - * not rely on it having a - * certain value, but rather take - * its symbolic name. - */ + * 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. + */ static const unsigned int invalid_dof_index = numbers::invalid_unsigned_int; /** - * 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 - * DoFHandler. - */ + * 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); /** - * Destructor. - */ + * Destructor. + */ 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 - * according to the given distribution - * method. The purpose of this function - * is first discussed in the introduction - * to the step-2 tutorial program. - * - * A pointer of the transferred - * finite element is - * stored. Therefore, the - * lifetime of the finite element - * object shall be longer than - * that of this object. If you - * don't want this behaviour, you - * may want to call the @p clear - * member function which also - * releases the lock of this - * object to the finite element. - */ + * Go through the triangulation and + * distribute the degrees of freedoms + * needed for the given finite element + * according to the given distribution + * method. The purpose of this function + * is first discussed in the introduction + * to the step-2 tutorial program. + * + * A pointer of the transferred + * finite element is + * stored. Therefore, the + * lifetime of the finite element + * object shall be longer than + * that of this object. If you + * don't want this behaviour, 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); virtual void distribute_mg_dofs (const FiniteElement &fe); @@ -331,94 +331,94 @@ public: */ 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. - * - * 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 - * 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. - */ + * 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. + * + * @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. + */ void renumber_dofs (const std::vector &new_numbers); /** @@ -430,74 +430,74 @@ public: const std::vector &new_numbers); /** - * @deprecated Use - * CompressedSparsityPattern instead of - * initializing SparsityPattern with this - * value, see the discussion in step-2 - * and the @ref Sparsity module. - * - * 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 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 that 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. - */ + * @deprecated Use + * CompressedSparsityPattern instead of + * initializing SparsityPattern with this + * value, see the discussion in step-2 + * and the @ref Sparsity module. + * + * 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 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 that 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; /** - * @deprecated Use - * CompressedSparsityPattern - * instead of initializing - * SparsityPattern with this - * value. - * - * 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 - * dimension less. - */ + * @deprecated Use + * CompressedSparsityPattern + * instead of initializing + * SparsityPattern with this + * value. + * + * 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 + * dimension less. + */ unsigned int max_couplings_between_boundary_dofs () const; /*--------------------------------------*/ @@ -510,7 +510,7 @@ public: * Iterator to the first used * cell on level @p level. */ - cell_iterator begin (const unsigned int level = 0) const; + cell_iterator begin (const unsigned int level = 0) const; /** * Iterator to the first active @@ -573,72 +573,73 @@ public: /*---------------------------------------*/ + /** - * 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 - * processors. - * - * In either case, included in - * the returned number are those - * DoFs which are constrained by - * hanging nodes, see @ref constraints. - */ + * 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 + * processors. + * + * In either case, included in + * the returned number are those + * DoFs which are constrained by + * hanging nodes, see @ref constraints. + */ unsigned int n_dofs () const; /** - * 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_unsigned_int. Else - * returns the number of - * degrees of freedom on this 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_unsigned_int. Else + * returns the number of + * degrees of freedom on this level. + */ unsigned int 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. + */ unsigned int 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 - * function. - */ + * 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. + */ unsigned int n_boundary_dofs (const FunctionMap &boundary_indicators) const; @@ -654,75 +655,80 @@ public: n_boundary_dofs (const std::set &boundary_indicators) const; /** - * 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. - * - * 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(). - */ + * 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. + * + * 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. - * - * 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. - */ + * 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. + */ 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 - * n_locally_owned_dofs(). - */ + * 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). const IndexSet &locally_owned_mg_dofs(const unsigned int level) const; @@ -749,125 +755,125 @@ 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. - * - * 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(). - */ + * 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 + * global_dof_indices(). + * + * 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. - * - * 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. - */ + * 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. + */ virtual std::size_t memory_consumption () const; /** - * Write the data of this object to a - * stream for the purpose of - * serialization. - */ + * 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 - * serialization. - */ + * Read the data of this object from a + * stream for the purpose of + * serialization. + */ template void load (Archive &ar, const unsigned int version); BOOST_SERIALIZATION_SPLIT_MEMBER() /** - * We are trying to renumber the - * degrees of freedom, but - * somehow did not count - * correctly. - * - * @ingroup Exceptions - */ + * We are trying to renumber the + * degrees of freedom, but + * somehow did not count + * correctly. + * + * @ingroup Exceptions + */ DeclException0 (ExcRenumberingIncomplete); /** - * Exception - * @ingroup Exceptions - */ + * Exception + * @ingroup Exceptions + */ DeclException0 (ExcGridsDoNotMatch); /** - * Exception - * @ingroup Exceptions - */ + * Exception + * @ingroup Exceptions + */ DeclException0 (ExcInvalidBoundaryIndicator); /** - * Exception - * @ingroup Exceptions - */ + * Exception + * @ingroup Exceptions + */ DeclException1 (ExcNewNumbersNotConsecutive, int, << "The given list of new dof indices is not consecutive: " << "the index " << arg1 << " does not exist."); /** - * Exception - * @ingroup Exceptions - */ + * Exception + * @ingroup Exceptions + */ DeclException1 (ExcInvalidLevel, int, << "The given level " << arg1 << " is not in the valid range!"); /** - * Exception - * @ingroup Exceptions - */ + * Exception + * @ingroup Exceptions + */ DeclException0 (ExcFacesHaveNoLevel); /** - * The triangulation level you - * accessed is empty. - * @ingroup Exceptions - */ + * The triangulation level you + * accessed is empty. + * @ingroup Exceptions + */ DeclException1 (ExcEmptyLevel, int, << "You tried to do something on level " << arg1 @@ -876,60 +882,60 @@ public: protected: /** - * The object containing - * information on the block structure. - */ + * The object containing + * information on the block structure. + */ BlockInfo block_info_object; /** - * 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; /** - * 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_cxx1x::shared_ptr > policy; /** - * 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. - */ + * 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. + */ dealii::internal::DoFHandler::NumberCache number_cache; /** @@ -940,25 +946,25 @@ protected: 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 &); class MGVertexDoFs @@ -983,8 +989,8 @@ private: void clear_mg_space (); /** - * Free all used memory. - */ + * Free all used memory. + */ void clear_space (); void reserve_space (); @@ -996,24 +1002,24 @@ private: 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 unsigned int global_index) const; /** - * 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; dealii::internal::DoFHandler::DoFFaces *mg_faces; @@ -1021,10 +1027,10 @@ private: std::vector mg_vertex_dofs; /** - * Make accessor objects friends. - */ - template friend class DoFAccessor; - template friend class DoFCellAccessor; + * Make accessor objects friends. + */ + template friend class DoFAccessor; + template friend class DoFCellAccessor; friend struct dealii::internal::DoFAccessor::Implementation; friend struct dealii::internal::DoFCellAccessor::Implementation; -- 2.39.5