From: Wolfgang Bangerth Date: Tue, 8 Aug 2000 13:48:40 +0000 (+0000) Subject: Change many @p's to @refs and assorted small doc updates. X-Git-Tag: v8.0.0~20193 X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=908cb9099806cc286eb9daadaee0b5d445036e3a;p=dealii.git Change many @p's to @refs and assorted small doc updates. git-svn-id: https://svn.dealii.org/trunk@3236 0785d39b-7218-0410-832d-ea1e28bc413d --- diff --git a/deal.II/deal.II/include/dofs/dof_accessor.h b/deal.II/deal.II/include/dofs/dof_accessor.h index f0d191b362..c32820885c 100644 --- a/deal.II/deal.II/include/dofs/dof_accessor.h +++ b/deal.II/deal.II/include/dofs/dof_accessor.h @@ -41,10 +41,10 @@ template class DoFHandler; * result in a strange kind of behaviour, though every reasonable * operating system should disallow access through that pointer. * The reason we do not check for the null pointer in the - * constructor which gets passed the @p{DoFHandler} pointer is that + * constructor which gets passed the @ref{DoFHandler} pointer is that * if we did we could not make dof iterators member of other classes - * (like in the @p{FEValues} class) if we did not know about the - * @p{DoFHandler} object to be used upon construction of that object. + * (like in the @ref{FEValues} class) if we did not know about the + * @ref{DoFHandler} object to be used upon construction of that object. * Through the way this class is implemented here, we allow the * creation of a kind of virgin object which only gets useful if * assigned to from another object before first usage. @@ -85,7 +85,7 @@ class DoFAccessor /** * Return a handle on the - * @p{DoFHandler} object which we + * @ref{DoFHandler} object which we * are using. */ const DoFHandler & @@ -120,7 +120,7 @@ class DoFAccessor protected: /** - * Store the address of the @p{DoFHandler} object + * Store the address of the @ref{DoFHandler} object * to be accessed. */ DoFHandler *dof_handler; @@ -131,13 +131,13 @@ class DoFAccessor /** * This is a switch class which only declares a @p{typedef}. It is meant to - * determine which class a @p{DoFObjectAccessor} class is to be derived + * determine which class a @ref{DoFObjectAccessor} class is to be derived * from. By default, @p{DoFObjectAccessor} derives from * the @p{typedef} in the general @p{DoFObjectAccessor_Inheritance} * class, which is @p{TriaObjectAccessor}, * but if @p{celldim==dim}, then the specialization @p{DoFObjectAccessor_Inheritance} * is used which declares its local type to be @p{CellAccessor}. Therefore, - * the inheritance is automatically chosen to be from @p{CellAccessor} if the + * the inheritance is automatically chosen to be from @ref{CellAccessor} if the * object under consideration has full dimension, i.e. constitutes a cell. * * @author Wolfgang Bangerth, 1999 @@ -156,13 +156,13 @@ class DoFObjectAccessor_Inheritance /** * This is a switch class which only declares a @p{typedef}. It is meant to - * determine which class a @p{DoFObjectAccessor} class is to be derived + * determine which class a @ref{DoFObjectAccessor} class is to be derived * from. By default, @p{DoFObjectAccessor} derives from * the @p{typedef} in the general @p{DoFObjectAccessor_Inheritance} * class, which is @p{TriaObjectAccessor}, * but if @p{celldim==dim}, then the specialization @p{DoFObjectAccessor_Inheritance} * is used which declares its local type to be @p{CellAccessor}. Therefore, - * the inheritance is automatically chosen to be from @p{CellAccessor} if the + * the inheritance is automatically chosen to be from @ref{CellAccessor} if the * object under consideration has full dimension, i.e. constitutes a cell. * * @author Wolfgang Bangerth, 1999 @@ -243,7 +243,7 @@ class DoFObjectAccessor : public DoFAccessor, /** * Constructor. The @p{local_data} * argument is assumed to be a pointer - * to a @p{DoFHandler} object. + * to a @ref{DoFHandler} object. */ DoFObjectAccessor (Triangulation *tria, const int level, @@ -309,8 +309,8 @@ class DoFObjectAccessor : public DoFAccessor, * * The input vector may be either * a @p{Vector}, - * @p{Vector}, or a - * @p{BlockVector<...,double>}. It + * @ref{Vector}@p{}, or a + * @ref{BlockVector}@p{<...,double>}. It * is in the responsibility of * the caller to assure that the * types of the numbers stored in @@ -346,9 +346,9 @@ class DoFObjectAccessor : public DoFAccessor, * to this function. * * The output vector may be either - * a @p{Vector}, - * @p{Vector}, or a - * @p{BlockVector<...,double>}. It + * a @ref{Vector}@p{}, + * @ref{Vector}@p{}, or a + * @ref{BlockVector}@p{<...,double>}. It * is in the responsibility of * the caller to assure that the * types of the numbers stored in @@ -375,7 +375,7 @@ class DoFObjectAccessor : public DoFAccessor, quad (const unsigned int i) const; /** - * @p{i}th child as a @p{DoFObjectAccessor} + * @p{i}th child as a @ref{DoFObjectAccessor} * iterator. This function is needed since * the child function of the base * class returns a hex accessor without @@ -400,7 +400,7 @@ class DoFObjectAccessor : public DoFAccessor, /** * This function does much the same as the - * @p{distribute_local_to_global(dVector,dVector)} + * @p{distribute_local_to_global(Vector,Vector)} * function, but operates on matrices * instead of vectors. The sparse matrix * is supposed to have non-zero entry @@ -497,7 +497,7 @@ class DoFObjectAccessor<1, dim> : public DoFAccessor, /** * Constructor. The @p{local_data} * argument is assumed to be a pointer - * to a @p{DoFHandler} object. + * to a @ref{DoFHandler} object. */ DoFObjectAccessor (Triangulation *tria, const int level, @@ -559,9 +559,9 @@ class DoFObjectAccessor<1, dim> : public DoFAccessor, * cells. * * The input vector may be either - * a @p{Vector}, - * @p{Vector}, or a - * @p{BlockVector<...,double>}. It + * a @ref{Vector}@p{}, + * @ref{Vector}@p{}, or a + * @ref{BlockVector}@p{<...,double>}. It * is in the responsibility of * the caller to assure that the * types of the numbers stored in @@ -596,9 +596,9 @@ class DoFObjectAccessor<1, dim> : public DoFAccessor, * have the right size beforehand. * * The output vector may be either - * a @p{Vector}, - * @p{Vector}, or a - * @p{BlockVector<...,double>}. It + * a @ref{Vector}@p{}, + * @ref{Vector}@p{}, or a + * @ref{BlockVector}@p{<...,double>}. It * is in the responsibility of * the caller to assure that the * types of the numbers stored in @@ -636,7 +636,7 @@ class DoFObjectAccessor<1, dim> : public DoFAccessor, /** * This function does much the same as the - * @p{distribute_local_to_global(dVector,dVector)} + * @p{distribute_local_to_global(Vector,Vector)} * function, but operates on matrices * instead of vectors. The sparse matrix * is supposed to have non-zero entry @@ -685,7 +685,7 @@ class DoFObjectAccessor<2, dim> : public DoFAccessor, /** * Constructor. The @p{local_data} * argument is assumed to be a pointer - * to a @p{DoFHandler} object. + * to a @ref{DoFHandler} object. */ DoFObjectAccessor (Triangulation *tria, const int level, @@ -748,9 +748,9 @@ class DoFObjectAccessor<2, dim> : public DoFAccessor, * cells. * * The input vector may be either - * a @p{Vector}, - * @p{Vector}, or a - * @p{BlockVector<...,double>}. It + * a @ref{Vector}@p{}, + * @ref{Vector}@p{}, or a + * @ref{BlockVector}@p{<...,double>}. It * is in the responsibility of * the caller to assure that the * types of the numbers stored in @@ -785,9 +785,9 @@ class DoFObjectAccessor<2, dim> : public DoFAccessor, * have the right size beforehand. * * The output vector may be either - * a @p{Vector}, - * @p{Vector}, or a - * @p{BlockVector<...,double>}. It + * a @ref{Vector}@p{}, + * @ref{Vector}@p{}, or a + * @ref{BlockVector}@p{<...,double>}. It * is in the responsibility of * the caller to assure that the * types of the numbers stored in @@ -833,7 +833,7 @@ class DoFObjectAccessor<2, dim> : public DoFAccessor, /** * This function does much the same as the - * @p{distribute_local_to_global(dVector,dVector)} + * @p{distribute_local_to_global(Vector,Vector)} * function, but operates on matrices * instead of vectors. The sparse matrix * is supposed to have non-zero entry @@ -882,7 +882,7 @@ class DoFObjectAccessor<3, dim> : public DoFAccessor, /** * Constructor. The @p{local_data} * argument is assumed to be a pointer - * to a @p{DoFHandler} object. + * to a @ref{DoFHandler} object. */ DoFObjectAccessor (Triangulation *tria, const int level, @@ -945,9 +945,9 @@ class DoFObjectAccessor<3, dim> : public DoFAccessor, * cells. * * The input vector may be either - * a @p{Vector}, - * @p{Vector}, or a - * @p{BlockVector<...,double>}. It + * a @ref{Vector}@p{}, + * @ref{Vector}@p{}, or a + * @ref{BlockVector}@p{<...,double>}. It * is in the responsibility of * the caller to assure that the * types of the numbers stored in @@ -982,9 +982,9 @@ class DoFObjectAccessor<3, dim> : public DoFAccessor, * have the right size beforehand. * * The output vector may be either - * a @p{Vector}, - * @p{Vector}, or a - * @p{BlockVector<...,double>}. It + * a @ref{Vector}@p{}, + * @ref{Vector}@p{}, or a + * @ref{BlockVector}@p{<...,double>}. It * is in the responsibility of * the caller to assure that the * types of the numbers stored in @@ -1036,7 +1036,7 @@ class DoFObjectAccessor<3, dim> : public DoFAccessor, /** * This function does much the same as the - * @p{distribute_local_to_global(dVector,dVector)} + * @p{distribute_local_to_global(Vector,Vector)} * function, but operates on matrices * instead of vectors. The sparse matrix * is supposed to have non-zero entry @@ -1053,6 +1053,7 @@ class DoFObjectAccessor<3, dim> : public DoFAccessor, }; + /** * Grant access to the degrees of freedom on a cell. In fact, since all * access to the degrees of freedom has been enabled by the classes @@ -1060,14 +1061,14 @@ class DoFObjectAccessor<3, dim> : public DoFAccessor, * one and two, respectively, this class only collects the pieces * together by deriving from the appropriate @p{DoF*Accessor} and the * right @p{CellAccessor} and finally adding two functions which give - * access to the neighbors and children as @p{DoFCellAccessor} objects - * rather than @p{CellAccessor} objects (the latter function was inherited + * access to the neighbors and children as @ref{DoFCellAccessor} objects + * rather than @ref{CellAccessor} objects (the latter function was inherited * from the @p{CellAccessor} class). * * Note that since for the class we derive from, i.e. @p{DoFObjectAccessor}, * the two template parameters are equal, the base class is actually derived from - * @p{CellAccessor}, which makes the functions of this class available to the - * @p{DoFCellAccessor} class as well. + * @ref{CellAccessor}, which makes the functions of this class available to the + * @ref{DoFCellAccessor} class as well. * * @author Wolfgang Bangerth, 1998 */ @@ -1233,9 +1234,9 @@ class DoFCellAccessor : public DoFObjectAccessor * objects. * * The output vector may be either - * a @p{Vector}, - * @p{Vector}, or a - * @p{BlockVector<...,double>}. It + * a @ref{Vector}@p{}, + * @ref{Vector}@p{}, or a + * @ref{BlockVector}@p{<...,double>}. It * is in the responsibility of * the caller to assure that the * types of the numbers stored in diff --git a/deal.II/deal.II/include/dofs/dof_constraints.h b/deal.II/deal.II/include/dofs/dof_constraints.h index c599e6407e..a44c9bcd14 100644 --- a/deal.II/deal.II/include/dofs/dof_constraints.h +++ b/deal.II/deal.II/include/dofs/dof_constraints.h @@ -44,7 +44,7 @@ template class BlockIndices; * operation. * * Condensation is done in four steps: first the large matrix sparsity pattern - * is created (e.g. using @p{DoFHandler::create_sparsity_pattern}), then the + * is created (e.g. using @ref{DoFHandler}@p{::create_sparsity_pattern}), then the * sparsity pattern of the condensed matrix is made out of the large sparsity * pattern and the constraints. After that the global matrix is assembled and * finally condensed. To do these steps, you have (at least) two possibilities: @@ -286,9 +286,9 @@ class ConstraintMatrix : public Subscriptor * entries of @p{condensed} be zero! * * The @p{VectorType} may be a - * @p{Vector}, - * @p{Vector}, - * @p{BlockVector<...>}, or any + * @ref{Vector}@p{}, + * @ref{Vector}@p{}, + * @ref{BlockVector}@p{<...>}, or any * other type having the same * interface. */ @@ -299,9 +299,9 @@ class ConstraintMatrix : public Subscriptor /** * Condense the given vector * in-place. The @p{VectorType} may - * be a @p{Vector}, - * @p{Vector}, - * @p{BlockVector<...>}, or any + * be a @ref{Vector}@p{}, + * @ref{Vector}@p{}, + * @ref{BlockVector}@p{<...>}, or any * other type having the same * interface. */ @@ -323,9 +323,9 @@ class ConstraintMatrix : public Subscriptor * @p{condense}. * * The @p{VectorType} may be a - * @p{Vector}, - * @p{Vector}, - * @p{BlockVector<...>}, or any + * @ref{Vector}@p{}, + * @ref{Vector}@p{}, + * @ref{BlockVector}@p{<...>}, or any * other type having the same * interface. */ @@ -337,9 +337,9 @@ class ConstraintMatrix : public Subscriptor * Re-distribute the elements of * the vector in-place. The * @p{VectorType} may be a - * @p{Vector}, - * @p{Vector}, - * @p{BlockVector<...>}, or any + * @ref{Vector}@p{}, + * @ref{Vector}@p{}, + * @ref{BlockVector}@p{<...>}, or any * other type having the same * interface. */ @@ -351,9 +351,9 @@ class ConstraintMatrix : public Subscriptor * vector. Sets all hanging node * values to zero. The * @p{VectorType} may be a - * @p{Vector}, - * @p{Vector}, - * @p{BlockVector<...>}, or any + * @ref{Vector}@p{}, + * @ref{Vector}@p{}, + * @ref{BlockVector}@p{<...>}, or any * other type having the same * interface. */ @@ -443,7 +443,7 @@ class ConstraintMatrix : public Subscriptor * For the reason why we use a vector * instead of a map and the consequences * thereof, the same applies as what is - * said for @p{ConstraintMatrix::lines}. + * said for @ref{ConstraintMatrix}@p{::lines}. */ vector > entries; diff --git a/deal.II/deal.II/include/dofs/dof_handler.h b/deal.II/deal.II/include/dofs/dof_handler.h index a344be7c04..edbf9d2dc0 100644 --- a/deal.II/deal.II/include/dofs/dof_handler.h +++ b/deal.II/deal.II/include/dofs/dof_handler.h @@ -48,7 +48,8 @@ class DoFDimensionInfo; * * The types have the same meaning as those declared in @ref{TriaDimensionInfo<2>}. */ -class DoFDimensionInfo<1> { +class DoFDimensionInfo<1> +{ public: typedef TriaRawIterator<1,DoFCellAccessor<1> > raw_line_iterator; typedef TriaIterator<1,DoFCellAccessor<1> > line_iterator; @@ -72,12 +73,14 @@ class DoFDimensionInfo<1> { }; + /** * Define some types for the DoF handling in two dimensions. * * The types have the same meaning as those declared in @ref{TriaDimensionInfo<2>}. */ -class DoFDimensionInfo<2> { +class DoFDimensionInfo<2> +{ public: typedef TriaRawIterator<2,DoFObjectAccessor<1, 2> > raw_line_iterator; typedef TriaIterator<2,DoFObjectAccessor<1, 2> > line_iterator; @@ -101,12 +104,14 @@ class DoFDimensionInfo<2> { }; + /** * Define some types for the DoF handling in two dimensions. * * The types have the same meaning as those declared in @ref{TriaDimensionInfo<3>}. */ -class DoFDimensionInfo<3> { +class DoFDimensionInfo<3> +{ public: typedef TriaRawIterator<3,DoFObjectAccessor<1, 3> > raw_line_iterator; typedef TriaIterator<3,DoFObjectAccessor<1, 3> > line_iterator; @@ -130,6 +135,7 @@ class DoFDimensionInfo<3> { }; + /** * Manage the distribution and numbering of the degrees of freedom for * non-multigrid algorithms. @@ -149,7 +155,7 @@ class DoFDimensionInfo<3> { * by offering @p{begin()} and @p{end()} functions which return iterators * to walk on the DoF structures as well as the triangulation data. * These iterators work much like those described in the documentation - * of the @p{Triangulation} class and of the iterator classes themselved, + * of the @ref{Triangulation} class and of the iterator classes themselved, * but offer more functionality than pure triangulation iterators. The * order in which dof iterators are presented by the @p{++} and @p{--} operators * is the same as that for the alike triangulation iterators. @@ -175,14 +181,14 @@ class DoFDimensionInfo<3> { * * This numbering implies very large bandwiths of the resulting matrices and * is thus vastly suboptimal for some solution algorithms. For this reason, - * the @p{DoFRenumbering} class offers the function @p{renumber_dofs} which reorders + * the @ref{DoFRenumbering} class offers the function @p{renumber_dofs} which reorders * the dof numbering according to some scheme. See there for a discussion of * the implemented algorithms. * * * @sect3{User defined renumbering schemes} * - * The @p{DoFRenumbering} class offers a fixed number of renumbering + * The @ref{DoFRenumbering} class offers a fixed number of renumbering * schemes like the Cuthill-McKey scheme. Basically, the function sets * up an array in which for each degree of freedom the index is stored * which is to be assigned by the renumbering. Using this array, the @@ -250,7 +256,7 @@ class DoFDimensionInfo<3> { * Lagrange elements this is the point where it has the function value @p{1}), is * located on the boundary. We do not check this directly, the criterion is * rather defined through the information the finite element class gives: the - * @p{FiniteElementBase} class defines the numbers of basis functions per vertex, + * @ref{FiniteElementBase} class defines the numbers of basis functions per vertex, * per line, and so on and the basis functions are numbered after this * information; a basis function is to be considered to be on the face of a * cell (and thus on the boundary if the cell is at the boundary) according @@ -405,7 +411,7 @@ class DoFHandler : public Subscriptor, * This is the maximum number of entries * per line in the system matrix; this * information can therefore be used upon - * construction of the @p{SparsityPattern} + * construction of the @ref{SparsityPattern} * object. * * The returned number is not really the diff --git a/deal.II/deal.II/include/dofs/dof_levels.h b/deal.II/deal.II/include/dofs/dof_levels.h index f8e52e8cf9..40a3cf92de 100644 --- a/deal.II/deal.II/include/dofs/dof_levels.h +++ b/deal.II/deal.II/include/dofs/dof_levels.h @@ -21,6 +21,8 @@ * Store the indices of the degrees of freedom which are located on the lines. * Declare it to have a template parameter, but do not actually declare * other types than those explicitely instantiated. + * + * @author Wolfgang Bangerth, 1998 */ template class DoFLevel @@ -37,9 +39,9 @@ class DoFLevel /** * Store the indices of the degrees of freedom which are located on the lines. * - * @sect3{Information for all @p{DoFLevel} classes} + * @sect3{Information for all @ref{DoFLevel} classes} * - * The @p{DoFLevel} classes + * The @ref{DoFLevel}@p{} classes * store the global indices of the degrees of freedom for each cell on a * certain level. The index or number of a degree of freedom is the zero-based * index of the according value in the solution vector and the row and column @@ -57,25 +59,27 @@ class DoFLevel * $\ldots, u_1^m, u_2^m, u_1^{m+1}, u_2^{m+1},\ldots$ with $m$ denoting the * $m$th basis function, or $\ldots, u_1^m, u_1^{m+1}, u_1^{m+2}, \ldots, * u_2^m, u_2^{m+1}, u_2^{m+2}, \ldots$, respectively). Likewise, the - * constraint matrix returned by @p{DoFHandler::make_hanging_node_constraints ()} + * constraint matrix returned by @ref{DoFHandler}@p{::make_hanging_node_constraints ()} * is then * to be understood as a block matrix. * * The storage format of the degrees of freedom indices (short: DoF indices) is * somewhat like a mirror of the data structures of the triangulation classes. - * There is a hierarchy of @p{DoFLevel} classes for the different dimensions + * There is a hierarchy of @ref{DoFLevel}@p{} classes for the different dimensions * which have objects named @p{line_dofs}, @p{quad_dofs} and so on, in which the * indices of DoFs located on lines and quads, respectively, are stored. The * indices are stored levelwise. The layout in * these arrays is as follows: if for a selected finite element (use - * @p{DoFHandler::distribute_dofs()} to select a finite element) the number of + * @ref{DoFHandler}@p{::distribute_dofs()} to select a finite element) the number of * DoFs on each line (without those in the vertices) is @p{N}, then the length * of the @p{line_dofs} array is @p{N} times the number of lines on this level. The * DoF indices for the @p{i}th line are at the positions @p{N*i...(N+1)*i-1}. * * The DoF indices for vertices are not stored this way, since they need * different treatment in multigrid environments. If no multigrid is used, the - * indices are stored in the @p{vertex_dofs} array of the @p{DoFHandler} class. + * indices are stored in the @p{vertex_dofs} array of the @ref{DoFHandler} class. + * + * @author Wolfgang Bangerth, 1998 */ class DoFLevel<1> { @@ -89,11 +93,15 @@ class DoFLevel<1> }; + /** * Store the indices of the degrees of freedom which are located on quads. * See @ref{DoFLevel<1>} for more information. + * + * @author Wolfgang Bangerth, 1998 */ -class DoFLevel<2> : public DoFLevel<1> { +class DoFLevel<2> : public DoFLevel<1> +{ public: /** * Store the global indices of the degrees @@ -104,11 +112,15 @@ class DoFLevel<2> : public DoFLevel<1> { }; + /** * Store the indices of the degrees of freedom which are located on hexhedra. * See @ref{DoFLevel<1>} for more information. + * + * @author Wolfgang Bangerth, 1998 */ -class DoFLevel<3> : public DoFLevel<2> { +class DoFLevel<3> : public DoFLevel<2> +{ public: /** * Store the global indices of the degrees diff --git a/deal.II/deal.II/include/dofs/dof_tools.h b/deal.II/deal.II/include/dofs/dof_tools.h index 0ed2a26456..2ac82095cb 100644 --- a/deal.II/deal.II/include/dofs/dof_tools.h +++ b/deal.II/deal.II/include/dofs/dof_tools.h @@ -33,7 +33,7 @@ template