]> https://gitweb.dealii.org/ - dealii.git/commitdiff
More work towards doxygen.
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Mon, 19 Apr 2004 01:37:38 +0000 (01:37 +0000)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Mon, 19 Apr 2004 01:37:38 +0000 (01:37 +0000)
git-svn-id: https://svn.dealii.org/trunk@9047 0785d39b-7218-0410-832d-ea1e28bc413d

117 files changed:
deal.II/deal.II/include/dofs/dof_accessor.h
deal.II/deal.II/include/dofs/dof_constraints.h
deal.II/deal.II/include/dofs/dof_constraints.templates.h
deal.II/deal.II/include/dofs/dof_handler.h
deal.II/deal.II/include/dofs/dof_levels.h
deal.II/deal.II/include/dofs/dof_renumbering.h
deal.II/deal.II/include/dofs/dof_tools.h
deal.II/deal.II/include/dofs/function_map.h
deal.II/deal.II/include/fe/fe.h
deal.II/deal.II/include/fe/fe_base.h
deal.II/deal.II/include/fe/fe_dgp.h
deal.II/deal.II/include/fe/fe_dgp_monomial.h
deal.II/deal.II/include/fe/fe_dgp_nonparametric.h
deal.II/deal.II/include/fe/fe_dgq.h
deal.II/deal.II/include/fe/fe_nedelec.h
deal.II/deal.II/include/fe/fe_poly.h
deal.II/deal.II/include/fe/fe_q.h
deal.II/deal.II/include/fe/fe_q_hierarchical.h
deal.II/deal.II/include/fe/fe_raviart_thomas.h
deal.II/deal.II/include/fe/fe_system.h
deal.II/deal.II/include/fe/fe_tools.h
deal.II/deal.II/include/fe/fe_update_flags.h
deal.II/deal.II/include/fe/fe_values.h
deal.II/deal.II/include/fe/mapping.h
deal.II/deal.II/include/fe/mapping_c1.h
deal.II/deal.II/include/fe/mapping_cartesian.h
deal.II/deal.II/include/fe/mapping_q.h
deal.II/deal.II/include/fe/mapping_q1.h
deal.II/deal.II/include/fe/mapping_q1_eulerian.h
deal.II/deal.II/include/grid/filtered_iterator.h
deal.II/deal.II/include/grid/geometry_info.h
deal.II/deal.II/include/grid/grid_generator.h
deal.II/deal.II/include/grid/grid_in.h
deal.II/deal.II/include/grid/grid_out.h
deal.II/deal.II/include/grid/grid_refinement.h
deal.II/deal.II/include/grid/grid_reordering.h
deal.II/deal.II/include/grid/grid_reordering_internal.h
deal.II/deal.II/include/grid/grid_tools.h
deal.II/deal.II/include/grid/intergrid_map.h
deal.II/deal.II/include/grid/persistent_tria.h
deal.II/deal.II/include/grid/tria.h
deal.II/deal.II/include/grid/tria_accessor.h
deal.II/deal.II/include/grid/tria_accessor.templates.h
deal.II/deal.II/include/grid/tria_boundary.h
deal.II/deal.II/include/grid/tria_boundary_lib.h
deal.II/deal.II/include/grid/tria_hex.h
deal.II/deal.II/include/grid/tria_iterator.h
deal.II/deal.II/include/grid/tria_levels.h
deal.II/deal.II/include/grid/tria_line.h
deal.II/deal.II/include/grid/tria_quad.h
deal.II/deal.II/include/multigrid/mg_coarse.h
deal.II/deal.II/include/multigrid/mg_dof_accessor.h
deal.II/deal.II/include/multigrid/mg_dof_handler.h
deal.II/deal.II/include/multigrid/mg_dof_tools.h
deal.II/deal.II/include/multigrid/mg_level_object.h
deal.II/deal.II/include/multigrid/mg_matrix.h
deal.II/deal.II/include/multigrid/mg_smoother.h
deal.II/deal.II/include/multigrid/mg_transfer.h
deal.II/deal.II/include/multigrid/multigrid.h
deal.II/deal.II/include/numerics/data_out.h
deal.II/deal.II/include/numerics/data_out_faces.h
deal.II/deal.II/include/numerics/data_out_rotation.h
deal.II/deal.II/include/numerics/data_out_stack.h
deal.II/deal.II/include/numerics/derivative_approximation.h
deal.II/deal.II/include/numerics/dof_print_solver_step.h
deal.II/deal.II/include/numerics/error_estimator.h
deal.II/deal.II/include/numerics/histogram.h
deal.II/deal.II/include/numerics/matrices.h
deal.II/deal.II/include/numerics/solution_transfer.h
deal.II/deal.II/include/numerics/time_dependent.h
deal.II/deal.II/include/numerics/vectors.h
deal.II/lac/include/lac/block_indices.h
deal.II/lac/include/lac/block_matrix.h
deal.II/lac/include/lac/block_matrix_array.h
deal.II/lac/include/lac/block_sparse_matrix.h
deal.II/lac/include/lac/block_sparse_matrix_ez.h
deal.II/lac/include/lac/block_sparsity_pattern.h
deal.II/lac/include/lac/block_vector.h
deal.II/lac/include/lac/compressed_sparsity_pattern.h
deal.II/lac/include/lac/eigen.h
deal.II/lac/include/lac/filtered_matrix.h
deal.II/lac/include/lac/full_matrix.h
deal.II/lac/include/lac/matrix_lib.h
deal.II/lac/include/lac/matrix_out.h
deal.II/lac/include/lac/petsc_full_matrix.h
deal.II/lac/include/lac/petsc_matrix_base.h
deal.II/lac/include/lac/petsc_parallel_sparse_matrix.h
deal.II/lac/include/lac/petsc_parallel_vector.h
deal.II/lac/include/lac/petsc_solver.h
deal.II/lac/include/lac/petsc_sparse_matrix.h
deal.II/lac/include/lac/petsc_vector.h
deal.II/lac/include/lac/petsc_vector_base.h
deal.II/lac/include/lac/pointer_matrix.h
deal.II/lac/include/lac/precondition_block.h
deal.II/lac/include/lac/precondition_block.templates.h
deal.II/lac/include/lac/precondition_selector.h
deal.II/lac/include/lac/schur_matrix.h
deal.II/lac/include/lac/solver.h
deal.II/lac/include/lac/solver_bicgstab.h
deal.II/lac/include/lac/solver_cg.h
deal.II/lac/include/lac/solver_control.h
deal.II/lac/include/lac/solver_gmres.h
deal.II/lac/include/lac/solver_minres.h
deal.II/lac/include/lac/solver_qmrs.h
deal.II/lac/include/lac/solver_richardson.h
deal.II/lac/include/lac/solver_selector.h
deal.II/lac/include/lac/sparse_direct.h
deal.II/lac/include/lac/sparse_ilu.h
deal.II/lac/include/lac/sparse_matrix_ez.h
deal.II/lac/include/lac/sparse_mic.h
deal.II/lac/include/lac/sparse_vanka.h
deal.II/lac/include/lac/sparse_vanka.templates.h
deal.II/lac/include/lac/sparsity_pattern.h
deal.II/lac/include/lac/swappable_vector.h
deal.II/lac/include/lac/swappable_vector.templates.h
deal.II/lac/include/lac/vector.h
deal.II/lac/include/lac/vector_memory.h

index 56770658d8427e41d0c89ca110417cb283c098d2..f6daa50b4e832844c0c5d4986cefa23ef58a8bdf 100644 (file)
@@ -47,14 +47,14 @@ template <int dim>              class DoFObjectAccessor<3, dim>;
  * Define the basis for accessors to the degrees of freedom.
  *
  * Note that it is allowed to construct an object of which the
- * @p{dof_handler} pointer is a Null pointer. Such an object would
+ * @p dof_handler pointer is a Null pointer. Such an object would
  * 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 @ref{DoFHandler} pointer is that
+ * constructor which gets passed the DoFHandler pointer is that
  * if we did we could not make dof iterators member of other classes
- * (like in the @ref{FEValues} class) if we did not know about the
- * @ref{DoFHandler} object to be used upon construction of that object.
+ * (like in the FEValues class) if we did not know about the
+ * 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.
@@ -63,7 +63,7 @@ template <int dim>              class DoFObjectAccessor<3, dim>;
  * which has an invalid dof handler pointer. This is to guarantee
  * that every iterator which is once assigned to is a valid
  * object. However, this assertion only holds in debug mode, when
- * the @p{Assert} macro is switched on.
+ * the @p Assert macro is switched on.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -78,7 +78,7 @@ class DoFAccessor
 
                                     /**
                                      * This should be the default constructor.
-                                     * We cast away the @p{const}ness of the
+                                     * We cast away the @p constness of the
                                      * pointer which clearly is EVIL but
                                      * we can't help without making all
                                      * functions which could somehow use
@@ -95,7 +95,7 @@ class DoFAccessor
 
                                     /**
                                      * Return a handle on the
-                                     * @ref{DoFHandler} object which we
+                                     * DoFHandler object which we
                                      * are using.
                                      */
     const DoFHandler<dim> &
@@ -138,7 +138,7 @@ class DoFAccessor
 
   protected:
                                     /**
-                                     * Store the address of the @ref{DoFHandler} object
+                                     * Store the address of the DoFHandler object
                                      * to be accessed.
                                      */
     DoFHandler<dim> *dof_handler;  
@@ -148,14 +148,14 @@ class DoFAccessor
 /* -------------------------------------------------------------------------- */
 
 /**
- * This is a switch class which only declares a @p{typedef}. It is meant to
- * determine which class a @ref{DoFObjectAccessor} class is to be derived
+ * This is a switch class which only declares a @p typedef. It is meant to
+ * determine which class a DoFObjectAccessor class is to be derived
  * from. By default, @p{DoFObjectAccessor<celldim,dim>} derives from
- * the @p{typedef} in the general @p{DoFObjectAccessor_Inheritance<celldim,dim>}
+ * the @p typedef in the general @p{DoFObjectAccessor_Inheritance<celldim,dim>}
  * class, which is @p{TriaObjectAccessor<celldim,dim>},
  * but if @p{celldim==dim}, then the specialization @p{DoFObjectAccessor_Inheritance<dim,dim>}
  * is used which declares its local type to be @p{CellAccessor<dim>}. Therefore,
- * the inheritance is automatically chosen to be from @ref{CellAccessor} if the
+ * the inheritance is automatically chosen to be from CellAccessor if the
  * object under consideration has full dimension, i.e. constitutes a cell.
  *
  * @author Wolfgang Bangerth, 1999
@@ -165,7 +165,7 @@ class DoFObjectAccessor_Inheritance
 {
   public:
                                     /**
-                                     * Declaration of the @p{typedef}.
+                                     * Declaration of the @p typedef.
                                      * See the full documentation for
                                      * more information.
                                      */
@@ -174,14 +174,14 @@ class DoFObjectAccessor_Inheritance
 
 
 /**
- * This is a switch class which only declares a @p{typedef}. It is meant to
- * determine which class a @ref{DoFObjectAccessor} class is to be derived
+ * This is a switch class which only declares a @p typedef. It is meant to
+ * determine which class a DoFObjectAccessor class is to be derived
  * from. By default, @p{DoFObjectAccessor<celldim,dim>} derives from
- * the @p{typedef} in the general @p{DoFObjectAccessor_Inheritance<celldim,dim>}
+ * the @p typedef in the general @p{DoFObjectAccessor_Inheritance<celldim,dim>}
  * class, which is @p{TriaObjectAccessor<celldim,dim>},
  * but if @p{celldim==dim}, then the specialization @p{DoFObjectAccessor_Inheritance<dim,dim>}
  * is used which declares its local type to be @p{CellAccessor<dim>}. Therefore,
- * the inheritance is automatically chosen to be from @ref{CellAccessor} if the
+ * the inheritance is automatically chosen to be from CellAccessor if the
  * object under consideration has full dimension, i.e. constitutes a cell.
  *
  * @author Wolfgang Bangerth, 1999
@@ -191,7 +191,7 @@ class DoFObjectAccessor_Inheritance<dim,dim>
 {
   public:
                                     /**
-                                     * Declaration of the @p{typedef}.
+                                     * Declaration of the @p typedef.
                                      * See the full documentation for
                                      * more information.
                                      */
@@ -209,10 +209,10 @@ class DoFObjectAccessor_Inheritance<dim,dim>
  * parameters. In this class here, we only collect all functions which
  * are in the specialized classes for simpler reference. Some
  * functions, however, might be missing in the specialized classes,
- * such as @p{quad} in the accessors for lines and quads, etc.
+ * such as @p quad in the accessors for lines and quads, etc.
  *
  * This class follows mainly the route laid out by the accessor library
- * declared in the triangulation library (@ref{TriaAccessor}). It enables
+ * declared in the triangulation library (TriaAccessor). It enables
  * the user to access the degrees of freedom on the lines (there are similar
  * versions for the DoFs on quads, etc), where the dimension of the underlying
  * triangulation does not really matter (i.e. this accessor works with the
@@ -221,7 +221,7 @@ class DoFObjectAccessor_Inheritance<dim,dim>
  *
  * @sect3{Usage}
  *
- * The @ref{DoFDimensionInfo} classes inherited by the @ref{DoFHandler} classes
+ * The DoFDimensionInfo classes inherited by the DoFHandler classes
  * declare typedefs to iterators using the accessors declared in this class
  * hierarchy tree. Usage is best to happen through these typedefs, since they
  * are more secure to changes in the class naming and template interface as well
@@ -262,9 +262,9 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
     DoFObjectAccessor ();
 
                                     /**
-                                     * Constructor. The @p{local_data}
+                                     * Constructor. The @p local_data
                                      * argument is assumed to be a pointer
-                                     * to a @ref{DoFHandler} object.
+                                     * to a DoFHandler object.
                                      */
     DoFObjectAccessor (const Triangulation<dim> *tria,
                       const int                 level,
@@ -272,28 +272,28 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
                       const AccessorData       *local_data);
     
                                     /**
-                                     * Index of the @p{i}th degree
+                                     * Index of the @p ith degree
                                      * of freedom of this object.
                                      */
     unsigned int dof_index (const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the @p{i}th degree
-                                     * of freedom of this object to @p{index}.
+                                     * Set the index of the @p ith degree
+                                     * of freedom of this object to @p index.
                                      */
     void set_dof_index (const unsigned int i,
                        const int index) const;
 
                                     /**
-                                     * Index of the @p{i}th degree
-                                     * on the @p{vertex}th vertex.
+                                     * Index of the @p ith degree
+                                     * on the @p vertexth vertex.
                                      */
     unsigned int vertex_dof_index (const unsigned int vertex,
                                   const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the @p{i}th degree
-                                     * on the @p{vertex}th vertex to @p{index}.
+                                     * Set the index of the @p ith degree
+                                     * on the @p vertexth vertex to @p index.
                                      */
     void set_vertex_dof_index (const unsigned int vertex,
                               const unsigned int i,
@@ -328,8 +328,8 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
                                      *
                                      * The input vector may be either a
                                      * @p{Vector<float>},
-                                     * @ref{Vector}@p{<double>}, or a
-                                     * @ref{BlockVector}@p{<double>}, or a
+                                     * Vector@p{<double>}, or a
+                                     * BlockVector@p{<double>}, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -343,11 +343,11 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
 
                                     /**
                                      * This function is the counterpart to
-                                     * @p{get_dof_values}: it takes a vector
+                                     * @p get_dof_values: it takes a vector
                                      * of values for the degrees of freedom
                                      * of the cell pointed to by this iterator
                                      * and writes these values into the global
-                                     * data vector @p{values}. This function
+                                     * data vector @p values. This function
                                      * is only callable for active cells.
                                      *
                                      * Note that for continuous finite
@@ -365,9 +365,9 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
                                      * to this function.
                                      *
                                      * The output vector may be either a
-                                     * @ref{Vector}@p{<float>},
-                                     * @ref{Vector}@p{<double>}, or a
-                                     * @ref{BlockVector}@p{<double>}, or a
+                                     * Vector@p{<float>},
+                                     * Vector@p{<double>}, or a
+                                     * BlockVector@p{<double>}, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -380,21 +380,21 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
                         OutputVector         &values) const;
 
                                     /**
-                                     *  Pointer to the @p{i}th line
+                                     *  Pointer to the @p ith line
                                      *  bounding this Object.
                                      */
     TriaIterator<dim,DoFObjectAccessor<1, dim> >
     line (const unsigned int i) const;
 
                                     /**
-                                     *  Pointer to the @p{i}th quad
+                                     *  Pointer to the @p ith quad
                                      *  bounding this Object.
                                      */
     TriaIterator<dim,DoFObjectAccessor<2, dim> >
     quad (const unsigned int i) const;
     
                                     /**
-                                     * @p{i}th child as a @ref{DoFObjectAccessor}
+                                     * @p ith child as a DoFObjectAccessor
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a hex accessor without
@@ -472,7 +472,7 @@ class DoFObjectAccessor<0, dim> : public DoFAccessor<dim>,
 /**
  * Access to the degrees of freedom located on lines.
  * This class follows mainly the route laid out by the accessor library
- * declared in the triangulation library (@ref{TriaAccessor}). It enables
+ * declared in the triangulation library (TriaAccessor). It enables
  * the user to access the degrees of freedom on the lines (there are similar
  * versions for the DoFs on quads, etc), where the dimension of the underlying
  * triangulation does not really matter (i.e. this accessor works with the
@@ -481,7 +481,7 @@ class DoFObjectAccessor<0, dim> : public DoFAccessor<dim>,
  *
  * @sect3{Usage}
  *
- * The @ref{DoFDimensionInfo} classes inherited by the @ref{DoFHandler} classes
+ * The DoFDimensionInfo classes inherited by the DoFHandler classes
  * declare typedefs to iterators using the accessors declared in this class
  * hierarchy tree. Usage is best to happens through these typedefs, since they
  * are more secure to changes in the class naming and template interface as well
@@ -492,7 +492,7 @@ class DoFObjectAccessor<0, dim> : public DoFAccessor<dim>,
  *
  * Inheritance from @p{DoFObjectAccessor_Inheritance<1,dim>::BaseClass} yields
  * inheritance from @p{CellAccessor<1>} if @p{dim==1} and from
- * @p{TriaObjectAccessor<1,dim>} for all other @p{dim} values. Thus, an object
+ * @p{TriaObjectAccessor<1,dim>} for all other @p dim values. Thus, an object
  * of this class shares all features of cells in one dimension, but behaves
  * like an ordinary line in all other cases.
  *
@@ -523,9 +523,9 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
     DoFObjectAccessor ();
     
                                     /**
-                                     * Constructor. The @p{local_data}
+                                     * Constructor. The @p local_data
                                      * argument is assumed to be a pointer
-                                     * to a @ref{DoFHandler} object.
+                                     * to a DoFHandler object.
                                      */
     DoFObjectAccessor (const Triangulation<dim> *tria,
                       const int                 level,
@@ -533,28 +533,28 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
                       const AccessorData       *local_data);
     
                                     /**
-                                     * Return the index of the @p{i}th degree
+                                     * Return the index of the @p ith degree
                                      * of freedom of this line.
                                      */
     unsigned int dof_index (const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the @p{i}th degree
-                                     * of freedom of this line to @p{index}.
+                                     * Set the index of the @p ith degree
+                                     * of freedom of this line to @p index.
                                      */
     void set_dof_index (const unsigned int i,
                        const unsigned int index) const;
 
                                     /**
-                                     * Return the index of the @p{i}th degree
-                                     * on the @p{vertex}th vertex.
+                                     * Return the index of the @p ith degree
+                                     * on the @p vertexth vertex.
                                      */
     unsigned int vertex_dof_index (const unsigned int vertex,
                                   const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the @p{i}th degree
-                                     * on the @p{vertex}th vertex to @p{index}.
+                                     * Set the index of the @p ith degree
+                                     * on the @p vertexth vertex to @p index.
                                      */
     void set_vertex_dof_index (const unsigned int vertex,
                               const unsigned int i,
@@ -585,9 +585,9 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
                                      * cells.
                                      *
                                      * The input vector may be either a
-                                     * @ref{Vector}@p{<float>},
-                                     * @ref{Vector}@p{<double>}, or a
-                                     * @ref{BlockVector}@p{<double>}, or a
+                                     * Vector@p{<float>},
+                                     * Vector@p{<double>}, or a
+                                     * BlockVector@p{<double>}, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -601,11 +601,11 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
 
                                     /**
                                      * This function is the counterpart to
-                                     * @p{get_dof_values}: it takes a vector
+                                     * @p get_dof_values: it takes a vector
                                      * of values for the degrees of freedom
                                      * of the cell pointed to by this iterator
                                      * and writes these values into the global
-                                     * data vector @p{values}. This function
+                                     * data vector @p values. This function
                                      * is only callable for active cells.
                                      *
                                      * Note that for continuous finite
@@ -622,9 +622,9 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
                                      * have the right size beforehand.
                                      *
                                      * The output vector may be either a
-                                     * @ref{Vector}@p{<float>},
-                                     * @ref{Vector}@p{<double>}, or a
-                                     * @ref{BlockVector}@p{<double>}, or a
+                                     * Vector@p{<float>},
+                                     * Vector@p{<double>}, or a
+                                     * BlockVector@p{<double>}, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -637,7 +637,7 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
                         OutputVector         &values) const;
 
                                     /**
-                                     * Return the @p{i}th child as a DoF line
+                                     * Return the @p ith child as a DoF line
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a line accessor without
@@ -716,9 +716,9 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
     DoFObjectAccessor ();
 
                                     /**
-                                     * Constructor. The @p{local_data}
+                                     * Constructor. The @p local_data
                                      * argument is assumed to be a pointer
-                                     * to a @ref{DoFHandler} object.
+                                     * to a DoFHandler object.
                                      */
     DoFObjectAccessor (const Triangulation<dim> *tria,
                       const int                 level,
@@ -726,28 +726,28 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
                       const AccessorData       *local_data);
     
                                     /**
-                                     * Return the index of the @p{i}th degree
+                                     * Return the index of the @p ith degree
                                      * of freedom of this quad.
                                      */
     unsigned int dof_index (const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the @p{i}th degree
-                                     * of freedom of this quad to @p{index}.
+                                     * Set the index of the @p ith degree
+                                     * of freedom of this quad to @p index.
                                      */
     void set_dof_index (const unsigned int i,
                        const unsigned int index) const;
 
                                     /**
-                                     * Return the index of the @p{i}th degree
-                                     * on the @p{vertex}th vertex.
+                                     * Return the index of the @p ith degree
+                                     * on the @p vertexth vertex.
                                      */
     unsigned int vertex_dof_index (const unsigned int vertex,
                                   const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the @p{i}th degree
-                                     * on the @p{vertex}th vertex to @p{index}.
+                                     * Set the index of the @p ith degree
+                                     * on the @p vertexth vertex to @p index.
                                      */
     void set_vertex_dof_index (const unsigned int vertex,
                               const unsigned int i,
@@ -779,9 +779,9 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
                                      * cells.
                                      *
                                      * The input vector may be either a
-                                     * @ref{Vector}@p{<float>},
-                                     * @ref{Vector}@p{<double>}, or a
-                                     * @ref{BlockVector}@p{<double>}, or a
+                                     * Vector@p{<float>},
+                                     * Vector@p{<double>}, or a
+                                     * BlockVector@p{<double>}, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -795,11 +795,11 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
 
                                     /**
                                      * This function is the counterpart to
-                                     * @p{get_dof_values}: it takes a vector
+                                     * @p get_dof_values: it takes a vector
                                      * of values for the degrees of freedom
                                      * of the cell pointed to by this iterator
                                      * and writes these values into the global
-                                     * data vector @p{values}. This function
+                                     * data vector @p values. This function
                                      * is only callable for active cells.
                                      *
                                      * Note that for continuous finite
@@ -816,9 +816,9 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
                                      * have the right size beforehand.
                                      *
                                      * The output vector may be either a
-                                     * @ref{Vector}@p{<float>},
-                                     * @ref{Vector}@p{<double>}, or a
-                                     * @ref{BlockVector}@p{<double>}, or a
+                                     * Vector@p{<float>},
+                                     * Vector@p{<double>}, or a
+                                     * BlockVector@p{<double>}, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -831,14 +831,14 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
                         OutputVector         &values) const;
 
                                     /**
-                                     *  Return a pointer to the @p{i}th line
-                                     *  bounding this @p{Quad}.
+                                     *  Return a pointer to the @p ith line
+                                     *  bounding this @p Quad.
                                      */
     TriaIterator<dim,DoFObjectAccessor<1, dim> >
     line (const unsigned int i) const;
     
                                     /**
-                                     * Return the @p{i}th child as a DoF quad
+                                     * Return the @p ith child as a DoF quad
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a quad accessor without
@@ -918,9 +918,9 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
     DoFObjectAccessor ();
 
                                     /**
-                                     * Constructor. The @p{local_data}
+                                     * Constructor. The @p local_data
                                      * argument is assumed to be a pointer
-                                     * to a @ref{DoFHandler} object.
+                                     * to a DoFHandler object.
                                      */
     DoFObjectAccessor (const Triangulation<dim> *tria,
                       const int                 level,
@@ -928,28 +928,28 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
                       const AccessorData       *local_data);
     
                                     /**
-                                     * Return the index of the @p{i}th degree
+                                     * Return the index of the @p ith degree
                                      * of freedom of this hex.
                                      */
     unsigned int dof_index (const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the @p{i}th degree
-                                     * of freedom of this hex to @p{index}.
+                                     * Set the index of the @p ith degree
+                                     * of freedom of this hex to @p index.
                                      */
     void set_dof_index (const unsigned int i,
                        const unsigned int index) const;
 
                                     /**
-                                     * Return the index of the @p{i}th degree
-                                     * on the @p{vertex}th vertex.
+                                     * Return the index of the @p ith degree
+                                     * on the @p vertexth vertex.
                                      */
     unsigned int vertex_dof_index (const unsigned int vertex,
                                   const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the @p{i}th degree
-                                     * on the @p{vertex}th vertex to @p{index}.
+                                     * Set the index of the @p ith degree
+                                     * on the @p vertexth vertex to @p index.
                                      */
     void set_vertex_dof_index (const unsigned int vertex,
                               const unsigned int i,
@@ -981,9 +981,9 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
                                      * cells.
                                      *
                                      * The input vector may be either a
-                                     * @ref{Vector}@p{<float>},
-                                     * @ref{Vector}@p{<double>}, or a
-                                     * @ref{BlockVector}@p{<double>}, or a
+                                     * Vector@p{<float>},
+                                     * Vector@p{<double>}, or a
+                                     * BlockVector@p{<double>}, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -997,11 +997,11 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
 
                                     /**
                                      * This function is the counterpart to
-                                     * @p{get_dof_values}: it takes a vector
+                                     * @p get_dof_values: it takes a vector
                                      * of values for the degrees of freedom
                                      * of the cell pointed to by this iterator
                                      * and writes these values into the global
-                                     * data vector @p{values}. This function
+                                     * data vector @p values. This function
                                      * is only callable for active cells.
                                      *
                                      * Note that for continuous finite
@@ -1018,9 +1018,9 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
                                      * have the right size beforehand.
                                      *
                                      * The output vector may be either a
-                                     * @ref{Vector}@p{<float>},
-                                     * @ref{Vector}@p{<double>}, or a
-                                     * @ref{BlockVector}@p{<double>}, or a
+                                     * Vector@p{<float>},
+                                     * Vector@p{<double>}, or a
+                                     * BlockVector@p{<double>}, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -1033,21 +1033,21 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
                         OutputVector         &values) const;
 
                                     /**
-                                     *  Return a pointer to the @p{i}th line
-                                     *  bounding this @p{Hex}.
+                                     *  Return a pointer to the @p ith line
+                                     *  bounding this @p Hex.
                                      */
     TriaIterator<dim,DoFObjectAccessor<1, dim> >
     line (const unsigned int i) const;
 
                                     /**
-                                     *  Return a pointer to the @p{i}th quad
-                                     *  bounding this @p{Hex}.
+                                     *  Return a pointer to the @p ith quad
+                                     *  bounding this @p Hex.
                                      */
     TriaIterator<dim,DoFObjectAccessor<2, dim> >
     quad (const unsigned int i) const;
     
                                     /**
-                                     * Return the @p{i}th child as a DoF hex
+                                     * Return the @p ith child as a DoF hex
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a hex accessor without
@@ -1106,14 +1106,14 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
  * one and two, respectively, this class only collects the pieces
  * together by deriving from the appropriate @p{DoF*Accessor} and the
  * right @p{CellAccessor<dim>} and finally adding two functions which give
- * access to the neighbors and children as @ref{DoFCellAccessor} objects
- * rather than @ref{CellAccessor} objects (the latter function was inherited
+ * access to the neighbors and children as DoFCellAccessor objects
+ * rather than CellAccessor objects (the latter function was inherited
  * from the @p{CellAccessor<dim>} class).
  *
  * Note that since for the class we derive from, i.e. @p{DoFObjectAccessor<dim,dim>},
  * the two template parameters are equal, the base class is actually derived from
- * @ref{CellAccessor}, which makes the functions of this class available to the
- * @ref{DoFCellAccessor} class as well.
+ * CellAccessor, which makes the functions of this class available to the
+ * DoFCellAccessor class as well.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -1138,7 +1138,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                     const AccessorData       *local_data);
 
                                     /**
-                                     * Return the @p{i}th neighbor as
+                                     * Return the @p ith neighbor as
                                      * a DoF cell iterator. This
                                      * function is needed since the
                                      * neighbor function of the base
@@ -1150,7 +1150,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
     neighbor (const unsigned int) const;
 
                                     /**
-                                     * Return the @p{i}th child as a
+                                     * Return the @p ith child as a
                                      * DoF cell iterator. This
                                      * function is needed since the
                                      * child function of the base
@@ -1162,7 +1162,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
     child (const unsigned int) const;
 
                                     /**
-                                     * Return an iterator to the @p{i}th face
+                                     * Return an iterator to the @p ith face
                                      * of this cell.
                                      *
                                      * This function is not implemented in 1D,
@@ -1173,7 +1173,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
 
                                     /**
                                      * Return the result of the
-                                     * @p{neighbor_child_on_subface}
+                                     * @p neighbor_child_on_subface
                                      * function of the base class,
                                      * but convert it so that one can
                                      * also access the DoF data (the
@@ -1197,7 +1197,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                                      * vector of nodal values on that
                                      * cell. You could then as well
                                      * get the desired values through
-                                     * the @p{get_dof_values}
+                                     * the @p get_dof_values
                                      * function In the other case,
                                      * when the cell has children, we
                                      * use the restriction matrices
@@ -1237,7 +1237,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                                      * decided what the this function
                                      * does in these cases.
                                      *
-                                     * Unlike the @p{get_dof_values}
+                                     * Unlike the @p get_dof_values
                                      * function, this function is
                                      * associated to cells rather
                                      * than to lines, quads, and
@@ -1253,7 +1253,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                                     /**
                                      * This, again, is the
                                      * counterpart to
-                                     * @p{get_interpolated_dof_values}:
+                                     * @p get_interpolated_dof_values:
                                      * you specify the dof values on
                                      * a cell and these are
                                      * interpolated to the children
@@ -1265,7 +1265,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                                      * to by this object is terminal,
                                      * then the dof values are set in
                                      * the global data vector by
-                                     * calling the @p{set_dof_values}
+                                     * calling the @p set_dof_values
                                      * function; otherwise, the
                                      * values are prolonged to each
                                      * of the children and this
@@ -1273,7 +1273,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                                      * them.
                                      *
                                      * Using the
-                                     * @p{get_interpolated_dof_values}
+                                     * @p get_interpolated_dof_values
                                      * and this function, you can
                                      * compute the interpolation of a
                                      * finite element function to a
@@ -1319,7 +1319,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                                      * what the prolongation matrices
                                      * represent in this case.
                                      *
-                                     * Unlike the @p{set_dof_values}
+                                     * Unlike the @p set_dof_values
                                      * function, this function is
                                      * associated to cells rather
                                      * than to lines, quads, and
@@ -1329,9 +1329,9 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                                      * objects.
                                      *
                                      * The output vector may be either a
-                                     * @ref{Vector}@p{<float>},
-                                     * @ref{Vector}@p{<double>}, or a
-                                     * @ref{BlockVector}@p{<double>}, or a
+                                     * Vector@p{<float>},
+                                     * Vector@p{<double>}, or a
+                                     * BlockVector@p{<double>}, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
index 544cab8e2cb4b8973f5437e601faa5f99471f6e1..747c3a68e6119d5d255edbde352981871fa44b5f 100644 (file)
@@ -47,8 +47,8 @@ class BlockIndices;
  *
  * The matrix is organized in lines (rows), but only those lines are stored
  * where constraints are present. New constraints are added by adding new
- * lines using the @ref{add_line} function, and then populating it using the
- * @ref{add_entry} function to a given line, or @ref{add_entries} to add more
+ * lines using the add_line() function, and then populating it using the
+ * add_entry() function to a given line, or add_entries() to add more
  * than one entry at a time. After all constraints have been added, you need
  * to call @ref{close()}, which compresses the storage format and sorts the
  * entries.
@@ -78,14 +78,14 @@ class BlockIndices;
  * 
  * Condensation of a matrix is done in four steps: first one builds the
  * sparsity pattern (e.g. using
- * @ref{DoFHandler}@p{::create_sparsity_pattern}); then the sparsity pattern
+ * DoFHandler@p ::create_sparsity_pattern); then the sparsity pattern
  * of the condensed matrix is made out of the original sparsity pattern and
  * the constraints; third, the global matrix is assembled; and fourth, the
  * matrix is finally condensed. To do these steps, you have (at least) two
  * possibilities:
  * 
- * @begin{itemize}
- * @item Use two different sparsity patterns and two different matrices: you
+ * <ul>
+ * <li> Use two different sparsity patterns and two different matrices: you
  *   may eliminate the lines and rows connected with a constraint and create
  *   a totally new sparsity pattern and a new system matrix. This has the
  *   advantage that the resulting system of equations is smaller and free from
@@ -96,7 +96,7 @@ class BlockIndices;
  *   expensive, since <em>all</em> entries of the matrix have to be copied, not only
  *   those which are subject to constraints.
  *
- * @item Use only one sparsity pattern and one matrix: doing it this way, the
+ * <li> Use only one sparsity pattern and one matrix: doing it this way, the
  *   condense functions add nonzero entries to the sparsity pattern of the large
  *   matrix (with constrained nodes in it) where the condensation process of the
  *   matrix will create additional nonzero elements. In the condensation process
@@ -122,22 +122,22 @@ class BlockIndices;
  *   consumption for those iterative solution methods using a larger number of
  *   auxiliary vectors (e.g. methods using explicit orthogonalization
  *   procedures).
- * @end{itemize}
+ * </ul>
  *
  * Usually, the second way is chosen since memory consumption upon
  * construction of a second matrix rules out the first
  * possibility. Furthermore, all example programs use this method, and we
  * recommend that you use it instead of the first way.
  *
- * This class provides two sets of @p{condense} functions: those taking two
+ * This class provides two sets of @p condense functions: those taking two
  * arguments refer to the first possibility above, those taking only one do
  * their job in-place and refer to the second possibility.
  *
  * The condensation functions exist for different argument types. The in-place
  * functions (i.e. those following the second way) exist for arguments of type
- * @ref{SparsityPattern}, @ref{SparseMatrix} and @ref{BlockSparseMatrix}. Note
+ * SparsityPattern, SparseMatrix and BlockSparseMatrix. Note
  * that there are no versions for arguments of type
- * @ref{PETScWrappers::SparseMatrix} or any of the other PETSc matrix wrapper
+ * PETScWrappers::SparseMatrix() or any of the other PETSc matrix wrapper
  * classes. This is due to the fact that it is relatively hard to get a
  * representation of the sparsity structure of PETSc matrices, and to modify
  * them; this holds in particular, if the matrix is actually distributed
@@ -183,7 +183,7 @@ class BlockIndices;
  * @sect3{Distributing constraints}
  * 
  * After solving the condensed system of equations, the solution vector has to
- * be redistributed. This is done by the two @p{distribute} function, one
+ * be redistributed. This is done by the two @p distribute function, one
  * working with two vectors, one working in-place. The operation of
  * distribution undoes the condensation process in some sense, but it should
  * be noted that it is not the inverse operation. Basically, distribution sets
@@ -281,7 +281,7 @@ class ConstraintMatrix : public Subscriptor
                                      * this object. Both objects may
                                      * or may not be closed (by
                                      * having their function
-                                     * @p{close} called before), if
+                                     * @p close called before), if
                                      * this object was closed before,
                                      * then it will be closed
                                      * afterwards as well. Note,
@@ -303,10 +303,10 @@ class ConstraintMatrix : public Subscriptor
                                      * an exception is thrown.
                                      *
                                      * However, the following is
-                                     * possible: if DoF @p{x} is
-                                     * constrained to dofs @p{x_i}
-                                     * for some set of indices @p{i},
-                                     * then the DoFs @p{x_i} may be
+                                     * possible: if DoF @p x is
+                                     * constrained to dofs @p x_i
+                                     * for some set of indices @p i,
+                                     * then the DoFs @p x_i may be
                                      * further constrained by the
                                      * constraints object given as
                                      * argument, although not to
@@ -314,7 +314,7 @@ class ConstraintMatrix : public Subscriptor
                                      * constrained in either of the
                                      * two objects. Note that it is
                                      * not possible that the DoFs
-                                     * @p{x_i} are constrained within
+                                     * @p x_i are constrained within
                                      * the present object.
                                      *
                                      * Because of simplicity of
@@ -363,13 +363,13 @@ class ConstraintMatrix : public Subscriptor
 
                                     /**
                                      * Shift all entries of this
-                                     * matrix down @p{offset} rows
-                                     * and over @p{offset} columns.
+                                     * matrix down @p offset rows
+                                     * and over @p offset columns.
                                      *
                                      * This function is useful if you
                                      * are building block matrices,
                                      * where all blocks are built by
-                                     * the same @p{DoFHandler}
+                                     * the same @p DoFHandler
                                      * object, i.e. the matrix size
                                      * is larger than the number of
                                      * degrees of freedom. Since
@@ -378,7 +378,7 @@ class ConstraintMatrix : public Subscriptor
                                      * degrees of freedom, you'd
                                      * generate several constraint
                                      * objects, then shift them, and
-                                     * finally @p{merge} them
+                                     * finally @p merge them
                                      * together again.
                                      */
     void shift (const unsigned int offset);
@@ -402,17 +402,17 @@ class ConstraintMatrix : public Subscriptor
 
                                     /**
                                      * Return whether the degree of
-                                     * freedom with number @p{index} is
+                                     * freedom with number @p index is
                                      * a constrained one.
                                      *
-                                     * Note that if @p{close} was
+                                     * Note that if @p close was
                                      * called before, then this
                                      * function is significantly
                                      * faster, since then the
                                      * constrained degrees of freedom
                                      * are sorted and we can do a
                                      * binary search, while before
-                                     * @p{close} was called, we have to
+                                     * @p close was called, we have to
                                      * perform a linear search
                                      * through all entries.
                                      */
@@ -429,7 +429,7 @@ class ConstraintMatrix : public Subscriptor
                                      * eliminated in favor of exactly
                                      * one other degree of freedom.
                                      *
-                                     * The function returns @p{false}
+                                     * The function returns @p false
                                      * if either the degree of
                                      * freedom is not constrained at
                                      * all, or if it is constrained
@@ -448,7 +448,7 @@ class ConstraintMatrix : public Subscriptor
                                      * in 2d a hanging node is
                                      * constrained only to its two
                                      * neighbors, so the returned
-                                     * value would be @p{2}. However,
+                                     * value would be @p 2. However,
                                      * for higher order elements
                                      * and/or higher dimensions, or
                                      * other types of constraints,
@@ -530,7 +530,7 @@ class ConstraintMatrix : public Subscriptor
                                      * matrix struct should be condensed and
                                      * compressed. It is the user's
                                      * responsibility to guarantee that all
-                                     * entries in the @p{condensed} matrix be
+                                     * entries in the @p condensed matrix be
                                      * zero!
                                      *
                                      * The constraint matrix object must be
@@ -560,15 +560,15 @@ class ConstraintMatrix : public Subscriptor
     
                                     /**
                                      * Condense the given vector
-                                     * @p{uncondensed} into @p{condensed}. It
+                                     * @p uncondensed into @p condensed. It
                                      * is the user's responsibility to
                                      * guarantee that all entries of
-                                     * @p{condensed} be zero.
+                                     * @p condensed be zero.
                                      *
-                                     * The @p{VectorType} may be a
-                                     * @ref{Vector}@p{<float>},
-                                     * @ref{Vector}@p{<double>},
-                                     * @ref{BlockVector}@p{<...>}, a PETSc
+                                     * The @p VectorType may be a
+                                     * Vector@p{<float>},
+                                     * Vector@p{<double>},
+                                     * BlockVector@p{<...>}, a PETSc
                                      * vector wrapper class, or any other
                                      * type having the same interface.
                                      */
@@ -578,10 +578,10 @@ class ConstraintMatrix : public Subscriptor
 
                                     /**
                                      * Condense the given vector
-                                     * in-place. The @p{VectorType} may be a
-                                     * @ref{Vector}@p{<float>},
-                                     * @ref{Vector}@p{<double>},
-                                     * @ref{BlockVector}@p{<...>}, a PETSc
+                                     * in-place. The @p VectorType may be a
+                                     * Vector@p{<float>},
+                                     * Vector@p{<double>},
+                                     * BlockVector@p{<...>}, a PETSc
                                      * vector wrapper class, or any other
                                      * type having the same interface.
                                      */
@@ -590,22 +590,22 @@ class ConstraintMatrix : public Subscriptor
 
                                     /**
                                      * Re-distribute the elements of
-                                     * the vector @p{condensed} to
-                                     * @p{uncondensed}. It is the
+                                     * the vector @p condensed to
+                                     * @p uncondensed. It is the
                                      * user's responsibility to
                                      * guarantee that all entries of
-                                     * @p{uncondensed} be zero!
+                                     * @p uncondensed be zero!
                                      *
                                      * This function undoes the
-                                     * action of @p{condense} somehow,
+                                     * action of @p condense somehow,
                                      * but it should be noted that it
                                      * is not the inverse of
-                                     * @p{condense}.
+                                     * @p condense.
                                      *
-                                     * The @p{VectorType} may be a
-                                     * @ref{Vector}@p{<float>},
-                                     * @ref{Vector}@p{<double>},
-                                     * @ref{BlockVector}@p{<...>}, a PETSc
+                                     * The @p VectorType may be a
+                                     * Vector@p{<float>},
+                                     * Vector@p{<double>},
+                                     * BlockVector@p{<...>}, a PETSc
                                      * vector wrapper class, or any other
                                      * type having the same interface.
                                      */
@@ -615,10 +615,10 @@ class ConstraintMatrix : public Subscriptor
 
                                     /**
                                      * Re-distribute the elements of the
-                                     * vector in-place. The @p{VectorType}
-                                     * may be a @ref{Vector}@p{<float>},
-                                     * @ref{Vector}@p{<double>},
-                                     * @ref{BlockVector}@p{<...>}, a PETSc
+                                     * vector in-place. The @p VectorType
+                                     * may be a Vector@p{<float>},
+                                     * Vector@p{<double>},
+                                     * BlockVector@p{<...>}, a PETSc
                                      * vector wrapper class, or any other
                                      * type having the same interface.
                                      */
@@ -628,10 +628,10 @@ class ConstraintMatrix : public Subscriptor
                                     /**
                                      * Delete hanging nodes in a vector.
                                      * Sets all hanging node values to
-                                     * zero. The @p{VectorType} may be a
-                                     * @ref{Vector}@p{<float>},
-                                     * @ref{Vector}@p{<double>},
-                                     * @ref{BlockVector}@p{<...>}, a PETSc
+                                     * zero. The @p VectorType may be a
+                                     * Vector@p{<float>},
+                                     * Vector@p{<double>},
+                                     * BlockVector@p{<...>}, a PETSc
                                      * vector wrapper class, or any other
                                      * type having the same interface.
                                      */
@@ -844,7 +844,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 @ref{ConstraintMatrix}@p{::lines}.
+                                         * said for ConstraintMatrix@p ::lines.
                                          */
        std::vector<std::pair<unsigned int,double> > entries;
 
@@ -910,7 +910,7 @@ class ConstraintMatrix : public Subscriptor
     bool sorted;
 
                                     /**
-                                     * Return @p{true} if the weight
+                                     * Return @p true if the weight
                                      * of an entry (the second
                                      * element of the pair) equals
                                      * zero. This function is used to
index 454794425ca9db4cc9f72b1b4f87226008bb5e64..feb6b71efeb13b3137f8c5bba2eb71a68f0b3420 100644 (file)
@@ -65,7 +65,7 @@ ConstraintMatrix::condense (const SparseMatrix<number> &uncondensed,
        {
                                           // this line is constrained
          new_line.push_back (-1);
-                                          // note that @p{lines} is ordered
+                                          // note that @p lines is ordered
          ++shift;
          ++next_constraint;
          if (next_constraint == lines.end())
@@ -83,8 +83,8 @@ ConstraintMatrix::condense (const SparseMatrix<number> &uncondensed,
 
   next_constraint = lines.begin();
                                   // note: in this loop we need not check
-                                  // whether @p{next_constraint} is a valid
-                                  // iterator, since @p{next_constraint} is
+                                  // whether @p next_constraint is a valid
+                                  // iterator, since @p next_constraint is
                                   // only evaluated so often as there are
                                   // entries in new_line[*] which tells us
                                   // which constraints exist
@@ -202,7 +202,7 @@ ConstraintMatrix::condense (SparseMatrix<number> &uncondensed) const
            
               if (distribute[column] != deal_II_numbers::invalid_unsigned_int)
                                                  // distribute entry at
-                                                 // regular row @p{row}
+                                                 // regular row @p row
                                                  // and irregular column
                                                  // sparsity.get_column_numbers()[j];
                                                  // set old entry to
@@ -240,7 +240,7 @@ ConstraintMatrix::condense (SparseMatrix<number> &uncondensed) const
               if (distribute[column] == deal_II_numbers::invalid_unsigned_int)
                                                  // distribute entry at
                                                  // irregular row
-                                                 // @p{row} and regular
+                                                 // @p row and regular
                                                  // column
                                                  // column. set
                                                  // old entry to zero
@@ -257,9 +257,9 @@ ConstraintMatrix::condense (SparseMatrix<number> &uncondensed) const
                 }
               else
                                                  // distribute entry at
-                                                 // irregular row @p{row} and
+                                                 // irregular row @p row and
                                                  // irregular column
-                                                 // @p{column} set old entry
+                                                 // @p column set old entry
                                                  // to one if on main
                                                  // diagonal, zero otherwise
                 {
@@ -359,7 +359,7 @@ ConstraintMatrix::condense (BlockSparseMatrix<number> &uncondensed) const
                    
                   if (distribute[global_col] != deal_II_numbers::invalid_unsigned_int)
                                                      // distribute entry at
-                                                     // regular row @p{row}
+                                                     // regular row @p row
                                                      // and irregular column
                                                      // global_col; set old
                                                      // entry to zero
@@ -400,7 +400,7 @@ ConstraintMatrix::condense (BlockSparseMatrix<number> &uncondensed) const
                                                      // distribute
                                                      // entry at
                                                      // irregular
-                                                     // row @p{row}
+                                                     // row @p row
                                                      // and regular
                                                      // column
                                                      // global_col. set
@@ -420,9 +420,9 @@ ConstraintMatrix::condense (BlockSparseMatrix<number> &uncondensed) const
                     }
                   else
                                                      // distribute entry at
-                                                     // irregular row @p{row}
+                                                     // irregular row @p row
                                                      // and irregular column
-                                                     // @p{global_col} set old
+                                                     // @p global_col set old
                                                      // entry to one if on
                                                      // main diagonal, zero
                                                      // otherwise
@@ -478,7 +478,7 @@ ConstraintMatrix::condense (const VectorType &uncondensed,
        {
                                           // this line is constrained
          new_line.push_back (-1);
-                                          // note that @p{lines} is ordered
+                                          // note that @p lines is ordered
          ++shift;
          ++next_constraint;
          if (next_constraint == lines.end())
@@ -496,8 +496,8 @@ ConstraintMatrix::condense (const VectorType &uncondensed,
 
   next_constraint = lines.begin();
                                   // note: in this loop we need not check
-                                  // whether @p{next_constraint} is a valid
-                                  // iterator, since @p{next_constraint} is
+                                  // whether @p next_constraint is a valid
+                                  // iterator, since @p next_constraint is
                                   // only evaluated so often as there are
                                   // entries in new_line[*] which tells us
                                   // which constraints exist
@@ -781,7 +781,7 @@ ConstraintMatrix::distribute (const VectorType &condensed,
        {
                                           // this line is constrained
          old_line.push_back (-1);
-                                          // note that @p{lines} is ordered
+                                          // note that @p lines is ordered
          ++shift;
          ++next_constraint;
          if (next_constraint == lines.end())
@@ -799,8 +799,8 @@ ConstraintMatrix::distribute (const VectorType &condensed,
 
   next_constraint = lines.begin();
                                   // note: in this loop we need not check
-                                  // whether @p{next_constraint} is a valid
-                                  // iterator, since @p{next_constraint} is
+                                  // whether @p next_constraint is a valid
+                                  // iterator, since @p next_constraint is
                                   // only evaluated so often as there are
                                   // entries in new_line[*] which tells us
                                   // which constraints exist
index a8e3997848de32676a37117a63426f6a9f965455..74d0a35827c30edbb0ef21fbfc76bc914666cd48 100644 (file)
@@ -40,7 +40,7 @@ template <int dim> class Triangulation;
 
 /**
  * Define some types which differ between the dimensions. This class
- * is analogous to the @ref{TriaDimensionInfo} class hierarchy.
+ * is analogous to the TriaDimensionInfo class hierarchy.
  * 
  * @ref DoFDimensionInfo<1>
  * @ref DoFDimensionInfo<2>
@@ -169,15 +169,15 @@ class DoFDimensionInfo<3>
  * 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 @ref{DoFLevel} class documentation.
+ * is described in the DoFLevel class documentation.
  *
  * Finally it offers a starting point for the assemblage of the matrices
  * 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 @ref{Triangulation} class and of the iterator classes themselved,
+ * of the 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
+ * order in which dof iterators are presented by the @p{++} and @p -- operators
  * is the same as that for the alike triangulation iterators.
  *
  * This class also provides functions to create the sparsity patterns of
@@ -201,14 +201,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 @ref{DoFRenumbering} class offers the function @p{renumber_dofs} which reorders
+ * the 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 @ref{DoFRenumbering} class offers a number of renumbering
+ * 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 the index is stored
  * which is to be assigned by the renumbering. Using this array, the
@@ -253,7 +253,7 @@ class DoFHandler  :  public Subscriptor,
     typedef typename DoFDimensionInfo<dim>::active_face_iterator active_face_iterator;
 
                                     /**
-                                     * Alias the @p{FunctionMap} type
+                                     * Alias the @p FunctionMap type
                                      * declared elsewhere.
                                      */
     typedef typename ::FunctionMap<dim>::type FunctionMap;
@@ -276,7 +276,7 @@ class DoFHandler  :  public Subscriptor,
     static const unsigned int invalid_dof_index = deal_II_numbers::invalid_unsigned_int;
     
                                     /**
-                                     * Constructor. Take @p{tria} as the
+                                     * Constructor. Take @p tria as the
                                      * triangulation to work on.
                                      */
     DoFHandler (const Triangulation<dim> &tria);
@@ -294,7 +294,7 @@ class DoFHandler  :  public Subscriptor,
                                      * method.
                                      *
                                      * The additional optional
-                                     * parameter @p{offset} allows you
+                                     * parameter @p offset allows you
                                      * to reserve space for a finite
                                      * number of additional vector
                                      * entries in the beginning of
@@ -312,7 +312,7 @@ class DoFHandler  :  public Subscriptor,
                                      * object shall be longer than
                                      * that of this object. If you
                                      * don't want this behaviour, you
-                                     * may want to call the @p{clear}
+                                     * may want to call the @p clear
                                      * member function which also
                                      * releases the lock of this
                                      * object to the finite element.
@@ -324,7 +324,7 @@ class DoFHandler  :  public Subscriptor,
                                      * 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.
+                                     * time when @p distribute_dofs was called.
                                      */
     virtual void clear ();
     
@@ -333,14 +333,14 @@ class DoFHandler  :  public Subscriptor,
                                      * a list of new dof numbers for all the
                                      * dofs.
                                      *
-                                     * @p{new_numbers} is an array of integers
+                                     * @p new_numbers is an array of integers
                                      * with size equal to the number of dofs
                                      * on the present grid. It stores the new
                                      * indices after renumbering in the
                                      * order of the old indices.
                                      *
                                      * This function is called by the
-                                     * @p{renumber_dofs} function after computing
+                                     * @p renumber_dofs function after computing
                                      * the ordering of the degrees of freedom.
                                      * However, you can call this function
                                      * yourself, which is necessary if a user
@@ -357,7 +357,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 @ref{SparsityPattern}
+                                     * construction of the SparsityPattern
                                      * object.
                                      *
                                      * The returned number is not really the
@@ -381,7 +381,7 @@ class DoFHandler  :  public Subscriptor,
                                      * the boundary can couple with.
                                      *
                                      * The number is the same as for
-                                     * @p{max_coupling_between_dofs} in one
+                                     * @p max_coupling_between_dofs in one
                                      * dimension less.
                                      */
     unsigned int max_couplings_between_boundary_dofs () const;
@@ -392,30 +392,30 @@ class DoFHandler  :  public Subscriptor,
                                     /*@{*/
                                     /**
                                      *  Iterator to the first cell, used
-                                     *  or not, on level @p{level}. If a level
+                                     *  or not, on level @p level. If a level
                                      *  has no cells, a past-the-end iterator
                                      *  is returned.
                                      *
-                                     *  This function calls @p{begin_raw_line}
-                                     *  in 1D and @p{begin_raw_quad} in 2D.
+                                     *  This function calls @p begin_raw_line
+                                     *  in 1D and @p begin_raw_quad in 2D.
                                      */
     raw_cell_iterator    begin_raw   (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first used cell
-                                     *  on level @p{level}.
+                                     *  on level @p level.
                                      *
-                                     *  This function calls @p{begin_line}
-                                     *  in 1D and @p{begin_quad} in 2D.
+                                     *  This function calls @p begin_line
+                                     *  in 1D and @p begin_quad in 2D.
                                      */
     cell_iterator        begin       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  cell on level @p{level}.
+                                     *  cell on level @p level.
                                      *
-                                     *  This function calls @p{begin_active_line}
-                                     *  in 1D and @p{begin_active_quad} in 2D.
+                                     *  This function calls @p begin_active_line
+                                     *  in 1D and @p begin_active_quad in 2D.
                                      */
     active_cell_iterator begin_active(const unsigned int level = 0) const;
 
@@ -425,14 +425,14 @@ class DoFHandler  :  public Subscriptor,
                                      *  iterators with past-the-end or
                                      *  before-the-beginning states.
                                      *
-                                     *  This function calls @p{end_line}
-                                     *  in 1D and @p{end_quad} in 2D.
+                                     *  This function calls @p end_line
+                                     *  in 1D and @p end_quad in 2D.
                                      */
     raw_cell_iterator    end () const;
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -440,7 +440,7 @@ class DoFHandler  :  public Subscriptor,
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -448,7 +448,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If @p{level}
+                                     * first iterator not on level. If @p level
                                      * is the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -458,17 +458,17 @@ class DoFHandler  :  public Subscriptor,
                                      *  Return an iterator pointing to the
                                      *  last cell, used or not.
                                      *
-                                     *  This function calls @p{last_raw_line}
-                                     *  in 1D and @p{last_raw_quad} in 2D.
+                                     *  This function calls @p last_raw_line
+                                     *  in 1D and @p last_raw_quad in 2D.
                                      */
     raw_cell_iterator    last_raw () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  cell of the level @p{level}, used or not.
+                                     *  cell of the level @p level, used or not.
                                      *
-                                     *  This function calls @p{last_raw_line}
-                                     *  in 1D and @p{last_raw_quad} in 2D.
+                                     *  This function calls @p last_raw_line
+                                     *  in 1D and @p last_raw_quad in 2D.
                                      */
     raw_cell_iterator    last_raw (const unsigned int level) const;
 
@@ -476,17 +476,17 @@ class DoFHandler  :  public Subscriptor,
                                      *  Return an iterator pointing to the last
                                      *  used cell.
                                      *
-                                     *  This function calls @p{last_line}
-                                     *  in 1D and @p{last_quad} in 2D.
+                                     *  This function calls @p last_line
+                                     *  in 1D and @p last_quad in 2D.
                                      */
     cell_iterator        last () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used cell on level @p{level}.
+                                     *  used cell on level @p level.
                                      *
-                                     *  This function calls @p{last_line}
-                                     *  in 1D and @p{last_quad} in 2D.
+                                     *  This function calls @p last_line
+                                     *  in 1D and @p last_quad in 2D.
                                      */
     cell_iterator        last (const unsigned int level) const;
 
@@ -494,17 +494,17 @@ class DoFHandler  :  public Subscriptor,
                                      *  Return an iterator pointing to the last
                                      *  active cell.
                                      *
-                                     *  This function calls @p{last_active_line}
-                                     *  in 1D and @p{last_active_quad} in 2D.
+                                     *  This function calls @p last_active_line
+                                     *  in 1D and @p last_active_quad in 2D.
                                      */
     active_cell_iterator last_active () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active cell on level @p{level}.
+                                     *  active cell on level @p level.
                                      *
-                                     *  This function calls @p{last_active_line}
-                                     *  in 1D and @p{last_active_quad} in 2D.
+                                     *  This function calls @p last_active_line
+                                     *  in 1D and @p last_active_quad in 2D.
                                      */
     active_cell_iterator last_active (const unsigned int level) const;
                                     //@}
@@ -517,30 +517,30 @@ class DoFHandler  :  public Subscriptor,
                                     /*@{*/
                                     /**
                                      *  Iterator to the first face, used
-                                     *  or not, on level @p{level}. If a level
+                                     *  or not, on level @p level. If a level
                                      *  has no faces, a past-the-end iterator
                                      *  is returned.
                                      *
-                                     *  This function calls @p{begin_raw_line}
-                                     *  in 2D and @p{begin_raw_quad} in 3D.
+                                     *  This function calls @p begin_raw_line
+                                     *  in 2D and @p begin_raw_quad in 3D.
                                      */
     raw_face_iterator    begin_raw_face   (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first used face
-                                     *  on level @p{level}.
+                                     *  on level @p level.
                                      *
-                                     *  This function calls @p{begin_line}
-                                     *  in 2D and @p{begin_quad} in 3D.
+                                     *  This function calls @p begin_line
+                                     *  in 2D and @p begin_quad in 3D.
                                      */
     face_iterator        begin_face       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  face on level @p{level}.
+                                     *  face on level @p level.
                                      *
-                                     *  This function calls @p{begin_active_line}
-                                     *  in 2D and @p{begin_active_quad} in 3D.
+                                     *  This function calls @p begin_active_line
+                                     *  in 2D and @p begin_active_quad in 3D.
                                      */
     active_face_iterator begin_active_face(const unsigned int level = 0) const;
 
@@ -550,14 +550,14 @@ class DoFHandler  :  public Subscriptor,
                                      *  iterators with past-the-end or
                                      *  before-the-beginning states.
                                      *
-                                     *  This function calls @p{end_line}
-                                     *  in 2D and @p{end_quad} in 3D.
+                                     *  This function calls @p end_line
+                                     *  in 2D and @p end_quad in 3D.
                                      */
     raw_face_iterator    end_face () const;
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -565,7 +565,7 @@ class DoFHandler  :  public Subscriptor,
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -573,7 +573,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If @p{level}
+                                     * first iterator not on level. If @p level
                                      * is the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -583,17 +583,17 @@ class DoFHandler  :  public Subscriptor,
                                      *  Return an iterator pointing to the
                                      *  last face, used or not.
                                      *
-                                     *  This function calls @p{last_raw_line}
-                                     *  in 2D and @p{last_raw_quad} in 3D.
+                                     *  This function calls @p last_raw_line
+                                     *  in 2D and @p last_raw_quad in 3D.
                                      */
     raw_face_iterator    last_raw_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  face of the level @p{level}, used or not.
+                                     *  face of the level @p level, used or not.
                                      *
-                                     *  This function calls @p{last_raw_line}
-                                     *  in 2D and @p{last_raw_quad} in 3D.
+                                     *  This function calls @p last_raw_line
+                                     *  in 2D and @p last_raw_quad in 3D.
                                      */
     raw_face_iterator    last_raw_face (const unsigned int level) const;
 
@@ -601,17 +601,17 @@ class DoFHandler  :  public Subscriptor,
                                      *  Return an iterator pointing to the last
                                      *  used face.
                                      *
-                                     *  This function calls @p{last_line}
-                                     *  in 2D and @p{last_quad} in 3D.
+                                     *  This function calls @p last_line
+                                     *  in 2D and @p last_quad in 3D.
                                      */
     face_iterator        last_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used face on level @p{level}.
+                                     *  used face on level @p level.
                                      *
-                                     *  This function calls @p{last_line}
-                                     *  in 2D and @p{last_quad} in 3D.
+                                     *  This function calls @p last_line
+                                     *  in 2D and @p last_quad in 3D.
                                      */
     face_iterator        last_face (const unsigned int level) const;
 
@@ -619,17 +619,17 @@ class DoFHandler  :  public Subscriptor,
                                      *  Return an iterator pointing to the last
                                      *  active face.
                                      *
-                                     *  This function calls @p{last_active_line}
-                                     *  in 2D and @p{last_active_quad} in 3D.
+                                     *  This function calls @p last_active_line
+                                     *  in 2D and @p last_active_quad in 3D.
                                      */
     active_face_iterator last_active_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active face on level @p{level}.
+                                     *  active face on level @p level.
                                      *
-                                     *  This function calls @p{last_active_line}
-                                     *  in 2D and @p{last_active_quad} in 3D.
+                                     *  This function calls @p last_active_line
+                                     *  in 2D and @p last_active_quad in 3D.
                                      */
     active_face_iterator last_active_face (const unsigned int level) const;
                                     //@}
@@ -643,7 +643,7 @@ class DoFHandler  :  public Subscriptor,
                                     /*@{*/
                                     /**
                                      *  Iterator to the first line, used
-                                     *  or not, on level @p{level}. If a level
+                                     *  or not, on level @p level. If a level
                                      *  has no lines, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -651,13 +651,13 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Iterator to the first used line
-                                     *  on level @p{level}.
+                                     *  on level @p level.
                                      */
     line_iterator        begin_line       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  line on level @p{level}.
+                                     *  line on level @p level.
                                      */
     active_line_iterator begin_active_line(const unsigned int level = 0) const;
 
@@ -671,7 +671,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -679,7 +679,7 @@ class DoFHandler  :  public Subscriptor,
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -687,7 +687,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If @p{level}
+                                     * first iterator not on level. If @p level
                                      * is the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -702,7 +702,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  line of the level @p{level}, used or not.
+                                     *  line of the level @p level, used or not.
 
                                      */
     raw_line_iterator    last_raw_line (const unsigned int level) const;
@@ -715,7 +715,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used line on level @p{level}.
+                                     *  used line on level @p level.
                                      */
     line_iterator        last_line (const unsigned int level) const;
 
@@ -727,7 +727,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active line on level @p{level}.
+                                     *  active line on level @p level.
                                      */
     active_line_iterator last_active_line (const unsigned int level) const;
                                     /*@}*/       
@@ -740,7 +740,7 @@ class DoFHandler  :  public Subscriptor,
                                      */
                                     /**
                                      *  Iterator to the first quad, used
-                                     *  or not, on level @p{level}. If a level
+                                     *  or not, on level @p level. If a level
                                      *  has no quads, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -748,13 +748,13 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Iterator to the first used quad
-                                     *  on level @p{level}.
+                                     *  on level @p level.
                                      */
     quad_iterator        begin_quad       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  quad on level @p{level}.
+                                     *  quad on level @p level.
                                      */
     active_quad_iterator begin_active_quad(const unsigned int level = 0) const;
 
@@ -768,7 +768,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -776,7 +776,7 @@ class DoFHandler  :  public Subscriptor,
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -784,7 +784,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If @p{level}
+                                     * first iterator not on level. If @p level
                                      * is the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -799,7 +799,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  quad of the level @p{level}, used or not.
+                                     *  quad of the level @p level, used or not.
 
                                      */
     raw_quad_iterator    last_raw_quad (const unsigned int level) const;
@@ -812,7 +812,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used quad on level @p{level}.
+                                     *  used quad on level @p level.
                                      */
     quad_iterator        last_quad (const unsigned int level) const;
 
@@ -824,7 +824,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active quad on level @p{level}.
+                                     *  active quad on level @p level.
                                      */
     active_quad_iterator last_active_quad (const unsigned int level) const;
                                     /*@}*/
@@ -837,7 +837,7 @@ class DoFHandler  :  public Subscriptor,
                                      */
                                     /**
                                      *  Iterator to the first hex, used
-                                     *  or not, on level @p{level}. If a level
+                                     *  or not, on level @p level. If a level
                                      *  has no hexs, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -846,14 +846,14 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Iterator to the first used hex
-                                     *  on level @p{level}.
+                                     *  on level @p level.
                                      */
     hex_iterator
     begin_hex       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  hex on level @p{level}.
+                                     *  hex on level @p level.
                                      */
     active_hex_iterator
     begin_active_hex(const unsigned int level = 0) const;
@@ -869,7 +869,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -877,7 +877,7 @@ class DoFHandler  :  public Subscriptor,
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -885,7 +885,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If @p{level}
+                                     * first iterator not on level. If @p level
                                      * is the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -900,7 +900,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  hex of the level @p{level}, used or not.
+                                     *  hex of the level @p level, used or not.
 
                                      */
     raw_hex_iterator
@@ -915,7 +915,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used hex on level @p{level}.
+                                     *  used hex on level @p level.
                                      */
     hex_iterator
     last_hex (const unsigned int level) const;
@@ -929,7 +929,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active hex on level @p{level}.
+                                     *  active hex on level @p level.
                                      */
     active_hex_iterator
     last_active_hex (const unsigned int level) const;
@@ -958,11 +958,11 @@ class DoFHandler  :  public Subscriptor,
                                      * 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
+                                     * reason that a @p map rather
+                                     * than a @p set is used is the
                                      * same as descibed in the
                                      * section on the
-                                     * @p{make_boundary_sparsity_pattern}
+                                     * @p make_boundary_sparsity_pattern
                                      * function.
                                      */
     unsigned int
@@ -1098,7 +1098,7 @@ class DoFHandler  :  public Subscriptor,
                                      * needed for the given element. The
                                      * given element is that one which
                                      * was selected when calling
-                                     * @p{distribute_dofs} the last time.
+                                     * @p distribute_dofs the last time.
                                      */
     void reserve_space ();
 
@@ -1110,14 +1110,14 @@ class DoFHandler  :  public Subscriptor,
                                     /**
                                      * Distribute dofs on the given cell,
                                      * with new dofs starting with index
-                                     * @p{next_free_dof}. Return the next
+                                     * @p next_free_dof. Return the next
                                      * unused index number. The finite
                                      * element used is the one given to
-                                     * @p{distribute_dofs}, which is copied
-                                     * to @p{selected_fe}.
+                                     * @p distribute_dofs, which is copied
+                                     * to @p selected_fe.
                                      *
                                      * This function is excluded from the
-                                     * @p{distribute_dofs} function since
+                                     * @p distribute_dofs function since
                                      * it can not be implemented dimension
                                      * independent.
                                      */
@@ -1127,7 +1127,7 @@ class DoFHandler  :  public Subscriptor,
                                     /**
                                      * Space to store the DoF numbers for the
                                      * different levels. Analogous to the
-                                     * @p{levels[]} tree of the @ref{Triangulation}
+                                     * @p{levels[]} tree of the Triangulation
                                      * objects.
                                      */
     std::vector<DoFLevel<dim>*>    levels;
index 67f58570079bffa12a38442d255957d270678fab..3ccf4573a4eb5d36039ee5603ddcd74ad4a594ad 100644 (file)
@@ -20,7 +20,7 @@
 
 /**
  * Store the indices of the degrees of freedom which are located on
- * objects of dimension @p{N}.  Declare this general template
+ * objects of dimension @p N.  Declare this general template
  * class, but do not actually use it. Rather, only specializations of
  * this class are used.
  *
@@ -43,9 +43,9 @@ class DoFLevel
  * Store the indices of the degrees of freedom which are located on
  * the lines.
  *
- * @sect3{Information for all @ref{DoFLevel} classes}
+ * @sect3{Information for all DoFLevel classes}
  *
- * The @ref{DoFLevel}@p{<N>} classes 
+ * The DoFLevel@p{<N>} 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
@@ -63,28 +63,28 @@ 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 @ref{DoFHandler}@p{::make_hanging_node_constraints ()}
+ * constraint matrix returned by 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
- * @ref{DoFLevel}@p{<dim>} classes for the different dimensions which
- * have objects named @p{line_dofs}, @p{quad_dofs} and so on, in which
+ * DoFLevel@p{<dim>} 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
- * @ref{DoFHandler}@p{::distribute_dofs()} to select a finite element)
+ * 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
+ * @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 ith
  * 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
- * @ref{DoFHandler} class.
+ * is used, the indices are stored in the @p vertex_dofs array of the
+ * DoFHandler class.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -95,7 +95,7 @@ class DoFLevel<1>
                                     /**
                                      * Store the global indices of
                                      * the degrees of freedom. See
-                                     * @ref{DoFLevel} for detailed
+                                     * DoFLevel for detailed
                                      * information.
                                      */
     std::vector<unsigned int> line_dofs;
@@ -123,7 +123,7 @@ class DoFLevel<2> : public DoFLevel<1>
                                     /**
                                      * Store the global indices of
                                      * the degrees of freedom. See
-                                     * @ref{DoFLevel} for detailed
+                                     * DoFLevel for detailed
                                      * information.
                                      */
     std::vector<unsigned int> quad_dofs;
@@ -151,7 +151,7 @@ class DoFLevel<3> : public DoFLevel<2>
                                     /**
                                      * Store the global indices of
                                      * the degrees of freedom. See
-                                     * @ref{DoFLevel} for detailed
+                                     * DoFLevel for detailed
                                      * information.
                                      */
     std::vector<unsigned int> hex_dofs;
index ebb9f4e7d950d21d5694a96e31ab88b5a0de4485..569436f2d8464c2ebd33f6435bb113f73a017627 100644 (file)
  *
  * The renumbering algorithms need quite a lot of memory, since they have
  * to store for each dof with which other dofs it couples. This is done
- * using a @ref{SparsityPattern} object used to store the sparsity pattern of
+ * using a SparsityPattern object used to store the sparsity pattern of
  * matrices. It
  * is not useful for the user to do anything between distributing the dofs
- * and renumbering, i.e. the calls to @ref{DoFHandler}@p{::distribute_dofs} and
- * @ref{DoFHandler}@p{::renumber_dofs} should follow each other immediately. If
+ * and renumbering, i.e. the calls to DoFHandler@p ::distribute_dofs and
+ * DoFHandler@p ::renumber_dofs should follow each other immediately. If
  * you try to create a sparsity pattern or anything else in between, these
  * will be invalid afterwards.
  *
  * The renumbering may take care of dof-to-dof couplings only induced by
  * eliminating constraints. In addition to the memory consumption mentioned
  * above, this also takes quite some computational time, but it may be
- * switched off upon calling the @p{renumber_dofs} function. This will then
+ * switched off upon calling the @p renumber_dofs function. This will then
  * give inferior results, since knots in the graph (representing dofs)
  * are not found to be neighbors even if they would be after condensation.
  * 
  *
  * @sect2{Component-wise numbering}
  *
- * For finite elements composed of several base elements using the @ref{FESystem}
+ * For finite elements composed of several base elements using the FESystem
  * class, or for elements which provide several components themselves, it
  * may be of interest to sort the DoF indices by component. This will then
  * bring out the block matrix structure, since otherwise the degrees of freedom
  * different components.
  *
  * This kind of numbering may be obtained by calling the
- * @p{component_wise} function of this class. Since it does not touch
+ * @p component_wise function of this class. Since it does not touch
  * the order of indices within each, it may be worthwhile to first
  * renumber using the Cuthill-McKee or a similar algorithm and
  * afterwards renumbering component-wise. This will bring out the
  *
  * @sect2{Random renumbering}
  *
- * The @p{random} function renumbers degrees of freedom randomly. This
+ * The @p random function renumbers degrees of freedom randomly. This
  * function is probably seldom of use, except to check the dependence of
  * solvers (iterative or direct ones) on the numbering of the degrees
- * of freedom. It uses the @p{random_shuffle} function from the C++
+ * of freedom. It uses the @p random_shuffle function from the C++
  * standard library to do its work.
  *
  *
@@ -226,10 +226,10 @@ class DoFRenumbering
                                     /**
                                      * Computes the renumbering
                                      * vector needed by the
-                                     * @p{Cuthill_McKee}
+                                     * @p Cuthill_McKee
                                      * function. Does not perform the
                                      * renumbering on the
-                                     * @p{DoFHandler} dofs but
+                                     * @p DoFHandler dofs but
                                      * returns the renumbering
                                      * vector.
                                      */    
@@ -283,14 +283,14 @@ class DoFRenumbering
                                      * You can specify that the
                                      * components are ordered in a
                                      * different way than suggested
-                                     * by the @p{FESystem} object you
+                                     * by the @p FESystem object you
                                      * use. To this end, Set up the
-                                     * vector @p{target_component}
+                                     * vector @p target_component
                                      * such that the entry at index
-                                     * @p{i} denotes the number of
+                                     * @p i denotes the number of
                                      * the target component for dofs
-                                     * with component @p{i} in the
-                                     * @p{FESystem}. Naming the same
+                                     * with component @p i in the
+                                     * @p FESystem. Naming the same
                                      * component more than once is
                                      * possible and results in a
                                      * blocking of several components
@@ -343,10 +343,10 @@ class DoFRenumbering
                                     /**
                                      * Computes the renumbering
                                      * vector needed by the
-                                     * @p{component_wise}
+                                     * @p component_wise
                                      * functions. Does not perform the
                                      * renumbering on the
-                                     * @p{DoFHandler} dofs but
+                                     * @p DoFHandler dofs but
                                      * returns the renumbering
                                      * vector.
                                      */    
@@ -361,7 +361,7 @@ class DoFRenumbering
                                      * Cell-wise renumbering for DG
                                      * elements.  This function takes
                                      * the ordered set of cells in
-                                     * @p{cell_order}, and makes sure
+                                     * @p cell_order, and makes sure
                                      * that all degrees of freedom in
                                      * a cell with higher index are
                                      * behind all degrees of freedom
@@ -384,10 +384,10 @@ class DoFRenumbering
                                     /**
                                      * Computes the renumbering
                                      * vector needed by the
-                                     * @p{cell_wise_dg}
+                                     * @p cell_wise_dg
                                      * function. Does not perform the
                                      * renumbering on the
-                                     * @p{DoFHandler} dofs but
+                                     * @p DoFHandler dofs but
                                      * returns the renumbering
                                      * vector.
                                      */
@@ -419,7 +419,7 @@ class DoFRenumbering
                                      * the centers of higher numbers
                                      * are further downstream with
                                      * respect to the constant vector
-                                     * @p{direction} than the centers
+                                     * @p direction than the centers
                                      * of lower numbers. Even if this
                                      * yields a downstream numbering
                                      * with respect to the flux on
@@ -430,7 +430,7 @@ class DoFRenumbering
                                      * This function produces a
                                      * downstream ordering of the
                                      * mesh cells and calls
-                                     * @ref{cell_wise_dg}.
+                                     * cell_wise_dg().
                                      * Therefore, it only works with
                                      * Discontinuous Galerkin Finite
                                      * Elements, i.e. all degrees of
@@ -458,10 +458,10 @@ class DoFRenumbering
                                     /**
                                      * Computes the renumbering
                                      * vector needed by the
-                                     * @p{downstream_dg}
+                                     * @p downstream_dg
                                      * function. Does not perform the
                                      * renumbering on the
-                                     * @p{DoFHandler} dofs but
+                                     * @p DoFHandler dofs but
                                      * returns the renumbering
                                      * vector.
                                      */
@@ -478,8 +478,8 @@ class DoFRenumbering
                                      * This function produces a
                                      * (counter)clockwise ordering of
                                      * the mesh cells with respect to
-                                     * the hub @p{center} and calls
-                                     * @ref{cell_wise_dg}.
+                                     * the hub @p center and calls
+                                     * cell_wise_dg().
                                      * Therefore, it only works with
                                      * Discontinuous Galerkin Finite
                                      * Elements, i.e. all degrees of
@@ -507,10 +507,10 @@ class DoFRenumbering
                                     /**
                                      * Computes the renumbering
                                      * vector needed by the
-                                     * @p{clockwise_dg}
+                                     * @p clockwise_dg
                                      * functions. Does not perform the
                                      * renumbering on the
-                                     * @p{DoFHandler} dofs but
+                                     * @p DoFHandler dofs but
                                      * returns the renumbering
                                      * vector.
                                      */
@@ -523,8 +523,8 @@ class DoFRenumbering
 
                                     /**
                                      * Sort those degrees of freedom
-                                     * which are tagged with @p{true}
-                                     * in the @p{selected_dofs} array
+                                     * which are tagged with @p true
+                                     * in the @p selected_dofs array
                                      * to the back of the DoF
                                      * numbers. The sorting is
                                      * stable, i.e. the relative
@@ -542,10 +542,10 @@ class DoFRenumbering
                                     /**
                                      * Computes the renumbering
                                      * vector needed by the
-                                     * @p{sort_selected_dofs_back}
+                                     * @p sort_selected_dofs_back
                                      * function. Does not perform the
                                      * renumbering on the
-                                     * @p{DoFHandler} dofs but
+                                     * @p DoFHandler dofs but
                                      * returns the renumbering
                                      * vector.
                                      */
@@ -566,9 +566,9 @@ class DoFRenumbering
                                     /**
                                      * Computes the renumbering
                                      * vector needed by the
-                                     * @p{random} function. Does not
+                                     * @p random function. Does not
                                      * perform the renumbering on the
-                                     * @p{DoFHandler} dofs but
+                                     * @p DoFHandler dofs but
                                      * returns the renumbering
                                      * vector.
                                      */   
@@ -588,7 +588,7 @@ class DoFRenumbering
                                      * when doing parallel computations after
                                      * assigning subdomain ids using a
                                      * partitioner (see the
-                                     * @p{GridTools::partition_triangulation}
+                                     * @p GridTools::partition_triangulation
                                      * function for this).
                                      *
                                      * Note that degrees of freedom
@@ -600,7 +600,7 @@ class DoFRenumbering
                                      * which subdomain they have to be
                                      * associated. For this, we use what we
                                      * get from the
-                                     * @p{DoFTools::get_subdomain_association}
+                                     * @p DoFTools::get_subdomain_association
                                      * function.
                                      *
                                      * The algorithm is stable, i.e. if
@@ -615,9 +615,9 @@ class DoFRenumbering
 
                                     /**
                                      * Computes the renumbering vector needed
-                                     * by the @p{subdomain_wise}
+                                     * by the @p subdomain_wise
                                      * function. Does not perform the
-                                     * renumbering on the @p{DoFHandler} dofs
+                                     * renumbering on the @p DoFHandler dofs
                                      * but returns the renumbering vector.
                                      */   
     template <int dim>
index 5dd60ce33d420e469d616e77d805a597594faa7e..b1edb1c267c862e50eb8a8616fce343606db3abb 100644 (file)
@@ -42,7 +42,7 @@ template <int dim> class Mapping;
  * documentation stating some commonalities.
  *
  * All member functions are static, so there is no need to create an
- * object of class @ref{DoFTools}.
+ * object of class DoFTools.
  *
  *
  * @sect3{Setting up sparsity patterns}
@@ -76,11 +76,11 @@ template <int dim> class Mapping;
  * of freedom on the boundary. What is needed in this case is a
  * numbering of the boundary degrees of freedom, starting from zero on
  * and not considering the degrees of freedom in the interior. The
- * @p{map_dof_to_boundary_indices} function does exactly this, by
+ * @p map_dof_to_boundary_indices function does exactly this, by
  * providing a vector with as many entries as there are degrees of
  * freedom on the whole domain, with each entry being the number in
  * the numbering of the boundary or
- * @ref{DoFHandler}@p{::invalid_dof_index} if the dof is not on the
+ * DoFHandler@p ::invalid_dof_index if the dof is not on the
  * boundary. You should always use this function to get the mapping
  * between local (boundary) and the global numbers, for example to
  * build the mass matrix on the boundary, or to get the global index
@@ -98,7 +98,7 @@ template <int dim> class Mapping;
  * algorithm, you are better off if you just accept the mapping `as
  * is'.
  *
- * Actually, there are two @p{map_dof_to_boundary_indices} functions,
+ * Actually, there are two @p map_dof_to_boundary_indices functions,
  * one producing a numbering for all boundary degrees of freedom and
  * one producing a numbering for only parts of the boundary, namely
  * those parts for which the boundary indicator is listed in a set of
@@ -113,11 +113,11 @@ template <int dim> class Mapping;
  * indices of degrees of freedom on different parts may be intermixed.
  *
  * Degrees of freedom on the boundary but not on one of the specified
- * boundary parts are given the index @p{invalid_dof_index}, as if
+ * boundary parts are given the index @p invalid_dof_index, as if
  * they were in the interior. If no boundary indicator was given or if
  * no face of a cell has a boundary indicator contained in the given
  * list, the vector of new indices consists solely of
- * @p{invalid_dof_index}s.
+ * @p invalid_dof_indexs.
  *
  * The question what a degree of freedom on the boundary is, is not so
  * easy.  It should really be a degree of freedom of which the
@@ -125,10 +125,10 @@ template <int dim> class Mapping;
  * least for Lagrange elements this definition is equal to the
  * statement that the off-point of the shape function, i.e. the point
  * where the function assumes its nominal value (for Lagrange elements
- * this is the point where it has the function value @p{1}), is
+ * 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 @ref{FiniteElementBase} class defines the
+ * element class gives: the 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
@@ -166,7 +166,7 @@ class DoFTools
                                      * correspond to degrees of
                                      * freedom of at least one common
                                      * cell. Therefore,
-                                     * @p{make_sparsity_pattern} just
+                                     * @p make_sparsity_pattern just
                                      * loops over all cells and
                                      * enters all couplings local to
                                      * that cell. As the generation
@@ -183,19 +183,19 @@ class DoFTools
                                      * of hanging nodes.  They have
                                      * to be taken care of by a call
                                      * to
-                                     * @ref{ConstraintMatrix}@p{::condense()}
+                                     * ConstraintMatrix@p{::condense()}
                                      * afterwards.
                                      *
                                      * Remember using
-                                     * @ref{SparsityPattern}@p{::compress()}
+                                     * SparsityPattern@p{::compress()}
                                      * after generating the pattern.
                                      *
                                      * The actual type of the
                                      * sparsity pattern may be
-                                     * @ref{SparsityPattern},
-                                     * @ref{CompressedSparsityPattern},
-                                     * @ref{BlockSparsityPattern},
-                                     * @ref{CompressedBlockSparsityPattern},
+                                     * SparsityPattern,
+                                     * CompressedSparsityPattern,
+                                     * BlockSparsityPattern,
+                                     * CompressedBlockSparsityPattern,
                                      * or any other class that
                                      * satisfies similar
                                      * requirements. It is assumed
@@ -222,48 +222,48 @@ class DoFTools
                                      * ector valued finite elements.
                                      * This function does mostly the
                                      * same as the previous
-                                     * @p{make_sparsity_pattern}, but
+                                     * @p make_sparsity_pattern, but
                                      * it is specialized for vector
                                      * finite elements and allows to
                                      * specify which variables couple
                                      * in which equation. For
                                      * example, if wanted to solve
                                      * the Stokes equations,
-                                     * @begin{verbatim}
+                                     * @verbatim
                                      * -\Delta \vec u + \nabla p = 0,
                                      * \div u                    = 0
-                                     * @end{verbatim}
+                                     * @endverbatim
                                      * in two space dimensions,
                                      * using stable Q2/Q1 mixed
-                                     * elements (using the @ref{FESystem}
+                                     * elements (using the FESystem
                                      * class), then you don't want
                                      * all degrees of freedom to
                                      * couple in each equation. You
                                      * rather may want to give the
                                      * following pattern of
                                      * couplings:
-                                     * @begin{verbatim}
+                                     * @verbatim
                                      *   1 0 1
                                      *   0 1 1
                                      *   1 1 0
-                                     * @end{verbatim}
+                                     * @endverbatim
                                      * where "1" indicates that two
                                      * variables (i.e. components of
-                                     * the @ref{FESystem}) couple in the
+                                     * the FESystem) couple in the
                                      * respective equation, and a "0"
                                      * means no coupling, in which
                                      * case it is not necessary to
                                      * allocate space in the matrix
                                      * structure. Obviously, the mask
                                      * refers to components of the
-                                     * composed @ref{FESystem}, rather
+                                     * composed FESystem, rather
                                      * than to the degrees of freedom
                                      * contained in there.
                                      *
                                      * This function is designed to
                                      * accept a mask, like the one
                                      * shown above, through the
-                                     * @p{mask} parameter, which
+                                     * @p mask parameter, which
                                      * contains boolean values. It
                                      * builds the matrix structure
                                      * just like the previous
@@ -276,10 +276,10 @@ class DoFTools
                                      *
                                      * The actual type of the
                                      * sparsity pattern may be
-                                     * @ref{SparsityPattern},
-                                     * @ref{CompressedSparsityPattern},
-                                     * @ref{BlockSparsityPattern},
-                                     * @ref{CompressedBlockSparsityPattern},
+                                     * SparsityPattern,
+                                     * CompressedSparsityPattern,
+                                     * BlockSparsityPattern,
+                                     * CompressedBlockSparsityPattern,
                                      * or any other class that
                                      * satisfies similar
                                      * requirements.
@@ -316,21 +316,21 @@ class DoFTools
                                      * nodes.  The sparsity pattern
                                      * is not compressed, since if
                                      * you want to call
-                                     * @ref{ConstraintMatrix}@p{::condense(1)}
+                                     * ConstraintMatrix@p{::condense(1)}
                                      * afterwards, new entries have
                                      * to be added. However, if you
                                      * don't want to call
-                                     * @ref{ConstraintMatrix}@p{::condense(1)},
+                                     * ConstraintMatrix@p{::condense(1)},
                                      * you have to compress the
                                      * matrix yourself, using
-                                     * @ref{SparsityPattern}@p{::compress()}.
+                                     * SparsityPattern@p{::compress()}.
                                      *
                                      * The actual type of the
                                      * sparsity pattern may be
-                                     * @ref{SparsityPattern},
-                                     * @ref{CompressedSparsityPattern},
-                                     * @ref{BlockSparsityPattern},
-                                     * @ref{CompressedBlockSparsityPattern},
+                                     * SparsityPattern,
+                                     * CompressedSparsityPattern,
+                                     * BlockSparsityPattern,
+                                     * CompressedBlockSparsityPattern,
                                      * or any other class that
                                      * satisfies similar
                                      * requirements. It is assumed
@@ -377,9 +377,9 @@ class DoFTools
                                      * the boundary indicator is listed in the
                                      * set of numbers passed to this function.
                                      *
-                                     * In fact, rather than a @p{set}
+                                     * In fact, rather than a @p set
                                      * of boundary indicators, a
-                                     * @p{map} needs to be passed,
+                                     * @p map needs to be passed,
                                      * since most of the functions
                                      * handling with boundary
                                      * indicators take a mapping of
@@ -429,7 +429,7 @@ class DoFTools
                                      * couple across faces of cells.
                                      * This is a replacement of the
                                      * function
-                                     * @p{make_sparsity_pattern} for
+                                     * @p make_sparsity_pattern for
                                      * discontinuous methods. Since
                                      * the fluxes include couplings
                                      * between neighboring elements,
@@ -490,11 +490,11 @@ class DoFTools
                                      * immediately. The object is not cleared
                                      * before use, so you should make sure
                                      * it containts only constraints you still
-                                     * want; otherwise call the @p{clear}
+                                     * want; otherwise call the @p clear
                                      * function.
                                      *
                                      * To condense a given sparsity pattern,
-                                     * use @ref{ConstraintMatrix}@p{::condense}.
+                                     * use ConstraintMatrix@p ::condense.
                                      * Before doing so, you need to close
                                      * the constraint object, which must be
                                      * done after all constraints are entered.
@@ -532,29 +532,29 @@ class DoFTools
                                      * note that the resulting field will not
                                      * be continuous at hanging nodes. This
                                      * can, however, easily be arranged by
-                                     * calling the appropraite @p{distribute}
-                                     * function of a @ref{ConstraintMatrix}
+                                     * calling the appropraite @p distribute
+                                     * function of a ConstraintMatrix
                                      * object created for this
-                                     * @ref{DoFHandler} object, after the
+                                     * DoFHandler object, after the
                                      * vector has been fully assembled.
                                      *
                                      * It is assumed that the number
-                                     * of elements in @p{cell_data}
+                                     * of elements in @p cell_data
                                      * equals the number of active
                                      * cells. The size of
-                                     * @p{dof_data} is adjusted to
+                                     * @p dof_data is adjusted to
                                      * the right size.
                                      *
                                      * Note that the input vector may
                                      * be a vector of any data type
                                      * as long as it is convertible
-                                     * to @p{double}.  The output
+                                     * to @p double.  The output
                                      * vector, being a data vector on
                                      * the grid, always consists of
-                                     * elements of type @p{double}.
+                                     * elements of type @p double.
                                      *
                                      * In case the finite element
-                                     * used by this @ref{DoFHandler}
+                                     * used by this DoFHandler
                                      * consists of more than one
                                      * component, you should give
                                      * which component in the output
@@ -569,7 +569,7 @@ class DoFTools
                                      * contents are not changed.
                                      *
                                      * It is assumed that the output
-                                     * vector @p{dof_data} already
+                                     * vector @p dof_data already
                                      * has the right size,
                                      * i.e. @p{n_dofs()} elements.
                                      *
@@ -594,24 +594,24 @@ class DoFTools
                                      * to certain vector components
                                      * of a vector-valued finite
                                      * element. The bit vector
-                                     * @p{select} defines, which
+                                     * @p select defines, which
                                      * components of an
-                                     * @ref{FESystem} are to be
+                                     * FESystem are to be
                                      * extracted from the
-                                     * @ref{DoFHandler} @p{dof}. The
-                                     * entries in @p{selected_dofs}
+                                     * DoFHandler @p dof. The
+                                     * entries in @p selected_dofs
                                      * corresponding to degrees of
                                      * freedom belonging to these
                                      * components are then flagged
-                                     * @p{true}, while all others are
-                                     * set to @p{false}.
+                                     * @p true, while all others are
+                                     * set to @p false.
                                      *
                                      * The size of
-                                     * @p{component_select} shall
+                                     * @p component_select shall
                                      * equal the number of components
                                      * in the finite element used by
-                                     * @p{dof}. The size of
-                                     * @p{selected_dofs} shall equal
+                                     * @p dof. The size of
+                                     * @p selected_dofs shall equal
                                      * @p{dof_handler.n_dofs()}. Previous
                                      * contents of this array or
                                      * overwritten.
@@ -630,7 +630,7 @@ class DoFTools
                                      * case, if <em>one</em> shape
                                      * vector component of this
                                      * element is flagged in
-                                     * @p{component_select}, then
+                                     * @p component_select, then
                                      * this is equivalent to
                                      * selecting <em>all</em> vector
                                      * components corresponding to
@@ -645,7 +645,7 @@ class DoFTools
 
                                     /**
                                      * Do the same thing as
-                                     * @p{extract_dofs} for one level
+                                     * @p extract_dofs for one level
                                      * of a multi-grid DoF numbering.
                                      */
     template <int dim>
@@ -663,14 +663,14 @@ class DoFTools
                                      * returns its results in the
                                      * last non-default-valued
                                      * parameter which contains
-                                     * @p{true} if a degree of
+                                     * @p true if a degree of
                                      * freedom is at the boundary and
                                      * belongs to one of the selected
-                                     * components, and @p{false}
+                                     * components, and @p false
                                      * otherwise.
                                      *
                                      * By specifying the
-                                     * @p{boundary_indicator}
+                                     * @p boundary_indicator
                                      * variable, you can select which
                                      * boundary indicators the faces
                                      * have to have on which the
@@ -680,11 +680,11 @@ class DoFTools
                                      * boundary indicators are
                                      * accepted.
                                      *
-                                     * The size of @p{component_select}
+                                     * The size of @p component_select
                                      * shall equal the number of
                                      * components in the finite
-                                     * element used by @p{dof}. The
-                                     * size of @p{selected_dofs} shall
+                                     * element used by @p dof. The
+                                     * size of @p selected_dofs shall
                                      * equal
                                      * @p{dof_handler.n_dofs()}. Previous
                                      * contents of this array or
@@ -724,7 +724,7 @@ class DoFTools
                                      * constraints, i.e. all hanging
                                      * nodes.
                                      *
-                                     * The size of @p{selected_dofs}
+                                     * The size of @p selected_dofs
                                      * shall equal
                                      * @p{dof_handler.n_dofs()}. Previous
                                      * contents of this array or
@@ -765,7 +765,7 @@ class DoFTools
                                      * If you want to get a unique
                                      * association of degree of freedom with
                                      * subdomains, use the
-                                     * @p{get_subdomain_association}
+                                     * @p get_subdomain_association
                                      * function.
                                      */
     template <int dim>
@@ -878,7 +878,7 @@ class DoFTools
                                      * degrees of freedom.
                                      *
                                      * The additional optional
-                                     * argument @p{target_component}
+                                     * argument @p target_component
                                      * allows for a re-sorting and
                                      * grouping of components. To
                                      * this end, it contains for each
@@ -893,13 +893,13 @@ class DoFTools
                                      * vectors, but want to pack
                                      * several components into the
                                      * same block (for example, when
-                                     * you have @p{dim} velocities
+                                     * you have @p dim velocities
                                      * and one pressure, to put all
                                      * velocities into one block, and
                                      * the pressure into another).
                                      *
                                      * The result is returned in
-                                     * @p{dofs_per_component}.
+                                     * @p dofs_per_component.
                                      */
     template <int dim>
     static void
@@ -1101,7 +1101,7 @@ class DoFTools
                                      * to the variable ``q''; zero
                                      * would be ``u'', two would be
                                      * ``lambda''). Furthermore, an
-                                     * object of type @ref{IntergridMap}
+                                     * object of type IntergridMap
                                      * is needed; this could in
                                      * principle be generated by the
                                      * function itself from the two
@@ -1113,7 +1113,7 @@ class DoFTools
                                      * it. Finally, the computed
                                      * constraints are entered into a
                                      * variable of type
-                                     * @ref{ConstraintMatrix}; the
+                                     * ConstraintMatrix; the
                                      * constraints are added,
                                      * i.e. previous contents which
                                      * may have, for example, be
@@ -1150,10 +1150,10 @@ class DoFTools
                                      *
                                      * The output of this function is
                                      * a compressed format that can
-                                     * be given to the @p{reinit}
+                                     * be given to the @p reinit
                                      * functions of the
-                                     * @ref{SparsityPattern} ad
-                                     * @ref{SparseMatrix} classes.
+                                     * SparsityPattern ad
+                                     * SparseMatrix classes.
                                      */
     template <int dim>
     static void
@@ -1172,13 +1172,13 @@ class DoFTools
                                      * this operation, @p{mapping[dof]}
                                      * gives the index of the
                                      * degree of freedom with global
-                                     * number @p{dof} in the list of
+                                     * number @p dof in the list of
                                      * degrees of freedom on the
                                      * boundary.  If the degree of
                                      * freedom requested is not on
                                      * the boundary, the value of
                                      * @p{mapping[dof]} is
-                                     * @p{invalid_dof_index}. This
+                                     * @p invalid_dof_index. This
                                      * function is mainly used when
                                      * setting up matrices and
                                      * vectors on the boundary from
@@ -1188,7 +1188,7 @@ class DoFTools
                                      * numbers of the trial functions
                                      * local to the boundary.
                                      *
-                                     * Prior content of @p{mapping}
+                                     * Prior content of @p mapping
                                      * is deleted.
                                      */
     template <int dim>
index 377924b8459875a41fd0f195226a6089f9cc02f3..31b9b63471345a27186655853eba41725b0f121e 100644 (file)
@@ -39,7 +39,7 @@ struct FunctionMap
                                     /**
                                      * Declare the type as discussed
                                      * above. Since we can't name it
-                                     * @p{FunctionMap} (as that would
+                                     * @p FunctionMap (as that would
                                      * ambiguate a possible
                                      * constructor of this class),
                                      * name it in the fashion of the
index aaff9e3621e17517712da9a68a5b4d96dbcf4a56..6dd351d921d90e8b3d00f6a1af83ed2984f86564 100644 (file)
@@ -29,26 +29,26 @@ template <int dim> class FESystem;
 
 /**
  * Common interface of all finite elements. Here, the functions to
- * fill the data fields of @ref{FEValues} are declared. While
- * @ref{FiniteElementBase} provides implementation of common
+ * fill the data fields of FEValues are declared. While
+ * FiniteElementBase provides implementation of common
  * functionality, this class only serves as an abstract base class.
  *
  * The interface of this class is very restrictive. The reason is that
  * finite element values should be accessed only by use of
- * @ref{FEValues} objects. These, together with @p{FiniteElement} are
+ * FEValues objects. These, together with @p FiniteElement are
  * responsible to provide an optimized implementation.
  *
  * This even holds for evaluating finite elements at their support
  * points (provided the element is based on Lagrangian interpolation):
  * first, it is necessary to construct a quadrature rule from the
  * support points. This is then fed into an object of class
- * @ref{FEValues}. Even for evaluation on the unit cell, you will need
+ * FEValues. Even for evaluation on the unit cell, you will need
  * a triangulation containing that single cell.
  *
  * Basically, this class just declares the shape function and their
  * derivatives on the unit cell $[0,1]^d$, and the means to transform
  * them onto a given cell in physical space if provided by the
- * @ref{FEValues} class with a @ref{Mapping} object.
+ * FEValues class with a Mapping object.
  *
  * @author Wolfgang Bangerth, Guido Kanschat, Ralf Hartmann, 1998, 2000, 2001
  */
@@ -68,7 +68,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                       * exception, since copying finite
                                       * element objects is not really
                                       * supported. If you want to copy such an
-                                      * object, use the @p{clone} function.
+                                      * object, use the @p clone function.
                                       */
     FiniteElement (const FiniteElement &);
     
@@ -96,7 +96,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * coincide with the number of
                                      * base elements, since they may
                                      * be reused. For example, if you
-                                     * create a @ref{FESystem} with
+                                     * create a FESystem with
                                      * three identical finite element
                                      * classes by using the
                                      * constructor that takes one
@@ -115,7 +115,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * objects. If the element is
                                      * scalar, then
                                      * @p{base_element(0)} is
-                                     * @p{this}.
+                                     * @p this.
                                      */
     virtual
     const FiniteElement<dim> &
@@ -123,12 +123,12 @@ class FiniteElement : public FiniteElementBase<dim>
 
                                      /**
                                       * This index denotes how often
-                                      * the base element @p{index} is
+                                      * the base element @p index is
                                       * used in a composed element. If
                                       * the element is scalar, then
                                       * the result is always equal to
                                       * one. See the documentation for
-                                      * the @p{n_base_elements}
+                                      * the @p n_base_elements
                                       * function for more details.
                                       */
     virtual
@@ -139,10 +139,10 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * Check for non-zero values on a face.
                                      *
                                      * This function returns
-                                     * @p{true}, if the shape
-                                     * function @p{shape_index} has
+                                     * @p true, if the shape
+                                     * function @p shape_index has
                                      * non-zero values on the face
-                                     * @p{face_index}.
+                                     * @p face_index.
                                      */
     virtual bool has_support_on_face (const unsigned int shape_index,
                                      const unsigned int face_index) const = 0;
@@ -183,13 +183,13 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * Determine the values a finite
                                      * element should compute on
                                      * initialization of data for
-                                     * @p{FEValues}.
+                                     * @p FEValues.
                                      *
                                      * Given a set of flags
                                      * indicating what quantities are
-                                     * requested from a @p{FEValues}
-                                     * object, @p{update_once} and
-                                     * @p{update_each} compute which
+                                     * requested from a @p FEValues
+                                     * object, @p update_once and
+                                     * @p update_each compute which
                                      * values must really be
                                      * computed. Then, the
                                      * @p{fill_*_values} functions
@@ -200,31 +200,31 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * computed either on the unit
                                      * cell or on the physical
                                      * cell. For instance, the
-                                     * function values of @p{FE_Q} do
+                                     * function values of @p FE_Q do
                                      * only depend on the quadrature
                                      * points on the unit
                                      * cell. Therefore, this flags
                                      * will be returned by
-                                     * @p{update_once}. The gradients
+                                     * @p update_once. The gradients
                                      * require computation of the
                                      * covariant transformation
                                      * matrix. Therefore,
-                                     * @p{update_covariant_transformation}
-                                     * and @p{update_gradients} will
+                                     * @p update_covariant_transformation
+                                     * and @p update_gradients will
                                      * be returned by
-                                     * @p{update_each}.
+                                     * @p update_each.
                                      *
                                      * For an example see the same
                                      * function in the derived class
-                                     * @p{FE_Q}.
+                                     * @p FE_Q.
                                      */
     virtual UpdateFlags update_once (const UpdateFlags flags) const = 0;
   
                                     /**
                                      * Complementary function for
-                                     * @p{update_once}.
+                                     * @p update_once.
                                      *
-                                     * While @p{update_once} returns
+                                     * While @p update_once returns
                                      * the values to be computed on
                                      * the unit cell for yielding the
                                      * required data, this function
@@ -232,17 +232,17 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * must be recomputed on each
                                      * cell.
                                      *
-                                     * Refer to @p{update_once} for
+                                     * Refer to @p update_once for
                                      * more details.
                                      */
     virtual UpdateFlags update_each (const UpdateFlags flags) const = 0;
   
                                     /**
-                                     * @p{clone} function instead of
+                                     * @p clone function instead of
                                      * a copy constructor.
                                      *
                                      * This function is needed by the
-                                     * constructors of @p{FESystem}.
+                                     * constructors of @p FESystem.
                                      */
     virtual FiniteElement<dim> *clone() const = 0;
     
@@ -298,13 +298,13 @@ class FiniteElement : public FiniteElementBase<dim>
 
                                     /**
                                      * Fill the fields of
-                                     * @ref{FEValues}. This function
+                                     * FEValues. This function
                                      * performs all the operations
                                      * needed to compute the data of an
-                                     * @p{FEValues} object.
+                                     * @p FEValues object.
                                      *
                                      * The same function in
-                                     * @p{mapping} must have been
+                                     * @p mapping must have been
                                      * called for the same cell first!
                                      */                                      
     virtual void
@@ -317,13 +317,13 @@ class FiniteElement : public FiniteElementBase<dim>
     
                                     /**
                                      * Fill the fields of
-                                     * @ref{FEFaceValues}. This function
+                                     * FEFaceValues. This function
                                      * performs all the operations
                                      * needed to compute the data of an
-                                     * @p{FEFaceValues} object.
+                                     * @p FEFaceValues object.
                                      *
                                      * The same function in
-                                     * @p{mapping} must have been
+                                     * @p mapping must have been
                                      * called for the same cell first!
                                      */                                      
     virtual void
@@ -337,13 +337,13 @@ class FiniteElement : public FiniteElementBase<dim>
     
                                     /**
                                      * Fill the fields of
-                                     * @ref{FESubfaceValues}. This function
+                                     * FESubfaceValues. This function
                                      * performs all the operations
                                      * needed to compute the data of an
-                                     * @p{FESubfaceValues} object.
+                                     * @p FESubfaceValues object.
                                      *
                                      * The same function in
-                                     * @p{mapping} must have been
+                                     * @p mapping must have been
                                      * called for the same cell first!
                                      */                                      
     virtual void
index e684515446052c80c9ba2df9ba725c77ae4680ab..285bd6174529fdd61802e9999b663d9fc93f747e 100644 (file)
@@ -34,7 +34,7 @@ template<int dim> class FESystem;
 
 /**
  * Dimension independent data for finite elements. See the derived
- * class @ref{FiniteElementBase} class for information on its use. All
+ * class FiniteElementBase class for information on its use. All
  * its data are available to the implementation in a concrete finite
  * element class.
  *
@@ -127,7 +127,7 @@ class FiniteElementData
                                      * components is in many cases
                                      * equal to the number of base
                                      * elements glued together with
-                                     * the help of the @ref{FESystem}
+                                     * the help of the FESystem
                                      * class. However, for elements
                                      * like the Nedelec element, the
                                      * number is greater than one
@@ -399,7 +399,7 @@ class FiniteElementBase : public Subscriptor,
                                   /**
                                    * Base class for internal data.
                                    * Adds data for second derivatives to
-                                   * @ref{Mapping::InternalDataBase}
+                                   * Mapping::InternalDataBase()
                                    *
                                    * For information about the
                                    * general purpose of this class,
@@ -430,15 +430,15 @@ class FiniteElementBase : public Subscriptor,
                             const Quadrature<dim>    &quadrature);
        
                                         /**
-                                         * Storage for @p{FEValues}
+                                         * Storage for @p FEValues
                                          * objects needed to
                                          * approximate second
                                          * derivatives.
                                          *
                                          * The ordering is @p{p+hx},
                                          * @p{p+hy}, @p{p+hz},
-                                         * @p{p-hx}, @p{p-hy},
-                                         * @p{p-hz}, where unused
+                                         * @p p-hx, @p p-hy,
+                                         * @p p-hz, where unused
                                          * entries in lower dimensions
                                          * are missing.
                                          */
@@ -479,14 +479,14 @@ class FiniteElementBase : public Subscriptor,
                                      *
                                      * Systems of elements have their
                                      * own naming convention, see the
-                                     * @ref{FESystem} class.
+                                     * FESystem class.
                                      */
     virtual std::string get_name () const = 0;
     
                                     /**
                                      * Return the value of the
-                                     * @p{i}th shape function at the
-                                     * point @p{p}. @p{p} is a point
+                                     * @p ith shape function at the
+                                     * point @p p. @p p is a point
                                      * on the reference element. If
                                      * the finite element is
                                      * vector-valued, then return the
@@ -500,15 +500,15 @@ class FiniteElementBase : public Subscriptor,
                                      * classes implementing this
                                      * function should throw an
                                      * exception of type
-                                     * @p{ExcShapeFunctionNotPrimitive}. In
+                                     * @p ExcShapeFunctionNotPrimitive. In
                                      * that case, use the
-                                     * @ref{shape_value_component}
+                                     * shape_value_component()
                                      * function.
                                      *
                                      * An
-                                     * @p{ExcUnitShapeValuesDoNotExist}
+                                     * @p ExcUnitShapeValuesDoNotExist
                                      * is thrown if the shape values
-                                     * of the @p{FiniteElement} under
+                                     * of the @p FiniteElement under
                                      * consideration depends on the
                                      * shape of the cell in real
                                      * space.
@@ -517,16 +517,16 @@ class FiniteElementBase : public Subscriptor,
                                const Point<dim>   &p) const;
 
                                     /**
-                                     * Just like for @p{shape_value},
+                                     * Just like for @p shape_value,
                                      * but this function will be
                                      * called when the shape function
                                      * has more than one non-zero
                                      * vector component. In that
                                      * case, this function should
                                      * return the value of the
-                                     * @p{component}-th vector
-                                     * component of the @p{i}th shape
-                                     * function at point @p{p}.
+                                     * @p component-th vector
+                                     * component of the @p ith shape
+                                     * function at point @p p.
                                      */
     virtual double shape_value_component (const unsigned int i,
                                          const Point<dim>   &p,
@@ -534,8 +534,8 @@ class FiniteElementBase : public Subscriptor,
     
                                     /**
                                      * Return the gradient of the
-                                     * @p{i}th shape function at the
-                                     * point @p{p}. @p{p} is a point
+                                     * @p ith shape function at the
+                                     * point @p p. @p p is a point
                                      * on the reference element, and
                                      * likewise the gradient is the
                                      * gradient on the unit cell with
@@ -553,15 +553,15 @@ class FiniteElementBase : public Subscriptor,
                                      * classes implementing this
                                      * function should throw an
                                      * exception of type
-                                     * @p{ExcShapeFunctionNotPrimitive}. In
+                                     * @p ExcShapeFunctionNotPrimitive. In
                                      * that case, use the
-                                     * @ref{shape_grad_component}
+                                     * shape_grad_component()
                                      * function.
                                      *
                                      * An
-                                     * @p{ExcUnitShapeValuesDoNotExist}
+                                     * @p ExcUnitShapeValuesDoNotExist
                                      * is thrown if the shape values
-                                     * of the @p{FiniteElement} under
+                                     * of the @p FiniteElement under
                                      * consideration depends on the
                                      * shape of the cell in real
                                      * space.
@@ -570,16 +570,16 @@ class FiniteElementBase : public Subscriptor,
                                      const Point<dim>   &p) const;
 
                                     /**
-                                     * Just like for @p{shape_grad},
+                                     * Just like for @p shape_grad,
                                      * but this function will be
                                      * called when the shape function
                                      * has more than one non-zero
                                      * vector component. In that
                                      * case, this function should
                                      * return the gradient of the
-                                     * @p{component}-th vector
-                                     * component of the @p{i}th shape
-                                     * function at point @p{p}.
+                                     * @p component-th vector
+                                     * component of the @p ith shape
+                                     * function at point @p p.
                                      */
     virtual Tensor<1,dim> shape_grad_component (const unsigned int i,
                                                const Point<dim>   &p,
@@ -587,8 +587,8 @@ class FiniteElementBase : public Subscriptor,
 
                                     /**
                                      * Return the tensor of second
-                                     * derivatives of the @p{i}th
-                                     * shape function at point @p{p}
+                                     * derivatives of the @p ith
+                                     * shape function at point @p p
                                      * on the unit cell. The
                                      * derivatives are derivatives on
                                      * the unit cell with respect to
@@ -605,15 +605,15 @@ class FiniteElementBase : public Subscriptor,
                                      * classes implementing this
                                      * function should throw an
                                      * exception of type
-                                     * @p{ExcShapeFunctionNotPrimitive}. In
+                                     * @p ExcShapeFunctionNotPrimitive. In
                                      * that case, use the
-                                     * @ref{shape_grad_grad_component}
+                                     * shape_grad_grad_component()
                                      * function.
                                      *
                                      * An
-                                     * @p{ExcUnitShapeValuesDoNotExist}
+                                     * @p ExcUnitShapeValuesDoNotExist
                                      * is thrown if the shape values
-                                     * of the @p{FiniteElement} under
+                                     * of the @p FiniteElement under
                                      * consideration depends on the
                                      * shape of the cell in real
                                      * space.
@@ -622,16 +622,16 @@ class FiniteElementBase : public Subscriptor,
                                           const Point<dim>   &p) const;
 
                                     /**
-                                     * Just like for @p{shape_grad_grad},
+                                     * Just like for @p shape_grad_grad,
                                      * but this function will be
                                      * called when the shape function
                                      * has more than one non-zero
                                      * vector component. In that
                                      * case, this function should
                                      * return the gradient of the
-                                     * @p{component}-th vector
-                                     * component of the @p{i}th shape
-                                     * function at point @p{p}.
+                                     * @p component-th vector
+                                     * component of the @p ith shape
+                                     * function at point @p p.
                                      */
     virtual Tensor<2,dim> shape_grad_grad_component (const unsigned int i,
                                                     const Point<dim>   &p,
@@ -642,16 +642,16 @@ class FiniteElementBase : public Subscriptor,
                                      * space onto a coarse grid
                                      * space. If this projection
                                      * operator is associated with a
-                                     * matrix @p{P}, then the
+                                     * matrix @p P, then the
                                      * restriction of this matrix
-                                     * @p{P_i} to a single child cell
+                                     * @p P_i to a single child cell
                                      * is returned here.
                                      *
-                                     * The matrix @p{P} is the
+                                     * The matrix @p P is the
                                      * concatenation or the sum of
-                                     * the cell matrices @p{P_i},
+                                     * the cell matrices @p P_i,
                                      * depending on the
-                                     * @p{restriction_is_additive_flags}
+                                     * @p restriction_is_additive_flags
                                      * given to the constructor. This
                                      * distinguishes interpolation
                                      * (concatenation) and projection
@@ -669,7 +669,7 @@ class FiniteElementBase : public Subscriptor,
                                      * implemented in the derived
                                      * finite element class, this
                                      * function aborts with
-                                     * @p{ExcProjectionVoid}.
+                                     * @p ExcProjectionVoid.
                                      */
     const FullMatrix<double> &
     get_restriction_matrix (const unsigned int child) const;
@@ -680,21 +680,21 @@ class FiniteElementBase : public Subscriptor,
                                      * The identity operator from a
                                      * coarse grid space into a fine
                                      * grid space is associated with
-                                     * a matrix @p{P}. The
-                                     * restriction of this matrix @p{P_i} to
+                                     * a matrix @p P. The
+                                     * restriction of this matrix @p P_i to
                                      * a single child cell is
                                      * returned here.
                                      *
-                                     * The matrix @p{P} is the
+                                     * The matrix @p P is the
                                      * concatenation, not the sum of
                                      * the cell matrices
-                                     * @p{P_i}. That is, if the same
+                                     * @p P_i. That is, if the same
                                      * non-zero entry @p{j,k} exists
                                      * in in two different child
-                                     * matrices @p{P_i}, the value
+                                     * matrices @p P_i, the value
                                      * should be the same in both
                                      * matrices and it is copied into
-                                     * the matrix @p{P} only once.
+                                     * the matrix @p P only once.
                                      *
                                      * Row and column indices are
                                      * related to fine grid and
@@ -718,7 +718,7 @@ class FiniteElementBase : public Subscriptor,
                                      * implemented in the derived
                                      * finite element class, this
                                      * function aborts with
-                                     * @p{ExcEmbeddingVoid}. You can
+                                     * @p ExcEmbeddingVoid. You can
                                      * check whether this is the case
                                      * by calling the
                                      * @ref{prolongation_is_implemented()}.
@@ -730,7 +730,7 @@ class FiniteElementBase : public Subscriptor,
                                       * Return whether this element implements
                                       * its prolongation matrices. The return
                                       * value also indicates whether a call to
-                                      * the @p{get_prolongation_matrix}
+                                      * the @p get_prolongation_matrix
                                       * function will generate an error or
                                       * not.
                                       *
@@ -776,7 +776,7 @@ class FiniteElementBase : public Subscriptor,
                                      * should have a way to live with
                                      * this, then you might want to
                                      * use the
-                                     * @p{constraints_are_implemented}
+                                     * @p constraints_are_implemented
                                      * function to check up front
                                      * whethehr this function will
                                      * succeed or generate the
@@ -789,7 +789,7 @@ class FiniteElementBase : public Subscriptor,
                                       * implements its hanging node
                                       * constraints. The return value
                                       * also indicates whether a call
-                                      * to the @p{constraint} function
+                                      * to the @p constraint function
                                       * will generate an error or not.
                                       *
                                       * This function is mostly here
@@ -821,7 +821,7 @@ class FiniteElementBase : public Subscriptor,
                                      * interpolating from the given
                                      * finite element to the present
                                      * one. The size of the matrix is
-                                     * then @p{dofs_per_cell} times
+                                     * then @p dofs_per_cell times
                                      * @p{source.dofs_per_cell}.
                                      *
                                      * Derived elements will have to
@@ -854,8 +854,8 @@ class FiniteElementBase : public Subscriptor,
                                      * implementational question
                                      * about comparing arrays and do
                                      * not compare the matrix arrays
-                                     * @p{restriction} and
-                                     * @p{prolongation}.
+                                     * @p restriction and
+                                     * @p prolongation.
                                      */
     bool operator == (const FiniteElementBase<dim> &) const;
 
@@ -881,7 +881,7 @@ class FiniteElementBase : public Subscriptor,
                                      * cannot be associated with one
                                      * vector component, and an
                                      * exception of type
-                                     * @p{ExcShapeFunctionNotPrimitive}
+                                     * @p ExcShapeFunctionNotPrimitive
                                      * will be raised.
                                      *
                                      * Note that if the element is
@@ -905,9 +905,9 @@ class FiniteElementBase : public Subscriptor,
                                      * that has more than one
                                      * vector-component). For this
                                      * information, refer to the
-                                     * @p{system_to_base_table} field
+                                     * @p system_to_base_table field
                                      * and the
-                                     * @p{system_to_base_index}
+                                     * @p system_to_base_index
                                      * function.
                                      */
     std::pair<unsigned int,unsigned int>
@@ -923,7 +923,7 @@ class FiniteElementBase : public Subscriptor,
 
                                      /**
                                       * Return for shape function
-                                      * @p{index} the base element it
+                                      * @p index the base element it
                                       * belongs to, the number of the
                                       * copy of this base element
                                       * (which is between zero and the
@@ -944,7 +944,7 @@ class FiniteElementBase : public Subscriptor,
                                      * then base values and dof
                                      * indices within this element
                                      * are equal to the
-                                     * @p{system_to_component_table}. It
+                                     * @p system_to_component_table. It
                                      * differs only in case the
                                      * element is composed of other
                                      * elements and at least one of
@@ -955,7 +955,7 @@ class FiniteElementBase : public Subscriptor,
                                      * vector-valued
                                      * (i.e. non-primitive) shape
                                      * functions, in contrast to the
-                                     * @p{system_to_component_index}
+                                     * @p system_to_component_index
                                      * function.
                                       */
     std::pair<std::pair<unsigned int, unsigned int>, unsigned int>
@@ -963,7 +963,7 @@ class FiniteElementBase : public Subscriptor,
 
                                      /**
                                       * Same as
-                                      * @p{system_to_base_index}, but
+                                      * @p system_to_base_index, but
                                       * for degrees of freedom located
                                       * on a face.
                                       */
@@ -986,7 +986,7 @@ class FiniteElementBase : public Subscriptor,
                                      * implementing a certain vector
                                      * component, which can be done
                                      * using this function and the
-                                     * @ref{FESystem}::@p{base_element}
+                                     * FESystem::@p base_element
                                      * function.
                                      *
                                      * If this is a scalar finite
@@ -999,7 +999,7 @@ class FiniteElementBase : public Subscriptor,
 
                                     /**
                                      * Access the
-                                     * @p{restriction_is_additive_flag}
+                                     * @p restriction_is_additive_flag
                                      * field. See there for more
                                      * information on its contents.
                                      *
@@ -1046,7 +1046,7 @@ class FiniteElementBase : public Subscriptor,
                                      * element has defined support
                                      * points. If the result is true,
                                      * then a call to the
-                                     * @p{get_unit_support_points}
+                                     * @p get_unit_support_points
                                      * yields a non-empty array.
                                      *
                                      * The result may be false if an
@@ -1063,7 +1063,7 @@ class FiniteElementBase : public Subscriptor,
                                      * other shape functions.
                                      *
                                      * In composed elements (i.e. for
-                                     * the @ref{FESystem} class, the
+                                     * the FESystem class, the
                                      * result will be true if all all
                                      * the base elements have defined
                                      * support points.
@@ -1073,7 +1073,7 @@ class FiniteElementBase : public Subscriptor,
                                      /**
                                       * Return the position of the
                                       * support point of the
-                                      * @p{index}th shape function. If
+                                      * @p indexth shape function. If
                                       * it does not exist, raise an
                                       * exception.
                                       *
@@ -1081,11 +1081,11 @@ class FiniteElementBase : public Subscriptor,
                                       * simply returns the respective
                                       * element from the array you get
                                       * from
-                                      * @ref{get_unit_support_points},
+                                      * get_unit_support_points(),
                                       * but derived elements may
                                       * overload this function. In
                                       * particular, note that the
-                                      * @ref{FESystem} class overloads
+                                      * FESystem class overloads
                                       * it so that it can return the
                                       * support points of individual
                                       * base elements, of not all the
@@ -1093,7 +1093,7 @@ class FiniteElementBase : public Subscriptor,
                                       * points. In this way, you can
                                       * still ask for certain support
                                       * points, even if
-                                      * @p{get_unit_support_points}
+                                      * @p get_unit_support_points
                                       * only returns an empty array.
                                       */
     virtual
@@ -1147,7 +1147,7 @@ class FiniteElementBase : public Subscriptor,
                                      * support points, then their
                                      * number equals the number of
                                      * degrees of freedom on the face
-                                     * (@p{dofs_per_face}). The order
+                                     * (@p dofs_per_face). The order
                                      * of points in the array matches
                                      * that returned by the
                                      * @p{cell->get_dof_indices}
@@ -1164,19 +1164,19 @@ class FiniteElementBase : public Subscriptor,
                                      * element has defined support
                                      * points on faces. If the result
                                      * is true, then a call to the
-                                     * @p{get_unit_support_points}
+                                     * @p get_unit_support_points
                                      * yields a non-empty array.
                                      *
                                      * For more information, see the
                                      * documentation for the
-                                     * @ref{has_support_points}
+                                     * has_support_points()
                                      * function.
                                      */
     bool has_face_support_points () const;
 
                                      /**
                                       * The function corresponding to
-                                      * the @p{unit_support_point}
+                                      * the @p unit_support_point
                                       * function, but for faces. See
                                       * there for more information.
                                       */
@@ -1187,7 +1187,7 @@ class FiniteElementBase : public Subscriptor,
                                     /**
                                      * Return in which of the vector
                                      * components of this finite
-                                     * element the @p{i}the shape
+                                     * element the @p ithe shape
                                      * function is non-zero. The
                                      * length of the returned array
                                      * is equal to the number of
@@ -1198,7 +1198,7 @@ class FiniteElementBase : public Subscriptor,
                                      * spaces, the result of this
                                      * function will be a vector with
                                      * exactly one element being
-                                     * @p{true}, since for most
+                                     * @p true, since for most
                                      * spaces the individual vector
                                      * components are independent. In
                                      * that case, the component with
@@ -1212,19 +1212,19 @@ class FiniteElementBase : public Subscriptor,
                                      * components, for example to
                                      * make a shape function
                                      * divergence free, will there be
-                                     * more than one @p{true} entry.
+                                     * more than one @p true entry.
                                      */
     const std::vector<bool> &
     get_nonzero_components (const unsigned int i) const;
 
                                     /**
                                      * Return in how many vector
-                                     * components the @p{i}th shape
+                                     * components the @p ith shape
                                      * function is non-zero. This
                                      * value equals the number of
-                                     * entries equal to @p{true} in
+                                     * entries equal to @p true in
                                      * the result of the
-                                     * @p{get_nonzero_components}
+                                     * @p get_nonzero_components
                                      * function.
                                      *
                                      * For most finite element
@@ -1241,7 +1241,7 @@ class FiniteElementBase : public Subscriptor,
     n_nonzero_components (const unsigned int i) const;
 
                                     /**
-                                     * Return whether the @p{i}th
+                                     * Return whether the @p ith
                                      * shape function is primitive in
                                      * the sense that the shape
                                      * function is non-zero in only
@@ -1254,7 +1254,7 @@ class FiniteElementBase : public Subscriptor,
                                      * components are coupled.
                                      *
                                      * The result of the function is
-                                     * @p{true} if and only if the
+                                     * @p true if and only if the
                                      * result of
                                      * @p{n_nonzero_components(i)} is
                                      * equal to one.
@@ -1274,7 +1274,7 @@ class FiniteElementBase : public Subscriptor,
                                      * Since this is an extremely
                                      * common operation, the result
                                      * is cached in the
-                                     * @p{cached_primitivity}
+                                     * @p cached_primitivity
                                      * variable which is computed in
                                      * the constructor.
                                      */
@@ -1288,7 +1288,7 @@ class FiniteElementBase : public Subscriptor,
                                      *
                                      * This function is not
                                      * virtual. Use a
-                                     * @ref{FiniteElement} object to
+                                     * FiniteElement object to
                                      * get the actual size of a
                                      * concrete element.
                                      */
@@ -1350,7 +1350,7 @@ class FiniteElementBase : public Subscriptor,
   protected:  
                                     /**
                                      * Array of projection matrices. See
-                                     * @p{get_restriction_matrix} above.
+                                     * @p get_restriction_matrix above.
                                      *
                                      * Matrices in this array are
                                      * automatically initialized to
@@ -1420,7 +1420,7 @@ class FiniteElementBase : public Subscriptor,
     
                                     /**
                                      * Store what
-                                     * @p{system_to_component_index}
+                                     * @p system_to_component_index
                                      * will return.
                                      */
     std::vector< std::pair<unsigned int, unsigned int> > system_to_component_table;
@@ -1463,7 +1463,7 @@ class FiniteElementBase : public Subscriptor,
                                      * then base values and dof
                                      * indices within this element
                                      * are equal to the
-                                     * @p{system_to_component_table}. It
+                                     * @p system_to_component_table. It
                                      * differs only in case the
                                      * element is composed of other
                                      * elements and at least one of
@@ -1474,7 +1474,7 @@ class FiniteElementBase : public Subscriptor,
                                      * vector-valued
                                      * (i.e. non-primitive) shape
                                      * functions, in contrast to the
-                                     * @p{system_to_component_table}.
+                                     * @p system_to_component_table.
                                      */
     std::vector<std::pair<std::pair<unsigned int,unsigned int>,unsigned int> >
     system_to_base_table;
@@ -1493,7 +1493,7 @@ class FiniteElementBase : public Subscriptor,
                                      * This table converts a
                                      * component number to a pair
                                      * consisting of the
-                                     * @p{base_element} number, and
+                                     * @p base_element number, and
                                      * the component within this base
                                      * element. While component
                                      * information contains
@@ -1535,13 +1535,13 @@ class FiniteElementBase : public Subscriptor,
                                      * functional are identified and
                                      * enter the interpolated value
                                      * only once. In this case, the
-                                     * flag must be @p{false}.
+                                     * flag must be @p false.
                                      *
                                      * For projections with respect
                                      * to scalar products, the child
                                      * matrices must be summed up to
                                      * build the complete matrix. The
-                                     * flag should be @p{true}.
+                                     * flag should be @p true.
                                      *
                                      * For examples of use of these
                                      * flags, see the places in the
@@ -1569,7 +1569,7 @@ class FiniteElementBase : public Subscriptor,
                                      * this flag in the vector-valued
                                      * case: this used to be done
                                      * with the
-                                     * @p{system_to_component_index}
+                                     * @p system_to_component_index
                                      * function that returns which
                                      * vector component a shape
                                      * function is associated
@@ -1612,7 +1612,7 @@ class FiniteElementBase : public Subscriptor,
                                     /**
                                      * Same for the faces. See the
                                      * description of the
-                                     * @p{get_unit_face_support_points}
+                                     * @p get_unit_face_support_points
                                      * function for a discussion of
                                      * what contributes a face
                                      * support point.
@@ -1637,7 +1637,7 @@ class FiniteElementBase : public Subscriptor,
                                     /**
                                      * This array holds how many
                                      * values in the respective entry
-                                     * of the @p{nonzero_components}
+                                     * of the @p nonzero_components
                                      * element are non-zero. The
                                      * array is thus a short-cut to
                                      * allow faster access to this
@@ -1708,8 +1708,8 @@ class FiniteElementBase : public Subscriptor,
                                      * possibility to see if these matrices
                                      * are initialized without accessing
                                      * these matrices through the
-                                     * @p{get_restriction_matrix} and
-                                     * @p{get_prolongation_matrix}
+                                     * @p get_restriction_matrix and
+                                     * @p get_prolongation_matrix
                                      * functions. This is important as these
                                      * functions include assertions that
                                      * throw if the matrices are not already
index c705483430b435c25a745e33e071eb9825efa08a..4048a9385e66259f6d1f61fe8fade3997b10de2f 100644 (file)
@@ -47,7 +47,7 @@ class FE_DGP : public FE_Poly<PolynomialSpace<dim>,dim>
                                      * identifies a finite
                                      * element. This class returns
                                      * @p{FE_DGP<dim>(degree)}, with
-                                     * @p{dim} and @p{degree}
+                                     * @p dim and @p degree
                                      * replaced by appropriate
                                      * values.
                                      */
@@ -57,14 +57,14 @@ class FE_DGP : public FE_Poly<PolynomialSpace<dim>,dim>
                                      * Check for non-zero values on a face.
                                      *
                                      * This function returns
-                                     * @p{true}, if the shape
-                                     * function @p{shape_index} has
+                                     * @p true, if the shape
+                                     * function @p shape_index has
                                      * non-zero values on the face
-                                     * @p{face_index}.
+                                     * @p face_index.
                                      *
                                      * Implementation of the
                                      * interface in
-                                     * @ref{FiniteElement}
+                                     * FiniteElement
                                      */
     virtual bool has_support_on_face (const unsigned int shape_index,
                                      const unsigned int face_index) const;
@@ -115,14 +115,14 @@ class FE_DGP : public FE_Poly<PolynomialSpace<dim>,dim>
        static const unsigned int n_embedding_matrices;
 
                                         /**
-                                         * As @p{embedding} but for
+                                         * As @p embedding but for
                                          * projection matrices.
                                          */
        static const double * const projection_matrices[][GeometryInfo<dim>::children_per_cell];
 
                                         /**
                                          * As
-                                         * @p{n_embedding_matrices}
+                                         * @p n_embedding_matrices
                                          * but for projection
                                          * matrices.
                                          */
@@ -132,11 +132,11 @@ class FE_DGP : public FE_Poly<PolynomialSpace<dim>,dim>
   protected:
 
                                     /**
-                                     * @p{clone} function instead of
+                                     * @p clone function instead of
                                      * a copy constructor.
                                      *
                                      * This function is needed by the
-                                     * constructors of @p{FESystem}.
+                                     * constructors of @p FESystem.
                                      */
     virtual FiniteElement<dim> *clone() const;
 
@@ -145,12 +145,12 @@ class FE_DGP : public FE_Poly<PolynomialSpace<dim>,dim>
                                     /**
                                      * Only for internal use. Its
                                      * full name is
-                                     * @p{get_dofs_per_object_vector}
+                                     * @p get_dofs_per_object_vector
                                      * function and it creates the
-                                     * @p{dofs_per_object} vector that is
+                                     * @p dofs_per_object vector that is
                                      * needed within the constructor to
                                      * be passed to the constructor of
-                                     * @p{FiniteElementData}.
+                                     * @p FiniteElementData.
                                      */
     static std::vector<unsigned int> get_dpo_vector(unsigned int degree);
     
@@ -160,7 +160,7 @@ class FE_DGP : public FE_Poly<PolynomialSpace<dim>,dim>
     template <int dim1> friend class FE_DGP;
 
                                     /**
-                                     * Allows @p{MappingQ} class
+                                     * Allows @p MappingQ class
                                      * access to build_renumbering
                                      * function.
                                      */
index 6d4b2f5fb138e26c4917e4ab87ad15aa0639442b..53e9be9e0613397ce605bd814a4a0e0788534913 100644 (file)
@@ -60,12 +60,12 @@ class FE_DGPMonomial : public FE_Poly<PolynomialsP<dim>,dim>
                                      * interpolating from the given
                                      * finite element to the present
                                      * one. The size of the matrix is
-                                     * then @p{dofs_per_cell} times
+                                     * then @p dofs_per_cell times
                                      * @p{source.dofs_per_cell}.
                                      *
                                      * These matrices are only
                                      * available if the source
-                                     * element is also a @p{FE_Q}
+                                     * element is also a @p FE_Q
                                      * element. Otherwise, an
                                      * exception of type
                                      * @ref{FiniteElementBase<dim>::ExcInterpolationNotImplemented}
@@ -79,14 +79,14 @@ class FE_DGPMonomial : public FE_Poly<PolynomialsP<dim>,dim>
                                      * Check for non-zero values on a face.
                                      *
                                      * This function returns
-                                     * @p{true}, if the shape
-                                     * function @p{shape_index} has
+                                     * @p true, if the shape
+                                     * function @p shape_index has
                                      * non-zero values on the face
-                                     * @p{face_index}.
+                                     * @p face_index.
                                      *
                                      * Implementation of the
                                      * interface in
-                                     * @ref{FiniteElement}
+                                     * FiniteElement
                                      */
     virtual bool has_support_on_face (const unsigned int shape_index,
                                      const unsigned int face_index) const;
@@ -107,11 +107,11 @@ class FE_DGPMonomial : public FE_Poly<PolynomialsP<dim>,dim>
   protected:
 
                                     /**
-                                     * @p{clone} function instead of
+                                     * @p clone function instead of
                                      * a copy constructor.
                                      *
                                      * This function is needed by the
-                                     * constructors of @p{FESystem}.
+                                     * constructors of @p FESystem.
                                      */
     virtual FiniteElement<dim> *clone() const;
 
@@ -120,12 +120,12 @@ class FE_DGPMonomial : public FE_Poly<PolynomialsP<dim>,dim>
                                     /**
                                      * Only for internal use. Its
                                      * full name is
-                                     * @p{get_dofs_per_object_vector}
+                                     * @p get_dofs_per_object_vector
                                      * function and it creates the
-                                     * @p{dofs_per_object} vector that is
+                                     * @p dofs_per_object vector that is
                                      * needed within the constructor to
                                      * be passed to the constructor of
-                                     * @p{FiniteElementData}.
+                                     * @p FiniteElementData.
                                      */
     static std::vector<unsigned int> get_dpo_vector(unsigned int degree);
 
@@ -144,7 +144,7 @@ class FE_DGPMonomial : public FE_Poly<PolynomialsP<dim>,dim>
     void initialize_restriction ();
 
                                     /**
-                                     * Allows @p{MappingQ} class
+                                     * Allows @p MappingQ class
                                      * access to build_renumbering
                                      * function.
                                      */
index f1fbe682fd488a668c6449e8055cd581c96b57b0..156eb0b4ac464a5c1b48ba954e697ca694a5b0bc 100644 (file)
@@ -51,7 +51,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
   public:
                                     /**
                                      * Constructor for tensor product
-                                     * polynomials of degree @p{k}.
+                                     * polynomials of degree @p k.
                                      */
     FE_DGPNonparametric (const unsigned int k);
     
@@ -60,7 +60,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                      * identifies a finite
                                      * element. This class returns
                                      * @p{FE_DGPNonparametric<dim>(degree)},
-                                     * with @p{dim} and @p{degree}
+                                     * with @p dim and @p degree
                                      * replaced by appropriate
                                      * values.
                                      */
@@ -68,9 +68,9 @@ class FE_DGPNonparametric : public FiniteElement<dim>
 
                                     /**
                                      * Return the value of the
-                                     * @p{i}th shape function at the
-                                     * point @p{p}. See the
-                                     * @ref{FiniteElementBase} base
+                                     * @p ith shape function at the
+                                     * point @p p. See the
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -80,11 +80,11 @@ class FE_DGPNonparametric : public FiniteElement<dim>
 
                                     /**
                                      * Return the value of the
-                                     * @p{component}th vector
-                                     * component of the @p{i}th shape
+                                     * @p componentth vector
+                                     * component of the @p ith shape
                                      * function at the point
-                                     * @p{p}. See the
-                                     * @ref{FiniteElementBase} base
+                                     * @p p. See the
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -92,7 +92,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                      * Since this element is scalar,
                                      * the returned value is the same
                                      * as if the function without the
-                                     * @p{_component} suffix were
+                                     * @p _component suffix were
                                      * called, provided that the
                                      * specified component is zero.
                                      */
@@ -102,9 +102,9 @@ class FE_DGPNonparametric : public FiniteElement<dim>
     
                                     /**
                                      * Return the gradient of the
-                                     * @p{i}th shape function at the
-                                     * point @p{p}. See the
-                                     * @ref{FiniteElementBase} base
+                                     * @p ith shape function at the
+                                     * point @p p. See the
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -114,11 +114,11 @@ class FE_DGPNonparametric : public FiniteElement<dim>
 
                                     /**
                                      * Return the gradient of the
-                                     * @p{component}th vector
-                                     * component of the @p{i}th shape
+                                     * @p componentth vector
+                                     * component of the @p ith shape
                                      * function at the point
-                                     * @p{p}. See the
-                                     * @ref{FiniteElementBase} base
+                                     * @p p. See the
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -126,7 +126,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                      * Since this element is scalar,
                                      * the returned value is the same
                                      * as if the function without the
-                                     * @p{_component} suffix were
+                                     * @p _component suffix were
                                      * called, provided that the
                                      * specified component is zero.
                                      */
@@ -136,10 +136,10 @@ class FE_DGPNonparametric : public FiniteElement<dim>
 
                                     /**
                                      * Return the tensor of second
-                                     * derivatives of the @p{i}th
-                                     * shape function at point @p{p}
+                                     * derivatives of the @p ith
+                                     * shape function at point @p p
                                      * on the unit cell.  See the
-                                     * @ref{FiniteElementBase} base
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -149,11 +149,11 @@ class FE_DGPNonparametric : public FiniteElement<dim>
     
                                     /**
                                      * Return the second derivative
-                                     * of the @p{component}th vector
-                                     * component of the @p{i}th shape
+                                     * of the @p componentth vector
+                                     * component of the @p ith shape
                                      * function at the point
-                                     * @p{p}. See the
-                                     * @ref{FiniteElementBase} base
+                                     * @p p. See the
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -161,7 +161,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                      * Since this element is scalar,
                                      * the returned value is the same
                                      * as if the function without the
-                                     * @p{_component} suffix were
+                                     * @p _component suffix were
                                      * called, provided that the
                                      * specified component is zero.
                                      */
@@ -189,7 +189,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                      * Access to base element
                                      * objects. Since this element is
                                      * scalar, @p{base_element(0)} is
-                                     * @p{this}, and all other
+                                     * @p this, and all other
                                      * indices throw an error.
                                      */
     virtual const FiniteElement<dim> &
@@ -197,7 +197,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
 
                                      /**
                                       * Multiplicity of base element
-                                      * @p{index}. Since this is a
+                                      * @p index. Since this is a
                                       * scalar element,
                                       * @p{element_multiplicity(0)}
                                       * returns one, and all other
@@ -209,14 +209,14 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                      * Check for non-zero values on a face.
                                      *
                                      * This function returns
-                                     * @p{true}, if the shape
-                                     * function @p{shape_index} has
+                                     * @p true, if the shape
+                                     * function @p shape_index has
                                      * non-zero values on the face
-                                     * @p{face_index}.
+                                     * @p face_index.
                                      *
                                      * Implementation of the
                                      * interface in
-                                     * @ref{FiniteElement}
+                                     * FiniteElement
                                      */
     virtual bool has_support_on_face (const unsigned int shape_index,
                                      const unsigned int face_index) const;
@@ -267,14 +267,14 @@ class FE_DGPNonparametric : public FiniteElement<dim>
        static const unsigned int n_embedding_matrices;
 
                                         /**
-                                         * As @p{embedding} but for
+                                         * As @p embedding but for
                                          * projection matrices.
                                          */
        static const double * const projection_matrices[][GeometryInfo<dim>::children_per_cell];
 
                                         /**
                                          * As
-                                         * @p{n_embedding_matrices}
+                                         * @p n_embedding_matrices
                                          * but for projection
                                          * matrices.
                                          */
@@ -284,11 +284,11 @@ class FE_DGPNonparametric : public FiniteElement<dim>
   protected:
 
                                     /**
-                                     * @p{clone} function instead of
+                                     * @p clone function instead of
                                      * a copy constructor.
                                      *
                                      * This function is needed by the
-                                     * constructors of @p{FESystem}.
+                                     * constructors of @p FESystem.
                                      */
     virtual FiniteElement<dim> *clone() const;
   
@@ -306,7 +306,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                     /**
                                      * Implementation of the same
                                      * function in
-                                     * @ref{FiniteElement}.
+                                     * FiniteElement.
                                      */
     virtual void
     fill_fe_values (const Mapping<dim> &mapping,
@@ -319,7 +319,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                     /**
                                      * Implementation of the same
                                      * function in
-                                     * @ref{FiniteElement}.
+                                     * FiniteElement.
                                      */
     virtual void
     fill_fe_face_values (const Mapping<dim> &mapping,
@@ -333,7 +333,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                     /**
                                      * Implementation of the same
                                      * function in
-                                     * @ref{FiniteElement}.
+                                     * FiniteElement.
                                      */
     virtual void
     fill_fe_subface_values (const Mapping<dim> &mapping,
@@ -350,19 +350,19 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                     /**
                                      * Only for internal use. Its
                                      * full name is
-                                     * @p{get_dofs_per_object_vector}
+                                     * @p get_dofs_per_object_vector
                                      * function and it creates the
-                                     * @p{dofs_per_object} vector that is
+                                     * @p dofs_per_object vector that is
                                      * needed within the constructor to
                                      * be passed to the constructor of
-                                     * @p{FiniteElementData}.
+                                     * @p FiniteElementData.
                                      */
     static std::vector<unsigned int> get_dpo_vector(unsigned int degree);
     
                                     /**
                                      * Given a set of flags indicating
                                      * what quantities are requested
-                                     * from a @p{FEValues} object,
+                                     * from a @p FEValues object,
                                      * return which of these can be
                                      * precomputed once and for
                                      * all. Often, the values of
@@ -371,8 +371,8 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                      * example, in which case the
                                      * return value of this function
                                      * would be the logical and of
-                                     * the input @p{flags} and
-                                     * @p{update_values}.
+                                     * the input @p flags and
+                                     * @p update_values.
                                      *
                                      * For the present kind of finite
                                      * element, this is exactly the
@@ -433,7 +433,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
     template <int dim1> friend class FE_DGPNonparametric;
 
                                     /**
-                                     * Allows @p{MappingQ} class to
+                                     * Allows @p MappingQ class to
                                      * access to build_renumbering
                                      * function.
                                      */
index b2e007aa85041ae215da336dc11d8ac09a7647e9..26ae81837eef5fdb53a15a81347b61b793cd41e8 100644 (file)
@@ -60,12 +60,12 @@ class FE_DGQ : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * interpolating from the given
                                      * finite element to the present
                                      * one. The size of the matrix is
-                                     * then @p{dofs_per_cell} times
+                                     * then @p dofs_per_cell times
                                      * @p{source.dofs_per_cell}.
                                      *
                                      * These matrices are only
                                      * available if the source
-                                     * element is also a @p{FE_DGQ}
+                                     * element is also a @p FE_DGQ
                                      * element. Otherwise, an
                                      * exception of type
                                      * @ref{FiniteElementBase<dim>::ExcInterpolationNotImplemented}
@@ -79,14 +79,14 @@ class FE_DGQ : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * Check for non-zero values on a face.
                                      *
                                      * This function returns
-                                     * @p{true}, if the shape
-                                     * function @p{shape_index} has
+                                     * @p true, if the shape
+                                     * function @p shape_index has
                                      * non-zero values on the face
-                                     * @p{face_index}.
+                                     * @p face_index.
                                      *
                                      * Implementation of the
                                      * interface in
-                                     * @ref{FiniteElement}
+                                     * FiniteElement
                                      */
     virtual bool has_support_on_face (const unsigned int shape_index,
                                      const unsigned int face_index) const;
@@ -137,14 +137,14 @@ class FE_DGQ : public FE_Poly<TensorProductPolynomials<dim>,dim>
        static const unsigned int n_embedding_matrices;
 
                                         /**
-                                         * As @p{embedding} but for
+                                         * As @p embedding but for
                                          * projection matrices.
                                          */
        static const double * const projection_matrices[];
 
                                         /**
                                          * As
-                                         * @p{n_embedding_matrices}
+                                         * @p n_embedding_matrices
                                          * but for projection
                                          * matrices.
                                          */
@@ -155,11 +155,11 @@ class FE_DGQ : public FE_Poly<TensorProductPolynomials<dim>,dim>
   protected:
 
                                     /**
-                                     * @p{clone} function instead of
+                                     * @p clone function instead of
                                      * a copy constructor.
                                      *
                                      * This function is needed by the
-                                     * constructors of @p{FESystem}.
+                                     * constructors of @p FESystem.
                                      */
     virtual FiniteElement<dim> *clone() const;
 
@@ -167,12 +167,12 @@ class FE_DGQ : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                     /**
                                      * Only for internal use. Its
                                      * full name is
-                                     * @p{get_dofs_per_object_vector}
+                                     * @p get_dofs_per_object_vector
                                      * function and it creates the
-                                     * @p{dofs_per_object} vector that is
+                                     * @p dofs_per_object vector that is
                                      * needed within the constructor to
                                      * be passed to the constructor of
-                                     * @p{FiniteElementData}.
+                                     * @p FiniteElementData.
                                      */
     static std::vector<unsigned int> get_dpo_vector(unsigned int degree);
   
@@ -191,7 +191,7 @@ class FE_DGQ : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * The direction parameter
                                      * determines the type of
                                      * rotation. It is one character
-                                     * of @p{xXyYzZ}. The character
+                                     * of @p xXyYzZ. The character
                                      * determines the axis of
                                      * rotation, case determines the
                                      * direction. Lower case is
@@ -211,7 +211,7 @@ class FE_DGQ : public FE_Poly<TensorProductPolynomials<dim>,dim>
     template <int dim1> friend class FE_DGQ;
 
                                     /**
-                                     * Allows @p{MappingQ} class to
+                                     * Allows @p MappingQ class to
                                      * access to build_renumbering
                                      * function.
                                      */
index c20927514815f037fb61b8091eab13973d7605a2..9b28a8a10f3ae6d129af3792fc5d07def0a3df0e 100644 (file)
@@ -28,7 +28,7 @@ template <int dim> class MappingQ;
  * H_curl. Note, however, that continuity only concerns the tangential
  * component of the vector field.
  *
- * The constructor of this class takes the degree @p{p} of this finite
+ * The constructor of this class takes the degree @p p of this finite
  * element. However, presently, only lowest order elements
  * (i.e. @p{p==1}) are implemented. For a general overview of this
  * element and its properties, see the report by Anna Schneebeli that
@@ -105,7 +105,7 @@ template <int dim> class MappingQ;
  * interpolated or projected, or better: whether the matrices the
  * finite element provides are to be treated with the properties of a
  * projection or of an interpolation, is controlled by the
- * @p{restriction_is_additive} flag. See there for more information.)
+ * @p restriction_is_additive flag. See there for more information.)
  *
  * Here, things are not so simple: since the element has some
  * continuity requirements across faces, we can only resort to some
@@ -133,7 +133,7 @@ template <int dim> class MappingQ;
  * direction. We use the standard enumeration and direction of edges
  * in deal.II, yielding the following shape functions in 2d:
  *
- *   @begin{verbatim}
+ *   @verbatim
  *          2
  *      *--->---*
  *      |       |
@@ -141,12 +141,12 @@ template <int dim> class MappingQ;
  *      |       |
  *      *--->---*
  *          0
- *   @end{verbatim}
+ *   @endverbatim
  *
  * For the 3d case, the ordering follows the same scheme: the lines
  * are numbered as described in the documentation of the
- * @ref{Triangulation} class, i.e.
- *   @begin{verbatim}
+ * Triangulation class, i.e.
+ *   @verbatim
  *         *---6---*        *---6---*
  *        /|       |       /       /|
  *      11 |       5      11     10 5
@@ -157,9 +157,9 @@ template <int dim> class MappingQ;
  *     3 8       9      3       | 9
  *     |/       /       |       |/
  *     *---0---*        *---0---*
- *   @end{verbatim}
+ *   @endverbatim
  * and their directions are as follows:
- *   @begin{verbatim}
+ *   @verbatim
  *         *--->---*        *--->---*
  *        /|       |       /       /|
  *       ^ |       ^      ^       ^ ^
@@ -170,7 +170,7 @@ template <int dim> class MappingQ;
  *     ^ ^       ^      ^       | ^
  *     |/       /       |       |/
  *     *--->---*        *--->---*
- *   @end{verbatim}
+ *   @endverbatim
  *
  * The element does not make much sense in 1d, so it is not
  * implemented there.
@@ -184,7 +184,7 @@ class FE_Nedelec : public FiniteElement<dim>
   public:
                                     /**
                                      * Constructor for the Nedelec
-                                     * element of degree @p{p}.
+                                     * element of degree @p p.
                                      */
     FE_Nedelec (const unsigned int p);
     
@@ -193,7 +193,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                      * identifies a finite
                                      * element. This class returns
                                      * @p{FE_Nedelec<dim>(degree)}, with
-                                     * @p{dim} and @p{degree}
+                                     * @p dim and @p degree
                                      * replaced by appropriate
                                      * values.
                                      */
@@ -201,11 +201,11 @@ class FE_Nedelec : public FiniteElement<dim>
 
                                     /**
                                      * Return the value of the
-                                     * @p{component}th vector
-                                     * component of the @p{i}th shape
+                                     * @p componentth vector
+                                     * component of the @p ith shape
                                      * function at the point
-                                     * @p{p}. See the
-                                     * @ref{FiniteElementBase} base
+                                     * @p p. See the
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -216,11 +216,11 @@ class FE_Nedelec : public FiniteElement<dim>
 
                                     /**
                                      * Return the gradient of the
-                                     * @p{component}th vector
-                                     * component of the @p{i}th shape
+                                     * @p componentth vector
+                                     * component of the @p ith shape
                                      * function at the point
-                                     * @p{p}. See the
-                                     * @ref{FiniteElementBase} base
+                                     * @p p. See the
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -231,11 +231,11 @@ class FE_Nedelec : public FiniteElement<dim>
 
                                     /**
                                      * Return the second derivative
-                                     * of the @p{component}th vector
-                                     * component of the @p{i}th shape
+                                     * of the @p componentth vector
+                                     * component of the @p ith shape
                                      * function at the point
-                                     * @p{p}. See the
-                                     * @ref{FiniteElementBase} base
+                                     * @p p. See the
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -264,7 +264,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                      * Access to base element
                                      * objects. Since this element is
                                      * atomic, @p{base_element(0)} is
-                                     * @p{this}, and all other
+                                     * @p this, and all other
                                      * indices throw an error.
                                      */
     virtual const FiniteElement<dim> &
@@ -272,7 +272,7 @@ class FE_Nedelec : public FiniteElement<dim>
 
                                      /**
                                       * Multiplicity of base element
-                                      * @p{index}. Since this is an
+                                      * @p index. Since this is an
                                       * atomic element,
                                       * @p{element_multiplicity(0)}
                                       * returns one, and all other
@@ -282,10 +282,10 @@ class FE_Nedelec : public FiniteElement<dim>
     
                                     /**
                                      * This function returns
-                                     * @p{true}, if the shape
-                                     * function @p{shape_index} has
+                                     * @p true, if the shape
+                                     * function @p shape_index has
                                      * non-zero values on the face
-                                     * @p{face_index}. For the lowest
+                                     * @p face_index. For the lowest
                                      * order Nedelec elements, this
                                      * is actually the case for the
                                      * one on which the shape
@@ -294,7 +294,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                      *
                                      * Implementation of the
                                      * interface in
-                                     * @ref{FiniteElement}
+                                     * FiniteElement
                                      */
     virtual bool has_support_on_face (const unsigned int shape_index,
                                      const unsigned int face_index) const;
@@ -363,7 +363,7 @@ class FE_Nedelec : public FiniteElement<dim>
 
                                         /**
                                          * As the
-                                         * @p{embedding_matrices}
+                                         * @p embedding_matrices
                                          * field, but for the
                                          * interface constraints. One
                                          * for each element for which
@@ -373,7 +373,7 @@ class FE_Nedelec : public FiniteElement<dim>
 
                                         /**
                                          * Like
-                                         * @p{n_embedding_matrices},
+                                         * @p n_embedding_matrices,
                                          * but for the number of
                                          * interface constraint
                                          * matrices.
@@ -387,11 +387,11 @@ class FE_Nedelec : public FiniteElement<dim>
     
   protected:    
                                     /**
-                                     * @p{clone} function instead of
+                                     * @p clone function instead of
                                      * a copy constructor.
                                      *
                                      * This function is needed by the
-                                     * constructors of @p{FESystem}.
+                                     * constructors of @p FESystem.
                                      */
     virtual FiniteElement<dim> * clone() const;
   
@@ -409,7 +409,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                     /**
                                      * Implementation of the same
                                      * function in
-                                     * @ref{FiniteElement}.
+                                     * FiniteElement.
                                      */
     virtual void
     fill_fe_values (const Mapping<dim> &mapping,
@@ -422,7 +422,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                     /**
                                      * Implementation of the same
                                      * function in
-                                     * @ref{FiniteElement}.
+                                     * FiniteElement.
                                      */
     virtual void
     fill_fe_face_values (const Mapping<dim> &mapping,
@@ -436,7 +436,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                     /**
                                      * Implementation of the same
                                      * function in
-                                     * @ref{FiniteElement}.
+                                     * FiniteElement.
                                      */
     virtual void
     fill_fe_subface_values (const Mapping<dim> &mapping,
@@ -453,12 +453,12 @@ class FE_Nedelec : public FiniteElement<dim>
                                     /**
                                      * Only for internal use. Its
                                      * full name is
-                                     * @p{get_dofs_per_object_vector}
+                                     * @p get_dofs_per_object_vector
                                      * function and it creates the
-                                     * @p{dofs_per_object} vector that is
+                                     * @p dofs_per_object vector that is
                                      * needed within the constructor to
                                      * be passed to the constructor of
-                                     * @p{FiniteElementData}.
+                                     * @p FiniteElementData.
                                      */
     static std::vector<unsigned int> get_dpo_vector(const unsigned int degree);
 
@@ -486,8 +486,8 @@ class FE_Nedelec : public FiniteElement<dim>
     
                                     /**
                                      * Initialize the
-                                     * @p{unit_support_points} field
-                                     * of the @ref{FiniteElementBase}
+                                     * @p unit_support_points field
+                                     * of the FiniteElementBase
                                      * class. Called from the
                                      * constructor.
                                      */
@@ -495,8 +495,8 @@ class FE_Nedelec : public FiniteElement<dim>
 
                                     /**
                                      * Initialize the
-                                     * @p{unit_face_support_points} field
-                                     * of the @ref{FiniteElementBase}
+                                     * @p unit_face_support_points field
+                                     * of the FiniteElementBase
                                      * class. Called from the
                                      * constructor.
                                      */
@@ -505,7 +505,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                     /**
                                      * Given a set of flags indicating
                                      * what quantities are requested
-                                     * from a @p{FEValues} object,
+                                     * from a @p FEValues object,
                                      * return which of these can be
                                      * precomputed once and for
                                      * all. Often, the values of
@@ -514,8 +514,8 @@ class FE_Nedelec : public FiniteElement<dim>
                                      * example, in which case the
                                      * return value of this function
                                      * would be the logical and of
-                                     * the input @p{flags} and
-                                     * @p{update_values}.
+                                     * the input @p flags and
+                                     * @p update_values.
                                      *
                                      * For the present kind of finite
                                      * element, this is exactly the
index 9a22974b6af8aac67bc38e3da4b02f2784f509ec..8a96788969a7108946699adb98f44b4614436afb 100644 (file)
@@ -308,9 +308,9 @@ class FE_Poly : public FiniteElement<dim>
                                      *
                                      * The effect in this element is
                                      * as follows:
-                                     * @begin{itemize}
+                                     * <ul>
 
-                                     * @item if
+                                     * <li> if
                                      * <tt>update_gradients</tt> is
                                      * set, the result will contain
                                      * <tt>update_gradients</tt> and
@@ -324,7 +324,7 @@ class FE_Poly : public FiniteElement<dim>
                                      * is actually performed by the
                                      * Mapping object used in
                                      * conjunction with this finite
-                                     * element.  @item if
+                                     * element.  <li> if
                                      * <tt>update_second_derivatives</tt>
                                      * is set, the result will
                                      * contain
@@ -339,7 +339,7 @@ class FE_Poly : public FiniteElement<dim>
                                      * quotients for the actual
                                      * computation.
                                      *
-                                     * @end{itemize}
+                                     * </ul>
                                      */
     virtual UpdateFlags update_each (const UpdateFlags flags) const;
 
index 2dacccea9e403e22d120eb6183b963230f912009..872650069a8a7d67116d2bb116cbf35c531ad4f2 100644 (file)
 /*@{*/
 
 /**
- * Implementation of Lagrange finite elements @p{Qp} that yield the
+ * Implementation of Lagrange finite elements @p Qp that yield the
  * finite element space of continuous, piecewise polynomials of degree
- * @p{p}. This class is realized using tensor product polynomials
+ * @p p. This class is realized using tensor product polynomials
  * based on equidistant support points.
  *
- * The constructor of this class takes the degree @p{p} of this finite
+ * The constructor of this class takes the degree @p p of this finite
  * element.
  *
  * @sect3{Implementation}
  *
- * The constructor creates a @ref{TensorProductPolynomials} object
- * that includes the tensor product of @p{LagrangeEquidistant}
- * polynomials of degree @p{p}. This @p{TensorProductPolynomials}
+ * The constructor creates a TensorProductPolynomials object
+ * that includes the tensor product of @p LagrangeEquidistant
+ * polynomials of degree @p p. This @p TensorProductPolynomials
  * object provides all values and derivatives of the shape functions.
  *
- * Furthermore the constructor filles the @p{interface_constraints},
- * the @p{prolongation} (embedding) and the @p{restriction}
+ * Furthermore the constructor filles the @p interface_constraints,
+ * the @p prolongation (embedding) and the @p restriction
  * matrices. These are implemented only up to a certain degree, that
  * is listed in the following:
  *
- * @begin{itemize}
- * @item @p{dim==1}
- *   @begin{itemize}
- *   @item the @p{interface_constraints} are not needed
- *   @item the @p{prolongation} matrices up to degree 4, and
- *   @item the @p{restriction} matrices up to degree 4.
- *   @end{itemize}
- * @item @p{dim==2}
- *   @begin{itemize}
- *   @item the @p{interface_constraints} up to degree 4,
- *   @item the @p{prolongation} matrices up to degree 3, and
- *   @item the @p{restriction} matrices up to degree 4.
- *   @end{itemize}
- * @item @p{dim==3}
- *   @begin{itemize}
- *   @item the @p{interface_constraints} up to degree 2,
- *   @item the @p{prolongation} matrices up to degree 2, and
- *   @item the @p{restriction} matrices up to degree 4.
- *   @end{itemize}
- * @end{itemize}
+ * <ul>
+ * <li> @p{dim==1}
+ *   <ul>
+ *   <li> the @p interface_constraints are not needed
+ *   <li> the @p prolongation matrices up to degree 4, and
+ *   <li> the @p restriction matrices up to degree 4.
+ *   </ul>
+ * <li> @p{dim==2}
+ *   <ul>
+ *   <li> the @p interface_constraints up to degree 4,
+ *   <li> the @p prolongation matrices up to degree 3, and
+ *   <li> the @p restriction matrices up to degree 4.
+ *   </ul>
+ * <li> @p{dim==3}
+ *   <ul>
+ *   <li> the @p interface_constraints up to degree 2,
+ *   <li> the @p prolongation matrices up to degree 2, and
+ *   <li> the @p restriction matrices up to degree 4.
+ *   </ul>
+ * </ul>
  *
  * @sect3{Numbering of the degrees of freedom (DoFs)}
  *
  * The original ordering of the shape functions represented by the
- * @ref{TensorProductPolynomials} is a tensor product
+ * TensorProductPolynomials is a tensor product
  * numbering. However, the shape functions on a cell are renumbered
  * beginning with the shape functions whose support points are at the
  * vertices, then on the line, on the quads, and finally (for 3d) on
  * following:
  *
  * @sect4{Q1 elements}
- * @begin{itemize}
- * @item 1D case:
- *   @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ *   @verbatim
  *      0-------1
- *   @end{verbatim}
+ *   @endverbatim
  *
- * @item 2D case:
- *   @begin{verbatim}
+ * <li> 2D case:
+ *   @verbatim
  *      3-------2
  *      |       |
  *      |       |
  *      |       |
  *      0-------1
- *   @end{verbatim}
+ *   @endverbatim
  *
- * @item 3D case:
- *   @begin{verbatim}
+ * <li> 3D case:
+ *   @verbatim
  *         7-------6        7-------6
  *        /|       |       /       /|
  *       / |       |      /       / |
  *     | /       /      |       | /
  *     |/       /       |       |/
  *     0-------1        0-------1
- *   @end{verbatim}
+ *   @endverbatim
  *
  *   The respective coordinate values of the support points of the degrees
  *   of freedom are as follows:
- *   @begin{itemize}
- *   @item Index 0: @p{[0, 0, 0]};
- *   @item Index 1: @p{[1, 0, 0]};
- *   @item Index 2: @p{[1, 0, 1]};
- *   @item Index 3: @p{[0, 0, 1]};
- *   @item Index 4: @p{[0, 1, 0]};
- *   @item Index 5: @p{[1, 1, 0]};
- *   @item Index 6: @p{[1, 1, 1]};
- *   @item Index 7: @p{[0, 1, 1]};
- *   @end{itemize}
- * @end{itemize}
+ *   <ul>
+ *   <li> Index 0: @p{[0, 0, 0]};
+ *   <li> Index 1: @p{[1, 0, 0]};
+ *   <li> Index 2: @p{[1, 0, 1]};
+ *   <li> Index 3: @p{[0, 0, 1]};
+ *   <li> Index 4: @p{[0, 1, 0]};
+ *   <li> Index 5: @p{[1, 1, 0]};
+ *   <li> Index 6: @p{[1, 1, 1]};
+ *   <li> Index 7: @p{[0, 1, 1]};
+ *   </ul>
+ * </ul>
  * @sect4{Q2 elements}
- * @begin{itemize}
- * @item 1D case:
- *   @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ *   @verbatim
  *      0---2---1
- *   @end{verbatim}
+ *   @endverbatim
  *
- * @item 2D case:
- *   @begin{verbatim}
+ * <li> 2D case:
+ *   @verbatim
  *      3---6---2
  *      |       |
  *      7   8   5
  *      |       |
  *      0---4---1
- *   @end{verbatim}
+ *   @endverbatim
  *
- * @item 3D case:
- *   @begin{verbatim}
+ * <li> 3D case:
+ *   @verbatim
  *         7--14---6        7--14---6
  *        /|       |       /       /|
  *      19 |       13     19      1813
  *     | /  22   /      |       | /
  *     |/       /       |       |/
  *     *-------*        *-------* 
- *   @end{verbatim}
+ *   @endverbatim
  *   The center vertex has number 26.
  *
  *   The respective coordinate values of the support points of the degrees
  *   of freedom are as follows:
- *   @begin{itemize}
- *   @item Index 0: @p{[0, 0, 0]};
- *   @item Index 1: @p{[1, 0, 0]};
- *   @item Index 2: @p{[1, 0, 1]};
- *   @item Index 3: @p{[0, 0, 1]};
- *   @item Index 4: @p{[0, 1, 0]};
- *   @item Index 5: @p{[1, 1, 0]};
- *   @item Index 6: @p{[1, 1, 1]};
- *   @item Index 7: @p{[0, 1, 1]};
- *   @item Index 8: @p{[1/2, 0, 0]};
- *   @item Index 9: @p{[1, 0, 1/2]};
- *   @item Index 10: @p{[1/2, 0, 1]};
- *   @item Index 11: @p{[0, 0, 1/2]};
- *   @item Index 12: @p{[1/2, 1, 0]};
- *   @item Index 13: @p{[1, 1, 1/2]};
- *   @item Index 14: @p{[1/2, 1, 1]};
- *   @item Index 15: @p{[0, 1, 1/2]};
- *   @item Index 16: @p{[0, 1/2, 0]};
- *   @item Index 17: @p{[1, 1/2, 0]};
- *   @item Index 18: @p{[1, 1/2, 1]};
- *   @item Index 19: @p{[0, 1/2, 1]};
- *   @item Index 20: @p{[1/2, 0, 1/2]};
- *   @item Index 21: @p{[1/2, 1, 1/2]};
- *   @item Index 22: @p{[1/2, 1/2, 0]};
- *   @item Index 23: @p{[1, 1/2, 1/2]};
- *   @item Index 24: @p{[1/2, 1/2, 1]};
- *   @item Index 25: @p{[0, 1/2, 1/2]};
- *   @item Index 26: @p{[1/2, 1/2, 1/2]}; 
- *   @end{itemize}
- * @end{itemize}
+ *   <ul>
+ *   <li> Index 0: @p{[0, 0, 0]};
+ *   <li> Index 1: @p{[1, 0, 0]};
+ *   <li> Index 2: @p{[1, 0, 1]};
+ *   <li> Index 3: @p{[0, 0, 1]};
+ *   <li> Index 4: @p{[0, 1, 0]};
+ *   <li> Index 5: @p{[1, 1, 0]};
+ *   <li> Index 6: @p{[1, 1, 1]};
+ *   <li> Index 7: @p{[0, 1, 1]};
+ *   <li> Index 8: @p{[1/2, 0, 0]};
+ *   <li> Index 9: @p{[1, 0, 1/2]};
+ *   <li> Index 10: @p{[1/2, 0, 1]};
+ *   <li> Index 11: @p{[0, 0, 1/2]};
+ *   <li> Index 12: @p{[1/2, 1, 0]};
+ *   <li> Index 13: @p{[1, 1, 1/2]};
+ *   <li> Index 14: @p{[1/2, 1, 1]};
+ *   <li> Index 15: @p{[0, 1, 1/2]};
+ *   <li> Index 16: @p{[0, 1/2, 0]};
+ *   <li> Index 17: @p{[1, 1/2, 0]};
+ *   <li> Index 18: @p{[1, 1/2, 1]};
+ *   <li> Index 19: @p{[0, 1/2, 1]};
+ *   <li> Index 20: @p{[1/2, 0, 1/2]};
+ *   <li> Index 21: @p{[1/2, 1, 1/2]};
+ *   <li> Index 22: @p{[1/2, 1/2, 0]};
+ *   <li> Index 23: @p{[1, 1/2, 1/2]};
+ *   <li> Index 24: @p{[1/2, 1/2, 1]};
+ *   <li> Index 25: @p{[0, 1/2, 1/2]};
+ *   <li> Index 26: @p{[1/2, 1/2, 1/2]}; 
+ *   </ul>
+ * </ul>
  * @sect4{Q3 elements}
- * @begin{itemize}
- * @item 1D case:
- *   @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ *   @verbatim
  *      0--2--3--1
- *   @end{verbatim}
+ *   @endverbatim
  *
- * @item 2D case:
- *   @begin{verbatim}
+ * <li> 2D case:
+ *   @verbatim
  *      3--8--9--2
  *      |        |
  *      11 14 15 7
  *      10 12 13 6
  *      |        |
  *      0--4--5--1
- *   @end{verbatim}
+ *   @endverbatim
  *   Note the reverse ordering of degrees of freedom on the left and
  *   upper line.
- * @end{itemize}
+ * </ul>
  * @sect4{Q4 elements}
- * @begin{itemize}
- * @item 1D case:
- *   @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ *   @verbatim
  *      0--2--3--4--1
- *   @end{verbatim}
+ *   @endverbatim
  *
- * @item 2D case:
- *   @begin{verbatim}
+ * <li> 2D case:
+ *   @verbatim
  *      3--10-11-12-2
  *      |           |
  *      15 22 23 24 9
  *      13 16 17 18 7
  *      |           |
  *      0--4--5--6--1
- *   @end{verbatim}
- * @end{itemize}
+ *   @endverbatim
+ * </ul>
  * Note the reverse ordering of degrees of freedom on the left and upper
  * line.
  *
@@ -241,7 +241,7 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
   public:
                                     /**
                                      * Constructor for tensor product
-                                     * polynomials of degree @p{p}.
+                                     * polynomials of degree @p p.
                                      */
     FE_Q (const unsigned int p);
     
@@ -250,7 +250,7 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * identifies a finite
                                      * element. This class returns
                                      * @p{FE_Q<dim>(degree)}, with
-                                     * @p{dim} and @p{degree}
+                                     * @p dim and @p degree
                                      * replaced by appropriate
                                      * values.
                                      */
@@ -261,12 +261,12 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * interpolating from the given
                                      * finite element to the present
                                      * one. The size of the matrix is
-                                     * then @p{dofs_per_cell} times
+                                     * then @p dofs_per_cell times
                                      * @p{source.dofs_per_cell}.
                                      *
                                      * These matrices are only
                                      * available if the source
-                                     * element is also a @p{FE_Q}
+                                     * element is also a @p FE_Q
                                      * element. Otherwise, an
                                      * exception of type
                                      * @ref{FiniteElementBase<dim>::ExcInterpolationNotImplemented}
@@ -280,14 +280,14 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * Check for non-zero values on a face.
                                      *
                                      * This function returns
-                                     * @p{true}, if the shape
-                                     * function @p{shape_index} has
+                                     * @p true, if the shape
+                                     * function @p shape_index has
                                      * non-zero values on the face
-                                     * @p{face_index}.
+                                     * @p face_index.
                                      *
                                      * Implementation of the
                                      * interface in
-                                     * @ref{FiniteElement}
+                                     * FiniteElement
                                      */
     virtual bool has_support_on_face (const unsigned int shape_index,
                                      const unsigned int face_index) const;
@@ -319,7 +319,7 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
     {
                                         /**
                                          * As the
-                                         * @p{embedding_matrices}
+                                         * @p embedding_matrices
                                          * field, but for the
                                          * interface constraints. One
                                          * for each element for which
@@ -329,7 +329,7 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
 
                                         /**
                                          * Like
-                                         * @p{n_embedding_matrices},
+                                         * @p n_embedding_matrices,
                                          * but for the number of
                                          * interface constraint
                                          * matrices.
@@ -339,11 +339,11 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
 
   protected:    
                                     /**
-                                     * @p{clone} function instead of
+                                     * @p clone function instead of
                                      * a copy constructor.
                                      *
                                      * This function is needed by the
-                                     * constructors of @p{FESystem}.
+                                     * constructors of @p FESystem.
                                      */
     virtual FiniteElement<dim> * clone() const;
 
@@ -352,12 +352,12 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                     /**
                                      * Only for internal use. Its
                                      * full name is
-                                     * @p{get_dofs_per_object_vector}
+                                     * @p get_dofs_per_object_vector
                                      * function and it creates the
-                                     * @p{dofs_per_object} vector that is
+                                     * @p dofs_per_object vector that is
                                      * needed within the constructor to
                                      * be passed to the constructor of
-                                     * @p{FiniteElementData}.
+                                     * @p FiniteElementData.
                                      */
     static std::vector<unsigned int> get_dpo_vector(const unsigned int degree);
     
@@ -366,12 +366,12 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * shape function numbering. This
                                      * function is actually an alike
                                      * replica of the respective
-                                     * function in the @ref{FETools}
+                                     * function in the FETools
                                      * class, but is kept for three
                                      * reasons:
                                      *
                                      * 1. It only operates on a
-                                     * @ref{FiniteElementData}
+                                     * FiniteElementData
                                      * structure. This is ok in the
                                      * present context, since we can
                                      * control which types of
@@ -379,14 +379,14 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * because this is a private
                                      * function. However, the
                                      * publicly visible function in
-                                     * the @ref{FETools} class needs
+                                     * the FETools class needs
                                      * to make sure that the
-                                     * @ref{FiniteElementData} object
+                                     * FiniteElementData object
                                      * it works on actually
                                      * represents a continuous finite
                                      * element, which we found too
                                      * difficult if we do not pass an
-                                     * object of type @ref{FE_Q}
+                                     * object of type FE_Q()
                                      * directly.
                                      *
                                      * 2. If we would call the
@@ -468,8 +468,8 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
 
                                     /**
                                      * Initialize the
-                                     * @p{unit_support_points} field
-                                     * of the @ref{FiniteElementBase}
+                                     * @p unit_support_points field
+                                     * of the FiniteElementBase
                                      * class. Called from the
                                      * constructor.
                                      */
@@ -477,8 +477,8 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
 
                                     /**
                                      * Initialize the
-                                     * @p{unit_face_support_points} field
-                                     * of the @ref{FiniteElementBase}
+                                     * @p unit_face_support_points field
+                                     * of the FiniteElementBase
                                      * class. Called from the
                                      * constructor.
                                      */
@@ -497,8 +497,8 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * Allow access from other
                                      * dimensions. We need this since
                                      * we want to call the functions
-                                     * @p{get_dpo_vector} and
-                                     * @p{lexicographic_to_hierarchic_numbering}
+                                     * @p get_dpo_vector and
+                                     * @p lexicographic_to_hierarchic_numbering
                                      * for the faces of the finite
                                      * element of dimension dim+1.
                                      */
index 5b4ffc63d024cb27ae74a157548b5bc1fa25f37a..b12d7c19072c21bfd47b1351f5575dc1c84f80e3 100644 (file)
@@ -24,45 +24,45 @@ template <int dim> class MappingQ;
 /*@{*/
 
 /**
- * Implementation of Hierarchical finite elements @p{Qp} that yield the
+ * Implementation of Hierarchical finite elements @p Qp that yield the
  * finite element space of continuous, piecewise polynomials of degree
- * @p{p}. This class is realized using tensor product polynomials
- * based on a hierarchical basis @p{Hierarchical} of the interval 
- * @p{[0,1]} which is suitable for building an @p{hp} tensor product 
+ * @p p. This class is realized using tensor product polynomials
+ * based on a hierarchical basis @p Hierarchical of the interval 
+ * @p{[0,1]} which is suitable for building an @p hp tensor product 
  * finite element, if we assume that each element has a single degree.
  * 
- * There are not many differences between @p{FE_Q_Hierarchical} and 
- * @p{FE_Q}, except that we add a function @p{embedding_dofs} that takes 
- * a given integer @p{q}, between @p{1} and @p{p}, and 
+ * There are not many differences between @p FE_Q_Hierarchical and 
+ * @p FE_Q, except that we add a function @p embedding_dofs that takes 
+ * a given integer @p q, between @p 1 and @p p, and 
  * returns the numbering of basis functions of the element of order 
- * @p{q} in basis of order @p{p}.  This function is 
+ * @p q in basis of order @p p.  This function is 
  * useful if one wants to make calculations using the hierarchical
  * nature of these shape functions.
  *
- * The unit support points now are reduced to @p{0}, @p{1}, and @p{0.5} in 
+ * The unit support points now are reduced to @p 0, @p 1, and @p{0.5} in 
  * one dimension, and tensor products in higher dimensions. Thus, various 
  * interpolation functions will only work correctly for the linear case. 
  * Future work will involve writing projection--interpolation operators
  * that can interpolate onto the higher order bubble functions.
  *
  * The various constraint, prolongation, and restriction matrices are 
- * now available in all dimensions for all degrees @p{p}, currently up to 
+ * now available in all dimensions for all degrees @p p, currently up to 
  * order 19.
  *
- * The constructor of this class takes the degree @p{p} of this finite
+ * The constructor of this class takes the degree @p p of this finite
  * element.
  *
  * @sect3{Implementation}
  *
- * The constructor creates a @ref{TensorProductPolynomials} object
- * that includes the tensor product of @p{Hierarchical}
- * polynomials of degree @p{p}. This @p{TensorProductPolynomials}
+ * The constructor creates a TensorProductPolynomials object
+ * that includes the tensor product of @p Hierarchical
+ * polynomials of degree @p p. This @p TensorProductPolynomials
  * object provides all values and derivatives of the shape functions.
  *
  * @sect3{Numbering of the degrees of freedom (DoFs)}
  *
  * The original ordering of the shape functions represented by the
- * @ref{TensorProductPolynomials} is a tensor product
+ * TensorProductPolynomials is a tensor product
  * numbering. However, the shape functions on a cell are renumbered
  * beginning with the shape functions whose support points are at the
  * vertices, then on the line, on the quads, and finally (for 3d) on
@@ -70,23 +70,23 @@ template <int dim> class MappingQ;
  * following:
  *
  * @sect4{Q1 elements}
- * @begin{itemize}
- * @item 1D case:
- *   @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ *   @verbatim
  *      0-------1
- *   @end{verbatim}
+ *   @endverbatim
  *
- * @item 2D case:
- *   @begin{verbatim}
+ * <li> 2D case:
+ *   @verbatim
  *      3-------2
  *      |       |
  *      |       |
  *      |       |
  *      0-------1
- *   @end{verbatim}
+ *   @endverbatim
  *
- * @item 3D case:
- *   @begin{verbatim}
+ * <li> 3D case:
+ *   @verbatim
  *         7-------6        7-------6
  *        /|       |       /       /|
  *       / |       |      /       / |
@@ -100,35 +100,35 @@ template <int dim> class MappingQ;
  *
  *   The respective coordinate values of the support points of the degrees
  *   of freedom are as follows:
- *   @begin{itemize}
- *   @item Index 0: @p{[0, 0, 0]};
- *   @item Index 1: @p{[1, 0, 0]};
- *   @item Index 2: @p{[1, 0, 1]};
- *   @item Index 3: @p{[0, 0, 1]};
- *   @item Index 4: @p{[0, 1, 0]};
- *   @item Index 5: @p{[1, 1, 0]};
- *   @item Index 6: @p{[1, 1, 1]};
- *   @item Index 7: @p{[0, 1, 1]};
- *   @end{itemize}
- * @end{itemize}
+ *   <ul>
+ *   <li> Index 0: @p{[0, 0, 0]};
+ *   <li> Index 1: @p{[1, 0, 0]};
+ *   <li> Index 2: @p{[1, 0, 1]};
+ *   <li> Index 3: @p{[0, 0, 1]};
+ *   <li> Index 4: @p{[0, 1, 0]};
+ *   <li> Index 5: @p{[1, 1, 0]};
+ *   <li> Index 6: @p{[1, 1, 1]};
+ *   <li> Index 7: @p{[0, 1, 1]};
+ *   </ul>
+ * </ul>
  * @sect4{Q2 elements}
- * @begin{itemize}
- * @item 1D case:
- *   @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ *   @verbatim
  *      0---2---1
- *   @end{verbatim}
+ *   @endverbatim
  *
- * @item 2D case:
- *   @begin{verbatim}
+ * <li> 2D case:
+ *   @verbatim
  *      3---6---2
  *      |       |
  *      7   8   5
  *      |       |
  *      0---4---1
- *   @end{verbatim}
+ *   @endverbatim
  *
- * @item 3D case:
- *   @begin{verbatim}
+ * <li> 3D case:
+ *   @verbatim
  *         7--14---6        7--14---6
  *        /|       |       /       /|
  *      19 |       13     19      1813
@@ -150,50 +150,50 @@ template <int dim> class MappingQ;
  *     | /  22   /      |       | /
  *     |/       /       |       |/
  *     *-------*        *-------* 
- *   @end{verbatim}
+ *   @endverbatim
  *   The center vertex has number 26.
  *
  *   The respective coordinate values of the support points of the degrees
  *   of freedom are as follows:
- *   @begin{itemize}
- *   @item Index 0: @p{[0, 0, 0]};
- *   @item Index 1: @p{[1, 0, 0]};
- *   @item Index 2: @p{[1, 0, 1]};
- *   @item Index 3: @p{[0, 0, 1]};
- *   @item Index 4: @p{[0, 1, 0]};
- *   @item Index 5: @p{[1, 1, 0]};
- *   @item Index 6: @p{[1, 1, 1]};
- *   @item Index 7: @p{[0, 1, 1]};
- *   @item Index 8: @p{[1/2, 0, 0]};
- *   @item Index 9: @p{[1, 0, 1/2]};
- *   @item Index 10: @p{[1/2, 0, 1]};
- *   @item Index 11: @p{[0, 0, 1/2]};
- *   @item Index 12: @p{[1/2, 1, 0]};
- *   @item Index 13: @p{[1, 1, 1/2]};
- *   @item Index 14: @p{[1/2, 1, 1]};
- *   @item Index 15: @p{[0, 1, 1/2]};
- *   @item Index 16: @p{[0, 1/2, 0]};
- *   @item Index 17: @p{[1, 1/2, 0]};
- *   @item Index 18: @p{[1, 1/2, 1]};
- *   @item Index 19: @p{[0, 1/2, 1]};
- *   @item Index 20: @p{[1/2, 0, 1/2]};
- *   @item Index 21: @p{[1/2, 1, 1/2]};
- *   @item Index 22: @p{[1/2, 1/2, 0]};
- *   @item Index 23: @p{[1, 1/2, 1/2]};
- *   @item Index 24: @p{[1/2, 1/2, 1]};
- *   @item Index 25: @p{[0, 1/2, 1/2]};
- *   @item Index 26: @p{[1/2, 1/2, 1/2]}; 
- *   @end{itemize}
- * @end{itemize}
+ *   <ul>
+ *   <li> Index 0: @p{[0, 0, 0]};
+ *   <li> Index 1: @p{[1, 0, 0]};
+ *   <li> Index 2: @p{[1, 0, 1]};
+ *   <li> Index 3: @p{[0, 0, 1]};
+ *   <li> Index 4: @p{[0, 1, 0]};
+ *   <li> Index 5: @p{[1, 1, 0]};
+ *   <li> Index 6: @p{[1, 1, 1]};
+ *   <li> Index 7: @p{[0, 1, 1]};
+ *   <li> Index 8: @p{[1/2, 0, 0]};
+ *   <li> Index 9: @p{[1, 0, 1/2]};
+ *   <li> Index 10: @p{[1/2, 0, 1]};
+ *   <li> Index 11: @p{[0, 0, 1/2]};
+ *   <li> Index 12: @p{[1/2, 1, 0]};
+ *   <li> Index 13: @p{[1, 1, 1/2]};
+ *   <li> Index 14: @p{[1/2, 1, 1]};
+ *   <li> Index 15: @p{[0, 1, 1/2]};
+ *   <li> Index 16: @p{[0, 1/2, 0]};
+ *   <li> Index 17: @p{[1, 1/2, 0]};
+ *   <li> Index 18: @p{[1, 1/2, 1]};
+ *   <li> Index 19: @p{[0, 1/2, 1]};
+ *   <li> Index 20: @p{[1/2, 0, 1/2]};
+ *   <li> Index 21: @p{[1/2, 1, 1/2]};
+ *   <li> Index 22: @p{[1/2, 1/2, 0]};
+ *   <li> Index 23: @p{[1, 1/2, 1/2]};
+ *   <li> Index 24: @p{[1/2, 1/2, 1]};
+ *   <li> Index 25: @p{[0, 1/2, 1/2]};
+ *   <li> Index 26: @p{[1/2, 1/2, 1/2]}; 
+ *   </ul>
+ * </ul>
  * @sect4{Q3 elements}
- * @begin{itemize}
- * @item 1D case:
- *   @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ *   @verbatim
  *      0--2--3--1
- *   @end{verbatim}
+ *   @endverbatim
  *
- * @item 2D case:
- *   @begin{verbatim}
+ * <li> 2D case:
+ *   @verbatim
  *      3--8--9--2
  *      |        |
  *      11 14 15 7
@@ -201,19 +201,19 @@ template <int dim> class MappingQ;
  *      10 12 13 6
  *      |        |
  *      0--4--5--1
- *   @end{verbatim}
+ *   @endverbatim
  *   Note the reverse ordering of degrees of freedom on the left and
  *   upper line.
- * @end{itemize}
+ * </ul>
  * @sect4{Q4 elements}
- * @begin{itemize}
- * @item 1D case:
- *   @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ *   @verbatim
  *      0--2--3--4--1
- *   @end{verbatim}
+ *   @endverbatim
  *
- * @item 2D case:
- *   @begin{verbatim}
+ * <li> 2D case:
+ *   @verbatim
  *      3--10-11-12-2
  *      |           |
  *      15 22 23 24 9
@@ -223,8 +223,8 @@ template <int dim> class MappingQ;
  *      13 16 17 18 7
  *      |           |
  *      0--4--5--6--1
- *   @end{verbatim}
- * @end{itemize}
+ *   @endverbatim
+ * </ul>
  * Note the reverse ordering of degrees of freedom on the left and upper
  * line.
  *
@@ -245,7 +245,7 @@ class FE_Q_Hierarchical : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * identifies a finite
                                      * element. This class returns
                                      * @p{FE_Q_Hierarchical<dim>(degree)},
-                                     * with @p{dim} and @p{degree}
+                                     * with @p dim and @p degree
                                      * replaced by appropriate
                                      * values.
                                      */
@@ -255,14 +255,14 @@ class FE_Q_Hierarchical : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * Check for non-zero values on a face.
                                      *
                                      * This function returns
-                                     * @p{true}, if the shape
-                                     * function @p{shape_index} has
+                                     * @p true, if the shape
+                                     * function @p shape_index has
                                      * non-zero values on the face
-                                     * @p{face_index}.
+                                     * @p face_index.
                                      *
                                      * Implementation of the
                                      * interface in
-                                     * @ref{FiniteElement}
+                                     * FiniteElement
                                      */
     virtual bool has_support_on_face (const unsigned int shape_index,
                                      const unsigned int face_index) const;
@@ -282,21 +282,21 @@ class FE_Q_Hierarchical : public FE_Poly<TensorProductPolynomials<dim>,dim>
 
                                      /**
                                      * For a finite element of degree
-                                     * @p{sub_degree} < @p{degree}, we 
+                                     * @p sub_degree < @p degree, we 
                                      * return a vector which maps the 
                                      * numbering on an FE
-                                     * of degree @p{sub_degree} into the 
+                                     * of degree @p sub_degree into the 
                                      * numbering on this element.
                                      */
     std::vector<unsigned int> get_embedding_dofs (const unsigned int sub_degree) const;
 
   protected:    
                                     /**
-                                     * @p{clone} function instead of
+                                     * @p clone function instead of
                                      * a copy constructor.
                                      *
                                      * This function is needed by the
-                                     * constructors of @p{FESystem}.
+                                     * constructors of @p FESystem.
                                      */
     virtual FiniteElement<dim> * clone() const;
 
@@ -305,12 +305,12 @@ class FE_Q_Hierarchical : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                     /**
                                      * Only for internal use. Its
                                      * full name is
-                                     * @p{get_dofs_per_object_vector}
+                                     * @p get_dofs_per_object_vector
                                      * function and it creates the
-                                     * @p{dofs_per_object} vector that is
+                                     * @p dofs_per_object vector that is
                                      * needed within the constructor to
                                      * be passed to the constructor of
-                                     * @p{FiniteElementData}.
+                                     * @p FiniteElementData.
                                      */
     static std::vector<unsigned int> get_dpo_vector(const unsigned int degree);
     
@@ -319,12 +319,12 @@ class FE_Q_Hierarchical : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * shape function numbering. This
                                      * function is actually an alike
                                      * replica of the respective
-                                     * function in the @ref{FETools}
+                                     * function in the FETools
                                      * class, but is kept for three
                                      * reasons:
                                      *
                                      * 1. It only operates on a
-                                     * @ref{FiniteElementData}
+                                     * FiniteElementData
                                      * structure. This is ok in the
                                      * present context, since we can
                                      * control which types of
@@ -332,14 +332,14 @@ class FE_Q_Hierarchical : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * because this is a private
                                      * function. However, the
                                      * publicly visible function in
-                                     * the @ref{FETools} class needs
+                                     * the FETools class needs
                                      * to make sure that the
-                                     * @ref{FiniteElementData} object
+                                     * FiniteElementData object
                                      * it works on actually
                                      * represents a continuous finite
                                      * element, which we found too
                                      * difficult if we do not pass an
-                                     * object of type @ref{FE_Q}
+                                     * object of type FE_Q()
                                      * directly.
                                      *
                                      * 2. If we would call the
@@ -420,8 +420,8 @@ class FE_Q_Hierarchical : public FE_Poly<TensorProductPolynomials<dim>,dim>
 
                                     /**
                                      * Initialize the
-                                     * @p{unit_support_points} field
-                                     * of the @ref{FiniteElementBase}
+                                     * @p unit_support_points field
+                                     * of the FiniteElementBase
                                      * class. Called from the
                                      * constructor.
                                      */
@@ -429,8 +429,8 @@ class FE_Q_Hierarchical : public FE_Poly<TensorProductPolynomials<dim>,dim>
 
                                     /**
                                      * Initialize the
-                                     * @p{unit_face_support_points} field
-                                     * of the @ref{FiniteElementBase}
+                                     * @p unit_face_support_points field
+                                     * of the FiniteElementBase
                                      * class. Called from the
                                      * constructor.
                                      */
@@ -446,8 +446,8 @@ class FE_Q_Hierarchical : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * Allow access from other
                                      * dimensions. We need this since
                                      * we want to call the functions
-                                     * @p{get_dpo_vector} and
-                                     * @p{lexicographic_to_hierarchic_numbering}
+                                     * @p get_dpo_vector and
+                                     * @p lexicographic_to_hierarchic_numbering
                                      * for the faces of the finite
                                      * element of dimension dim+1.
                                      */
index 6ce814a42d98861b6aeec893c1aa886c225f0288..7b75a775cae6b494f44ffe3c54d150339330c7b2 100644 (file)
@@ -29,7 +29,7 @@ template <int dim> class MappingQ;
  * H_div. Note, however, that continuity only concerns the normal
  * component of the vector field.
  *
- * The constructor of this class takes the degree @p{p} of this finite
+ * The constructor of this class takes the degree @p p of this finite
  * element. The numbering of the degree of this element in the
  * literature is somewhat funny: the degree is defined not as the
  * polynomial degree of the finite element space, but as that of the
@@ -61,7 +61,7 @@ template <int dim> class MappingQ;
  * interpolated or projected, or better: whether the matrices the
  * finite element provides are to be treated with the properties of a
  * projection or of an interpolation, is controlled by the
- * @p{restriction_is_additive} flag. See there for more information.)
+ * @p restriction_is_additive flag. See there for more information.)
  *
  * Here, things are not so simple: since the element has some
  * continuity requirements across faces, we can only resort to some
@@ -89,7 +89,7 @@ template <int dim> class MappingQ;
  * direction. We use the standard enumeration and direction of edges
  * in deal.II, yielding the following shape functions in 2d:
  *
- *   @begin{verbatim}
+ *   @verbatim
  *          2
  *      *---^---*
  *      |       |
@@ -97,12 +97,12 @@ template <int dim> class MappingQ;
  *      |       |
  *      *---^---*
  *          0
- *   @end{verbatim}
+ *   @endverbatim
  *
  * For the 3d case, the ordering follows the same scheme: the lines
  * are numbered as described in the documentation of the
- * @ref{Triangulation} class, i.e.
- *   @begin{verbatim}
+ * Triangulation class, i.e.
+ *   @verbatim
  *         *---6---*        *---6---*
  *        /|       |       /       /|
  *      11 |       5      11     10 5
@@ -113,9 +113,9 @@ template <int dim> class MappingQ;
  *     3 8       9      3       | 9
  *     |/       /       |       |/
  *     *---0---*        *---0---*
- *   @end{verbatim}
+ *   @endverbatim
  * and their directions are as follows:
- *   @begin{verbatim}
+ *   @verbatim
  *         *--->---*        *--->---*
  *        /|       |       /       /|
  *       ^ |       ^      ^       ^ ^
@@ -126,7 +126,7 @@ template <int dim> class MappingQ;
  *     ^ ^       ^      ^       | ^
  *     |/       /       |       |/
  *     *--->---*        *--->---*
- *   @end{verbatim}
+ *   @endverbatim
  *
  * The element does not make much sense in 1d, so it is not
  * implemented there.
@@ -140,7 +140,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
   public:
                                     /**
                                      * Constructor for the Nedelec
-                                     * element of degree @p{p}.
+                                     * element of degree @p p.
                                      */
     FE_RaviartThomas (const unsigned int p);
     
@@ -149,7 +149,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                      * identifies a finite
                                      * element. This class returns
                                      * @p{FE_RaviartThomas<dim>(degree)}, with
-                                     * @p{dim} and @p{degree}
+                                     * @p dim and @p degree
                                      * replaced by appropriate
                                      * values.
                                      */
@@ -157,11 +157,11 @@ class FE_RaviartThomas : public FiniteElement<dim>
 
                                     /**
                                      * Return the value of the
-                                     * @p{component}th vector
-                                     * component of the @p{i}th shape
+                                     * @p componentth vector
+                                     * component of the @p ith shape
                                      * function at the point
-                                     * @p{p}. See the
-                                     * @ref{FiniteElementBase} base
+                                     * @p p. See the
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -172,11 +172,11 @@ class FE_RaviartThomas : public FiniteElement<dim>
 
                                     /**
                                      * Return the gradient of the
-                                     * @p{component}th vector
-                                     * component of the @p{i}th shape
+                                     * @p componentth vector
+                                     * component of the @p ith shape
                                      * function at the point
-                                     * @p{p}. See the
-                                     * @ref{FiniteElementBase} base
+                                     * @p p. See the
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -187,11 +187,11 @@ class FE_RaviartThomas : public FiniteElement<dim>
 
                                     /**
                                      * Return the second derivative
-                                     * of the @p{component}th vector
-                                     * component of the @p{i}th shape
+                                     * of the @p componentth vector
+                                     * component of the @p ith shape
                                      * function at the point
-                                     * @p{p}. See the
-                                     * @ref{FiniteElementBase} base
+                                     * @p p. See the
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -213,7 +213,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                      * interpolating from the given
                                      * finite element to the present
                                      * one. The size of the matrix is
-                                     * then @p{dofs_per_cell} times
+                                     * then @p dofs_per_cell times
                                      * @p{source.dofs_per_cell}.
                                      *
                                      * These matrices are only
@@ -240,7 +240,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                      * Access to base element
                                      * objects. Since this element is
                                      * atomic, @p{base_element(0)} is
-                                     * @p{this}, and all other
+                                     * @p this, and all other
                                      * indices throw an error.
                                      */
     virtual const FiniteElement<dim> &
@@ -248,7 +248,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
 
                                      /**
                                       * Multiplicity of base element
-                                      * @p{index}. Since this is an
+                                      * @p index. Since this is an
                                       * atomic element,
                                       * @p{element_multiplicity(0)}
                                       * returns one, and all other
@@ -263,11 +263,11 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                      * Right now, this is only
                                      * implemented for RT0 in
                                      * 1D. Otherwise, returns always
-                                     * @p{true}.
+                                     * @p true.
                                      *
                                      * Implementation of the
                                      * interface in
-                                     * @ref{FiniteElement}
+                                     * FiniteElement
                                      */
     virtual bool has_support_on_face (const unsigned int shape_index,
                                      const unsigned int face_index) const;
@@ -292,11 +292,11 @@ class FE_RaviartThomas : public FiniteElement<dim>
     
   protected:    
                                     /**
-                                     * @p{clone} function instead of
+                                     * @p clone function instead of
                                      * a copy constructor.
                                      *
                                      * This function is needed by the
-                                     * constructors of @p{FESystem}.
+                                     * constructors of @p FESystem.
                                      */
     virtual FiniteElement<dim> * clone() const;
   
@@ -314,7 +314,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                     /**
                                      * Implementation of the same
                                      * function in
-                                     * @ref{FiniteElement}.
+                                     * FiniteElement.
                                      */
     virtual void
     fill_fe_values (const Mapping<dim> &mapping,
@@ -327,7 +327,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                     /**
                                      * Implementation of the same
                                      * function in
-                                     * @ref{FiniteElement}.
+                                     * FiniteElement.
                                      */
     virtual void
     fill_fe_face_values (const Mapping<dim> &mapping,
@@ -341,7 +341,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                     /**
                                      * Implementation of the same
                                      * function in
-                                     * @ref{FiniteElement}.
+                                     * FiniteElement.
                                      */
     virtual void
     fill_fe_subface_values (const Mapping<dim> &mapping,
@@ -363,11 +363,11 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                       * Spaces describing the
                                       * anisotropic polynomial spaces
                                       * for each vector component,
-                                      * i.e. there are @p{dim}
+                                      * i.e. there are @p dim
                                       * elements of this field. The
                                       * values for this member are
                                       * created in
-                                      * @ref{create_polynomials}.
+                                      * create_polynomials().
                                       */
     const std::vector<AnisotropicPolynomials<dim> > polynomials;
 
@@ -384,7 +384,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                       * component.
                                       *
                                       * These values are computed by
-                                      * the @ref{compute_renumber}
+                                      * the compute_renumber()
                                       * function.
                                       */
     const std::vector<std::pair<unsigned int, unsigned int> > renumber;
@@ -392,7 +392,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
     
                                      /**
                                       * Generate the polynomial spaces
-                                      * for the @ref{polynomials}
+                                      * for the polynomials()
                                       * member.
                                       */
     static std::vector<AnisotropicPolynomials<dim> >
@@ -401,12 +401,12 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                     /**
                                      * Only for internal use. Its
                                      * full name is
-                                     * @p{get_dofs_per_object_vector}
+                                     * @p get_dofs_per_object_vector
                                      * function and it creates the
-                                     * @p{dofs_per_object} vector that is
+                                     * @p dofs_per_object vector that is
                                      * needed within the constructor to
                                      * be passed to the constructor of
-                                     * @p{FiniteElementData}.
+                                     * @p FiniteElementData.
                                      */
     static std::vector<unsigned int>
     get_dpo_vector (const unsigned int degree);
@@ -414,7 +414,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                     /**
                                      * Compute the vector used for
                                      * the
-                                     * @p{restriction_is_additive}
+                                     * @p restriction_is_additive
                                      * field passed to the base
                                      * class's constructor.
                                      */
@@ -423,7 +423,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
 
                                      /**
                                       * Compute the values of the
-                                      * @p{renumber} field.
+                                      * @p renumber field.
                                       */
     static std::vector<std::pair<unsigned int, unsigned int> >
     compute_renumber (const unsigned int);
@@ -451,8 +451,8 @@ class FE_RaviartThomas : public FiniteElement<dim>
     
                                     /**
                                      * Initialize the
-                                     * @p{unit_support_points} field
-                                     * of the @ref{FiniteElementBase}
+                                     * @p unit_support_points field
+                                     * of the FiniteElementBase
                                      * class. Called from the
                                      * constructor.
                                      */
@@ -460,8 +460,8 @@ class FE_RaviartThomas : public FiniteElement<dim>
 
                                     /**
                                      * Initialize the
-                                     * @p{unit_face_support_points} field
-                                     * of the @ref{FiniteElementBase}
+                                     * @p unit_face_support_points field
+                                     * of the FiniteElementBase
                                      * class. Called from the
                                      * constructor.
                                      */
@@ -470,7 +470,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                     /**
                                      * Given a set of flags indicating
                                      * what quantities are requested
-                                     * from a @p{FEValues} object,
+                                     * from a @p FEValues object,
                                      * return which of these can be
                                      * precomputed once and for
                                      * all. Often, the values of
@@ -479,8 +479,8 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                      * example, in which case the
                                      * return value of this function
                                      * would be the logical and of
-                                     * the input @p{flags} and
-                                     * @p{update_values}.
+                                     * the input @p flags and
+                                     * @p update_values.
                                      *
                                      * For the present kind of finite
                                      * element, this is exactly the
index 3cdc39eb96ccd497ac344876654f814c4f281d8d..f81ff1eeb43c77b4e45a0a24863e8a630095fa73 100644 (file)
  * elements and the third being a quadratic lagrange element, the
  * ordering for the system @p{s=(u,v,p)} is:
  *
- * @begin{itemize}
- * @item First vertex: @p{u0, v0, p0 = s0, s1, s2}
- * @item Second vertex: @p{u1, v1, p1 = s3, s4, s5}
- * @item First component on the line:
+ * <ul>
+ * <li> First vertex: @p{u0, v0, p0 = s0, s1, s2}
+ * <li> Second vertex: @p{u1, v1, p1 = s3, s4, s5}
+ * <li> First component on the line:
  *   @p{u2, u3 = s4, s5}
- * @item Second component on the line:
+ * <li> Second component on the line:
  *   @p{v2, v3 = s6, s7}.
- * @item Third component on the line:
+ * <li> Third component on the line:
  *   @p{p2 = s8}.
- * @end{itemize}
+ * </ul>
  * Do not rely on this numbering in your application as these
  * internals might change in future. Rather use the functions
- * @p{system_to_component_index} and @p{component_to_system_index},
+ * @p system_to_component_index and @p component_to_system_index,
  * instead.
  *
  * In the most cases, the composed element behaves as if it were a usual element
@@ -62,9 +62,9 @@
  * couple the degrees of freedom of the subobject. E.g. the continuity requirement
  * is imposed for the shape functions of the subobjects separately; no requirement
  * exist between shape functions of different subobjects, i.e. in the above
- * example: on a hanging node, the respective value of the @p{u} velocity is only
- * coupled to @p{u} at the vertices and the line on the larger cell next to this
- * vertex, there is no interaction with @p{v} and @p{w} of this or the other cell.
+ * example: on a hanging node, the respective value of the @p u velocity is only
+ * coupled to @p u at the vertices and the line on the larger cell next to this
+ * vertex, there is no interaction with @p v and @p w of this or the other cell.
  *
  * @author Wolfgang Bangerth, Guido Kanschat, 1999, 2002, 2003, partial reimplementation Ralf Hartmann 2001.
  */
@@ -78,14 +78,14 @@ class FESystem : public FiniteElement<dim>
                                      * and the number of elements you want to
                                      * group together using this class.
                                      *
-                                     * In fact, the object @p{fe} is not used,
+                                     * In fact, the object @p fe is not used,
                                      * apart from getting the number of dofs
                                      * per vertex, line, etc for that finite
                                      * element class. The objects creates its
                                      * own copy of the finite element object
                                      * at construction time (but after
                                      * the initialization of the base class
-                                     * @p{FiniteElement}, which is why we need
+                                     * @p FiniteElement, which is why we need
                                      * a valid finite element object passed
                                      * to the constructor).
                                      *
@@ -127,11 +127,11 @@ class FESystem : public FiniteElement<dim>
                                      * element. This element returns
                                      * a string that is composed of
                                      * the strings
-                                     * @p{name1}...@p{nameN} returned
+                                     * @p name1...@p nameN returned
                                      * by the basis elements. From
                                      * these, we create a sequence
                                      * @p{FESystem<dim>[name1^m1-name2^m2-...-nameN^mN]},
-                                     * where @p{mi} are the
+                                     * where @p mi are the
                                      * multiplicities of the basis
                                      * elements. If a multiplicity is
                                      * equal to one, then the
@@ -141,8 +141,8 @@ class FESystem : public FiniteElement<dim>
 
                                     /**
                                      * Return the value of the
-                                     * @p{i}th shape function at the
-                                     * point @p{p}.  @p{p} is a point
+                                     * @p ith shape function at the
+                                     * point @p p.  @p p is a point
                                      * on the reference element. Since
                                      * this finite element is always
                                      * vector-valued, we return the
@@ -154,13 +154,13 @@ class FESystem : public FiniteElement<dim>
                                      * we refer to with the term
                                      * non-primitive), then throw an
                                      * exception of type
-                                     * @p{ExcShapeFunctionNotPrimitive}.
+                                     * @p ExcShapeFunctionNotPrimitive.
                                      *
                                      * An
-                                     * @p{ExcUnitShapeValuesDoNotExist}
+                                     * @p ExcUnitShapeValuesDoNotExist
                                      * is thrown if the shape values
-                                     * of the @p{FiniteElement}
-                                     * (corresponding to the @p{i}th
+                                     * of the @p FiniteElement
+                                     * (corresponding to the @p ith
                                      * shape function) depend on the
                                      * shape of the cell in real
                                      * space.
@@ -170,11 +170,11 @@ class FESystem : public FiniteElement<dim>
 
                                     /**
                                      * Return the value of the
-                                     * @p{component}th vector
-                                     * component of the @p{i}th shape
+                                     * @p componentth vector
+                                     * component of the @p ith shape
                                      * function at the point
-                                     * @p{p}. See the
-                                     * @ref{FiniteElementBase} base
+                                     * @p p. See the
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -190,8 +190,8 @@ class FESystem : public FiniteElement<dim>
     
                                     /**
                                      * Return the gradient of the
-                                     * @p{i}th shape function at the
-                                     * point @p{p}. @p{p} is a point
+                                     * @p ith shape function at the
+                                     * point @p p. @p p is a point
                                      * on the reference element, and
                                      * likewise the gradient is the
                                      * gradient on the unit cell with
@@ -207,13 +207,13 @@ class FESystem : public FiniteElement<dim>
                                      * we refer to with the term
                                      * non-primitive), then throw an
                                      * exception of type
-                                     * @p{ExcShapeFunctionNotPrimitive}.
+                                     * @p ExcShapeFunctionNotPrimitive.
                                      *
                                      * An
-                                     * @p{ExcUnitShapeValuesDoNotExist}
+                                     * @p ExcUnitShapeValuesDoNotExist
                                      * is thrown if the shape values
-                                     * of the @p{FiniteElement}
-                                     * (corresponding to the @p{i}th
+                                     * of the @p FiniteElement
+                                     * (corresponding to the @p ith
                                      * shape function) depend on the
                                      * shape of the cell in real
                                      * space.
@@ -223,11 +223,11 @@ class FESystem : public FiniteElement<dim>
 
                                     /**
                                      * Return the gradient of the
-                                     * @p{component}th vector
-                                     * component of the @p{i}th shape
+                                     * @p componentth vector
+                                     * component of the @p ith shape
                                      * function at the point
-                                     * @p{p}. See the
-                                     * @ref{FiniteElementBase} base
+                                     * @p p. See the
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -243,8 +243,8 @@ class FESystem : public FiniteElement<dim>
 
                                     /**
                                      * Return the tensor of second
-                                     * derivatives of the @p{i}th
-                                     * shape function at point @p{p}
+                                     * derivatives of the @p ith
+                                     * shape function at point @p p
                                      * on the unit cell. The
                                      * derivatives are derivatives on
                                      * the unit cell with respect to
@@ -259,13 +259,13 @@ class FESystem : public FiniteElement<dim>
                                      * we refer to with the term
                                      * non-primitive), then throw an
                                      * exception of type
-                                     * @p{ExcShapeFunctionNotPrimitive}.
+                                     * @p ExcShapeFunctionNotPrimitive.
                                      *
                                      * An
-                                     * @p{ExcUnitShapeValuesDoNotExist}
+                                     * @p ExcUnitShapeValuesDoNotExist
                                      * is thrown if the shape values
-                                     * of the @p{FiniteElement}
-                                     * (corresponding to the @p{i}th
+                                     * of the @p FiniteElement
+                                     * (corresponding to the @p ith
                                      * shape function) depend on the
                                      * shape of the cell in real
                                      * space.
@@ -275,11 +275,11 @@ class FESystem : public FiniteElement<dim>
 
                                     /**
                                      * Return the second derivatives
-                                     * of the @p{component}th vector
-                                     * component of the @p{i}th shape
+                                     * of the @p componentth vector
+                                     * component of the @p ith shape
                                      * function at the point
-                                     * @p{p}. See the
-                                     * @ref{FiniteElementBase} base
+                                     * @p p. See the
+                                     * FiniteElementBase base
                                      * class for more information
                                      * about the semantics of this
                                      * function.
@@ -300,18 +300,18 @@ class FESystem : public FiniteElement<dim>
                                      * interpolating from the given
                                      * finite element to the present
                                      * one. The size of the matrix is
-                                     * then @p{dofs_per_cell} times
+                                     * then @p dofs_per_cell times
                                      * @p{source.dofs_per_cell}.
                                      *
                                      * These matrices are available
                                      * if source and destination
-                                     * element are both @p{FESystem}
+                                     * element are both @p FESystem
                                      * elements, have the same number
                                      * of base elements with same
                                      * element multiplicity, and if
                                      * these base elements also
                                      * implement their
-                                     * @p{get_interpolation_matrix}
+                                     * @p get_interpolation_matrix
                                      * functions. Otherwise, an
                                      * exception of type
                                      * @ref{FiniteElementBase<dim>::ExcInterpolationNotImplemented}
@@ -360,14 +360,14 @@ class FESystem : public FiniteElement<dim>
                                      * face.
                                      *
                                      * This function returns
-                                     * @p{true}, if the shape
-                                     * function @p{shape_index} has
+                                     * @p true, if the shape
+                                     * function @p shape_index has
                                      * non-zero values on the face
-                                     * @p{face_index}.
+                                     * @p face_index.
                                      *
                                      * Implementation of the
                                      * interface in
-                                     * @ref{FiniteElement}
+                                     * FiniteElement
                                      */
     virtual bool has_support_on_face (const unsigned int shape_index,
                                      const unsigned int face_index) const;
@@ -417,11 +417,11 @@ class FESystem : public FiniteElement<dim>
     virtual UpdateFlags update_each (const UpdateFlags flags) const;
 
                                     /**
-                                     * @p{clone} function instead of
+                                     * @p clone function instead of
                                      * a copy constructor.
                                      *
                                      * This function is needed by the
-                                     * constructors of @p{FESystem}.
+                                     * constructors of @p FESystem.
                                      */
     virtual FiniteElement<dim> * clone() const;
   
@@ -438,10 +438,10 @@ class FESystem : public FiniteElement<dim>
                                     /**
                                      * Implementation of the same
                                      * function in
-                                     * @ref{FiniteElement}.
+                                     * FiniteElement.
                                      *
                                      * Passes on control to
-                                     * @p{compute_fill} that does the
+                                     * @p compute_fill that does the
                                      * work for all three
                                      * @p{fill_fe*_values}
                                      * functions.
@@ -457,10 +457,10 @@ class FESystem : public FiniteElement<dim>
                                     /**
                                      * Implementation of the same
                                      * function in
-                                     * @ref{FiniteElement}.
+                                     * FiniteElement.
                                      *
                                      * Passes on control to
-                                     * @p{compute_fill} that does the
+                                     * @p compute_fill that does the
                                      * work for all three
                                      * @p{fill_fe*_values} functions.
                                      */    
@@ -476,10 +476,10 @@ class FESystem : public FiniteElement<dim>
                                     /**
                                      * Implementation of the same
                                      * function in
-                                     * @ref{FiniteElement}.
+                                     * FiniteElement.
                                      *
                                      * Passes on control to
-                                     * @p{compute_fill} that does the
+                                     * @p compute_fill that does the
                                      * work for all three
                                      * @p{fill_fe*_values} functions.
                                      */
@@ -501,17 +501,17 @@ class FESystem : public FiniteElement<dim>
                                      * Calls (among other things)
                                      * @p{fill_fe_([sub]face)_values}
                                      * of the base elements. Calls
-                                     * @p{fill_fe_values} if
+                                     * @p fill_fe_values if
                                      * @p{face_no==invalid_face_no}
                                      * and
                                      * @p{sub_no==invalid_face_no};
-                                     * calls @p{fill_fe_face_values}
+                                     * calls @p fill_fe_face_values
                                      * if
                                      * @p{face_no==invalid_face_no}
                                      * and
                                      * @p{sub_no!=invalid_face_no};
                                      * and calls
-                                     * @p{fill_fe_subface_values} if
+                                     * @p fill_fe_subface_values if
                                      * @p{face_no!=invalid_face_no}
                                      * and
                                      * @p{sub_no!=invalid_face_no}.
@@ -557,8 +557,8 @@ class FESystem : public FiniteElement<dim>
 
                                     /**
                                      * Initialize the
-                                     * @p{unit_support_points} field
-                                     * of the @ref{FiniteElementBase}
+                                     * @p unit_support_points field
+                                     * of the FiniteElementBase
                                      * class. Called from the
                                      * constructor.
                                      */
@@ -566,8 +566,8 @@ class FESystem : public FiniteElement<dim>
 
                                     /**
                                      * Initialize the
-                                     * @p{unit_face_support_points} field
-                                     * of the @ref{FiniteElementBase}
+                                     * @p unit_face_support_points field
+                                     * of the FiniteElementBase
                                      * class. Called from the
                                      * constructor.
                                      */
@@ -575,11 +575,11 @@ class FESystem : public FiniteElement<dim>
 
                                     /**
                                      * Helper function used in the constructor:
-                                     * take a @p{FiniteElementData} object
+                                     * take a @p FiniteElementData object
                                      * and return an object of the same type
                                      * with the number of degrees of
                                      * freedom per vertex, line, etc.
-                                     * multiplied by @p{n}. Don't touch the
+                                     * multiplied by @p n. Don't touch the
                                      * number of functions for the
                                      * transformation from unit to real
                                      * cell.
@@ -614,13 +614,13 @@ class FESystem : public FiniteElement<dim>
                                     /**
                                      * Helper function used in the
                                      * constructor: takes a
-                                     * @p{FiniteElement} object and
+                                     * @p FiniteElement object and
                                      * returns an boolean vector
                                      * including the
-                                     * @p{restriction_is_additive_flags}
+                                     * @p restriction_is_additive_flags
                                      * of the mixed element
-                                     * consisting of @p{N} elements
-                                     * of the sub-element @p{fe}.
+                                     * consisting of @p N elements
+                                     * of the sub-element @p fe.
                                      */
     static std::vector<bool>
     compute_restriction_is_additive_flags (const FiniteElement<dim> &fe,
@@ -712,24 +712,24 @@ class FESystem : public FiniteElement<dim>
                                      * constructors since there are
                                      * several of them. It sets up
                                      * the index table for the system
-                                     * as well as @p{restriction} and
-                                     * @p{prolongation}
+                                     * as well as @p restriction and
+                                     * @p prolongation
                                      * matrices.
                                      */
     void initialize();
 
                                     /**
-                                     * Used by @p{initialize}.
+                                     * Used by @p initialize.
                                      */
     void build_cell_tables();
     
                                     /**
-                                     * Used by @p{initialize}.
+                                     * Used by @p initialize.
                                      */
     void build_face_tables();
 
                                     /**
-                                     * Used by @p{initialize}.
+                                     * Used by @p initialize.
                                      */
     void build_interface_constraints ();
 
@@ -740,7 +740,7 @@ class FESystem : public FiniteElement<dim>
                                      * However, here, this class does
                                      * not itself store the data but
                                      * only pointers to
-                                     * @p{InternalData} objects for
+                                     * @p InternalData objects for
                                      * each of the base elements.
                                      */
     class InternalData : public FiniteElementBase<dim>::InternalDataBase
@@ -748,19 +748,19 @@ class FESystem : public FiniteElement<dim>
       public:
                                         /**
                                          * Constructor. Is called by
-                                         * the @p{get_data}
+                                         * the @p get_data
                                          * function. Sets the size of
-                                         * the @p{base_fe_datas}
+                                         * the @p base_fe_datas
                                          * vector to
-                                         * @p{n_base_elements}.
+                                         * @p n_base_elements.
                                          */
        InternalData (const unsigned int n_base_elements);
        
                                         /**
                                          * Destructor. Deletes all
-                                         * @p{InternalDatas} whose
+                                         * @p InternalDatas whose
                                          * pointers are stored by the
-                                         * @p{base_fe_datas}
+                                         * @p base_fe_datas
                                          * vector.
                                          */
        ~InternalData();
@@ -775,8 +775,8 @@ class FESystem : public FiniteElement<dim>
                                         /**
                                          * Gives write-access to the
                                          * pointer to a
-                                         * @p{InternalData} of the
-                                         * @p{base_no}th base
+                                         * @p InternalData of the
+                                         * @p base_noth base
                                          * element.
                                          */
        void set_fe_data(const unsigned int                        base_no,
@@ -785,8 +785,8 @@ class FESystem : public FiniteElement<dim>
                                         /**
                                          * Gives read-access to the
                                          * pointer to a
-                                         * @p{InternalData} of the
-                                         * @p{base_no}th base element.
+                                         * @p InternalData of the
+                                         * @p base_noth base element.
                                          */    
        typename FiniteElementBase<dim>::InternalDataBase &
        get_fe_data (const unsigned int base_no) const;
@@ -795,8 +795,8 @@ class FESystem : public FiniteElement<dim>
                                         /**
                                          * Gives write-access to the
                                          * pointer to a
-                                         * @p{FEValuesData} for the
-                                         * @p{base_no}th base
+                                         * @p FEValuesData for the
+                                         * @p base_noth base
                                          * element.
                                          */
        void set_fe_values_data (const unsigned int base_no,
@@ -805,14 +805,14 @@ class FESystem : public FiniteElement<dim>
                                         /**
                                          * Gives read-access to the
                                          * pointer to a
-                                         * @p{FEValuesData} for the
-                                         * @p{base_no}th base element.
+                                         * @p FEValuesData for the
+                                         * @p base_noth base element.
                                          */    
        FEValuesData<dim> & get_fe_values_data (const unsigned int base_no) const;
 
                                         /**
                                          * Deletes the
-                                         * @p{FEValuesData} the
+                                         * @p FEValuesData the
                                          * @p{fe_datas[base_no]}
                                          * pointer is pointing
                                          * to. Sets
@@ -820,21 +820,21 @@ class FESystem : public FiniteElement<dim>
                                          * zero.
                                          *
                                          * This function is used to
-                                         * delete @p{FEValuesData}
+                                         * delete @p FEValuesData
                                          * that are needed only on
                                          * the first cell but not any
                                          * more afterwards.  This is
                                          * the case for
                                          * e.g. Lagrangian elements
-                                         * (see e.g. @p{FE_Q}
+                                         * (see e.g. @p FE_Q
                                          * classes).
                                          */
        void delete_fe_values_data (const unsigned int base_no);
 
                                          /**
-                                          * Set the @p{first_cell}
-                                          * flag to @p{false}. Used by
-                                          * the @p{FEValues} class to
+                                          * Set the @p first_cell
+                                          * flag to @p false. Used by
+                                          * the @p FEValues class to
                                           * indicate that we have
                                           * already done the work on
                                           * the first cell.
@@ -851,18 +851,18 @@ class FESystem : public FiniteElement<dim>
        
                                         /**
                                          * Pointers to
-                                         * @p{InternalData} objects
+                                         * @p InternalData objects
                                          * for each of the base
                                          * elements. They are
                                          * accessed to by the
-                                         * @p{set_} and
-                                         * @p{get_fe_data} functions.
+                                         * @p set_ and
+                                         * @p get_fe_data functions.
                                          *
                                          * The size of this vector is
-                                         * set to @p{n_base_elements}
+                                         * set to @p n_base_elements
                                          * by the InternalData
                                          * constructor.  It is filled
-                                         * by the @p{get_data}
+                                         * by the @p get_data
                                          * function. Note that since
                                          * the data for each instance
                                          * of a base class is
@@ -876,18 +876,18 @@ class FESystem : public FiniteElement<dim>
 
                                         /**
                                          * Pointers to the
-                                         * @p{FEValuesData} objects
+                                         * @p FEValuesData objects
                                          * that are given to the
-                                         * @p{fill_fe_values}
+                                         * @p fill_fe_values
                                          * function of the base
                                          * elements. They are
                                          * accessed to by the
-                                         * @p{set_} and
-                                         * @p{get_fe_values_data}
+                                         * @p set_ and
+                                         * @p get_fe_values_data
                                          * functions.
                                          *
                                          * The size of this vector is
-                                         * set to @p{n_base_elements}
+                                         * set to @p n_base_elements
                                          * by the InternalData
                                          * constructor.
                                          */
index a8fcd2aff6a5a0bca0513f00a3dd918dbf7863c8..35564d19935f53ed40ad568dd9b70c3b816c2e26 100644 (file)
@@ -33,8 +33,8 @@ class ConstraintMatrix;
 
 /**
  * This class performs interpolations and extrapolations of discrete
- * functions of one @p{FiniteElement} @p{fe1} to another @p{FiniteElement}
- * @p{fe2}.
+ * functions of one @p FiniteElement @p fe1 to another @p FiniteElement
+ * @p fe2.
  *
  * It also provides the local interpolation matrices that interpolate
  * on each cell. Furthermore it provides the difference matrix
@@ -48,16 +48,16 @@ class FETools
   public:
                                     /**
                                      * Gives the interpolation matrix
-                                     * that interpolates a @p{fe1}-
-                                     * function to a @p{fe2}-function on
+                                     * that interpolates a @p fe1-
+                                     * function to a @p fe2-function on
                                      * each cell. The interpolation_matrix
                                      * needs to be of size
                                      * @p{(fe2.dofs_per_cell, fe1.dofs_per_cell)}.
                                      *
                                      * Note, that if the finite element
-                                     * space @p{fe1} is a subset of
+                                     * space @p fe1 is a subset of
                                      * the finite element space
-                                     * @p{fe2} then the @p{interpolation_matrix}
+                                     * @p fe2 then the @p interpolation_matrix
                                      * is an embedding matrix.
                                      */
     template <int dim, typename number>
@@ -67,20 +67,20 @@ class FETools
     
                                     /**
                                      * Gives the interpolation matrix
-                                     * that interpolates a @p{fe1}-
-                                     * function to a @p{fe2}-function, and
+                                     * that interpolates a @p fe1-
+                                     * function to a @p fe2-function, and
                                      * interpolates this to a second
-                                     * @p{fe1}-function on
+                                     * @p fe1-function on
                                      * each cell. The interpolation_matrix
                                      * needs to be of size
                                      * @p{(fe1.dofs_per_cell, fe1.dofs_per_cell)}.
                                      *
                                      * Note, that this function only
                                      * makes sense if the finite element
-                                     * space due to @p{fe1} is not a subset of
+                                     * space due to @p fe1 is not a subset of
                                      * the finite element space due to
-                                     * @p{fe2}, as if it were a subset then
-                                     * the @p{interpolation_matrix} would be 
+                                     * @p fe2, as if it were a subset then
+                                     * the @p interpolation_matrix would be 
                                      * only the unit matrix.
                                      */
     template <int dim, typename number>
@@ -91,16 +91,16 @@ class FETools
                                     /**
                                      * Gives the unit matrix minus the
                                      * back interpolation matrix.
-                                     * The @p{difference_matrix}
+                                     * The @p difference_matrix
                                      * needs to be of size
                                      * @p{(fe1.dofs_per_cell, fe1.dofs_per_cell)}.
                                      *
                                      * This function gives
                                      * the matrix that transforms a
-                                     * @p{fe1} function $z$ to $z-I_hz$
+                                     * @p fe1 function $z$ to $z-I_hz$
                                      * where $I_h$ denotes the interpolation
-                                     * operator from the @p{fe1} space to
-                                     * the @p{fe2} space. This matrix hence
+                                     * operator from the @p fe1 space to
+                                     * the @p fe2 space. This matrix hence
                                      * is useful to evaluate
                                      * error-representations where $z$
                                      * denotes the dual solution.
@@ -125,20 +125,20 @@ class FETools
     
                                     /**
                                      * Gives the interpolation of a the
-                                     * @p{dof1}-function @p{u1} to a
-                                     * @p{dof2}-function @p{u2}. @p{dof1} and
-                                     * @p{dof2} need to be @ref{DoFHandler}s
+                                     * @p dof1-function @p u1 to a
+                                     * @p dof2-function @p u2. @p dof1 and
+                                     * @p dof2 need to be DoFHandlers
                                      * based on the same triangulation.
                                      *
-                                     * If the elements @p{fe1} and @p{fe2}
+                                     * If the elements @p fe1 and @p fe2
                                      * are either both continuous or
                                      * both discontinuous then this
                                      * interpolation is the usual point
                                      * interpolation. The same is true
-                                     * if @p{fe1} is a continuous and
-                                     * @p{fe2} is a discontinuous finite
-                                     * element. For the case that @p{fe1}
-                                     * is a discontinuous and @p{fe2} is
+                                     * if @p fe1 is a continuous and
+                                     * @p fe2 is a discontinuous finite
+                                     * element. For the case that @p fe1
+                                     * is a discontinuous and @p fe2 is
                                      * a continuous finite element
                                      * there is no point interpolation
                                      * defined at the discontinuities.
@@ -171,12 +171,12 @@ class FETools
                                      * For this case (continuous
                                      * elements on grids with hanging
                                      * nodes), please use the
-                                     * @p{interpolate} function with
+                                     * @p interpolate function with
                                      * an additional
-                                     * @p{ConstraintMatrix} argument,
+                                     * @p ConstraintMatrix argument,
                                      * see below, or make the field
                                      * conforming yourself by calling
-                                     * the @p{distribute} function of
+                                     * the @p distribute function of
                                      * your hanging node constraints
                                      * object.
                                      */
@@ -188,30 +188,30 @@ class FETools
     
                                     /**
                                      * Gives the interpolation of a
-                                     * the @p{dof1}-function @p{u1}
-                                     * to a @p{dof2}-function
-                                     * @p{u2}. @p{dof1} and @p{dof2}
-                                     * need to be @ref{DoFHandler}s
+                                     * the @p dof1-function @p u1
+                                     * to a @p dof2-function
+                                     * @p u2. @p dof1 and @p dof2
+                                     * need to be DoFHandlers
                                      * based on the same
                                      * triangulation.
-                                     * @p{constraints} is a hanging
+                                     * @p constraints is a hanging
                                      * node constraints object
                                      * corresponding to
-                                     * @p{dof2}. This object is
+                                     * @p dof2. This object is
                                      * particular important when
                                      * interpolating onto continuous
                                      * elements on grids with hanging
                                      * nodes (locally refined grids).
                                      *
-                                     * If the elements @p{fe1} and @p{fe2}
+                                     * If the elements @p fe1 and @p fe2
                                      * are either both continuous or
                                      * both discontinuous then this
                                      * interpolation is the usual point
                                      * interpolation. The same is true
-                                     * if @p{fe1} is a continuous and
-                                     * @p{fe2} is a discontinuous finite
-                                     * element. For the case that @p{fe1}
-                                     * is a discontinuous and @p{fe2} is
+                                     * if @p fe1 is a continuous and
+                                     * @p fe2 is a discontinuous finite
+                                     * element. For the case that @p fe1
+                                     * is a discontinuous and @p fe2 is
                                      * a continuous finite element
                                      * there is no point interpolation
                                      * defined at the discontinuities.
@@ -229,27 +229,27 @@ class FETools
 
                                     /**
                                      * Gives the interpolation of the
-                                     * @p{fe1}-function @p{u1} to a
-                                     * @p{fe2}-function, and
+                                     * @p fe1-function @p u1 to a
+                                     * @p fe2-function, and
                                      * interpolates this to a second
-                                     * @p{fe1}-function named
-                                     * @p{u1_interpolated}.
+                                     * @p fe1-function named
+                                     * @p u1_interpolated.
                                      *
                                      * Note, that this function does
                                      * not work on continuous
                                      * elements at hanging nodes. For
                                      * that case use the
-                                     * @p{back_interpolate} function,
+                                     * @p back_interpolate function,
                                      * below, that takes an
                                      * additional
-                                     * @p{ConstraintMatrix} object.
+                                     * @p ConstraintMatrix object.
                                      *
                                      * Furthermore note, that for the
                                      * specific case when the finite
                                      * element space corresponding to
-                                     * @p{fe1} is a subset of the
+                                     * @p fe1 is a subset of the
                                      * finite element space
-                                     * corresponding to @p{fe2}, this
+                                     * corresponding to @p fe2, this
                                      * function is simply an identity
                                      * mapping.
                                      */
@@ -261,16 +261,16 @@ class FETools
 
                                     /**
                                      * Gives the interpolation of the
-                                     * @p{dof1}-function @p{u1} to a
-                                     * @p{dof2}-function, and
+                                     * @p dof1-function @p u1 to a
+                                     * @p dof2-function, and
                                      * interpolates this to a second
-                                     * @p{dof1}-function named
-                                     * @p{u1_interpolated}.
-                                     * @p{constraints1} and
-                                     * @p{constraints2} are the
+                                     * @p dof1-function named
+                                     * @p u1_interpolated.
+                                     * @p constraints1 and
+                                     * @p constraints2 are the
                                      * hanging node constraints
-                                     * corresponding to @p{dof1} and
-                                     * @p{dof2}, respectively. These
+                                     * corresponding to @p dof1 and
+                                     * @p dof2, respectively. These
                                      * objects are particular
                                      * important when continuous
                                      * elements on grids with hanging
@@ -280,9 +280,9 @@ class FETools
                                      * Furthermore note, that for the
                                      * specific case when the finite
                                      * element space corresponding to
-                                     * @p{dof1} is a subset of the
+                                     * @p dof1 is a subset of the
                                      * finite element space
-                                     * corresponding to @p{dof2}, this
+                                     * corresponding to @p dof2, this
                                      * function is simply an identity
                                      * mapping.
                                      */
@@ -296,19 +296,19 @@ class FETools
 
                                     /**
                                      * Gives $(Id-I_h)z1$ for a given
-                                     * @p{dof1}-function @p{z1}, where $I_h$
-                                     * is the interpolation from @p{fe1}
-                                     * to @p{fe2}. $(Id-I_h)z1$ is
-                                     * denoted by @p{z1_difference}.
+                                     * @p dof1-function @p z1, where $I_h$
+                                     * is the interpolation from @p fe1
+                                     * to @p fe2. $(Id-I_h)z1$ is
+                                     * denoted by @p z1_difference.
                                      *
                                      * Note, that this function does
                                      * not work on continuous
                                      * elements at hanging nodes. For
                                      * that case use the
-                                     * @p{interpolation_difference}
+                                     * @p interpolation_difference
                                      * function, below, that takes an
                                      * additional
-                                     * @p{ConstraintMatrix} object.
+                                     * @p ConstraintMatrix object.
                                      */
     template <int dim, class InVector, class OutVector>
     static void interpolation_difference(const DoFHandler<dim> &dof1,
@@ -318,15 +318,15 @@ class FETools
     
                                     /**
                                      * Gives $(Id-I_h)z1$ for a given
-                                     * @p{dof1}-function @p{z1}, where $I_h$
-                                     * is the interpolation from @p{fe1}
-                                     * to @p{fe2}. $(Id-I_h)z1$ is
-                                     * denoted by @p{z1_difference}.
-                                     * @p{constraints1} and
-                                     * @p{constraints2} are the
+                                     * @p dof1-function @p z1, where $I_h$
+                                     * is the interpolation from @p fe1
+                                     * to @p fe2. $(Id-I_h)z1$ is
+                                     * denoted by @p z1_difference.
+                                     * @p constraints1 and
+                                     * @p constraints2 are the
                                      * hanging node constraints
-                                     * corresponding to @p{dof1} and
-                                     * @p{dof2}, respectively. These
+                                     * corresponding to @p dof1 and
+                                     * @p dof2, respectively. These
                                      * objects are particular
                                      * important when continuous
                                      * elements on grids with hanging
@@ -363,10 +363,10 @@ class FETools
     
                                     /**
                                      * Gives the patchwise
-                                     * extrapolation of a @p{dof1}
-                                     * function @p{z1} to a @p{dof2}
-                                     * function @p{z2}.  @p{dof1} and
-                                     * @p{dof2} need to be @ref{DoFHandler}
+                                     * extrapolation of a @p dof1
+                                     * function @p z1 to a @p dof2
+                                     * function @p z2.  @p dof1 and
+                                     * @p dof2 need to be DoFHandler
                                      * based on the same triangulation.
                                      *
                                      * This function is interesting
@@ -383,9 +383,9 @@ class FETools
                                      * When you use continuous
                                      * elements on grids with hanging
                                      * nodes, please use the
-                                     * @p{extrapolate} function with
+                                     * @p extrapolate function with
                                      * an additional
-                                     * @p{ConstraintMatrix} argument,
+                                     * @p ConstraintMatrix argument,
                                      * see below.
                                      *
                                      * Since this function operates
@@ -404,22 +404,22 @@ class FETools
 
                                     /**
                                      * Gives the patchwise
-                                     * extrapolation of a @p{dof1}
-                                     * function @p{z1} to a @p{dof2}
-                                     * function @p{z2}.  @p{dof1} and
-                                     * @p{dof2} need to be @ref{DoFHandler}
+                                     * extrapolation of a @p dof1
+                                     * function @p z1 to a @p dof2
+                                     * function @p z2.  @p dof1 and
+                                     * @p dof2 need to be DoFHandler
                                      * based on the same triangulation.
-                                     * @p{constraints} is a hanging
+                                     * @p constraints is a hanging
                                      * node constraints object
                                      * corresponding to
-                                     * @p{dof2}. This object is
+                                     * @p dof2. This object is
                                      * particular important when
                                      * interpolating onto continuous
                                      * elements on grids with hanging
                                      * nodes (locally refined grids).
                                      *
                                      * Otherwise, the same holds as
-                                     * for the other @p{extrapolate}
+                                     * for the other @p extrapolate
                                      * function.
                                      */
     template <int dim, class InVector, class OutVector>
@@ -448,7 +448,7 @@ class FETools
                                      * running in x-direction, then
                                      * in y-direction and finally in
                                      * z-direction. Discontinuous
-                                     * elements of class @ref{FE_DGQ}
+                                     * elements of class FE_DGQ()
                                      * are numbered in this way, for
                                      * example.
                                      *
@@ -466,7 +466,7 @@ class FETools
                                      * uses specifics of the
                                      * continuous finite elements, it
                                      * can only operate on objects of
-                                     * type @ref{FE_Q}.
+                                     * type FE_Q().
                                      *
                                      * It is assumed that the size of
                                      * the output argument already
@@ -497,7 +497,7 @@ class FETools
                                     /**
                                      * Given a name in the form which
                                      * is returned by the
-                                     * @p{FiniteElement::get_name}
+                                     * @p FiniteElement::get_name
                                      * function, regenerate such a
                                      * finite element.
                                      *
@@ -515,7 +515,7 @@ class FETools
                                      * finite element can be
                                      * reconstructed from this
                                      * string, an exception of type
-                                     * @p{FETools::ExcInvalidFEName}
+                                     * @p FETools::ExcInvalidFEName
                                      * is thrown.
                                      *
                                      * There is one exception,
@@ -610,7 +610,7 @@ class FETools
                                      * calling site can continue
                                      * parsing finite element lists
                                      * (for example for
-                                     * @ref{FESystem} objects) at the
+                                     * FESystem objects) at the
                                      * position after which the
                                      * present element's name ends.
                                      *
@@ -619,7 +619,7 @@ class FETools
                                      * beginning of the given string,
                                      * then an exception is thrown,
                                      * just as for the
-                                     * @ref{get_fe_from_name}
+                                     * get_fe_from_name()
                                      * function.
                                      */
     template <int dim>
index 22c04806dbed8f06a4e536c74bcda74c91446575..d4e00217b72861a91641c4a639fa06417ab7adcd 100644 (file)
  * @sect2{Description of Flags}
  *
  * The following flags are declared:
- * @begin{itemize}
- * @item <tt>update_default</tt>: Default: update nothing.
- * @item <tt>update_values</tt>: Compute the values of the shape
+ * <ul>
+ * <li> <tt>update_default</tt>: Default: update nothing.
+ * <li> <tt>update_values</tt>: Compute the values of the shape
  *     functions at the quadrature points on the real space cell. For
  *     the usual Lagrange elements, these values are equal to the
  *     values of the shape functions at the quadrature points on the
  *     unit cell, but they are different for more complicated
  *     elements, such as BDM or Raviart-Thomas elements.
- * @item <tt>update_gradients</tt>: Transform gradients on unit cell
+ * <li> <tt>update_gradients</tt>: Transform gradients on unit cell
  *     to gradients on real cell.
- * @item <tt>update_second_derivatives</tt>: Update the second
+ * <li> <tt>update_second_derivatives</tt>: Update the second
  *     derivatives of the shape functions on the real cell.
- * @item <tt>update_boundary_forms</tt>: Update boundary forms on the
+ * <li> <tt>update_boundary_forms</tt>: Update boundary forms on the
  *     face.  This flag is only evaluated by the FEFaceValues class.
  *     Giving this flag to the FEValues class will result in an error,
  *     since boundary forms only exist on the boundary.
- * @item <tt>update_q_points</tt>: Compute quadrature points in real
+ * <li> <tt>update_q_points</tt>: Compute quadrature points in real
  *     space (not on unit cell).
- * @item <tt>update_JxW_values</tt>: Compute the JxW values (Jacobian
+ * <li> <tt>update_JxW_values</tt>: Compute the JxW values (Jacobian
  *     determinant at the quadrature point times the weight of this
  *     point).
- * @item <tt>update_normal_vectors</tt>: Update the outward normal
+ * <li> <tt>update_normal_vectors</tt>: Update the outward normal
  *     vectors to the face relative to this cell.  This flag is only
  *     evaluated by the FEFaceValues class.  Giving this flag to the
  *     FEValues class will result in an error, since normal vectors
  *     are not useful in that case.
- * @item <tt>update_jacobians</tt>: Compute jacobian matrices of the
+ * <li> <tt>update_jacobians</tt>: Compute jacobian matrices of the
  *     transform between unit and real cell in the evaluation points.
- * @item <tt>update_jacobian_grads</tt>: Update gradients of the
+ * <li> <tt>update_jacobian_grads</tt>: Update gradients of the
  *     jacobian. These are used to compute second derivatives.
- * @item <tt>update_covariant_transformation</tt>: Update co-variant
+ * <li> <tt>update_covariant_transformation</tt>: Update co-variant
  *     transformation.  This flag is used internally to tell Mapping
  *     objects to compute the transformation matrices for co-variant
  *     vectors.
- * @item <tt>update_contravariant_transformation</tt>: Update
+ * <li> <tt>update_contravariant_transformation</tt>: Update
  *     contra-variant transformation.  This flag is used internally to
  *     tell Mapping objects to compute the transformation matrices for
  *     contra-variant vectors.
- * @item <tt>update_transformation_values</tt>: Update the shape
+ * <li> <tt>update_transformation_values</tt>: Update the shape
  *     function values of the transformation.
- * @item <tt>update_transformation_gradients</tt>: Update the
+ * <li> <tt>update_transformation_gradients</tt>: Update the
  *     gradients of the shape functions of the transformation.
- * @end{itemize}
+ * </ul>
  *
  * @author Wolfgang Bangerth, Guido Kanschat, 1998, 1999, 2000, 2001, Ralf Hartmann 2004
  */
index 759c42df6c932c595f55bbcc09e9fb3d4a0a1183..6ba485e8dc8f51bc2aefa692510086d5ae987f11 100644 (file)
@@ -37,13 +37,13 @@ template <int dim> class Quadrature;
 /*@{*/
 
 /**
- * Contains all data vectors for @p{FEValues}.
- * This class has been extracted from @p{FEValuesBase} to be handed
- * over to the fill functions of @p{Mapping} and
- * @p{FiniteElement}.
+ * Contains all data vectors for @p FEValues.
+ * This class has been extracted from @p FEValuesBase to be handed
+ * over to the fill functions of @p Mapping and
+ * @p FiniteElement.
  *
  * @note All data fields are public, but this is not
- * critical, because access to this object is private in @p{FEValues}.
+ * critical, because access to this object is private in @p FEValues.
  *
  * @author Guido Kanschat, 2000
  */
@@ -84,14 +84,14 @@ class FEValuesData
                                      * shape function number equals
                                      * the row number. Otherwise, use
                                      * the
-                                     * @p{shape_function_to_row_table}
+                                     * @p shape_function_to_row_table
                                      * array to get at the first row
                                      * that belongs to this
                                      * particular shape function, and
                                      * navigate among all the rows
                                      * for this shape function using
                                      * the
-                                     * @p{FiniteElement::get_nonzero_components}
+                                     * @p FiniteElement::get_nonzero_components
                                      * function which tells us which
                                      * components are non-zero and
                                      * thus have a row in the array
@@ -103,7 +103,7 @@ class FEValuesData
                                      * Storage type for
                                      * gradients. The layout of data
                                      * is the same as for the
-                                     * @ref{ShapeVector} data type.
+                                     * ShapeVector data type.
                                      */
     typedef Table<2,Tensor<1,dim> > GradientVector;
 
@@ -147,7 +147,7 @@ class FEValuesData
                                      * times the Jacobi determinant
                                      * at the quadrature points. This
                                      * function is reset each time
-                                     * @p{reinit} is called. The
+                                     * @p reinit is called. The
                                      * Jacobi determinant is actually
                                      * the reciprocal value of the
                                      * Jacobi matrices stored in this
@@ -159,7 +159,7 @@ class FEValuesData
 
                                     /**
                                      * Array of quadrature points. This array
-                                     * is set up upon calling @p{reinit} and
+                                     * is set up upon calling @p reinit and
                                      * contains the quadrature points on the
                                      * real element, rather than on the
                                      * reference element.
@@ -183,8 +183,8 @@ class FEValuesData
                                     /**
                                      * Indicate the first row which a
                                      * given shape function occupies
-                                     * in the @p{ShapeVector},
-                                     * @p{ShapeGradient}, etc
+                                     * in the @p ShapeVector,
+                                     * @p ShapeGradient, etc
                                      * arrays. If all shape functions
                                      * are primitive, then this is
                                      * the identity mapping. If, on
@@ -213,7 +213,7 @@ class FEValuesData
                                      /**
                                      * Original update flags handed
                                      * to the constructor of
-                                     * @p{FEValues}.
+                                     * @p FEValues.
                                      */
     UpdateFlags          update_flags;
 };
@@ -262,8 +262,8 @@ class FEValuesData
  *  @sect3{Member functions}
  *
  *  The functions of this class fall into different cathegories:
- *  @begin{itemize}
- *  @item @p{shape_value}, @p{shape_grad}, etc: return one of the values 
+ *  <ul>
+ *  <li> @p shape_value, @p shape_grad, etc: return one of the values 
  *    of this object at a time. These functions are inlined, so this
  *    is the suggested access to all finite element values. There
  *    should be no loss in performance with an optimizing compiler. If
@@ -275,7 +275,7 @@ class FEValuesData
  *    throw an exception since they cannot generate a useful
  *    result. Rather, use the next set of functions.
  *
- *  @item @p{shape_value_component}, @p{shape_grad_component}, etc:
+ *  <li> @p shape_value_component, @p shape_grad_component, etc:
  *    This is the same set of functions as above, except that for vector
  *    valued finite elements they return only one vector component. This
  *    is useful for elements of which shape functions have more than one
@@ -283,29 +283,29 @@ class FEValuesData
  *    and you have to walk over all (or only the non-zero) components of
  *    the shape function using this set of functions.
  *   
- *  @item @p{get_function_values}, @p{get_function_grads}, @p{...}:
+ *  <li> @p get_function_values, @p get_function_grads, @p{...}:
  *    Compute a finite element function or its derivative
  *    in quadrature points.
  *
- *  @item @p{reinit}: initialize the @p{FEValues} object for a certain cell.
+ *  <li> @p reinit: initialize the @p FEValues object for a certain cell.
  *    This function is not in the present class but only in the derived
  *    classes and has a variable call syntax. 
  *    See the docs for the derived classes for more information.
- * @end{itemize}
+ * </ul>
  *
  *
  * @sect3{UpdateFlags}
  *
- * The @ref{UpdateFlags} object handed to the constructor is used to
+ * The UpdateFlags object handed to the constructor is used to
  * determine, which of the data fields to compute. This way, it is
  * possible to avoid expensive computations of useless derivatives.
  * In the beginning, these flags are processed through the functions
- * @p{update_once} and @p{update_each} of @ref{Mapping} and
- * @p{FiniteElement}. All the results are bit-wise or'd and determine
- * the fields actually computed. This enables @ref{Mapping} and
- * @p{FiniteElement} to schedule auxiliary data fields for
+ * @p update_once and @p update_each of Mapping and
+ * @p FiniteElement. All the results are bit-wise or'd and determine
+ * the fields actually computed. This enables Mapping and
+ * @p FiniteElement to schedule auxiliary data fields for
  * updating. Still, it is recommended to give ALL needed update flags
- * to @p{FEValues}.
+ * to @p FEValues.
  *
  * @author Wolfgang Bangerth, 1998, Guido Kanschat, 2001
  */
@@ -393,14 +393,14 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * finite element is scalar, then
                                      * only component zero is allowed
                                      * and the return value equals
-                                     * that of the @p{shape_value}
+                                     * that of the @p shape_value
                                      * function. If the finite
                                      * element is vector valued but
                                      * all shape functions are
                                      * primitive (i.e. they are
                                      * non-zero in only one
                                      * component), then the value
-                                     * returned by @p{shape_value}
+                                     * returned by @p shape_value
                                      * equals that of this function
                                      * for exactly one
                                      * component. This function is
@@ -448,7 +448,7 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * finite element in use is a scalar one,
                                      * i.e. has only one vector component. If
                                      * it is a vector-valued one, then use
-                                     * the other @p{get_function_values}
+                                     * the other @p get_function_values
                                      * function.
                                      * 
                                      * The function assumes that the
@@ -475,7 +475,7 @@ class FEValuesBase : protected FEValuesData<dim>
                                      *
                                      * This function does the same as
                                      * the other
-                                     * @p{get_function_values}, but
+                                     * @p get_function_values, but
                                      * applied to multi-component
                                      * elements.
                                      *
@@ -495,8 +495,8 @@ class FEValuesBase : protected FEValuesData<dim>
 
                                     /**
                                      * Compute the gradient of the
-                                     * @p{i}th shape function at the
-                                     * @p{j} quadrature point with
+                                     * @p ith shape function at the
+                                     * @p j quadrature point with
                                      * respect to real cell
                                      * coordinates.  If you want to
                                      * get the derivative in one of
@@ -558,8 +558,8 @@ class FEValuesBase : protected FEValuesData<dim>
                                     /**
                                      * Compute the gradients of the finite
                                      * element function characterized
-                                     * by @p{fe_function} restricted to
-                                     * @p{cell} at the quadrature points.
+                                     * by @p fe_function restricted to
+                                     * @p cell at the quadrature points.
                                      *
                                      * If the present cell is not an active
                                      * one the interpolated function values
@@ -569,11 +569,11 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * finite element in use is a scalar one,
                                      * i.e. has only one vector component. If
                                      * it is a vector-valued one, then use
-                                     * the other @p{get_function_grads}
+                                     * the other @p get_function_grads
                                      * function.
                                      * 
                                      * The function assumes that the
-                                     * @p{gradients} object already has the
+                                     * @p gradients object already has the
                                      * right size.
                                      *
                                      * The actual data type of the input
@@ -599,19 +599,19 @@ class FEValuesBase : protected FEValuesData<dim>
                                     /**
                                      * Compute the gradients of the finite
                                      * element function characterized
-                                     * by @p{fe_function} restricted to
-                                     * @p{cell} at the quadrature points.
+                                     * by @p fe_function restricted to
+                                     * @p cell at the quadrature points.
                                      *
                                      * If the present cell is not an active
                                      * one the interpolated function values
                                      * are returned.
                                      *
                                      * The function assumes that the
-                                     * @p{gradients} object already has the
+                                     * @p gradients object already has the
                                      * right size.
                                      *
                                      * This function does the same as
-                                     * the other @p{get_function_values},
+                                     * the other @p get_function_values,
                                      * but applied to multi-component
                                      * elements.
                                      *
@@ -621,8 +621,8 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * PETSc vector wrapper classes. It
                                      * represents a global vector of
                                      * DoF values associated with the
-                                     * @ref{DofHandler} object with
-                                     * which this @ref{FEValues}
+                                     * DofHandler object with
+                                     * which this FEValues
                                      * object was last initialized.
                                      *
                                      * The output are the gradients
@@ -637,14 +637,14 @@ class FEValuesBase : protected FEValuesData<dim>
 
                                     /**
                                      * Second derivatives of
-                                     * the @p{function_no}th shape function at
-                                     * the @p{point_no}th quadrature point
+                                     * the @p function_noth shape function at
+                                     * the @p point_noth quadrature point
                                      * with respect to real cell
                                      * coordinates. If you want to
                                      * get the derivatives in one of
                                      * the coordinate directions, use
                                      * the appropriate function of
-                                     * the @p{Tensor} class to
+                                     * the @p Tensor class to
                                      * extract one component. Since
                                      * only a reference to the
                                      * derivative values is returned,
@@ -659,9 +659,9 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * non-zero component (i.e. it is
                                      * not primitive), then throw an
                                      * exception of type
-                                     * @p{ExcShapeFunctionNotPrimitive}. In
+                                     * @p ExcShapeFunctionNotPrimitive. In
                                      * that case, use the
-                                     * @ref{shape_grad_grad_component}
+                                     * shape_grad_grad_component()
                                      * function.
                                      */
     const Tensor<2,dim> &
@@ -677,7 +677,7 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * is scalar, then only component
                                      * zero is allowed and the return
                                      * value equals that of the
-                                     * @p{shape_2nd_derivative}
+                                     * @p shape_2nd_derivative
                                      * function. If the finite
                                      * element is vector valued but
                                      * all shape functions are
@@ -685,7 +685,7 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * non-zero in only one
                                      * component), then the value
                                      * returned by
-                                     * @p{shape_2nd_derivative}
+                                     * @p shape_2nd_derivative
                                      * equals that of this function
                                      * for exactly one
                                      * component. This function is
@@ -704,12 +704,12 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * Compute the tensor of second
                                      * derivatives of the finite
                                      * element function characterized
-                                     * by @p{fe_function} restricted
-                                     * to @p{cell} at the quadrature
+                                     * by @p fe_function restricted
+                                     * to @p cell at the quadrature
                                      * points.
                                      *
                                      * The function assumes that the
-                                     * @p{second_derivatives} object
+                                     * @p second_derivatives object
                                      * already has the correct size.
                                      *
                                      * This function may only be used if the
@@ -717,7 +717,7 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * i.e. has only one vector component. If
                                      * it is a vector-valued one, then use
                                      * the other
-                                     * @p{get_function_2nd_derivatives}
+                                     * @p get_function_2nd_derivatives
                                      * function.
                                      * 
                                      * The actual data type of the input
@@ -726,8 +726,8 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * PETSc vector wrapper classes..It
                                      * represents a global vector of
                                      * DoF values associated with the
-                                     * @ref{DofHandler} object with
-                                     * which this @ref{FEValues}
+                                     * DofHandler object with
+                                     * which this FEValues
                                      * object was last initialized.
                                      *
                                      * The output are the second derivatives
@@ -746,11 +746,11 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * Compute the tensor of second
                                      * derivatives of the finite
                                      * element function characterized
-                                     * by @p{fe_function} restricted to
-                                     * @p{cell} at the quadrature points.
+                                     * by @p fe_function restricted to
+                                     * @p cell at the quadrature points.
                                      *
                                      * The function assumes that the
-                                     * @p{second_derivatives} object already has
+                                     * @p second_derivatives object already has
                                      * the right size.
                                      *
                                      * This function does the same as
@@ -764,8 +764,8 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * PETSc vector wrapper classes. It
                                      * represents a global vector of
                                      * DoF values associated with the
-                                     * @ref{DofHandler} object with
-                                     * which this @ref{FEValues}
+                                     * DofHandler object with
+                                     * which this FEValues
                                      * object was last initialized.
                                      *
                                      * The output are the second derivatives
@@ -780,7 +780,7 @@ class FEValuesBase : protected FEValuesData<dim>
                                   std::vector<std::vector<Tensor<2,dim> > > &second_derivatives) const;
     
                                     /**
-                                     * Position of the @p{i}th
+                                     * Position of the @p ith
                                      * quadrature point in real space.
                                      */
     const Point<dim> & quadrature_point (const unsigned int i) const;
@@ -795,7 +795,7 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * Mapped quadrature weight. This
                                      * is the Jacobi determinant
                                      * times the weight of the
-                                     * @p{i}th unit quadrature point.
+                                     * @p ith unit quadrature point.
                                      *
                                      * On faces, this is the mapped
                                      * surface element.
@@ -876,7 +876,7 @@ class FEValuesBase : protected FEValuesData<dim>
   protected:
                                     /**
                                      * Store the cell selected last time
-                                     * the @p{reinit} function was called
+                                     * the @p reinit function was called
                                      * to make access
                                      * to the @p{get_function_*} functions
                                      * safer.
@@ -907,7 +907,7 @@ class FEValuesBase : protected FEValuesData<dim>
                                     /**
                                      * Initialize some update
                                      * flags. Called from the
-                                     * @p{initialize} functions of
+                                     * @p initialize functions of
                                      * derived classes, which are in
                                      * turn called from their
                                      * constructors.
@@ -925,10 +925,10 @@ class FEValuesBase : protected FEValuesData<dim>
 
                                     /**
                                      * Returns reference to default
-                                     * @p{MappingQ1} object. Needed
+                                     * @p MappingQ1 object. Needed
                                      * by constructors of derived
                                      * classes that uses
-                                     * @p{MappingQ1} implicitly.
+                                     * @p MappingQ1 implicitly.
                                      */
     static const Mapping<dim> &get_default_mapping();
 };
@@ -939,7 +939,7 @@ class FEValuesBase : protected FEValuesData<dim>
  * Finite element evaluated in quadrature points of a cell.
  *
  * This function implements the initialization routines for
- * @ref{FEValuesBase}, if values in quadrature points of a cell are
+ * FEValuesBase, if values in quadrature points of a cell are
  * needed. For further documentation see this class.
  * 
  * @author Wolfgang Bangerth, 1998, Guido Kanschat, 2001
@@ -1005,14 +1005,14 @@ class FEValues : public FEValuesBase<dim>
 
 
 /**
- * Extend the interface of @ref{FEValuesBase} by surface values.
+ * Extend the interface of FEValuesBase by surface values.
  *
  * On surfaces of mesh cells, normal vectors and boundary forms are
  * additional values that can be computed. This class provides the
  * interface to access those. Implementations are in derived classes
- * @p{FEFaceValues} and @p{FESubfaceValues}.
+ * @p FEFaceValues and @p FESubfaceValues.
  *
- * @ref{FEValuesBase}
+ * FEValuesBase
  *
  *  @author Wolfgang Bangerth, 1998, Guido Kanschat, 2000, 2001
  */
@@ -1028,12 +1028,12 @@ class FEFaceValuesBase : public FEValuesBase<dim>
                                      * duty of the derived class's
                                      * constructors.
                                      *
-                                     * @p{n_faces_or_subfaces} is the number
+                                     * @p n_faces_or_subfaces is the number
                                      * of faces or subfaces that this object
                                      * is to store. The actual number depends
                                      * on the derived class, for
-                                     * @p{FEFaceValues} it is @p{2*dim}, while for
-                                     * the @p{FESubfaceValues} class it is
+                                     * @p FEFaceValues it is @p{2*dim}, while for
+                                     * the @p FESubfaceValues class it is
                                      * @p{2*dim*(1<<(dim-1))}, i.e. the number
                                      * of faces times the number of subfaces
                                      * per face.
@@ -1047,7 +1047,7 @@ class FEFaceValuesBase : public FEValuesBase<dim>
 
                                     /**
                                      * Return the outward normal vector to
-                                     * the cell at the @p{i}th quadrature
+                                     * the cell at the @p ith quadrature
                                      * point. The length of the vector
                                      * is normalized to one.
                                      */
@@ -1056,7 +1056,7 @@ class FEFaceValuesBase : public FEValuesBase<dim>
                                     /**
                                      * Boundary form of the
                                      * transformation of the cell at
-                                     * the @p{i}th quadrature point.
+                                     * the @p ith quadrature point.
                                      *
                                      * The boundary form is the cross
                                      * product of the images of the
@@ -1112,8 +1112,8 @@ class FEFaceValuesBase : public FEValuesBase<dim>
 /**
  * Finite element evaluated in quadrature points on a face.
  *
- * This class adds the functionality of @ref{FEFaceValuesBase} to
- * @ref{FEValues}; see there for more documentation.
+ * This class adds the functionality of FEFaceValuesBase to
+ * FEValues; see there for more documentation.
  *
  * Since finite element functions and their derivatives may be
  * discontinuous at cell boundaries, there is no restriction of this
@@ -1149,7 +1149,7 @@ class FEFaceValues : public FEFaceValuesBase<dim>
                                     /**
                                      * Reinitialize the gradients, Jacobi
                                      * determinants, etc for the face with
-                                     * number @p{face_no} of @p{cell}
+                                     * number @p face_no of @p cell
                                      * and the given finite element.
                                      */
     void reinit (const typename DoFHandler<dim>::cell_iterator& cell,
@@ -1168,8 +1168,8 @@ class FEFaceValues : public FEFaceValuesBase<dim>
 /**
  * Finite element evaluated in quadrature points on a face.
  *
- * This class adds the functionality of @ref{FEFaceValuesBase} to
- * @ref{FEValues}; see there for more documentation.
+ * This class adds the functionality of FEFaceValuesBase to
+ * FEValues; see there for more documentation.
  *
  * This class is used for faces lying on a refinement edge. In this
  * case, the neighboring cell is refined. To be able to compute
@@ -1209,7 +1209,7 @@ class FESubfaceValues : public FEFaceValuesBase<dim>
                                     /**
                                      * Reinitialize the gradients, Jacobi
                                      * determinants, etc for the face with
-                                     * number @p{face_no} of @p{cell}
+                                     * number @p face_no of @p cell
                                      * and the given finite element.
                                      */
     void reinit (const typename DoFHandler<dim>::cell_iterator& cell,
index 50c2c3e40a440c995b97e90870be3f3b6679d0d2..dd070ee10fdc2b7f76acc2c80a9e91574b24236a 100644 (file)
@@ -35,22 +35,22 @@ template <int dim> class FESubfaceValues;
 /**
  * Abstract base class for mapping classes.
  *
- * The interface for filling the tables of @ref{FEValues} is provided.
+ * The interface for filling the tables of FEValues is provided.
  * Everything else has to happen in derived classes.
  *
  * The following paragraph applies to the implementation of
- * @ref{FEValues}. Usage of the class is as follows: first, call the
- * functions @p{update_once} and @p{update_each} with the update
+ * FEValues. Usage of the class is as follows: first, call the
+ * functions @p update_once and @p update_each with the update
  * flags you need. This includes the flags needed by the
- * @ref{FiniteElement}. Then call @p{get_*_data} and with the or'd
+ * FiniteElement. Then call @p{get_*_data} and with the or'd
  * results.  This will initialize and return some internal data
  * structures.  On the first cell, call @p{fill_fe_*_values} with the
- * result of @p{update_once}. Finally, on each cell, use
- * @p{fill_fe_*_values} with the result of @p{update_each} to compute
+ * result of @p update_once. Finally, on each cell, use
+ * @p{fill_fe_*_values} with the result of @p update_each to compute
  * values for a special cell.
  *
  * A hint to implementators: no function except the two functions
- * @p{update_once} and @p{update_each} may add any flags.
+ * @p update_once and @p update_each may add any flags.
  *
  * @author Guido Kanschat, Ralf Hartmann 2000, 2001
  */
@@ -65,10 +65,10 @@ class Mapping : public Subscriptor
     virtual ~Mapping ();
     
                                     /**
-                                     * Transforms the point @p{p} on
+                                     * Transforms the point @p p on
                                      * the unit cell to the point
-                                     * @p{p_real} on the real cell
-                                     * @p{cell} and returns @p{p_real}.
+                                     * @p p_real on the real cell
+                                     * @p cell and returns @p p_real.
                                      */
     virtual Point<dim>
     transform_unit_to_real_cell (
@@ -76,10 +76,10 @@ class Mapping : public Subscriptor
       const Point<dim>                                 &p) const = 0;
     
                                     /**
-                                     * Transforms the point @p{p} on
+                                     * Transforms the point @p p on
                                      * the real cell to the point
-                                     * @p{p_unit} on the unit cell
-                                     * @p{cell} and returns @p{p_unit}.
+                                     * @p p_unit on the unit cell
+                                     * @p cell and returns @p p_unit.
                                      */
     virtual Point<dim>
     transform_real_to_unit_cell (
@@ -91,7 +91,7 @@ class Mapping : public Subscriptor
                                      * of finite element and mapping
                                      * objects. The internal
                                      * mechanism is that upon
-                                     * construction of a @p{FEValues}
+                                     * construction of a @p FEValues
                                      * objects, it asks the mapping
                                      * and finite element classes
                                      * that are to be used to
@@ -106,16 +106,16 @@ class Mapping : public Subscriptor
                                      * they do not change from cell
                                      * to cell and only need to be
                                      * computed once. Since different
-                                     * @p{FEValues} objects using
+                                     * @p FEValues objects using
                                      * different quadrature rules
                                      * might access the same finite
                                      * element object at the same
                                      * time, it is necessary to
                                      * create one such object per
-                                     * @p{FEValues} object. Ownership
+                                     * @p FEValues object. Ownership
                                      * of this object is then
                                      * transferred to the
-                                     * @p{FEValues} object, but a
+                                     * @p FEValues object, but a
                                      * pointer to this object is
                                      * passed to the finite element
                                      * object every time it shall
@@ -134,9 +134,9 @@ class Mapping : public Subscriptor
       public:
                                         /**
                                          * Constructor. Sets
-                                         * @p{UpdateFlags} to
-                                         * @p{update_default} and
-                                         * @p{first_cell} to @p{true}.
+                                         * @p UpdateFlags to
+                                         * @p update_default and
+                                         * @p first_cell to @p true.
                                          */
         InternalDataBase ();
        
@@ -167,11 +167,11 @@ class Mapping : public Subscriptor
                                         /**
                                          * If @p{first_cell==true}
                                          * this function returns
-                                         * @p{update_flags},
+                                         * @p update_flags,
                                          * i.e. @p{update_once|update_each}.
                                          * If @p{first_cell==false}
                                          * it returns
-                                         * @p{update_each}.
+                                         * @p update_each.
                                          */
        UpdateFlags  current_update_flags() const;
 
@@ -182,25 +182,25 @@ class Mapping : public Subscriptor
                                           * cell. The value of the
                                           * field this function is
                                           * returning is set to
-                                          * @p{true} in the
+                                          * @p true in the
                                           * constructor, and cleared
-                                          * by the @p{FEValues} class
+                                          * by the @p FEValues class
                                           * after the first cell has
                                           * been initialized.
                                           *
                                           * This function is used to
                                           * determine whether we need
-                                          * to use the @p{update_once}
+                                          * to use the @p update_once
                                           * flags for computing data,
                                           * or whether we can use the
-                                          * @p{update_each} flags.
+                                          * @p update_each flags.
                                           */
         bool is_first_cell () const;
 
                                          /**
-                                          * Set the @p{first_cell}
-                                          * flag to @p{false}. Used by
-                                          * the @p{FEValues} class to
+                                          * Set the @p first_cell
+                                          * flag to @p false. Used by
+                                          * the @p FEValues class to
                                           * indicate that we have
                                           * already done the work on
                                           * the first cell.
@@ -218,7 +218,7 @@ class Mapping : public Subscriptor
       private:
                                          /**
                                           * The value returned by
-                                          * @p{is_first_cell}.
+                                          * @p is_first_cell.
                                           */
         bool first_cell;
     };
@@ -238,14 +238,14 @@ class Mapping : public Subscriptor
                                      * matrix.
                                      *
                                      * The range of vectors spanned
-                                     * by @p{begin} and @p{end} must
+                                     * by @p begin and @p end must
                                      * have as many elements as there
                                      * are quadrature points (not
                                      * tested inside the function).
                                      * Also note the different
                                      * convention for parameters
                                      * compared to the standard C++
-                                     * @p{transform} function: here,
+                                     * @p transform function: here,
                                      * first destination, then source
                                      * are specified, and the number
                                      * of elements is determined by a
@@ -254,7 +254,7 @@ class Mapping : public Subscriptor
                                      * due to the way the function is
                                      * usually called.
                                      *
-                                     * The vector @p{src} must
+                                     * The vector @p src must
                                      * contain at least as many
                                      * elements as there are
                                      * quadrature points.
@@ -295,14 +295,14 @@ class Mapping : public Subscriptor
                                      * unit to real space cell.
                                      * 
                                      * The range of vectors spanned
-                                     * by @p{begin} and @p{end} must
+                                     * by @p begin and @p end must
                                      * have as many elements as there
                                      * are quadrature points (not
                                      * tested inside the function).
                                      * Also note the different
                                      * convention for parameters
                                      * compared to the standard C++
-                                     * @p{transform} function: here,
+                                     * @p transform function: here,
                                      * first destination, then source
                                      * are specified, and the number
                                      * of elements is determined by a
@@ -311,7 +311,7 @@ class Mapping : public Subscriptor
                                      * due to the way the function is
                                      * usually called.
                                      *
-                                     * The vector @p{src} must
+                                     * The vector @p src must
                                      * contain at least as many
                                      * elements as there are
                                      * quadrature points.
@@ -352,14 +352,14 @@ class Mapping : public Subscriptor
                                     /**
                                      * Indicate fields to be updated
                                      * in the constructor of
-                                     * @ref{FEValues}. Especially,
+                                     * FEValues. Especially,
                                      * fields not asked for by
-                                     * @ref{FEValues}, but computed
+                                     * FEValues, but computed
                                      * for efficiency reasons will be
                                      * notified here.
                                      *
                                      * Refer to the same function in
-                                     * @ref{FiniteElement} for
+                                     * FiniteElement for
                                      * further information.
                                      *
                                      * Example: refer to the same
@@ -368,7 +368,7 @@ class Mapping : public Subscriptor
     virtual UpdateFlags update_once (const UpdateFlags) const = 0;
     
                                     /**
-                                     * The same as @p{update_once},
+                                     * The same as @p update_once,
                                      * but for the flags to be updated for
                                      * each grid cell.
                                      */
@@ -438,18 +438,18 @@ class Mapping : public Subscriptor
 
                                     /**
                                      * Fill the transformation fields
-                                     * of @p{FEValues}.  Given a grid
+                                     * of @p FEValues.  Given a grid
                                      * cell and the quadrature points
                                      * on the unit cell, it computes
                                      * all values specified by
-                                     * @p{flags}. The arrays to be
+                                     * @p flags. The arrays to be
                                      * filled have to have the
                                      * correct size.
                                      *
                                      * Values are split into three
                                      * groups: first,
-                                     * @p{quadrature_points} and
-                                     * @p{JxW_values} are
+                                     * @p quadrature_points and
+                                     * @p JxW_values are
                                      * filled with the quadrature
                                      * rule transformed to the
                                      * cell in physical space.
@@ -458,10 +458,10 @@ class Mapping : public Subscriptor
                                      * matrices needed to transform
                                      * vector-valued functions,
                                      * namely
-                                     * @p{covariant_transformation},
-                                     * @p{contravariant_transformation} and the 
+                                     * @p covariant_transformation,
+                                     * @p contravariant_transformation and the 
                                      * derivatives
-                                     * @p{covariant_grads}.
+                                     * @p covariant_grads.
                                      *
                                      */
     virtual void
@@ -472,10 +472,10 @@ class Mapping : public Subscriptor
                    std::vector<double>                           &JxW_values) const = 0;
 
                                     /**
-                                     * Performs the same as @p{fill_fe_values}
+                                     * Performs the same as @p fill_fe_values
                                      * on a face.
-                                     * Additionally, @p{boundary_form} and
-                                     * @p{normal_vectors} can be
+                                     * Additionally, @p boundary_form and
+                                     * @p normal_vectors can be
                                      * computed on surfaces. The
                                      * boundary form is the vector
                                      * product of the image of
@@ -517,7 +517,7 @@ class Mapping : public Subscriptor
                            std::vector<Point<dim> >        &normal_vectors) const = 0;
 
                                     /**
-                                     * Give class @p{FEValues} access
+                                     * Give class @p FEValues access
                                      * to the private @p{get_...data}
                                      * and @p{fill_fe_...values}
                                      * functions.
index e6f9c00dfea1146f206231a1628e0d88853854f9..ea5cbe5917bd4247c1b19ab8c13d455dd2867a79 100644 (file)
 /**
  * Mapping class that uses C1 (continuously differentiable) cubic
  * mappings of the boundary. This class is built atop of
- * @ref{MappingQ} by simply determining the interpolation points for a
- * cubic mapping of the boundary differently: @ref{MappingQ} chooses
+ * MappingQ by simply determining the interpolation points for a
+ * cubic mapping of the boundary differently: MappingQ chooses
  * them such that they interpolate the boundary, while this class
  * chooses them such that the discretized boundary is globally
  * continuously differentiable.
  *  
  * To use this class, make sure that the
- * @ref{Boundary}::@p{get_normals_at_vertices} function is implemented
+ * Boundary::@p get_normals_at_vertices function is implemented
  * for the users boundary object.
  *
  * @author Wolfgang Bangerth, 2001
@@ -42,7 +42,7 @@ class MappingC1 : public MappingQ<dim>
   public:
                                     /**
                                      * Constructor. Pass the fixed
-                                     * degree @p{3} down to the base
+                                     * degree @p 3 down to the base
                                      * class, as a cubic mapping
                                      * suffices to generate a
                                      * continuous mapping of the
@@ -56,7 +56,7 @@ class MappingC1 : public MappingQ<dim>
                                      * support points of all shape
                                      * functions located on bounding
                                      * lines to the vector
-                                     * @p{a}. Points located on the
+                                     * @p a. Points located on the
                                      * line but on vertices are not
                                      * included.
                                      *
@@ -82,12 +82,12 @@ class MappingC1 : public MappingQ<dim>
                                      * support points of all shape
                                      * functions located on bounding
                                      * faces (quads in 3d) to the
-                                     * vector @p{a}. Points located
+                                     * vector @p a. Points located
                                      * on the line but on vertices
                                      * are not included.
                                      *
                                      * Needed by the
-                                     * @p{compute_support_points_laplace}
+                                     * @p compute_support_points_laplace
                                      * function. For @p{dim=1} and 2
                                      * this function is empty.
                                      *
index 245404d652d2a20d44632ca17236e149b90a2fbc..017e52412943b3c002ea29779ee75527fbc30d5a 100644 (file)
@@ -110,13 +110,13 @@ class MappingCartesian : public Mapping<dim>
       const Point<dim>                                 &p) const;
 
                                     /**
-                                     * Transforms the point @p{p} on
+                                     * Transforms the point @p p on
                                      * the real cell to the point
-                                     * @p{p_unit} on the unit cell
-                                     * @p{cell} and returns @p{p_unit}.
+                                     * @p p_unit on the unit cell
+                                     * @p cell and returns @p p_unit.
                                      *
                                      * Uses Newton iteration and the
-                                     * @p{transform_unit_to_real_cell}
+                                     * @p transform_unit_to_real_cell
                                      * function.
                                      */
     virtual Point<dim>
index a77ef51377bef30dd9a70e5d7018dbabce8fe02a..0f2a3f73324a3102b0e497740e262b7d8212af25 100644 (file)
@@ -40,7 +40,7 @@ class MappingQ : public MappingQ1<dim>
 {
   public:
                                     /**
-                                     * Constructor.  @p{p} gives the
+                                     * Constructor.  @p p gives the
                                      * degree of mapping polynomials
                                      * on boundary cells.
                                      */
@@ -52,10 +52,10 @@ class MappingQ : public MappingQ1<dim>
     virtual ~MappingQ ();
     
                                     /**
-                                     * Transforms the point @p{p} on
+                                     * Transforms the point @p p on
                                      * the unit cell to the point
-                                     * @p{p_real} on the real cell
-                                     * @p{cell} and returns @p{p_real}.
+                                     * @p p_real on the real cell
+                                     * @p cell and returns @p p_real.
                                      */
     virtual Point<dim>
     transform_unit_to_real_cell (
@@ -63,13 +63,13 @@ class MappingQ : public MappingQ1<dim>
       const Point<dim>                                 &p) const;
     
                                     /**
-                                     * Transforms the point @p{p} on
+                                     * Transforms the point @p p on
                                      * the real cell to the point
-                                     * @p{p_unit} on the unit cell
-                                     * @p{cell} and returns @p{p_unit}.
+                                     * @p p_unit on the unit cell
+                                     * @p cell and returns @p p_unit.
                                      *
                                      * Uses Newton iteration and the
-                                     * @p{transform_unit_to_real_cell}
+                                     * @p transform_unit_to_real_cell
                                      * function.
                                      */
     virtual Point<dim>
@@ -79,7 +79,7 @@ class MappingQ : public MappingQ1<dim>
 
                                     /**
                                      * Implementation of the
-                                     * interface in @ref{Mapping}.
+                                     * interface in Mapping.
                                      */
     virtual void
     transform_covariant (Tensor<1,dim>          *begin,
@@ -89,7 +89,7 @@ class MappingQ : public MappingQ1<dim>
     
                                     /**
                                      * Implementation of the
-                                     * interface in @ref{Mapping}.
+                                     * interface in Mapping.
                                      */
     virtual void
     transform_covariant (Tensor<2,dim>          *begin,
@@ -99,7 +99,7 @@ class MappingQ : public MappingQ1<dim>
     
                                     /**
                                      * Implementation of the
-                                     * interface in @ref{Mapping}.
+                                     * interface in Mapping.
                                      */
     virtual void
     transform_contravariant (Tensor<1,dim>          *begin,
@@ -109,7 +109,7 @@ class MappingQ : public MappingQ1<dim>
 
                                     /**
                                      * Implementation of the
-                                     * interface in @ref{Mapping}.
+                                     * interface in Mapping.
                                      */
     virtual void
     transform_contravariant (Tensor<2,dim>          *begin,
@@ -150,11 +150,11 @@ class MappingQ : public MappingQ1<dim>
                                          * for the alternative
                                          * computation of the normal
                                          * vectors. See doc of the
-                                         * @p{alternative_normals_computation}
+                                         * @p alternative_normals_computation
                                          * flag.
                                          *
                                          * Filled (hardcoded) once in
-                                         * @p{get_face_data}.
+                                         * @p get_face_data.
                                          */
         std::vector<std::vector<Point<dim> > > unit_normals;
 
@@ -163,17 +163,17 @@ class MappingQ : public MappingQ1<dim>
                                          * @p{fill_fe_[[sub]face]_values}
                                          * function.
                                          *
-                                         * If this flag is @p{true}
+                                         * If this flag is @p true
                                          * we are on an interior cell
                                          * and the
-                                         * @p{mapping_q1_data} is
+                                         * @p mapping_q1_data is
                                          * used.
                                          */
        bool use_mapping_q1_on_current_cell;
        
                                         /**
                                          * On interior cells
-                                         * @p{MappingQ1} is used.
+                                         * @p MappingQ1 is used.
                                          */
        typename MappingQ1<dim>::InternalData mapping_q1_data;
     };
@@ -181,7 +181,7 @@ class MappingQ : public MappingQ1<dim>
   protected:
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual void
     fill_fe_values (const typename DoFHandler<dim>::cell_iterator &cell,
@@ -192,7 +192,7 @@ class MappingQ : public MappingQ1<dim>
 
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual void
     fill_fe_face_values (const typename DoFHandler<dim>::cell_iterator &cell,
@@ -206,7 +206,7 @@ class MappingQ : public MappingQ1<dim>
 
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual void
     fill_fe_subface_values (const typename DoFHandler<dim>::cell_iterator &cell,
@@ -224,12 +224,12 @@ class MappingQ : public MappingQ1<dim>
                                      * support points of all shape
                                      * functions located on bounding
                                      * lines to the vector
-                                     * @p{a}. Points located on the
+                                     * @p a. Points located on the
                                      * line but not on vertices are not
                                      * included.
                                      *
                                      * Needed by the
-                                     * @p{compute_support_points_laplace}
+                                     * @p compute_support_points_laplace
                                      * function . For @p{dim=1} this
                                      * function is empty.
                                      *
@@ -251,12 +251,12 @@ class MappingQ : public MappingQ1<dim>
                                      * support points of all shape
                                      * functions located on bounding
                                      * faces (quads in 3d) to the
-                                     * vector @p{a}. Points located
+                                     * vector @p a. Points located
                                      * on the quad but not on vertices
                                      * are not included.
                                      *
                                      * Needed by the
-                                     * @p{compute_support_points_laplace}
+                                     * @p compute_support_points_laplace
                                      * function. For @p{dim=1} and
                                      * @p{dim=2} this function is
                                      * empty.
@@ -278,7 +278,7 @@ class MappingQ : public MappingQ1<dim>
     
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual
     typename Mapping<dim>::InternalDataBase *
@@ -287,7 +287,7 @@ class MappingQ : public MappingQ1<dim>
 
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual
     typename Mapping<dim>::InternalDataBase *
@@ -296,7 +296,7 @@ class MappingQ : public MappingQ1<dim>
 
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual
     typename Mapping<dim>::InternalDataBase *
@@ -318,13 +318,13 @@ class MappingQ : public MappingQ1<dim>
                                      *
                                      * For @p{degree<4} this function
                                      * sets the
-                                     * @p{laplace_on_quad_vector} to
+                                     * @p laplace_on_quad_vector to
                                      * the hardcoded data. For
                                      * @p{degree>=4} and MappingQ<2>
                                      * this vector is computed.
                                      *
                                      * For the definition of the
-                                     * @p{laplace_on_quad_vector}
+                                     * @p laplace_on_quad_vector
                                      * please refer to equation (8)
                                      * of the `mapping' report.
                                      */
@@ -337,13 +337,13 @@ class MappingQ : public MappingQ1<dim>
                                      *
                                      * For @p{degree==2} this function
                                      * sets the
-                                     * @p{laplace_on_hex_vector} to
+                                     * @p laplace_on_hex_vector to
                                      * the hardcoded data. For
                                      * @p{degree>2} this vector is
                                      * computed.
                                      *
                                      * For the definition of the
-                                     * @p{laplace_on_hex_vector}
+                                     * @p laplace_on_hex_vector
                                      * please refer to equation (8)
                                      * of the `mapping' report.
                                      */
@@ -369,15 +369,15 @@ class MappingQ : public MappingQ1<dim>
                                      * Takes a
                                      * @p{laplace_on_hex(quad)_vector}
                                      * and applies it to the vector
-                                     * @p{a} to compute the inner
+                                     * @p a to compute the inner
                                      * support points as a linear
                                      * combination of the exterior
                                      * points.
                                      *
-                                     * The vector @p{a} initially
+                                     * The vector @p a initially
                                      * contains the locations of the
-                                     * @p{n_outer} points, the
-                                     * @p{n_inner} computed inner
+                                     * @p n_outer points, the
+                                     * @p n_inner computed inner
                                      * points are appended.
                                      *
                                      * See equation (7) of the
@@ -414,7 +414,7 @@ class MappingQ : public MappingQ1<dim>
     
                                     /**
                                      * Needed by the
-                                     * @p{laplace_on_quad} function
+                                     * @p laplace_on_quad function
                                      * (for @p{dim==2}). Filled by the
                                      * constructor.
                                      *
@@ -436,7 +436,7 @@ class MappingQ : public MappingQ1<dim>
     
                                     /**
                                      * Needed by the
-                                     * @p{laplace_on_hex} function
+                                     * @p laplace_on_hex function
                                      * (for @p{dim==3}). Filled by the
                                      * constructor.
                                      *
@@ -454,7 +454,7 @@ class MappingQ : public MappingQ1<dim>
                    << "laplace_vector not set for degree=" << arg1 << ".");
      
                                     /**
-                                     * Degree @p{p} of the
+                                     * Degree @p p of the
                                      * polynomials used as shape
                                      * functions for the Qp mapping
                                      * of cells at the boundary.
@@ -475,7 +475,7 @@ class MappingQ : public MappingQ1<dim>
     
                                     /**
                                      * Pointer to the
-                                     * @p{dim}-dimensional tensor
+                                     * @p dim-dimensional tensor
                                      * product polynomials used as
                                      * shape functions for the Qp
                                      * mapping of cells at the
@@ -493,13 +493,13 @@ class MappingQ : public MappingQ1<dim>
                                      * Mapping from lexicographic to
                                      * to the Qp shape function
                                      * numbering. Its size is
-                                     * @p{dofs_per_cell}.
+                                     * @p dofs_per_cell.
                                      */
     std::vector<unsigned int> renumber;
 
                                     /**
-                                     * If this flag is set @p{true}
-                                     * then @p{MappingQ} is used on
+                                     * If this flag is set @p true
+                                     * then @p MappingQ is used on
                                      * all cells, not only on
                                      * boundary cells.
                                      *
index 55154001c613beab8be829c58d7f04d406db81b0..ad6bb8dfc2a008984c1f246aaef1fa8c065a4383 100644 (file)
  * functions.
  *
  * This function maps the unit cell to a general grid cell with
- * straight lines in @p{d} dimensions (remark that in 3D the surfaces
+ * straight lines in @p d dimensions (remark that in 3D the surfaces
  * may be curved, even if the edges are not). This is the well-known
  * mapping for polyhedral domains.
  *
  * Shape function for this mapping are the same as for the finite
- * element @p{FE_Q} of order 1. Therefore, coupling these two yields
+ * element @p FE_Q of order 1. Therefore, coupling these two yields
  * an isoparametric element.
  *
  * @author Guido Kanschat, Ralf Hartmann, 2000, 2001
@@ -56,10 +56,10 @@ class MappingQ1 : public Mapping<dim>
     MappingQ1 ();
     
                                     /**
-                                     * Transforms the point @p{p} on
+                                     * Transforms the point @p p on
                                      * the unit cell to the point
-                                     * @p{p_real} on the real cell
-                                     * @p{cell} and returns @p{p_real}.
+                                     * @p p_real on the real cell
+                                     * @p cell and returns @p p_real.
                                      */
     virtual Point<dim>
     transform_unit_to_real_cell (
@@ -67,13 +67,13 @@ class MappingQ1 : public Mapping<dim>
       const Point<dim>                                 &p) const;
     
                                     /**
-                                     * Transforms the point @p{p} on
+                                     * Transforms the point @p p on
                                      * the real cell to the point
-                                     * @p{p_unit} on the unit cell
-                                     * @p{cell} and returns @p{p_unit}.
+                                     * @p p_unit on the unit cell
+                                     * @p cell and returns @p p_unit.
                                      *
                                      * Uses Newton iteration and the
-                                     * @p{transform_unit_to_real_cell}
+                                     * @p transform_unit_to_real_cell
                                      * function.
                                      */
     virtual Point<dim>
@@ -83,7 +83,7 @@ class MappingQ1 : public Mapping<dim>
     
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual void
     transform_covariant (Tensor<1,dim>          *begin,
@@ -93,7 +93,7 @@ class MappingQ1 : public Mapping<dim>
     
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual void
     transform_covariant (Tensor<2,dim>          *begin,
@@ -103,7 +103,7 @@ class MappingQ1 : public Mapping<dim>
     
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual void
     transform_contravariant (Tensor<1,dim>          *begin,
@@ -113,7 +113,7 @@ class MappingQ1 : public Mapping<dim>
     
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual void
     transform_contravariant (Tensor<2,dim>          *begin,
@@ -123,77 +123,77 @@ class MappingQ1 : public Mapping<dim>
     
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      *
                                      * Description of effects:
-                                     * @begin{itemize}
-                                     * @item if @p{update_q_points}
+                                     * <ul>
+                                     * <li> if @p update_q_points
                                      * is required, the output will
                                      * contain
-                                     * @p{update_transformation_values}. This
+                                     * @p update_transformation_values. This
                                      * computes the values of the
                                      * transformation basis
                                      * polynomials at the unit cell
                                      * quadrature points.
-                                     * @item if any of
-                                     * @p{update_covariant_transformation},
-                                     * @p{update_contravariant_transformation},
-                                     * @p{update_JxW_values},
-                                     * @p{update_boundary_forms},
-                                     * @p{update_normal_vectors} is
+                                     * <li> if any of
+                                     * @p update_covariant_transformation,
+                                     * @p update_contravariant_transformation,
+                                     * @p update_JxW_values,
+                                     * @p update_boundary_forms,
+                                     * @p update_normal_vectors is
                                      * required, the output will
                                      * contain
-                                     * @p{update_transformation_gradients}
+                                     * @p update_transformation_gradients
                                      * to compute derivatives of the
                                      * transformation basis
                                      * polynomials.
-                                     * @end{itemize}
+                                     * </ul>
                                      */
     virtual UpdateFlags update_once (const UpdateFlags flags) const;
     
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      *
                                      * Description of effects if
-                                     * @p{flags} contains:
-                                     * @begin{itemize}
-                                     * @item p{update_q_points} is
+                                     * @p flags contains:
+                                     * <ul>
+                                     * <li> p{update_q_points} is
                                      * copied to the output to
                                      * compute the quadrature points
                                      * on the real cell.
-                                     * @item p{update_JxW_values} is
+                                     * <li> p{update_JxW_values} is
                                      * copied and requires
-                                     * @p{update_boundary_forms} on
+                                     * @p update_boundary_forms on
                                      * faces. The latter, because the
                                      * surface element is just the
                                      * norm of the boundary form.
-                                     * @item p{update_normal_vectors}
+                                     * <li> p{update_normal_vectors}
                                      * is copied and requires
-                                     * @p{update_boundary_forms}. The
+                                     * @p update_boundary_forms. The
                                      * latter, because the normal
                                      * vector is the normalized
                                      * boundary form.
-                                     * @item
+                                     * <li>
                                      * p{update_covariant_transformation}
                                      * is copied and requires
-                                     * @p{update_contravariant_transformation},
+                                     * @p update_contravariant_transformation,
                                      * since it is computed as the
                                      * inverse of the latter.
-                                     * @item p{update_JxW_values} is
+                                     * <li> p{update_JxW_values} is
                                      * copied and requires
-                                     * @p{update_contravariant_transformation},
+                                     * @p update_contravariant_transformation,
                                      * since it is computed as one
                                      * over determinant of the
                                      * latter.
-                                     * @item p{update_boundary_forms}
+                                     * <li> p{update_boundary_forms}
                                      * is copied and requires
-                                     * @p{update_contravariant_transformation},
+                                     * @p update_contravariant_transformation,
                                      * since the boundary form is
                                      * computed as the contravariant
                                      * image of the normal vector to
                                      * the unit cell.
-                                     * @end{itemize}
+                                     * </ul>
                                      */
     virtual UpdateFlags update_each (const UpdateFlags flags) const;
 
@@ -254,7 +254,7 @@ class MappingQ1 : public Mapping<dim>
                                         /**
                                          * Values of shape
                                          * functions. Access by
-                                         * function @p{shape}.
+                                         * function @p shape.
                                          *
                                          * Computed once.
                                          */
@@ -263,7 +263,7 @@ class MappingQ1 : public Mapping<dim>
                                         /**
                                          * Values of shape function
                                          * derivatives. Access by
-                                         * function @p{derivative}.
+                                         * function @p derivative.
                                          *
                                          * Computed once.
                                          */
@@ -277,7 +277,7 @@ class MappingQ1 : public Mapping<dim>
                                          * inverse of the Jacobian
                                          * matrix, which itself is
                                          * stored in the
-                                         * @p{contravariant} field of
+                                         * @p contravariant field of
                                          * this structure.
                                          *
                                          * Computed on each cell.
@@ -315,23 +315,23 @@ class MappingQ1 : public Mapping<dim>
                                         /**
                                          * Stores the support points of
                                          * the mapping shape functions on
-                                         * the @p{cell_of_current_support_points}.
+                                         * the @p cell_of_current_support_points.
                                          */
        std::vector<Point<dim> > mapping_support_points;
        
                                         /**
                                          * Stores the cell of which the
-                                         * @p{mapping_support_points} are
+                                         * @p mapping_support_points are
                                          * stored.
                                          */
        typename DoFHandler<dim>::cell_iterator cell_of_current_support_points;
        
                                         /**
                                          * Default value of this flag
-                                         * is @p{true}. If @p{*this}
+                                         * is @p true. If @p{*this}
                                          * is an object of a derived
                                          * class, this flag is set to
-                                         * @p{false}.
+                                         * @p false.
                                          */
        bool is_mapping_q1_data;
 
@@ -343,7 +343,7 @@ class MappingQ1 : public Mapping<dim>
                                          * cell. However, since also
                                          * derived classes use this
                                          * class (e.g. the
-                                         * @ref{Mapping_Q} class),
+                                         * Mapping_Q() class),
                                          * the number of shape
                                          * functions may also be
                                          * different.
@@ -371,7 +371,7 @@ class MappingQ1 : public Mapping<dim>
     
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual void
     fill_fe_values (const typename DoFHandler<dim>::cell_iterator &cell,
@@ -382,7 +382,7 @@ class MappingQ1 : public Mapping<dim>
 
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual void
     fill_fe_face_values (const typename DoFHandler<dim>::cell_iterator &cell,
@@ -396,7 +396,7 @@ class MappingQ1 : public Mapping<dim>
 
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual void
     fill_fe_subface_values (const typename DoFHandler<dim>::cell_iterator &cell,
@@ -414,21 +414,21 @@ class MappingQ1 : public Mapping<dim>
                                      * derivatives.
                                      *
                                      * Calls either the
-                                     * @p{compute_shapes_virtual} of
+                                     * @p compute_shapes_virtual of
                                      * this class or that of the
                                      * derived class, depending on
                                      * whether
                                      * @p{data.is_mapping_q1_data}
-                                     * equals @p{true} or @p{false}.
+                                     * equals @p true or @p false.
                                      */
     void compute_shapes (const std::vector<Point<dim> > &unit_points,
                         InternalData &data) const;
 
                                     /**
                                      * Do the computations for the
-                                     * @p{get_data} functions. Here,
+                                     * @p get_data functions. Here,
                                      * the data vectors of
-                                     * @p{InternalData} are
+                                     * @p InternalData are
                                      * reinitialized to proper size
                                      * and shape values are computed.
                                      */
@@ -439,14 +439,14 @@ class MappingQ1 : public Mapping<dim>
 
                                     /**
                                      * Do the computations for the
-                                     * @p{get_face_data}
+                                     * @p get_face_data
                                      * functions. Here, the data
-                                     * vectors of @p{InternalData}
+                                     * vectors of @p InternalData
                                      * are reinitialized to proper
                                      * size and shape values and
                                      * derivatives are
                                      * computed. Furthermore
-                                     * @p{unit_tangential} vectors of
+                                     * @p unit_tangential vectors of
                                      * the face are computed.
                                      */
     void compute_face_data (const UpdateFlags flags,
@@ -488,65 +488,65 @@ class MappingQ1 : public Mapping<dim>
                                         InternalData &data) const;
 
                                     /**
-                                     * Transforms a point @p{p} on
+                                     * Transforms a point @p p on
                                      * the unit cell to the point
-                                     * @p{p_real} on the real cell
-                                     * @p{cell} and returns @p{p_real}.
+                                     * @p p_real on the real cell
+                                     * @p cell and returns @p p_real.
                                      *
                                      * This function is called by
-                                     * @p{transform_unit_to_real_cell}
+                                     * @p transform_unit_to_real_cell
                                      * and multiply (through the
                                      * Newton iteration) by
-                                     * @p{transform_real_to_unit_cell_internal}.
+                                     * @p transform_real_to_unit_cell_internal.
                                      *
                                      * Takes a reference to an
-                                     * @p{InternalData} that must
+                                     * @p InternalData that must
                                      * already include the shape
-                                     * values at point @p{p} and the
+                                     * values at point @p p and the
                                      * mapping support points of the
                                      * cell.
                                      *
-                                     * This @p{InternalData} argument
+                                     * This @p InternalData argument
                                      * avoids multiple computations
                                      * of the shape values at point
-                                     * @p{p} and especially multiple
+                                     * @p p and especially multiple
                                      * computations of the mapping
                                      * support points.
                                      */
     Point<dim> transform_unit_to_real_cell_internal (const InternalData &mdata) const;
     
                                     /**
-                                     * Transforms the point @p{p} on
+                                     * Transforms the point @p p on
                                      * the real cell to the point
-                                     * @p{p_unit} on the unit cell
-                                     * @p{cell} by a Newton
+                                     * @p p_unit on the unit cell
+                                     * @p cell by a Newton
                                      * iteration.
                                      *
                                      * Takes a reference to an
-                                     * @p{InternalData} that is
+                                     * @p InternalData that is
                                      * assumed to be previously
-                                     * created by the @p{get_data}
-                                     * function with @p{UpdateFlags}
+                                     * created by the @p get_data
+                                     * function with @p UpdateFlags
                                      * including
-                                     * @p{update_transformation_values}
+                                     * @p update_transformation_values
                                      * and
-                                     * @p{update_transformation_gradients}
+                                     * @p update_transformation_gradients
                                      * and a one point Quadrature
                                      * including the given point
-                                     * @p{p_unit}.  Hence this
+                                     * @p p_unit.  Hence this
                                      * function assumes that
-                                     * @p{mdata} already includes the
+                                     * @p mdata already includes the
                                      * transformation shape values
                                      * and gradients computed at
-                                     * @p{p_unit}.
+                                     * @p p_unit.
                                      *
                                      * These assumptions should be
                                      * fulfilled by the calling
                                      * function. That is up to now
                                      * only the function
-                                     * @p{transform_real_to_unit_cell}
+                                     * @p transform_real_to_unit_cell
                                      * and its overloaded versions.
-                                     * @p{mdata} will be changed by
+                                     * @p mdata will be changed by
                                      * this function.
                                      */
     void transform_real_to_unit_cell_internal (const typename Triangulation<dim>::cell_iterator &cell,
@@ -564,7 +564,7 @@ class MappingQ1 : public Mapping<dim>
   private:
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual
     typename Mapping<dim>::InternalDataBase *
@@ -573,7 +573,7 @@ class MappingQ1 : public Mapping<dim>
 
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual
     typename Mapping<dim>::InternalDataBase *
@@ -582,7 +582,7 @@ class MappingQ1 : public Mapping<dim>
 
                                     /**
                                      * Implementation of the interface in
-                                     * @ref{Mapping}.
+                                     * Mapping.
                                      */
     virtual
     typename Mapping<dim>::InternalDataBase *
@@ -591,7 +591,7 @@ class MappingQ1 : public Mapping<dim>
 
                                     /**
                                      * Computes the support points of
-                                     * the mapping. For @p{MappingQ1}
+                                     * the mapping. For @p MappingQ1
                                      * these are the
                                      * vertices.
                                      */
index 6f88c5d292f1de399fba3a098cc5ac4ce0412d59..e80c0b82f2e193970290a8ada8fcf5c3e8050d04 100644 (file)
  * The constructor of this class takes two arguments: a reference to
  * the vector that defines the mapping from the reference
  * configuration to the current configuration and a reference to the
- * @ref{DoFHandler}. The vector should then represent a (flattened out
+ * DoFHandler. The vector should then represent a (flattened out
  * version of a) vector valued field defined at nodes defined by the 
- * the @ref{DoFHandler}, where the number of components of the vector
+ * the DoFHandler, where the number of components of the vector
  * field equals the number of space dimensions. Thus, the 
- * @ref{DoFHandler} shall operate on a finite element that has as many 
+ * DoFHandler shall operate on a finite element that has as many 
  * components as space dimensions. As an additional requirement, we 
  * impose that it have as many degree of freedom per vertex as there
  * are space dimensions; since this object only evaluates the finite 
  * element field at the vertices, the values
  * of all other degrees of freedom (not associated to vertices) are
  * ignored. These requirements are met if the finite element which the
- * given @ref{DoFHandler} operates on is constructed as a system
- * element (@ref{FESystem}) from @p{dim} continuous @ref{FE_Q}
+ * given DoFHandler operates on is constructed as a system
+ * element (FESystem) from @p dim continuous FE_Q()
  * objects.
  *
  * In many cases, the shift vector will also be the solution vector of
  * space dimension, e.g. for scalar problems in @p{dim>1} where the
  * Eulerian coordinates only give a background field) or for coupled
  * problems where more variables are computed than just the flow
- * field), then a different @ref{DoFHandler} has to be set up on the
+ * field), then a different DoFHandler has to be set up on the
  * given triangulation, and the shift vector has then to be associated
  * to it.
  *
  * An example is shown below:
- * @begin{verbatim}
+ * @verbatim
  *    FESystem<dim> fe(FE_Q<dim>(1), dim);
  *    DoFHandler<dim> flowfield_dof_handler(triangulation);
  *    flowfield_dof_handler.distribute_dofs(fe);
  *    Vector<double> map_points(flowfield_dof_handler.n_dofs());
  *    MappingQ1Eulerian<dim> mymapping(map_points, flowfield_dof_handler);
- * @end{verbatim}
+ * @endverbatim
  *
  * Note that since the vector of shift values and the dof handler are
  * only associated to this object at construction time, you have to
@@ -85,16 +85,16 @@ class MappingQ1Eulerian : public MappingQ1<dim>
                                      * problem from the reference to
                                      * the current configuration.
                                      * The organization of the
-                                     * elements in the @p{Vector}
+                                     * elements in the @p Vector
                                      * must follow the concept how
                                      * deal.II stores solutions that
                                      * are associated to a
                                      * triangulation.  This is
                                      * automatically the case if the
-                                     * @p{Vector} represents the
+                                     * @p Vector represents the
                                      * solution of the previous step
                                      * of a nonlinear problem.
-                                     * Alternatively, the @p{Vector}
+                                     * Alternatively, the @p Vector
                                      * can be initialized by
                                      * @p{DoFObjectAccessor::set_dof_values()}.
                                      */
@@ -142,7 +142,7 @@ class MappingQ1Eulerian : public MappingQ1<dim>
                                     /**
                                      * Computes the support points of
                                      * the mapping. For
-                                     * @p{MappingQ1Eulerian} these
+                                     * @p MappingQ1Eulerian these
                                      * are the vertices.
                                      */
     virtual void compute_mapping_support_points(
index f778fd4fe5d26a7f28e2e06ea2aecaf866ef9f26..f5b1f76732b7827aa656a99d0c977dd86cd06f3f 100644 (file)
 
 /**
  * In this namespace a number of classes is declared that may be used
- * as filters in the @ref{FilteredIterator} class. The filters either
- * check for binary information (for example, the @p{Active} filter
+ * as filters in the FilteredIterator class. The filters either
+ * check for binary information (for example, the @p Active filter
  * class checks whether the object pointed to is active), or for
  * valued information by comparison with prescribed values (for
- * example, the @ref{LevelEqualTo} filter class checks whether the
+ * example, the LevelEqualTo filter class checks whether the
  * level of the object pointed to by the iterator under consideration
  * is equal to a value that was given to the filter upon construction.
  *
  * For examples of use of these classes as well as requirements on
- * filters see the general description of the @ref{FilteredIterator}
+ * filters see the general description of the FilteredIterator
  * class.
  *
  * @author Wolfgang Bangerth, 2002
@@ -203,39 +203,39 @@ namespace IteratorFilters
  * pointers as well as classes that implement an @p{operator ()}.
  *
  * An example of a simple valid predicate is the following: given the function
- * @begin{verbatim}
+ * @verbatim
  *   template <typename Iterator>
  *   bool level_equal_to_3 (const Iterator c)
  *   {
  *     return (static_cast<unsigned int>(c->level()) == 3);
  *   };
- * @end{verbatim} 
+ * @endverbatim 
  * then
- * @begin{verbatim}
+ * @verbatim
  *   &level_equal_to_3<typename Triangulation<dim>::active_cell_iterator>
- * @end{verbatim}
+ * @endverbatim
  * is a valid predicate.
  *
  * Likewise, given the following binary function
- * @begin{verbatim}
+ * @verbatim
  *   template <typename Iterator>
  *   bool level_equal_to (const Iterator     c,
  *                        const unsigned int level)
  *   {
  *     return (static_cast<unsigned int>(c->level()) == level);
  *   };
- * @end{verbatim} 
+ * @endverbatim 
  * then
- * @begin{verbatim}
+ * @verbatim
  *   std::bind2nd (std::ptr_fun(&level_equal_to<active_cell_iterator>), 3)
- * @end{verbatim}
+ * @endverbatim
  * is another valid predicate (here: a function that returns true if
  * either the iterator is past the end or the level is equal to the
  * second argument; this second argument is bound to a fixed value
- * using the @p{std::bind2nd} function).
+ * using the @p std::bind2nd function).
  *
  * Finally, classes can be predicates. The following class is one:
- * @begin{verbatim}
+ * @verbatim
  *   class Active 
  *   {
  *     public:
@@ -244,10 +244,10 @@ namespace IteratorFilters
  *         return (i->active());
  *       }
  *   };
- * @end{verbatim}
+ * @endverbatim
  * and objects of this type can be used as predicates. Likewise, this
  * more complicated one can also be used:
- * @begin{verbatim}
+ * @verbatim
  *   class SubdomainEqualTo
  *   {
  *     public:
@@ -262,7 +262,7 @@ namespace IteratorFilters
  *     private:
  *       const unsigned int subdomain_id;
  *   };
- * @end{verbatim}
+ * @endverbatim
  * Objects like @p{SubdomainEqualTo(3)} can then be used as predicates.
  *
  * Since whenever a predicate is evaluated it is checked that the
@@ -270,7 +270,7 @@ namespace IteratorFilters
  * checks for this case have to be performed inside predicates.
  *
  * A number of filter classes are already implemented in the
- * @ref{IteratorFilters} namespace, but writing different ones is
+ * IteratorFilters namespace, but writing different ones is
  * simple following the examples above.
  *
  *
@@ -301,7 +301,7 @@ namespace IteratorFilters
  * iterator to the first one that satisfies a predicate (for example,
  * the first one for which the user flag is set, or the first one with
  * a given subdomain id), there are assignement functions
- * @p{set_to_next_positive} and @p{set_to_previous_positive} that
+ * @p set_to_next_positive and @p set_to_previous_positive that
  * assign the next or last previous iterator that satisfies the
  * predicate, i.e. they follow the list of iterators in either
  * direction until they find a matching one (or the past-the-end
@@ -313,49 +313,49 @@ namespace IteratorFilters
  *
  * The following call counts the number of active cells that
  * have a set user flag:
- * @begin{verbatim}
+ * @verbatim
  *   FilteredIterator<typename Triangulation<dim>::active_cell_iterator>
  *      begin (IteratorFilters::UserFlagSet()),
  *      end (IteratorFilters::UserFlagSet());
  *   begin.set_to_next_positive(tria.begin_active());
  *   end = tria.end();
  *   n_flagged_cells = std::distance (begin, end);
- * @begin{verbatim}
- * Note that by the @p{set_to_next_positive} call the first cell with
- * a set user flag was assigned to the @p{begin} iterator. For the
+ * @verbatim
+ * Note that by the @p set_to_next_positive call the first cell with
+ * a set user flag was assigned to the @p begin iterator. For the
  * @{end} iterator, no such call was necessary, since the past-the-end
  * iterator always satisfies all predicates.
  *
  * The same can be achieved by the following snippet, though harder to read:
- * @begin{verbatim}
+ * @verbatim
  *   typedef FilteredIterator<typename Triangulation<dim>::active_cell_iterator> FI;
  *   n_flagged_cells =
  *      std::distance (FI(IteratorFilters::UserFlagSet())
  *                            .set_to_next_positive(tria.begin_active()),
  *                     FI(IteratorFilters::UserFlagSet(), tria.end()));
- * @begin{verbatim}
+ * @verbatim
  * It relies on the fact that if we create an unnamed filtered
  * iterator with a given predicate but no iterator value and assign it
  * the next positive value with respect to this predicate, it returns
  * itself which is then used as the first parameter to the
- * @p{std::distance} function. This procedure is not necessary for the
+ * @p std::distance function. This procedure is not necessary for the
  * end element to this function here, since the past-the-end iterator
  * always satisfies the predicate so that we can assign this value to
  * the filtered iterator directly in the constructor.
  *
  * Finally, the following loop only assembles the matrix on cells with
  * subdomain id equal to three:
- * @begin{verbatim}
+ * @verbatim
  * FilteredIterator<typename Triangulation<dim>::active_cell_iterator>
  *   cell (FilteredIterator::SubdomainEqualTo(3)),
  *   endc (FilteredIterator::SubdomainEqualTo(3), tria.end());
  * cell.set_to_next_positive (tria.begin_active());
  * for (; cell!=endc; ++cell)
  *   assemble_local_matrix (cell);
- * @end{verbatim}
+ * @endverbatim
  *
  * Since comparison between filtered and unfiltered iterators is
- * defined, we could as well have let the @p{endc} variable in the
+ * defined, we could as well have let the @p endc variable in the
  * last example be of type
  * @p{Triangulation<dim>::active_cell_iterator} since it is unchanged
  * and its value does not depend on the filter.
@@ -434,7 +434,7 @@ class FilteredIterator : public BaseIterator
 
                                     /**
                                      * Search for the next iterator
-                                     * from @p{bi} onwards that
+                                     * from @p bi onwards that
                                      * satisfies the predicate of
                                      * this object and assign it to
                                      * this object.
@@ -451,7 +451,7 @@ class FilteredIterator : public BaseIterator
     
                                     /**
                                      * As above, but search for the
-                                     * previous iterator from @p{bi}
+                                     * previous iterator from @p bi
                                      * backwards that satisfies the
                                      * predicate of this object and
                                      * assign it to this object.
index 2303ba6dce8375207bcfff3fa7321fe7a4eaf8cf..becba6d22e79808814bd99c2011e36bdb9468055 100644 (file)
@@ -130,7 +130,7 @@ struct GeometryInfo
                                      *
                                      * For example, in 2D the layout of
                                      * a cell is as follows:
-                                     * @begin{verbatim}
+                                     * @verbatim
                                      * .      2
                                      * .   3-->--2
                                      * .   |     |
@@ -138,20 +138,20 @@ struct GeometryInfo
                                      * .   |     |
                                      * .   0-->--1
                                      * .      0
-                                     * @end{verbatim}
+                                     * @endverbatim
                                      * Vertices and faces are indicated
                                      * with their numbers, faces also with
                                      * their directions.
                                      *
                                      * Now, when refined, the layout is
                                      * like this:
-                                     * @begin{verbatim}
+                                     * @verbatim
                                      * *--*--*
                                      * | 3|2 |
                                      * *--*--*
                                      * | 0|1 |
                                      * *--*--*
-                                     * @end{verbatim}
+                                     * @endverbatim
                                      *
                                      * Thus, the child cells on face zero
                                      * are (ordered in the direction of the
@@ -162,7 +162,7 @@ struct GeometryInfo
                                      * the exact order of the
                                      * children is laid down in the
                                      * documentation of the
-                                     * @ref{Triangulation} class.
+                                     * Triangulation class.
                                      * However, it must be noted that
                                      * this class and function only
                                      * deals with faces in standard
@@ -193,12 +193,12 @@ struct GeometryInfo
 
                                     /**
                                      * Return the position of the
-                                     * @p{i}th vertex on the unit
+                                     * @p ith vertex on the unit
                                      * cell. The order of vertices is
                                      * the canonical one in deal.II,
                                      * as described in the
                                      * documentation of the
-                                     * @ref{Triangulation} class.
+                                     * Triangulation class.
                                      */
     static Point<dimension> unit_cell_vertex (const unsigned int vertex);
 
@@ -206,7 +206,7 @@ struct GeometryInfo
                                      * Report, for @p{vertex=0,1} the
                                      * indices of the two vertices
                                      * adjacent to the line with
-                                     * index @p{line} among the lines
+                                     * index @p line among the lines
                                      * forming this cell. In 1d, the
                                      * only line is the cell itself,
                                      * while in 2d and 3d there are 4
@@ -215,7 +215,7 @@ struct GeometryInfo
                                      * The positions of these
                                      * vertices in the unit cell can
                                      * be obtained using the
-                                     * @p{unit_cell_vertex} function.
+                                     * @p unit_cell_vertex function.
                                      *
                                      * The order of the lines, as
                                      * well as their direction (which
@@ -224,14 +224,14 @@ struct GeometryInfo
                                      * vertex on a line) is the
                                      * canonical one in deal.II, as
                                      * described in the documentation
-                                     * of the @ref{Triangulation}
+                                     * of the Triangulation
                                      * class.
                                      */
     static unsigned int vertices_adjacent_to_line (const unsigned int line,
                                                   const unsigned int vertex);
 
                                     /**
-                                     * Given a point @p{p} in unit
+                                     * Given a point @p p in unit
                                      * coordinates, return the number
                                      * of the child cell in which it
                                      * would lie in. If the point
@@ -243,12 +243,12 @@ struct GeometryInfo
                                      *
                                      * The order of child cells is
                                      * described the documentation of
-                                     * the @ref{Triangulation} class.
+                                     * the Triangulation class.
                                      */
     static unsigned int child_cell_from_point (const Point<dimension> &p);
 
                                     /**
-                                     * Given coordinates @p{p} on the
+                                     * Given coordinates @p p on the
                                      * unit cell, return the values
                                      * of the coordinates of this
                                      * point in the coordinate system
@@ -301,9 +301,9 @@ struct GeometryInfo
  * faces.
  *
  * This class contains as static members information on vertices and
- * faces of a @p{dim}-dimensional grid cell. The interface is the same
+ * faces of a @p dim-dimensional grid cell. The interface is the same
  * for all dimensions. If a value is of no use in a low dimensional
- * cell, it is (correctly) set to zero, e.g. @p{subfaces_per_cell} in
+ * cell, it is (correctly) set to zero, e.g. @p subfaces_per_cell in
  * 1d.
  *
  * This information should always replace hard-coded numbers of
@@ -349,7 +349,7 @@ struct GeometryInfo<0>
                                      * number (in the hope that a compiler
                                      * may warn when it sees constructs like
                                      * @p{for (i=0; i<vertices_per_face; ++i)},
-                                     * at least if @p{i} is an @p{unsigned int}.
+                                     * at least if @p i is an @p{unsigned int}.
                                      */
     static const unsigned int vertices_per_face = 0;
 
@@ -387,9 +387,9 @@ struct GeometryInfo<0>
  * Topological description of one dimensional cells.
  *
  * This class contains as static members information on vertices and
- * faces of a @p{dim}-dimensional grid cell. The interface is the same
+ * faces of a @p dim-dimensional grid cell. The interface is the same
  * for all dimensions. If a value is of no use in a low dimensional
- * cell, it is (correctly) set to zero, e.g. @p{subfaces_per_cell} in
+ * cell, it is (correctly) set to zero, e.g. @p subfaces_per_cell in
  * 1d.
  *
  * This information should always replace hard-coded numbers of
@@ -435,7 +435,7 @@ struct GeometryInfo<1>
                                      * number (in the hope that a compiler
                                      * may warn when it sees constructs like
                                      * @p{for (i=0; i<vertices_per_face; ++i)},
-                                     * at least if @p{i} is an @p{unsigned int}.
+                                     * at least if @p i is an @p{unsigned int}.
                                      */
     static const unsigned int vertices_per_face = 1;
 
@@ -504,7 +504,7 @@ struct GeometryInfo<1>
                                      *
                                      * For example, in 2D the layout of
                                      * a cell is as follows:
-                                     * @begin{verbatim}
+                                     * @verbatim
                                      * .      2
                                      * .   3-->--2
                                      * .   |     |
@@ -512,20 +512,20 @@ struct GeometryInfo<1>
                                      * .   |     |
                                      * .   0-->--1
                                      * .      0
-                                     * @end{verbatim}
+                                     * @endverbatim
                                      * Vertices and faces are indicated
                                      * with their numbers, faces also with
                                      * their directions.
                                      *
                                      * Now, when refined, the layout is
                                      * like this:
-                                     * @begin{verbatim}
+                                     * @verbatim
                                      * *--*--*
                                      * | 3|2 |
                                      * *--*--*
                                      * | 0|1 |
                                      * *--*--*
-                                     * @end{verbatim}
+                                     * @endverbatim
                                      *
                                      * Thus, the child cells on face zero
                                      * are (ordered in the direction of the
@@ -536,7 +536,7 @@ struct GeometryInfo<1>
                                      * the exact order of the
                                      * children is laid down in the
                                      * documentation of the
-                                     * @ref{Triangulation}
+                                     * Triangulation
                                      * class. However, it must be
                                      * noted that this class and
                                      * function only deals with faces
@@ -568,12 +568,12 @@ struct GeometryInfo<1>
 
                                     /**
                                      * Return the position of the
-                                     * @p{i}th vertex on the unit
+                                     * @p ith vertex on the unit
                                      * cell. The order of vertices is
                                      * the canonical one in deal.II,
                                      * as described in the
                                      * documentation of the
-                                     * @ref{Triangulation} class.
+                                     * Triangulation class.
                                      */
     static Point<1> unit_cell_vertex (const unsigned int vertex);
 
@@ -581,7 +581,7 @@ struct GeometryInfo<1>
                                      * Report, for @p{vertex=0,1} the
                                      * indices of the two vertices
                                      * adjacent to the line with
-                                     * index @p{line} among the lines
+                                     * index @p line among the lines
                                      * forming this cell. In 1d, the
                                      * only line is the cell itself,
                                      * while in 2d and 3d there are 4
@@ -590,7 +590,7 @@ struct GeometryInfo<1>
                                      * The positions of these
                                      * vertices in the unit cell can
                                      * be obtained using the
-                                     * @p{unit_cell_vertex} function.
+                                     * @p unit_cell_vertex function.
                                      *
                                      * The order of the lines, as
                                      * well as their direction (which
@@ -599,14 +599,14 @@ struct GeometryInfo<1>
                                      * vertex on a line) is the
                                      * canonical one in deal.II, as
                                      * described in the documentation
-                                     * of the @ref{Triangulation}
+                                     * of the Triangulation
                                      * class.
                                      */
     static unsigned int vertices_adjacent_to_line (const unsigned int line,
                                                   const unsigned int vertex);
 
                                     /**
-                                     * Given a point @p{p} in unit
+                                     * Given a point @p p in unit
                                      * coordinates, return the number
                                      * of the child cell in which it
                                      * would lie in. If the point
@@ -618,12 +618,12 @@ struct GeometryInfo<1>
                                      *
                                      * The order of child cells is
                                      * described the documentation of
-                                     * the @ref{Triangulation} class.
+                                     * the Triangulation class.
                                      */
     static unsigned int child_cell_from_point (const Point<1> &p);
 
                                     /**
-                                     * Given coordinates @p{p} on the
+                                     * Given coordinates @p p on the
                                      * unit cell, return the values
                                      * of the coordinates of this
                                      * point in the coordinate system
@@ -672,9 +672,9 @@ struct GeometryInfo<1>
  * Topological description of two dimensional cells.
  *
  * This class contains as static members information on vertices and
- * faces of a @p{dim}-dimensional grid cell. The interface is the same
+ * faces of a @p dim-dimensional grid cell. The interface is the same
  * for all dimensions. If a value is of no use in a low dimensional
- * cell, it is (correctly) set to zero, e.g. @p{subfaces_per_cell} in
+ * cell, it is (correctly) set to zero, e.g. @p subfaces_per_cell in
  * 1d.
  *
  * This information should always replace hard-coded numbers of
@@ -720,7 +720,7 @@ struct GeometryInfo<2>
                                      * number (in the hope that a compiler
                                      * may warn when it sees constructs like
                                      * @p{for (i=0; i<vertices_per_face; ++i)},
-                                     * at least if @p{i} is an @p{unsigned int}.
+                                     * at least if @p i is an @p{unsigned int}.
                                      */
     static const unsigned int vertices_per_face = 2;
 
@@ -788,7 +788,7 @@ struct GeometryInfo<2>
                                      *
                                      * For example, in 2D the layout of
                                      * a cell is as follows:
-                                     * @begin{verbatim}
+                                     * @verbatim
                                      * .      2
                                      * .   3-->--2
                                      * .   |     |
@@ -796,20 +796,20 @@ struct GeometryInfo<2>
                                      * .   |     |
                                      * .   0-->--1
                                      * .      0
-                                     * @end{verbatim}
+                                     * @endverbatim
                                      * Vertices and faces are indicated
                                      * with their numbers, faces also with
                                      * their directions.
                                      *
                                      * Now, when refined, the layout is
                                      * like this:
-                                     * @begin{verbatim}
+                                     * @verbatim
                                      * *--*--*
                                      * | 3|2 |
                                      * *--*--*
                                      * | 0|1 |
                                      * *--*--*
-                                     * @end{verbatim}
+                                     * @endverbatim
                                      *
                                      * Thus, the child cells on face zero
                                      * are (ordered in the direction of the
@@ -820,7 +820,7 @@ struct GeometryInfo<2>
                                      * the exact order of the
                                      * children is laid down in the
                                      * documentation of the
-                                     * @ref{Triangulation}
+                                     * Triangulation
                                      * class. However, it must be
                                      * noted that this class and
                                      * function only deals with faces
@@ -853,12 +853,12 @@ struct GeometryInfo<2>
 
                                     /**
                                      * Return the position of the
-                                     * @p{i}th vertex on the unit
+                                     * @p ith vertex on the unit
                                      * cell. The order of vertices is
                                      * the canonical one in deal.II,
                                      * as described in the
                                      * documentation of the
-                                     * @ref{Triangulation} class.
+                                     * Triangulation class.
                                      */
     static Point<2> unit_cell_vertex (const unsigned int i);
 
@@ -866,7 +866,7 @@ struct GeometryInfo<2>
                                      * Report, for @p{vertex=0,1} the
                                      * indices of the two vertices
                                      * adjacent to the line with
-                                     * index @p{line} among the lines
+                                     * index @p line among the lines
                                      * forming this cell. In 1d, the
                                      * only line is the cell itself,
                                      * while in 2d and 3d there are 4
@@ -875,7 +875,7 @@ struct GeometryInfo<2>
                                      * The positions of these
                                      * vertices in the unit cell can
                                      * be obtained using the
-                                     * @p{unit_cell_vertex} function.
+                                     * @p unit_cell_vertex function.
                                      *
                                      * The order of the lines, as
                                      * well as their direction (which
@@ -884,14 +884,14 @@ struct GeometryInfo<2>
                                      * vertex on a line) is the
                                      * canonical one in deal.II, as
                                      * described in the documentation
-                                     * of the @ref{Triangulation}
+                                     * of the Triangulation
                                      * class.
                                      */
     static unsigned int vertices_adjacent_to_line (const unsigned int line,
                                                   const unsigned int vertex);
 
                                     /**
-                                     * Given a point @p{p} in unit
+                                     * Given a point @p p in unit
                                      * coordinates, return the number
                                      * of the child cell in which it
                                      * would lie in. If the point
@@ -903,13 +903,13 @@ struct GeometryInfo<2>
                                      *
                                      * The order of child cells is
                                      * described the documentation of
-                                     * the @ref{Triangulation} class.
+                                     * the Triangulation class.
                                      */
     static unsigned int child_cell_from_point (const Point<2> &p);
 
 
                                     /**
-                                     * Given coordinates @p{p} on the
+                                     * Given coordinates @p p on the
                                      * unit cell, return the values
                                      * of the coordinates of this
                                      * point in the coordinate system
@@ -958,9 +958,9 @@ struct GeometryInfo<2>
  * Topological description of three dimensional cells.
  *
  * This class contains as static members information on vertices and
- * faces of a @p{dim}-dimensional grid cell. The interface is the same
+ * faces of a @p dim-dimensional grid cell. The interface is the same
  * for all dimensions. If a value is of no use in a low dimensional
- * cell, it is (correctly) set to zero, e.g. @p{subfaces_per_cell} in
+ * cell, it is (correctly) set to zero, e.g. @p subfaces_per_cell in
  * 1d.
  *
  * This information should always replace hard-coded numbers of
@@ -1006,7 +1006,7 @@ struct GeometryInfo<3>
                                      * number (in the hope that a compiler
                                      * may warn when it sees constructs like
                                      * @p{for (i=0; i<vertices_per_face; ++i)},
-                                     * at least if @p{i} is an @p{unsigned int}.
+                                     * at least if @p i is an @p{unsigned int}.
                                      */
     static const unsigned int vertices_per_face = 4;
 
@@ -1074,7 +1074,7 @@ struct GeometryInfo<3>
                                      *
                                      * For example, in 2D the layout of
                                      * a cell is as follows:
-                                     * @begin{verbatim}
+                                     * @verbatim
                                      * .      2
                                      * .   3-->--2
                                      * .   |     |
@@ -1082,20 +1082,20 @@ struct GeometryInfo<3>
                                      * .   |     |
                                      * .   0-->--1
                                      * .      0
-                                     * @end{verbatim}
+                                     * @endverbatim
                                      * Vertices and faces are indicated
                                      * with their numbers, faces also with
                                      * their directions.
                                      *
                                      * Now, when refined, the layout is
                                      * like this:
-                                     * @begin{verbatim}
+                                     * @verbatim
                                      * *--*--*
                                      * | 3|2 |
                                      * *--*--*
                                      * | 0|1 |
                                      * *--*--*
-                                     * @end{verbatim}
+                                     * @endverbatim
                                      *
                                      * Thus, the child cells on face zero
                                      * are (ordered in the direction of the
@@ -1106,7 +1106,7 @@ struct GeometryInfo<3>
                                      * the exact order of the
                                      * children is laid down in the
                                      * documentation of the
-                                     * @ref{Triangulation}
+                                     * Triangulation
                                      * class. However, it must be
                                      * noted that this class and
                                      * function only deals with faces
@@ -1136,12 +1136,12 @@ struct GeometryInfo<3>
                                            const unsigned int subface);
                                     /**
                                      * Return the position of the
-                                     * @p{i}th vertex on the unit
+                                     * @p ith vertex on the unit
                                      * cell. The order of vertices is
                                      * the canonical one in deal.II,
                                      * as described in the
                                      * documentation of the
-                                     * @ref{Triangulation} class.
+                                     * Triangulation class.
                                      */
     static Point<3> unit_cell_vertex (const unsigned int i);
 
@@ -1149,7 +1149,7 @@ struct GeometryInfo<3>
                                      * Report, for @p{vertex=0,1} the
                                      * indices of the two vertices
                                      * adjacent to the line with
-                                     * index @p{line} among the lines
+                                     * index @p line among the lines
                                      * forming this cell. In 1d, the
                                      * only line is the cell itself,
                                      * while in 2d and 3d there are 4
@@ -1158,7 +1158,7 @@ struct GeometryInfo<3>
                                      * The positions of these
                                      * vertices in the unit cell can
                                      * be obtained using the
-                                     * @p{unit_cell_vertex} function.
+                                     * @p unit_cell_vertex function.
                                      *
                                      * The order of the lines, as
                                      * well as their direction (which
@@ -1167,14 +1167,14 @@ struct GeometryInfo<3>
                                      * vertex on a line) is the
                                      * canonical one in deal.II, as
                                      * described in the documentation
-                                     * of the @ref{Triangulation}
+                                     * of the Triangulation
                                      * class.
                                      */
     static unsigned int vertices_adjacent_to_line (const unsigned int line,
                                                   const unsigned int vertex);
 
                                     /**
-                                     * Given a point @p{p} in unit
+                                     * Given a point @p p in unit
                                      * coordinates, return the number
                                      * of the child cell in which it
                                      * would lie in. If the point
@@ -1186,13 +1186,13 @@ struct GeometryInfo<3>
                                      *
                                      * The order of child cells is
                                      * described the documentation of
-                                     * the @ref{Triangulation} class.
+                                     * the Triangulation class.
                                      */
     static unsigned int child_cell_from_point (const Point<3> &p);
 
 
                                     /**
-                                     * Given coordinates @p{p} on the
+                                     * Given coordinates @p p on the
                                      * unit cell, return the values
                                      * of the coordinates of this
                                      * point in the coordinate system
@@ -1245,9 +1245,9 @@ struct GeometryInfo<3>
  * equation timestep after timestep in a (d+1)-dimensional space).
  *
  * This class contains as static members information on vertices and
- * faces of a @p{dim}-dimensional grid cell. The interface is the same
+ * faces of a @p dim-dimensional grid cell. The interface is the same
  * for all dimensions. If a value is of no use in a low dimensional
- * cell, it is (correctly) set to zero, e.g. @p{subfaces_per_cell} in
+ * cell, it is (correctly) set to zero, e.g. @p subfaces_per_cell in
  * 1d.
  *
  * This information should always replace hard-coded numbers of
@@ -1293,7 +1293,7 @@ struct GeometryInfo<4>
                                      * number (in the hope that a compiler
                                      * may warn when it sees constructs like
                                      * @p{for (i=0; i<vertices_per_face; ++i)},
-                                     * at least if @p{i} is an @p{unsigned int}.
+                                     * at least if @p i is an @p{unsigned int}.
                                      */
     static const unsigned int vertices_per_face = 8;
 
index c8698a9027efea527dc1cda7ae0740044a7b0d3b..d72cbc0968588609b7b1d4a26f6c308b16f882a8 100644 (file)
@@ -29,8 +29,8 @@ template <typename number> class SparseMatrix;
  * This class offers triangulations of some standard domains such as hypercubes,
  * hyperball and the like. Following is a list of domains that can be generated
  * by the functions of this class:
- * @begin{itemize}
- *    @item Hypercube triangulations: a hypercube triangulation is a
+ * <ul>
+ *    <li> Hypercube triangulations: a hypercube triangulation is a
  *       domain which is the tensor product of an interval $[a,b]$ in
  *       the given number of spatial dimensions. If you want to create such
  *       a domain, which is a common test case for model problems, call
@@ -42,21 +42,21 @@ template <typename number> class SparseMatrix;
  *       If you want the hypercube subdivided a certain number of
  *       times (and if this is not achievable by hierarchic
  *       refinement, for example 3 times), then the
- *       @p{subdivided_hyper_cube} function may be what you are
+ *       @p subdivided_hyper_cube function may be what you are
  *       looking for.
  *
- *    @item Rectangular coordinate-parallel domains as a generalization
+ *    <li> Rectangular coordinate-parallel domains as a generalization
  *      of hypercubes are generated by
  *      GridGenerator::hyper_rectangle (tria, p1, p2), with two
- *      opposite corner points @p{p1} and @p{p2}.
+ *      opposite corner points @p p1 and @p p2.
  *
- *    @item Rectangular coordinate-parallel domains with different numbers of
+ *    <li> Rectangular coordinate-parallel domains with different numbers of
  *     cells in each coordinate direction are generated by 
  *      GridGenerator::subdivided_hyper_rectangle
  *     (tria, int[dim] repetitions, p1, p2, colorize), with two
- *      opposite corner points @p{p1} and @p{p2}.
+ *      opposite corner points @p p1 and @p p2.
  *
- *    @item Generalized L-shape domain:
+ *    <li> Generalized L-shape domain:
  *      using the GridGenerator::hyper_L (tria, a,b) function produces
  *      the hypercube with the interval $[a,b]$ without the hypercube
  *      made out of the interval $[(a+b)/2,b]$. Let, for example, be $a=-1$
@@ -64,9 +64,9 @@ template <typename number> class SparseMatrix;
  *      $[-1,1]^2 - [0,1]^2$. To create a hyper-L in one dimension results in
  *      an error. The function is also implemented for three space dimensions.
  *
- *    @item Hyper ball:
+ *    <li> Hyper ball:
  *      You get the circle or ball (or generalized: hyperball) around
- *      origin @p{p} and with radius @p{r} by calling
+ *      origin @p p and with radius @p r by calling
  *      GridGenerator::hyper_ball (tria, p, r). The circle is
  *      triangulated by five cells, the ball by seven cells. The
  *      diameter of the center cell is chosen so that the aspect ratio
@@ -78,9 +78,9 @@ template <typename number> class SparseMatrix;
  *      to the triangulation object you passed to this function if you later want
  *      the triangulation to be refined at the outer boundaries.
  *
- *    @item Half Hyper ball:
+ *    <li> Half Hyper ball:
  *      You get half of the circle generated by Hyper ball.
- *      with center @p{p} and with radius @p{r} by calling
+ *      with center @p p and with radius @p r by calling
  *      GridGenerator::half_hyper_ball (tria, p, r). The half-circle is 
  *      triangulated by four cells. The diameter of the center cell is
  *      chosen to be the same as for the Hyper ball class. 
@@ -92,7 +92,7 @@ template <typename number> class SparseMatrix;
  *      the triangulation to be refined at the outer boundaries. The class
  *      HalfHyperBallBoundary will provide a boundary object.
  *
- *    @item Hyper shell: A hyper shell is the region between two hyper
+ *    <li> Hyper shell: A hyper shell is the region between two hyper
  *      sphere with the same origin. Therefore, it is a ring in two
  *      spatial dimensions. To triangulation it, call the function
  *      GridGenerator::hyper_shell (tria, origin, inner_radius, outer_radius, N),
@@ -100,7 +100,7 @@ template <typename number> class SparseMatrix;
  *      the inner and outer radius of the two spheres are given as
  *      shown.
  *
- *      The parameter @p{N} denotes how many cells are to be used for
+ *      The parameter @p N denotes how many cells are to be used for
  *      this coarse triangulation. It defaults to zero, which tells
  *      the function to chose the number itself; this, then, is done
  *      such that the aspect ration of the resulting cells is as small
@@ -110,31 +110,31 @@ template <typename number> class SparseMatrix;
  *      used in the radial direction.
  *
  *      You need to attach a boundary object to the triangulation. A
- *      suitable boundary class is provided as @ref{HyperSphereBoundary}
+ *      suitable boundary class is provided as HyperSphereBoundary
  *      in the library.
  *
- *    @item Half shells: This is a variant of the preceeding domain,
+ *    <li> Half shells: This is a variant of the preceeding domain,
  *      where only one half of the shell is taken, defined by the first
  *      coordinate having non-negative values. This class is useful in
  *      computations with rotational symmetry, as then a 3d shell can be
  *      modeled by a 2d half shell.
  *
- *    @item Slit domain: The slit domain is a variant of the hyper cube
+ *    <li> Slit domain: The slit domain is a variant of the hyper cube
  *      domain. In two spatial dimensions, it is a square into which a slit
  *      is sawed; if the initial square is though to be composed of four
  *      smaller squares, then two of them are not connected even though
  *      they are neighboring each other. Analogously, into the cube in
  *      three spatial dimensions, a half-plane is sawed, disconnecting four
  *      of the eight child-cubes from one of their neighbors.
- * @end{itemize}
+ * </ul>
  *
- * Some of these functions receive a flag @p{colorize}. If this is
+ * Some of these functions receive a flag @p colorize. If this is
  * set, parts of the boundary receive different boundary numbers,
  * allowing them to be distinguished by application programs. See the
  * documentation of the functions for details.
  * 
  * Additionally this class provides a function
- * (@p{laplace_transformation}) that smoothly transforms a grid
+ * (@p laplace_transformation) that smoothly transforms a grid
  * according to given new boundary points. This can be used to
  * transform (simple-shaped) grids to a more complicated ones, like a
  * shell onto a grid of an airfoil, for example.
@@ -169,12 +169,12 @@ class GridGenerator
                            const double        right= 1.);
 
                                     /**
-                                     * Same as @ref{hyper_cube}, but
+                                     * Same as hyper_cube(), but
                                      * with the difference that not
                                      * only one cell is created but
                                      * each coordinate direction is
                                      * subdivided into
-                                     * @p{repetitions} cells. Thus,
+                                     * @p repetitions cells. Thus,
                                      * the number of cells filling
                                      * the given volume is
                                      * @p{repetitions^d}.
@@ -189,18 +189,18 @@ class GridGenerator
                                      * Create a coordinate-parallel
                                      * parallelepiped from the two
                                      * diagonally opposite corner
-                                     * points @p{p1} and @p{p2}.
+                                     * points @p p1 and @p p2.
                                      *
-                                     * If the @p{colorize} flag is
+                                     * If the @p colorize flag is
                                      * set, the
-                                     * @p{boundary_indicator}s of the
+                                     * @p boundary_indicators of the
                                      * surfaces are assigned, such
                                      * that the lower one in
-                                     * @p{x}-direction is 0, the
+                                     * @p x-direction is 0, the
                                      * upper one is 1. The indicators
                                      * for the surfaces in
-                                     * @p{y}-direction are 2 and 3,
-                                     * the ones for @p{z} are 4 and
+                                     * @p y-direction are 2 and 3,
+                                     * the ones for @p z are 4 and
                                      * 5.
                                      * 
                                      * The triangulation needs to be
@@ -217,8 +217,8 @@ class GridGenerator
                                      * Create a coordinate-parallel
                                      * parallelepiped from the two
                                      * diagonally opposite corner
-                                     * points @p{p1} and @p{p2}. In
-                                     * dimension @p{i},
+                                     * points @p p1 and @p p2. In
+                                     * dimension @p i,
                                      * @p{repetitions[i]} cells are
                                      * generated.
                                      * 
@@ -230,21 +230,21 @@ class GridGenerator
                                      * directions. The minimum number
                                      * of subdivisions in each
                                      * direction is
-                                     * 1. @p{repetitions} is a list
+                                     * 1. @p repetitions is a list
                                      * of integers denoting the
                                      * number of subdivisions in each
                                      * coordinate direction.
                                      * 
-                                     * If the @p{colorize} flag is
+                                     * If the @p colorize flag is
                                      * set, the
-                                     * @p{boundary_indicator}s of the
+                                     * @p boundary_indicators of the
                                      * surfaces are assigned, such
                                      * that the lower one in
-                                     * @p{x}-direction is 0, the
+                                     * @p x-direction is 0, the
                                      * upper one is 1. The indicators
                                      * for the surfaces in
-                                     * @p{y}-direction are 2 and 3,
-                                     * the ones for @p{z} are 4 and
+                                     * @p y-direction are 2 and 3,
+                                     * the ones for @p z are 4 and
                                      * 5.
                                      */
     template <int dim>
@@ -263,7 +263,7 @@ class GridGenerator
                                      * lower and upper bound of the
                                      * inner hypercube in all
                                      * coordinate directions.
-                                     * @p{thickness} marks the size of
+                                     * @p thickness marks the size of
                                      * the layer cells.
                                      *
                                      * If the flag colorize is set,
@@ -357,8 +357,8 @@ class GridGenerator
                                      * from @p{x=-half_length} to
                                      * @p{x=+half_length} and its
                                      * projection into the
-                                     * @p{yz}-plane is a circle of
-                                     * radius @p{radius}.
+                                     * @p yz-plane is a circle of
+                                     * radius @p radius.
                                      *
                                      * The boundaries are colored
                                      * according to the following
@@ -374,7 +374,7 @@ class GridGenerator
                                     /**
                                      * Projection of the
                                      * three-dimensional cylinder
-                                     * into the @p{xy}-plane.
+                                     * into the @p xy-plane.
                                      * Therefore, this is simply a square.
                                      *
                                      * Coloring is like in 3D.
@@ -547,7 +547,7 @@ class GridGenerator
                                      * Currently, only a two-dimensional 
                                      * version is implemented. The appropriate
                                      * boundary class is 
-                                     * @ref{HalfHyperBallBoundary}.
+                                     * HalfHyperBallBoundary.
                                      */
     static void half_hyper_ball (Triangulation<2> &tria,
                                 const Point<2>   &center = Point<2>(),
@@ -600,17 +600,17 @@ class GridGenerator
 
                                     /**
                                      * This function transformes the
-                                     * @p{Triangulation} @p{tria}
+                                     * @p Triangulation @p tria
                                      * smoothly to a domain that is
                                      * described by the boundary
                                      * points in the map
-                                     * @p{new_points}. This map maps
+                                     * @p new_points. This map maps
                                      * the point indices to the
                                      * boundary points in the
                                      * transformed domain.
                                      *
                                      * Note, that the
-                                     * @p{Triangulation} is changed
+                                     * @p Triangulation is changed
                                      * in-place, therefore you don't
                                      * need to keep two
                                      * triangulations, but the given
@@ -653,8 +653,8 @@ class GridGenerator
   private:
                                     /**
                                      * Perform the action specified
-                                     * by the @p{colorize} flag of
-                                     * the @ref{hyper_rectangle}
+                                     * by the @p colorize flag of
+                                     * the hyper_rectangle()
                                      * function of this class.
                                      */
     template <int dim>
@@ -668,9 +668,9 @@ class GridGenerator
     
                                     /**
                                      * Perform the action specified
-                                     * by the @p{colorize} flag of
+                                     * by the @p colorize flag of
                                      * the
-                                     * @ref{subdivided_hyper_rectangle}
+                                     * subdivided_hyper_rectangle()
                                      * function of this class. This
                                      * function is singled out
                                      * because it is dimension
@@ -697,9 +697,9 @@ class GridGenerator
 
                                     /**
                                      * Solve the Laplace equation for
-                                     * @p{laplace_transformation}
+                                     * @p laplace_transformation
                                      * function for one of the
-                                     * @p{dim} space
+                                     * @p dim space
                                      * dimensions. Externalized into
                                      * a function of its own in order
                                      * to allow parallel execution.
index e898193725ea6b1ab40175f5a86cb074e27155fe..e27c6d2c5a258937d0e016ca6f750cf59ae62512 100644 (file)
@@ -34,7 +34,7 @@ class SubCellData;
  * format for grid data. Any numerical data after the block of
  * topological information is ignored.
  *
- * Since the coarse mesh fed into a @p{Triangulation} object cannot
+ * Since the coarse mesh fed into a @p Triangulation object cannot
  * have hanging nodes, strange things will happen if the input file
  * has them. This is due to the fact that most mesh description
  * formats do not store neighborship information between cells, so the
@@ -50,7 +50,7 @@ class SubCellData;
  *
  * Note: if you experience unexpected problems with the use of this
  * class, be sure to read the documentation right until the end, and
- * also read the documentation of the @ref{GridReordering} class.
+ * also read the documentation of the GridReordering class.
  *
  * To read grid data, the triangulation to be fed with has to be empty.
  * When giving a file which does not contain the assumed information or
@@ -64,35 +64,35 @@ class SubCellData;
  *
  * Material indicators are accepted to denote the material ID of cells and
  * to denote boundary part indication for lines in 2D. Read the according
- * sections in the documentation of the @ref{Triangulation} class for
+ * sections in the documentation of the Triangulation class for
  * further details.
  *
  *
  * @sect3{Supported input formats}
  *
  * At present, the following input formats are supported:
- * @begin{itemize}
- * @item @p{UCD} (unstructured cell data) format: this format is used
+ * <ul>
+ * <li> @p UCD (unstructured cell data) format: this format is used
  * for grid input as well as data output. If there are data vectors in
  * the input file, they are ignored, as we are only interested in the
  * grid in this class. The exact description of the format can be
  * found in the AVS Explorer manual (see @url{http://www.avs.com}).
- * The @p{UCD} format can be read by the @p{read_ucd} function.
+ * The @p UCD format can be read by the @p read_ucd function.
  *
- * @item @p{DB mesh} format: this format is used by the @p{BAMG} mesh
+ * <li> @p{DB mesh} format: this format is used by the @p BAMG mesh
  * generator (see
  * @url{http://www-rocq.inria.fr/gamma/cdrom/www/bamg/eng.htm}. The
- * documentation of the format in the @p{BAMG} manual is very
+ * documentation of the format in the @p BAMG manual is very
  * incomplete, so we don't actually parse many of the fields of the
  * output since we don't know their meaning, but the data that is read
  * is enough to build up the mesh as intended by the mesh generator.
- * This format can be read by the @p{read_dbmesh} function.
+ * This format can be read by the @p read_dbmesh function.
  *
- * @item @p{XDA} format: this is a rather simple format used by the MGF
+ * <li> @p XDA format: this is a rather simple format used by the MGF
  * code. We don't have an exact specification of the format, but the reader
  * can read in several example files. If the reader does not grok your files,
  * it should be fairly simple to extend it.
- * @end{itemize}
+ * </ul>
  *
  *
  * @sect3{Structure of input grid data. The GridReordering class}
@@ -101,32 +101,32 @@ class SubCellData;
  * list, i.e. for lines in 1d, you have to first give the vertex with
  * the lower coordinate value, then that with the higher coordinate
  * value. For quadrilaterals in two dimensions, the vertex indices in
- * the @p{quad} list have to be such that the vertices are numbered in
+ * the @p quad list have to be such that the vertices are numbered in
  * counter-clockwise sense.
  *
  * In two dimensions, another difficulty occurs, which has to do with the sense
  * of a quadrilateral. A quad consists of four lines which have a direction,
  * which is per definitionem as follows:
- * @begin{verbatim}
+ * @verbatim
  *   3-->--2
  *   |     |
  *   ^     ^
  *   |     |
  *   0-->--1
- * @end{verbatim}
+ * @endverbatim
  * Now, two adjacent cells must have a vertex numbering such that the direction
  * of the common side is the same. For example, the following two quads
- * @begin{verbatim}
+ * @verbatim
  *   3---4---5
  *   |   |   |
  *   0---1---2
- * @end{verbatim}
+ * @endverbatim
  * may be characterised by the vertex numbers @p{(0 1 4 3)} and
  * @p{(1 2 5 4)}, since the middle line would get the direction @p{1->4}
  * when viewed from both cells.  The numbering @p{(0 1 4 3)} and
  * @p{(5 4 1 2)} would not be allowed, since the left quad would give the
  * common line the direction @p{1->4}, while the right one would want
- * to use @p{4->1}, leading to an ambiguity. The @ref{Triangulation}
+ * to use @p{4->1}, leading to an ambiguity. The Triangulation
  * object is capable of detecting this special case, which can be
  * eliminated by rotating the indices of the right quad by
  * two. However, it would not know what to do if you gave the vertex
@@ -141,10 +141,10 @@ class SubCellData;
  * taken care of.
  *
  * For this reason, the @p{read_*} functions of this class that read
- * in grids in various input formats call the @ref{GridReordering}
+ * in grids in various input formats call the GridReordering
  * class to bring the order of vertices that define the cells into an
  * ordering that satisfies the requiremenets of the
- * @ref{Triangulation} class. Be sure to read the documentation of
+ * Triangulation class. Be sure to read the documentation of
  * that class if you experience unexpected problems when reading grids
  * through this class.
  *
@@ -297,7 +297,7 @@ class GridIn
                                      * what actually was created, if
                                      * it is known that the data is
                                      * not correct in some way, but
-                                     * the @ref{Triangulation} class
+                                     * the Triangulation class
                                      * refuses to generate a
                                      * triangulation because of these
                                      * errors. In particular, the
@@ -317,7 +317,7 @@ class GridIn
                                      * respect to neighboring cells
                                      * (see the documentations to
                                      * this class and the
-                                     * @ref{GridReordering} class).
+                                     * GridReordering class).
                                      *
                                      * The output of this function
                                      * consists of vectors for each
index 30da52ffbcd523c7d27e21fc05f1bf2e02d3a74c..afc433efa3b72c6c848fdfa9eb1ba96de07f5890 100644 (file)
@@ -28,7 +28,7 @@ template <int dim> class Mapping;
  * Within this namespace, we define several structures that are used
  * to describe flags that can be given to grid output routines to
  * modify the default outfit of the grids written into a file. See the
- * different subclasses and the documentation of the @ref{GridOut}
+ * different subclasses and the documentation of the GridOut
  * class for more details.
  */
 namespace GridOutFlags
@@ -90,7 +90,7 @@ namespace GridOutFlags
                                        * by this, so you can switch it off
                                        * this way.
                                        *
-                                       * Default: @p{true}.
+                                       * Default: @p true.
                                        */
       bool write_preamble;
       
@@ -109,7 +109,7 @@ namespace GridOutFlags
                                        * to write the triangulation to
                                        * view or print it.
                                        *
-                                       * Default: @p{false}.
+                                       * Default: @p false.
                                        */
       bool write_faces;
       
@@ -139,7 +139,7 @@ namespace GridOutFlags
                                        * the size of the output
                                        * significantly, however.
                                        *
-                                       * Default: @p{false}.
+                                       * Default: @p false.
                                        */
       bool write_cell_numbers;
 
@@ -177,7 +177,7 @@ namespace GridOutFlags
                                       /**
                                        * Enum denoting the possibilities
                                        * whether the scaling should be done
-                                       * such that the given @p{size} equals
+                                       * such that the given @p size equals
                                        * the width or the height of
                                        * the resulting picture.
                                        */
@@ -186,7 +186,7 @@ namespace GridOutFlags
       };
       
                                       /**
-                                       * See above. Default is @p{width}.
+                                       * See above. Default is @p width.
                                        */
       SizeType size_type;
       
@@ -197,7 +197,7 @@ namespace GridOutFlags
                                        * strange unit 1/72 inch. Whether
                                        * this is height or width is
                                        * specified by the flag
-                                       * @p{size_type}.
+                                       * @p size_type.
                                        *
                                        * Default is 300.
                                        */
@@ -211,7 +211,7 @@ namespace GridOutFlags
       
                                       /**
                                        * Should lines with a set
-                                       * @p{user_flag} be drawn in a
+                                       * @p user_flag be drawn in a
                                        * different color (red)?
                                        */
       bool color_lines_on_user_flag;
@@ -225,7 +225,7 @@ namespace GridOutFlags
                                        *
                                        * This is used if the
                                        * mapping used is not the
-                                       * standard @p{MappingQ1}
+                                       * standard @p MappingQ1
                                        * mapping.
                                        */
       unsigned int n_boundary_face_points;
@@ -307,7 +307,7 @@ namespace GridOutFlags
                                        * The format of the cell
                                        * number written is
                                        * @p{level.index}, or simply
-                                       * @p{index}, depending on the
+                                       * @p index, depending on the
                                        * value of the following flag.
                                        */
       bool write_cell_numbers;
@@ -318,14 +318,14 @@ namespace GridOutFlags
                                        * flag determines whether the
                                        * format shall be
                                        * @p{level.index}, or simply
-                                       * @p{index}. If @p{true}, the
+                                       * @p index. If @p true, the
                                        * first format is
-                                       * taken. Default is @p{true}.
+                                       * taken. Default is @p true.
                                        *
                                        * The flag has obviously no
                                        * effect if
-                                       * @p{write_cell_numbers} is
-                                       * @p{false}.
+                                       * @p write_cell_numbers is
+                                       * @p false.
                                        */
       bool write_cell_number_level;
 
@@ -334,7 +334,7 @@ namespace GridOutFlags
                                        * written onto the
                                        * vertices. This is controled
                                        * by the following
-                                       * flag. Default is @p{false}.
+                                       * flag. Default is @p false.
                                        */
       bool write_vertex_numbers;
       
@@ -478,58 +478,58 @@ namespace GridOutFlags
  * the different output functions based on a parameter given, e.g., through
  * a parameter file, thus making user programs invariant of the number and
  * names of the file formats implemented in this class. The main advantage of
- * this class over the @ref{DataOut} class is that it does not have to mess around
- * with actual data vectors and that no @ref{DoFHandler} object is needed to
+ * this class over the DataOut class is that it does not have to mess around
+ * with actual data vectors and that no DoFHandler object is needed to
  * write the pure geometrical information involved here.
  *
  * Available output formats can be found in the functions with names @p{write_...}
  *
  * @sect3{Usage}
  * Usage is simple: either you use the direct form
- * @begin{verbatim}
+ * @verbatim
  *   ofstream output_file("some_filename");
  *   GridOut().write_gnuplot (tria, output_file);
- * @end{verbatim}
+ * @endverbatim
  * if you know which format you want to have, or if you want the format to be
  * a runtime parameter, you can write
- * @begin{verbatim}
+ * @verbatim
  *   GridOut::OutputFormat grid_format =
  *                   GridOut::parse_output_format(get_format_name_from_somewhere());
  *   ofstream output_file("some_filename" + GridOut::default_suffix(output_format));
  *   GridOut().write (tria, output_file, output_format);
- * @end{verbatim}
+ * @endverbatim
  * The function @p{get_output_format_names()} provides a list of possible names of
- * output formats in a string that is understandable by the @ref{ParameterHandler} class.
+ * output formats in a string that is understandable by the ParameterHandler class.
  *
- * Note that here, we have created an unnamed object of type @ref{GridOut} and called
+ * Note that here, we have created an unnamed object of type GridOut and called
  * one of its @p{write_*} functions. This looks like as if the respective function
- * could really be made @p{static}. This was not done in order to allow for
+ * could really be made @p static. This was not done in order to allow for
  * parameters to be passed to the different output functions in a way compatible
  * with the scheme of allowing the right output format to be selected at run-time
- * through the generic @p{write} function.
+ * through the generic @p write function.
  *
  * In order to explain this, consider each function had one or more additional
  * parameters giving the details of output, for example position of the spectator
  * for 3d meshed, line thicknesses, etc. While this would allow each output
  * function any flexibility it needs, it would not allow us to use the generic
- * function @p{write} which is given a parameter determining the output format,
+ * function @p write which is given a parameter determining the output format,
  * since it is impractical to give it a list of parameters for each and every
  * output format supported which it may then pass on to the respective output
  * function.
  *
  * Rather, we have chosen to let each object of this class
- * @ref{GridOut} have a set of parameters for each supported output
- * format. These are collected in structures @ref{GridOutFlags::Eps},
- * @ref{GridOutFlags::Gnuplot}, etc declared in the @ref{GridOutFlags}
+ * GridOut have a set of parameters for each supported output
+ * format. These are collected in structures GridOutFlags::Eps(),
+ * GridOutFlags::Gnuplot(), etc declared in the GridOutFlags
  * namespace, and you can set your preferred flags like this:
- * @begin{verbatim}
+ * @verbatim
  *   GridOut grid_out;
  *   GridOutFlags::Ucd ucd_flags;
  *   ...    // set some fields in ucd_flags
  *   grid_out.set_flags (ucd_flags);
  *   ...
  *   ...    // write some file with data_out
- * @end{verbatim}
+ * @endverbatim
  * The respective output function then use the so-set flags. By default, they
  * are set to reasonable values as described above and in the documentation
  * of the different flags structures. Resetting the flags can
@@ -539,12 +539,12 @@ namespace GridOutFlags
  *
  * The advantage of this approach is that it is possible to change the flags
  * of one or more output formats according to your needs and later use the
- * generic @p{write} function; the actual output function then called will
+ * generic @p write function; the actual output function then called will
  * use the flags as set before.
  *
  * Note that some of the structures describing the flags of the different
  * output formats are empty since the respective format does not support
- * any flags. The structure and the @p{set_flags} function are provided
+ * any flags. The structure and the @p set_flags function are provided
  * anyway. Note also that some of the structures may differ between the
  * dimensions supported by this class; they then have a template parameter,
  * as usual.
@@ -603,9 +603,9 @@ class GridOut
                                      * this feature is the following:
                                      * if you use the GNUPLOT
                                      * command (for a 2d grid here)
-                                     * @begin{verbatim}
+                                     * @verbatim
                                      * splot [:][:][2.5:3.5] "grid_file.gnuplot" *
-                                     * @end{verbatim}
+                                     * @endverbatim
                                      * then the
                                      * whole x- and y-range will be
                                      * plotted, i.e. the whole grid,
@@ -621,7 +621,7 @@ class GridOut
                                      * plots of the different levels
                                      * of grid.
                                      *
-                                     * @p{mapping} is a pointer to a
+                                     * @p mapping is a pointer to a
                                      * mapping used for the
                                      * transformation of cells at the
                                      * boundary. If zero, then use
@@ -631,7 +631,7 @@ class GridOut
                                      * flags controlling the output
                                      * can be found in the
                                      * documentation of the
-                                     * @ref{GridOutFlags::Gnuplot} class.
+                                     * GridOutFlags::Gnuplot() class.
                                      */
     template <int dim>
     void write_gnuplot (const Triangulation<dim> &tria,
@@ -659,7 +659,7 @@ class GridOut
                                      * only, you can decide through
                                      * additional flags (see below,
                                      * and the documentation of the
-                                     * @ref{GridOutFlags::Ucd} class)
+                                     * GridOutFlags::Ucd() class)
                                      * whether boundary faces with
                                      * non-zero boundary indicator
                                      * shall be written to the file
@@ -679,7 +679,7 @@ class GridOut
                                      * flags controlling the output
                                      * can be found in the
                                      * documentation of the
-                                     * @ref{GridOut::Ucd} class.
+                                     * GridOut::Ucd() class.
                                      */
     template <int dim>
     void write_ucd (const Triangulation<dim> &tria,
@@ -702,7 +702,7 @@ class GridOut
                                      * shall fit into is determined
                                      * by the output flags (see
                                      * below, and the documentation
-                                     * of the @ref{GridOutFlags::Eps}
+                                     * of the GridOutFlags::Eps()
                                      * class).
                                      *
                                      * The bounding box is close to
@@ -716,16 +716,16 @@ class GridOut
                                      * of which the default is 300.
                                      *
                                      * The flag 
-                                     * @p{color_lines_on_user_flag}
+                                     * @p color_lines_on_user_flag
                                      * allows to draw lines with the
-                                     * @p{user_flag} set to be drawn in
+                                     * @p user_flag set to be drawn in
                                      * red. The colors black and red
-                                     * are defined as @p{b} and @p{r} in
+                                     * are defined as @p b and @p r in
                                      * the preamble of the output
                                      * file and can be changed there
                                      * according to need.
                                      *
-                                     * @p{mapping} is a pointer to a
+                                     * @p mapping is a pointer to a
                                      * mapping used for the
                                      * transformation of cells at the
                                      * boundary. If zero, then use
@@ -735,7 +735,7 @@ class GridOut
                                      * flags controlling the output
                                      * can be found in the
                                      * documentation of the
-                                     * @ref{GridOutFlags::Eps}
+                                     * GridOutFlags::Eps()
                                      * class. Especially the
                                      * viewpoint for three
                                      * dimensional grids is of
@@ -785,7 +785,7 @@ class GridOut
                    std::ostream             &out,
                    const Mapping<dim>       *mapping=0);
                                     /**
-                                     * Write data and grid to @p{out} according
+                                     * Write data and grid to @p out according
                                      * to the given data format. This function
                                      * simply calls the appropriate
                                      * @p{write_*} function.
@@ -840,12 +840,12 @@ class GridOut
                                      * suffix with a given output format
                                      * usually has. At present the following
                                      * formats are defined:
-                                     * @begin{itemize}
-                                     * @item @p{OpenDX}: @p{.dx}
-                                     * @item @p{gnuplot}: @p{.gnuplot}
-                                     * @item @p{ucd}: @p{.inp}
-                                     * @item @p{eps}: @p{.eps}.
-                                     * @end{itemize}
+                                     * <ul>
+                                     * <li> @p OpenDX: @p{.dx}
+                                     * <li> @p gnuplot: @p{.gnuplot}
+                                     * <li> @p ucd: @p{.inp}
+                                     * <li> @p eps: @p{.eps}.
+                                     * </ul>
                                      *
                                      * Since this function does not need data
                                      * from this object, it is static and can
@@ -855,7 +855,7 @@ class GridOut
     static std::string default_suffix (const OutputFormat output_format);
 
                                     /**
-                                     * Return the @p{OutputFormat} value
+                                     * Return the @p OutputFormat value
                                      * corresponding to the given string. If
                                      * the string does not match any known
                                      * format, an exception is thrown.
@@ -871,7 +871,7 @@ class GridOut
                                      *
                                      * To get a list of presently available
                                      * format names, e.g. to give it to the
-                                     * @ref{ParameterHandler} class, use the
+                                     * ParameterHandler class, use the
                                      * function @p{get_output_format_names ()}.
                                      */
     static OutputFormat parse_output_format (const std::string &format_name);
@@ -880,7 +880,7 @@ class GridOut
                                      * Return a list of implemented output
                                      * formats. The different names are
                                      * separated by vertical bar signs (@p{`|'})
-                                     * as used by the @ref{ParameterHandler}
+                                     * as used by the ParameterHandler
                                      * classes.
                                      */
     static std::string get_output_format_names ();
@@ -906,21 +906,21 @@ class GridOut
                                     /**
                                      * Flags for UCD output. Can be
                                      * changed by using the
-                                     * @p{set_flags} function.
+                                     * @p set_flags function.
                                      */
     GridOutFlags::Ucd     ucd_flags;
 
                                     /**
                                      * Flags to be used upon output of GNUPLOT
                                      * data. Can be changed by using the
-                                     * @p{set_flags} function.
+                                     * @p set_flags function.
                                      */
     GridOutFlags::Gnuplot gnuplot_flags;
 
                                     /**
                                      * Flags to be used upon output of EPS
                                      * data in one space dimension. Can be
-                                     * changed by using the @p{set_flags}
+                                     * changed by using the @p set_flags
                                      * function.
                                      */
     GridOutFlags::Eps<1>  eps_flags_1;
@@ -928,7 +928,7 @@ class GridOut
                                     /**
                                      * Flags to be used upon output of EPS
                                      * data in two space dimensions. Can be
-                                     * changed by using the @p{set_flags}
+                                     * changed by using the @p set_flags
                                      * function.
                                      */
     GridOutFlags::Eps<2>  eps_flags_2;
@@ -936,7 +936,7 @@ class GridOut
                                     /**
                                      * Flags to be used upon output of EPS
                                      * data in three space dimensions. Can be
-                                     * changed by using the @p{set_flags}
+                                     * changed by using the @p set_flags
                                      * function.
                                      */
     GridOutFlags::Eps<3>  eps_flags_3;
@@ -948,19 +948,19 @@ class GridOut
     
                                     /**
                                      * Write the grid information about
-                                     * faces to @p{out}. Only those faces
+                                     * faces to @p out. Only those faces
                                      * are printed which are on the boundary
                                      * and which have a boundary indicator
                                      * not equal to zero, since the latter
                                      * is the default for boundary faces.
                                      *
                                      * Since cells and faces are continuously
-                                     * numbered, the @p{starting_index} for
+                                     * numbered, the @p starting_index for
                                      * the numbering of the faces is passed
                                      * also.
                                      *
                                      * This function unfortunately can not
-                                     * be included in the regular @p{write_ucd}
+                                     * be included in the regular @p write_ucd
                                      * function, since it needs special
                                      * treatment for the case @p{dim==1}, in
                                      * which case the face iterators are
@@ -999,7 +999,7 @@ class GridOut
                                      * list in one dimension.
                                      *
                                      * The reason for this function is the
-                                     * same as for @p{write_ucd_faces}. See
+                                     * same as for @p write_ucd_faces. See
                                      * there for more information.
                                      */
     template <int dim>
index d7aeb1bfc03167155219244ffe2aaddd16c8e51f..4ad51c188e064da84bf83b9289bd2f8a204831f6 100644 (file)
@@ -40,10 +40,10 @@ template <class T> class Vector;
  *   flags those cells for
  *   coarsening for which the criterion is less than the threshold.
  *
- *   There are two variations of these functions, which rely on @p{refine} and
- *   @p{coarsen} by computing the thresholds from other information:
- *   @begin{itemize}
- *   @item @p{refine_and_coarsen_fixed_number}: this function takes a vector as
+ *   There are two variations of these functions, which rely on @p refine and
+ *   @p coarsen by computing the thresholds from other information:
+ *   <ul>
+ *   <li> @p refine_and_coarsen_fixed_number: this function takes a vector as
  *     above and two values between zero and one denoting the fractions of cells to
  *     be refined and coarsened. For this purpose, it sorts the criteria per cell
  *     and takes the threshold to be the one belonging to the cell with the
@@ -51,13 +51,13 @@ template <class T> class Vector;
  *     the fraction is $0.3$, the threshold is computed to a value such that
  *     30 per cent of cells have a criterion higher than the threshold and are
  *     thus flagged for refinement. The flagging for refinement is done through
- *     the central @p{refine} function. For coarsening, the same holds.
+ *     the central @p refine function. For coarsening, the same holds.
  *
  *     The sorting of criteria is not done actually, since we only need one
  *     value, in the example above the criterion of the cell which is at
  *     30 per cent in the sorted list of cells. The order of cells with higher
  *     and of those with lower criteria is irrelevant. Getting this value is
- *     accomplished by the @p{nth_element} function of the @p{C++} standard
+ *     accomplished by the @p nth_element function of the @p{C++} standard
  *     library, which takes only linear time in the number of elements, rather
  *     than @p{N log N} for sorting all values.
  *
@@ -66,7 +66,7 @@ template <class T> class Vector;
  *     want to chose a smaller value to avoid overrefinement in regions which
  *     do not contribute much to the error.
  *
- *   @item @p{refine_and_coarsen_fixed_fraction}: this function computes the
+ *   <li> @p refine_and_coarsen_fixed_fraction: this function computes the
  *     threshold such that the number of cells getting flagged for refinement
  *     makes up for a certain fraction of the total error. If this fraction is 50
  *     per cent, for example, the threshold is computed such that the cells with
@@ -92,11 +92,11 @@ template <class T> class Vector;
  *     From the point of view of implementation, this time we really need to
  *     sort the array of criteria.
  *     Just like the other strategy described above, this function only
- *     computes the threshold values and then passes over to @p{refine} and
- *     @p{coarsen}.
+ *     computes the threshold values and then passes over to @p refine and
+ *     @p coarsen.
  *
  *     A typical value for the fraction of the total error is 0.5.
- *   @end{itemize}
+ *   </ul>
  *
  *   There are other functions relying on different methods to flag
  *   cells for refinement or coarsening. See their documentation for
@@ -123,7 +123,7 @@ class GridRefinement
                                      * Refine the triangulation
                                      * according to the given
                                      * criteria. The criterion is a
-                                     * @p{double} value for each cell
+                                     * @p double value for each cell
                                      * which determines which cells
                                      * are to be refined by
                                      * comparison with the threshold:
@@ -134,13 +134,13 @@ class GridRefinement
                                      * guarantee that the threshold
                                      * value is in a resonable
                                      * range. Please note that the
-                                     * @p{criteria} array may contain
+                                     * @p criteria array may contain
                                      * negative values (sometimes,
                                      * error estimators are evaluated
                                      * in a way which produces
                                      * positive and negative values),
                                      * but the comparison with
-                                     * @p{threshold} is done only on
+                                     * @p threshold is done only on
                                      * the absolute values of the
                                      * criteria.
                                      *
@@ -148,7 +148,7 @@ class GridRefinement
                                      * refinement, they are not
                                      * actually refined. To do so,
                                      * you have to call the
-                                     * @p{execute_coarsening_and_refinement}
+                                     * @p execute_coarsening_and_refinement
                                      * function.
                                      *
                                      * There are more sophisticated
@@ -164,7 +164,7 @@ class GridRefinement
                        const double        threshold);
 
                                     /**
-                                     * Analogue to the @p{refine}
+                                     * Analogue to the @p refine
                                      * function: flag all cells for
                                      * coarsening for which the
                                      * absolute value of the
@@ -179,16 +179,16 @@ class GridRefinement
                                     /**
                                      * Refine the triangulation by
                                      * refining a certain fraction
-                                     * @p{top_fraction_of_cells} with
+                                     * @p top_fraction_of_cells with
                                      * the highest error. Likewise
                                      * coarsen the fraction
-                                     * @p{bottom_fraction_of_cells}
+                                     * @p bottom_fraction_of_cells
                                      * with the least error. To
                                      * actually perform the
                                      * refinement, call
-                                     * @p{execute_coarsening_and_refinement}.
+                                     * @p execute_coarsening_and_refinement.
                                      *
-                                     * @p{fraction_of_cells} shall be
+                                     * @p fraction_of_cells shall be
                                      * a value between zero and one.
                                      *
                                      * Refer to the general doc of
@@ -207,13 +207,13 @@ class GridRefinement
                                      * Refine the triangulation by
                                      * flagging those cells which
                                      * make up a certain
-                                     * @p{top_fraction} of the total
+                                     * @p top_fraction of the total
                                      * error.  Likewise, coarsen all
                                      * cells which make up only
-                                     * @p{bottom_fraction}.  To
+                                     * @p bottom_fraction.  To
                                      * actually perform the
                                      * refinement, call
-                                     * @p{execute_coarsening_and_refinement}.
+                                     * @p execute_coarsening_and_refinement.
                                      *
                                      * @p{*_fraction} shall be a
                                      * values between zero and one.
@@ -275,13 +275,13 @@ class GridRefinement
   private:
     
                                     /**
-                                     * Sorts the vector @p{ind} as an
-                                     * index vector of @p{a} in
+                                     * Sorts the vector @p ind as an
+                                     * index vector of @p a in
                                      * increasing order.  This
                                      * implementation of quicksort
                                      * seems to be faster than the
                                      * STL version and is needed in
-                                     * @p{refine_and_coarsen_optimize}
+                                     * @p refine_and_coarsen_optimize
                                      */
     template <class Vector>
     static void qsort_index (const Vector               &a,
index 24728269133fefb6fa59fb5a46cec5233b753a98..2f42d708629d67d4775e80fb9a94706616355f3b 100644 (file)
@@ -24,7 +24,7 @@
 
 /**
  * This class reorders the vertices of cells such that they meet the
- * requirements of the @ref{Triangulation} class when creating
+ * requirements of the Triangulation class when creating
  * grids. This class is mainly used when reading in grids from files
  * and converting them to deal.II triangulations.
  *
  *
  * For example, in two dimensions, a quad consists of four lines which
  * have a direction, which is by definition as follows:
- * @begin{verbatim}
+ * @verbatim
  *   3-->--2
  *   |     |
  *   ^     ^
  *   |     |
  *   0-->--1
- * @end{verbatim}
+ * @endverbatim
  * Now, two adjacent cells must have a vertex numbering such that the direction
  * of the common side is the same. For example, the following two quads
- * @begin{verbatim}
+ * @verbatim
  *   3---4---5
  *   |   |   |
  *   0---1---2
- * @end{verbatim}
+ * @endverbatim
  * may be characterised by the vertex numbers @p{(0 1 4 3)} and
  * @p{(1 2 5 4)}, since the middle line would get the direction @p{1->4}
  * when viewed from both cells.  The numbering @p{(0 1 4 3)} and
@@ -71,7 +71,7 @@
  * it is not possible to orient them such that they represent a
  * (counter-)clockwise sense, since then we couldn't already find a
  * valid orientation of the following patch of three cells:
- * @begin{verbatim}
+ * @verbatim
  *       o
  *     /   \
  *   o       o 
@@ -79,7 +79,7 @@
  *   |   o   |    
  *   |   |   |
  *   o---o---o
- * @end{verbatim}
+ * @endverbatim
  * (The reader is asked to try to find a conforming choice of line
  * directions; it will soon be obvious that there can't exists such a
  * thing, even if we allow that there might be cells with clockwise
  * the requirements stated above. To this end, we will first show some
  * examples why this is a difficult problem, and then develop
  * algorithms that finds such a reordering. Note that the algorithm
- * operates on a set of @ref{CellData} objects that are used to
+ * operates on a set of CellData objects that are used to
  * describe a mesh to the triangulation class. These objects are, for
- * example, generated by the @ref{GridIn} class, when reading in grids
+ * example, generated by the GridIn class, when reading in grids
  * from input files.
  *
  * As a last question for this first section: is it guaranteed that
  * following picture we only show one such column of three cells at
  * the left, but we will indicate what happens if we prolong this
  * list):
- * @begin{verbatim}
+ * @verbatim
  *   9---10-----11
  *   |   |    / |
  *   6---7---8  |
  *   3---4---5  |
  *   |   |    \ |
  *   0---1------2
- * @end{verbatim}
+ * @endverbatim
  * Assume that you had numbered the vertices in the cells at the left boundary
  * in a way, that the following line directions are induced:
- * @begin{verbatim}
+ * @verbatim
  *   9->-10-----11
  *   ^   ^    / |
  *   6->-7---8  |
  *   3->-4---5  |
  *   ^   ^    \ |
  *   0->-1------2
- * @end{verbatim}
+ * @endverbatim
  * (This could for example be done by using the indices @p{(0 1 4 3)}, @p{(3 4 7 6)},
  * @p{(6 7 10 9)} for the three cells). Now, you will not find a way of giving
  * indices for the right cells, without introducing either ambiguity for
  * The solution in this case is to renumber one of the three left cells, e.g.
  * by reverting the sense of the line between vertices 7 and 10 by numbering
  * the top left cell by @p{(9 6 7 10)}:
- * @begin{verbatim}
+ * @verbatim
  *   9->-10-----11
  *   v   v    / |
  *   6->-7---8  |
  *   3->-4---5  |
  *   ^   ^    \ |
  *   0->-1------2
- * @end{verbatim}
+ * @endverbatim
  *
  * The point here is the following: assume we wanted to prolong the grid to 
  * the left like this:
- * @begin{verbatim}
+ * @verbatim
  *   o---o---o---o---o------o
  *   |   |   |   |   |    / |
  *   o---o---o---o---o---o  |
  *   o---o---o---o---o---o  |
  *   |   |   |   |   |    \ |
  *   o---o---o---o---o------o
- * @end{verbatim}
+ * @endverbatim
  * Then we run into the same problem as above if we order the cells at
  * the left uniformly, thus forcing us to revert the ordering of one
  * cell (the one which we could order as @p{(9 6 7 10)}
  *
  * As a second example, consider the following simple grid, where the
  * order in which the cells are numbered is important:
- * @begin{verbatim}
+ * @verbatim
  *   3-----2-----o-----o ... o-----7-----6
  *   |     |     |     |     |     |     |
  *   |  0  |  N  | N-1 | ... |  2  |  1  |
  *   |     |     |     |     |     |     |
  *   0-----1-----o-----o ... o-----4-----5
- * @end{verbatim}
+ * @endverbatim
  * We have here only indicated the numbers of the vertices that are
  * relevant. Assume that the user had given the cells 0 and 1 by the
  * vertex indices @p{0 1 2 3} and @p{6 7 4 5}. Then, if we follow this
  * orientation, the grid after creating the lines for these two cells
  * would look like this:
- * @begin{verbatim}
+ * @verbatim
  *   3-->--2-----o-----o ... o-----7--<--6
  *   |     |     |     |     |     |     |
  *   ^  0  ^  N  | N-1 | ... |  2  v  1  v
  *   |     |     |     |     |     |     |
  *   0-->--1-----o-----o ... o-----4--<--5
- * @end{verbatim}
+ * @endverbatim
  * Now, since opposite lines must point in the same direction, we can
  * only add the cells 2 through N-1 to cells 1 such that all vertical
  * lines point down. Then, however, we cannot add cell N in any
  *
  * In more detail, the algorithm is best illustrated using an
  * example. We consider the mesh below:
- * @begin{verbatim}
+ * @verbatim
  *   9------10-------11
  *   |      |        /|
  *   |      |       / |
  *   |      |       \ |
  *   |      |        \|
  *   0------1---------2
- * @end{verbatim}
+ * @endverbatim
  * First a cell is chosen ( (0,1,4,3) in this case). A single side of the cell
  * is oriented arbitrarily (3->4). This choice of orientation is then propogated
  * through the mesh, across sides and elements. (0->1), (6->7) and (9->10).
  * The involves edge-hopping and face hopping, giving a path through the mesh
  * shown in dots.
- * @begin{verbatim}
+ * @verbatim
  *   9-->--10-------11
  *   |  .  |        /|
  *   |  .  |       / |
  *   |  X  |       \ |
  *   |  .  |        \|
  *   0-->--1---------2
- * @end{verbatim}
+ * @endverbatim
  * This is then repeated for the other sides of the chosen element, orienting
  * more sides of the mesh.
- * @begin{verbatim}
+ * @verbatim
  *   9-->--10-------11
  *   |     |        /|
  *   v.....v.......V |
  *   ^..X..^.......^ |
  *   |     |        \|
  *   0-->--1---------2
- * @end{verbatim}
+ * @endverbatim
  * Once an element has been completely oriented it need not be considered
  * further. These elements are filled with o's in the diagrams. We then move
  * to the next element.
- * @begin{verbatim}
+ * @verbatim
  *   9-->--10->-----11
  *   | ooo |  .     /|
  *   v ooo v  .    V |
  *   ^ ooo ^  X    ^ |
  *   | ooo |  .     \|
  *   0-->--1-->------2
- * @end{verbatim}
+ * @endverbatim
  * Repeating this gives
- * @begin{verbatim}
+ * @verbatim
  *   9-->--10->-----11
  *   | ooo | oooooo /|
  *   v ooo v ooooo V |
  *   ^ ooo ^ ooooo ^ |
  *   | ooo | oooooo \|
  *   0-->--1-->------2
- * @end{verbatim}
+ * @endverbatim
  * and the final oriented mesh is
- * @begin{verbatim}
+ * @verbatim
  *   9-->--10->-----11
  *   |     |        /|
  *   v     v       V |
  *   ^     ^       ^ |
  *   |     |        \|
  *   0-->--1-->-------2
- * @end{verbatim}
+ * @endverbatim
  * It is obvious that this algorithm has linear run-time, since it
  * only ever touches each face exactly once.
  *
  * in the initial algorithm; note also that the example is in 2d where
  * we now have the much better algorithm described above, but the same
  * observations also apply to 3d):
- * @begin{verbatim}
+ * @verbatim
  * 13----------14----15
  * | \         |     |
  * |  \    4   |  5  |
  * |  2  |  1  |  0  |
  * |     |     |     |
  * 0-----1-----2-----3
- * @end{verbatim}
+ * @endverbatim
  * Note that there is a hole in the middle. Assume now that the user
  * described the first cell 0 by the vertex numbers @p{2 3 7 6}, and
  * cell 5 by @p{15 14 10 11}, and assume that cells 1, 2, 3, and 4 are
  * cells, the algorithm will start with cell zero and add one cell
  * after the other, up until the sixth one. Then the situation will be
  * the following:
- * @begin{verbatim}
+ * @verbatim
  * 13----->---14--<--15
  * | \         |     |
  * |  >    4   v  5  v
  * ^  2  ^  1  ^  0  ^
  * |     |     |     |
  * 0-->--1-->--2-->--3
- * @end{verbatim}
+ * @endverbatim
  * Coming now to cell 7, we see that the two opposite lines at its top
  * and bottom have different directions; we will therefore find no
  * orientation of cell 7 in which it can be added without violation of
  * smaller (for example by one order of magnitude) than the time
  * needed to read the data from a file, and also to actually generate
  * the triangulation from this data using the
- * @ref{Triangulation}@p{<dim>::create_triangulation} function.
+ * Triangulation@p{<dim>::create_triangulation} function.
  *
  * @author Wolfgang Bangerth, 2000, Michael Anderson 2003
  */
index c17b0ce1b1bb9af3c319bd693c7fbb4830dc2357..b439bb24ba6cac278546d518c18fb6c4af4178f5 100644 (file)
@@ -48,7 +48,7 @@ namespace internal
                                       * already exists in a list of
                                       * edges, and if it already
                                       * exists in reverse order, then
-                                      * return @p{false}. If it is not
+                                      * return @p false. If it is not
                                       * already in the list, or in the
                                       * correct direction, then go on
                                       * with the next faces or cell.
@@ -63,7 +63,7 @@ namespace internal
  * edges come into each node and what the default deal.II directions
  * are for the quad.
  *
- * @begin{verbatim}
+ * @verbatim
  *       s2
  *       
  *     +-->--+       
@@ -73,7 +73,7 @@ namespace internal
  *     +-->--+               
  *   
  *       s0           
- * @end{verbatim}
+ * @endverbatim
  *
  * @author Michael Anderson, 2003
  */ 
@@ -139,7 +139,7 @@ namespace internal
        unsigned int side[4]; 
 
                                         /**
-                                         * Copy of the @p{CellData} object
+                                         * Copy of the @p CellData object
                                          * from which we construct the
                                          * data of this object.
                                          */
@@ -218,7 +218,7 @@ namespace internal
 
 /**
  * Implement the 2d algorithm for grid reordering described in the
- * documentation of the @ref{GridReordering} class.
+ * documentation of the GridReordering class.
  *
  * @author Michael Anderson, 2003
  */   
@@ -570,7 +570,7 @@ namespace internal
                                           * Export the data of this
                                           * object to the deal.II
                                           * format that the
-                                          * @ref{Triangulation} class
+                                          * Triangulation class
                                           * wants as input.
                                           */
         void
@@ -717,7 +717,7 @@ namespace internal
                                           * private, the only entry
                                           * point of this class is the
                                           * static function
-                                          * @ref{orient_mesh}.
+                                          * orient_mesh().
                                           */
         Orienter (const std::vector<CellData<3> > &incubes);
 
@@ -740,7 +740,7 @@ namespace internal
                                          /**
                                           * Return whether the cell
                                           * with cell number
-                                          * @p{cell_num} is fully
+                                          * @p cell_num is fully
                                           * oriented.
                                           */
         bool is_oriented (const unsigned int cell_num) const;
index 52ee05383acfeb80b6fdbc215237c59607708b2f..962b7fc1245313b0fbc25d3d697fdd0e940556dd 100644 (file)
@@ -93,7 +93,7 @@ class GridTools
                                      * Shift each vertex of the
                                      * triangulation by the given
                                      * shift vector. This function
-                                     * uses the @ref{transform}
+                                     * uses the transform()
                                      * function above, so the
                                      * requirements on the
                                      * triangulation stated there
@@ -115,7 +115,7 @@ class GridTools
                                      * system by the given angle
                                      * (given in radians, rather than
                                      * degrees). This function uses
-                                     * the @ref{transform} function
+                                     * the transform() function
                                      * above, so the requirements on
                                      * the triangulation stated there
                                      * hold for this function as
@@ -133,7 +133,7 @@ class GridTools
                                      * must be positive.
                                      *
                                      * This function uses the
-                                     * @ref{transform} function
+                                     * transform() function
                                      * above, so the requirements on
                                      * the triangulation stated there
                                      * hold for this function as
@@ -147,12 +147,12 @@ class GridTools
                                      /**
                                       * Find and return an iterator to
                                       * the active cell that surrounds
-                                      * a given point @p{ref}. The
+                                      * a given point @p ref. The
                                       * type of the first parameter
                                       * may be either
-                                      * @ref{Triangulation},
-                                      * @ref{DoFHandler}, or
-                                      * @ref{MGDoFHandler}, i.e. we
+                                      * Triangulation,
+                                      * DoFHandler, or
+                                      * MGDoFHandler, i.e. we
                                       * can find the cell around a
                                       * point for iterators into each
                                       * of these classes.
@@ -164,8 +164,8 @@ class GridTools
                                       * then recursively checking its
                                       * sibling cells. The complexity
                                       * is thus @p{O(M+log N)} where
-                                      * @p{M} is the number of coarse
-                                      * grid cells, and @p{N} the
+                                      * @p M is the number of coarse
+                                      * grid cells, and @p N the
                                       * total number of cells.
                                       *
                                       * There are cases where this
@@ -241,13 +241,13 @@ class GridTools
                                       * calling this function, the subdomain
                                       * ids of all active cells will have
                                       * values between zero and
-                                      * @p{n_partitions-1}. You can access the
+                                      * @p n_partitions-1. You can access the
                                       * subdomain id of a cell by using
                                       * @p{cell->subdomain_id()}.
                                       *
                                       * This function will generate an error
                                       * if METIS is not installed unless
-                                      * @p{n_partitions} is one. I.e., you can
+                                      * @p n_partitions is one. I.e., you can
                                       * write a program so that it runs in the
                                       * single-processor single-partition case
                                       * without METIS installed, and only
index 5e95ad2f61c3f00a393b8c89551682cac5113357..8f45b3619e9fcab37b556e2c3cff458e40aba594 100644 (file)
  *
  * Usually, the two grids will be refined differently. Then, the value
  * returned for an iterator on the source grid will be either:
- * @begin{itemize}
- *   @item The same cell on the destination grid, if it exists there;
- *   @item The most refined cell of the destination grid from which the
+ * <ul>
+ *   <li> The same cell on the destination grid, if it exists there;
+ *   <li> The most refined cell of the destination grid from which the
  *      pendant of the source cell could be obtained by refinement. This
  *      cell is always active and has a refinement level less than that
  *      of the source cell.
- * @end{itemize}
+ * </ul>
  * Keys for this map are all cells on the source grid, whether active or
  * not.
  *
  * For example, consider these two one-dimensional grids:
- * @begin{verbatim}
+ * @verbatim
  * Grid 1:
  *   x--x--x-----x-----------x
  *    1  2    3        4 
  * Grid 2:
  *   x-----x-----x-----x-----x
  *      1     2     3     4
- * @end{verbatim}
+ * @endverbatim
  * (Cell numbers are only given as an example and will not correspond
  * to real cell iterator's indices.) The mapping from grid 1 to grid 2
  * will then be as follows:
- * @begin{verbatim}
+ * @verbatim
  *    Cell on grid 1         Cell on grid 2
  *          1  ------------------>  1
  *          2  ------------------>  1
  *          3  ------------------>  2
  *          4  ------------------>  mother cell of cells 3 and 4
  *                                  (a non-active cell, not shown here)
- * @end{verbatim}
+ * @endverbatim
  * Besides the mappings shown here, the non-active cells on grid 1 are also
  * valid keys. For example, the mapping for the mother cell of cells 1 and 2
  * on the first grid will point to cell 1 on the second grid.
  *
  * The implementation of this class is such that not only cell iterators
  * into triangulations can be mapped, but also iterators into objects of
- * type @ref{DoFHandler} and @ref{MGDoFHandler}. The extension to other classes
+ * type DoFHandler and MGDoFHandler. The extension to other classes
  * offering iterator functions and some minor additional requirements is
  * simple.
  *
@@ -78,7 +78,7 @@
  * @sect2{Usage}
  *
  * In practice, use of this class is as follows:
- * @begin{verbatim}
+ * @verbatim
  *                   // have two grids, which are derived from the
  *                   // same coarse grid
  *   Triangulation<dim> tria1, tria2;
  *                                           endc = dof_handler_1.end();
  *   for (; cell!=endc; ++cell)
  *                    // now do something with the cell of dof_handler_2
- *                    // corresponding to @p{cell} (which is one of
+ *                    // corresponding to @p cell (which is one of
  *                    // dof_handler_1
  *     f( grid_1_to_2_map[cell]);
- * @end{verbatim}
+ * @endverbatim
  *
  * Note that the template parameters to this class have to be given as
  * @p{InterGridMap<DoFHandler,2>}, i.e. the dimension is given explicitly and
  * no dimension is attributed to the first parameter, which here is
- * @ref{DoFHandler} (and could equally well be @ref{Triangulation} or @ref{MGDoFHandler}).
+ * DoFHandler (and could equally well be Triangulation or MGDoFHandler).
  *
  * @author Wolfgang Bangerth, 1999
  */
@@ -228,16 +228,16 @@ class InterGridMap
                      const cell_iterator &dst_cell);
 
                                     /**
-                                     * Set the value of the key @p{src_cell}
-                                     * to @p{dst_cell}. Do so as well for
+                                     * Set the value of the key @p src_cell
+                                     * to @p dst_cell. Do so as well for
                                      * all the children and their children
-                                     * of @p{src_cell}. This function is
+                                     * of @p src_cell. This function is
                                      * used for cells which are more
-                                     * refined on @p{src_grid} than on
-                                     * @p{dst_grid}; then all values of
+                                     * refined on @p src_grid than on
+                                     * @p dst_grid; then all values of
                                      * the hierarchy of cells and their
                                      * children point to one cell on the
-                                     * @p{dst_grid}.
+                                     * @p dst_grid.
                                      */
     void set_entries_to_cell (const cell_iterator &src_cell,
                              const cell_iterator &dst_cell);
index 5cce0bf2adc32f12bb1bb3966b00f14ffbe2a214..a0e4e6114e5f9c402ec555e9a019a6ae69d78e25 100644 (file)
  * of cell numbers to the geometrical cells.
  *
  * Basically, this is a drop-in replacement for the triangulation. Since it
- * is derived from the @ref{Triangulation} class, it shares all the
+ * is derived from the Triangulation class, it shares all the
  * functionality, but it overrides some virtual functions and adds some
  * functions, too. The main change to the base class is that it overrides
- * the @p{execute_coarsening_and_refinement} function, where the new version
+ * the @p execute_coarsening_and_refinement function, where the new version
  * first stores all refinement and coarsening flags and only then calls the
  * respective function of the base class. The stored flags may later be
  * used to restore the grid just as it was before. Some other functions
@@ -41,7 +41,7 @@
  *
  * We note that since the triangulation is created in exactly the same state
  * as it was before, other objects working on it should result in the same
- * state as well. This holds in particular for the @ref{DoFHandler} object, which
+ * state as well. This holds in particular for the DoFHandler object, which
  * will assign the same degrees of freedom to the original cells and the ones
  * after reconstruction of the triangulation. You can therefore safely use data
  * vectors computed on the original grid on the reconstructed grid as well.
  *
  * @sect3{Usage}
  * You can use objects of this class almost in the same way as objects of the
- * @ref{Triangulation} class. One of the few differences is that you can only
+ * Triangulation class. One of the few differences is that you can only
  * construct such an object by giving a coarse grid to the constructor. The
  * coarse grid will be used to base the triangulation on, and therefore the
  * lifetime of the coarse grid has to be longer than the lifetime of the
  * object of this class.
  *
  * Basically, usage looks like this:
- * @begin{verbatim}
+ * @verbatim
  *   Triangulation<dim> coarse_grid;
  *   ...                     // initialize coarse grid
  *
  *                           // is not needed anymore, e.g.
  *                           // working with another grid
  *     };
- * @end{verbatim}
+ * @endverbatim
  *
- * Note that initially, the @ref{PersistentTriangulation} object does not
- * constitute a triangulation; it only becomes one after @p{restore} is first
- * called. Note also that the @p{execute_coarsening_and_refinement} stores
- * all necessary flags for later reconstruction using the @p{restore} function.
- * @ref{Triangulation}@p{<dim>::clear ()} resets the underlying triangulation to a
+ * Note that initially, the PersistentTriangulation object does not
+ * constitute a triangulation; it only becomes one after @p restore is first
+ * called. Note also that the @p execute_coarsening_and_refinement stores
+ * all necessary flags for later reconstruction using the @p restore function.
+ * Triangulation@p{<dim>::clear ()} resets the underlying triangulation to a
  * virgin state, but does not affect the stored refinement flags needed for
  * later reconstruction and does also not touch the coarse grid which is
  * used withing @p{restore()}.
@@ -108,7 +108,7 @@ class PersistentTriangulation : public Triangulation<dim>
                                      * flags, etc from that grid as well.
                                      * Note that the initial state of the
                                      * triangulation is empty, until
-                                     * @p{restore_grid} is called for the
+                                     * @p restore_grid is called for the
                                      * first time.
                                      *
                                      * The coarse grid must persist until
@@ -168,7 +168,7 @@ class PersistentTriangulation : public Triangulation<dim>
 
                                     /**
                                      * Differential restore. Performs
-                                     * the @p{step_no}th local
+                                     * the @p step_noth local
                                      * refinement and coarsening step.
                                      * Step 0 stands for the copying
                                      * of the coarse grid.
@@ -186,20 +186,20 @@ class PersistentTriangulation : public Triangulation<dim>
                                      * Returns the number of
                                      * refinement and coarsening
                                      * steps. This is given by the
-                                     * size of the @p{refine_flags}
+                                     * size of the @p refine_flags
                                      * vector.
                                      */
     unsigned int n_refinement_steps () const;
 
                                     /**
                                      * Overload this function to use
-                                     * @p{tria} as a new coarse grid. The
+                                     * @p tria as a new coarse grid. The
                                      * present triangulation and all
                                      * refinement and coarsening flags
                                      * storing its history are deleted,
                                      * and the state of the underlying
                                      * triangulation is reset to be
-                                     * empty, until @p{restore_grid} is
+                                     * empty, until @p restore_grid is
                                      * called the next time.
                                      *
                                      * The coarse grid must persist until
@@ -220,7 +220,7 @@ class PersistentTriangulation : public Triangulation<dim>
 
                                     /**
                                      * Writes all refine and coarsen
-                                     * flags to the ostream @p{out}.
+                                     * flags to the ostream @p out.
                                      */
     virtual void write_flags(std::ostream &out) const;
 
index c60189dcc31b652332f79845cf34597a558b5b46..5b60c6420a635b193dadb9b657e84d5d6065e6ee 100644 (file)
@@ -41,7 +41,7 @@ template <int dim> class MGDoFHandler;
 
 /**
  *  Structure which is passed to the
- *  @ref{Triangulation}@p{<dim>::create_triangulation} function. It
+ *  Triangulation@p{<dim>::create_triangulation} function. It
  *  contains all data needed to construct a cell, namely the indices
  *  of the vertices and the material indicator.
  */
@@ -102,7 +102,7 @@ struct CellData
 
 
 /**
- *  Structure to be passed to the @ref{Triangulation}@p{<dim>::create_triangulation}
+ *  Structure to be passed to the Triangulation@p{<dim>::create_triangulation}
  *  function to describe boundary information.
  *
  *  This structure is the same for all dimensions, since we use an input
@@ -146,7 +146,7 @@ struct SubCellData
                                      * dimension are really empty. I.e.,
                                      * whether the @p{boundary_*} arrays are
                                      * empty when in one space dimension
-                                     * and whether the @p{boundary_quads}
+                                     * and whether the @p boundary_quads
                                      * array is empty when in two dimensions.
                                      *
                                      * Since this structure is the same for all
@@ -179,25 +179,25 @@ class TriaDimensionInfo
  *  This class implements some types which differ between the dimensions.
  *  These are the declararions for the 1D case only.
  *
- *  A @p{line_iterator} is typdef'd to an iterator operating on the
- *  @p{lines} member variable of a @p{Triangulation<1>} object. An
- *  @p{active_line_iterator} only operates on the active lines.
- *  @p{raw_line_iterator} objects operate on all lines, used or not.
+ *  A @p line_iterator is typdef'd to an iterator operating on the
+ *  @p lines member variable of a @p{Triangulation<1>} object. An
+ *  @p active_line_iterator only operates on the active lines.
+ *  @p raw_line_iterator objects operate on all lines, used or not.
  *
  *  Since we are in one dimension, the following identities are declared:
- *  @begin{verbatim}
+ *  @verbatim
  *    typedef raw_line_iterator    raw_cell_iterator;
  *    typedef line_iterator        cell_iterator;
  *    typedef active_line_iterator active_cell_iterator;
- *  @end{verbatim}
+ *  @endverbatim
  *
- *  To enable the declaration of @p{begin_quad} and the like in
- *  @p{Triangulation<1>}, the @p{quad_iterator}s are declared as
+ *  To enable the declaration of @p begin_quad and the like in
+ *  @p{Triangulation<1>}, the @p quad_iterators are declared as
  *  @p{void *}. Thus these types exist, but are useless and will
  *  certainly make any involuntary use visible. The same holds
  *  for hexahedron iterators.
  *
- *  The same applies for the @p{face_iterator} types, since lines
+ *  The same applies for the @p face_iterator types, since lines
  *  have no substructures apart from vertices, which are handled in
  *  a different way, however.
  *
@@ -264,25 +264,25 @@ class TriaDimensionInfo<1>
  *  This class implements some types which differ between the dimensions.
  *  These are the declararions for the 2D case only.
  *
- *  A @p{line_iterator} is typdef'd to an iterator operating on the
- *  @p{lines} member variable of a @p{Triangulation<2>} object. An
- *  @p{active_line_iterator} only operates on the active lines.
- *  @p{raw_line_iterator} objects operate on all lines, used or not.
- *  Using @p{active_line_iterator}s may not be particularly in 2D useful since it
+ *  A @p line_iterator is typdef'd to an iterator operating on the
+ *  @p lines member variable of a @p{Triangulation<2>} object. An
+ *  @p active_line_iterator only operates on the active lines.
+ *  @p raw_line_iterator objects operate on all lines, used or not.
+ *  Using @p active_line_iterators may not be particularly in 2D useful since it
  *  only operates on unrefined lines. However, also refined lines may bound
  *  unrefined cells if the neighboring cell is refined once more than the
  *  present one.
  *
- *  Similarly to line iterators, @p{quad_iterator}, @p{raw_quad_iterator} and
- *  @p{active_quad_iterator} are declared.
+ *  Similarly to line iterators, @p quad_iterator, @p raw_quad_iterator and
+ *  @p active_quad_iterator are declared.
  *  
- *  To enable the declaration of @p{begin_hex} and the like in
- *  @p{Triangulation<[12]>}, the @p{hex_iterator}s are declared as
+ *  To enable the declaration of @p begin_hex and the like in
+ *  @p{Triangulation<[12]>}, the @p hex_iterators are declared as
  *  @p{void *}. Thus these types exist, but are useless and will
  *  certainly make any involuntary use visible.
  *
  *  Since we are in two dimension, the following identities are declared:
- *  @begin{verbatim}
+ *  @verbatim
  *    typedef raw_quad_iterator    raw_cell_iterator;
  *    typedef quad_iterator        cell_iterator;
  *    typedef active_quad_iterator active_cell_iterator;
@@ -290,7 +290,7 @@ class TriaDimensionInfo<1>
  *    typedef raw_line_iterator    raw_face_iterator;
  *    typedef line_iterator        face_iterator;
  *    typedef active_line_iterator active_face_iterator;    
- *  @end{verbatim}
+ *  @endverbatim
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -358,7 +358,7 @@ class TriaDimensionInfo<2>
  *  For the declarations of the data types, more or less the same holds
  *  as for lower dimensions (see @p{TriaDimensionInfo<[12]>}). The
  *  dimension specific data types are here, since we are in three dimensions:
- *  @begin{verbatim}
+ *  @verbatim
  *    typedef raw_hex_iterator    raw_cell_iterator;
  *    typedef hex_iterator        cell_iterator;
  *    typedef active_hex_iterator active_cell_iterator;
@@ -366,7 +366,7 @@ class TriaDimensionInfo<2>
  *    typedef raw_quad_iterator    raw_face_iterator;
  *    typedef quad_iterator        face_iterator;
  *    typedef active_quad_iterator active_face_iterator;    
- *  @end{verbatim}
+ *  @endverbatim
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -634,11 +634,11 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
 
 
 /**
- *  @ref{Triangulation}s denote a hierarchy of levels of elements which together
- *  form a region in @p{dim} spatial dimensions.
+ *  Triangulations denote a hierarchy of levels of elements which together
+ *  form a region in @p dim spatial dimensions.
  *
  *  This class is written to be as independent of the dimension as possible
- *  (thus the complex construction of the @ref{TriangulationLevel} classes) to
+ *  (thus the complex construction of the TriangulationLevel classes) to
  *  allow code-sharing, to allow reducing the need to mirror changes in the code
  *  for one dimension to the code for other dimensions. Nonetheless, some of
  *  the functions are dependent of the dimension and there only exist
@@ -647,51 +647,51 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *
  *  @sect3{Structure and iterators}
  *
- *  The actual data structure of a @ref{Triangulation} object is rather complex
+ *  The actual data structure of a Triangulation object is rather complex
  *  and quite inconvenient if one attempted to operate on it directly, since
  *  data is spread over quite a lot of arrays and other places. However,
  *  there are ways powerful enough to work on these data structures
  *  without knowing their exact relations. This is done through the
- *  concept of iterators (see the STL documentation and @ref{TriaRawIterator}).
+ *  concept of iterators (see the STL documentation and TriaRawIterator).
  *  In order to make things as easy and dimension independent as possible,
  *  use of class local typedefs is made, see below.
  *  
- *  In the base class @ref{TriaDimensionInfo}, a @p{Cell} is typedef'd to be whatever
- *  is reasonable for a cell in the respective dimension, i.e. a @p{Line} in
- *  one dimension, a @p{Quad} in two dimensions, and so on.
+ *  In the base class TriaDimensionInfo, a @p Cell is typedef'd to be whatever
+ *  is reasonable for a cell in the respective dimension, i.e. a @p Line in
+ *  one dimension, a @p Quad in two dimensions, and so on.
  *
- *  The @ref{Triangulation} class provides iterator which enable looping over all
+ *  The Triangulation class provides iterator which enable looping over all
  *  lines, cells,
  *  etc without knowing the exact representation used to describe them. Their
- *  names are typedefs in the @ref{TriaDimensionInfo} base class (thus making them
+ *  names are typedefs in the TriaDimensionInfo base class (thus making them
  *  local types to this class) and are as follows:
  *
- *  @begin{itemize}
- *  @item @p{raw_line_iterator}: loop over all lines, used or not (declared for
+ *  <ul>
+ *  <li> @p raw_line_iterator: loop over all lines, used or not (declared for
  *  all dimensions).
  *  
- *  @item @p{line_iterator}: loop over all used lines (declared for all dimensions).
+ *  <li> @p line_iterator: loop over all used lines (declared for all dimensions).
  *
- *  @item @p{active_line_iterator}: loop over all active lines (declared for all
+ *  <li> @p active_line_iterator: loop over all active lines (declared for all
  *  dimensions).
  *
- *  @item @p{raw_quad_iterator}: loop over all quads, used or not (declared only
+ *  <li> @p raw_quad_iterator: loop over all quads, used or not (declared only
  *  for @p{dim>=2}).
  *  
- *  @item @p{quad_iterator}: loop over all quads (declared only for @p{dim}>=2).
+ *  <li> @p quad_iterator: loop over all quads (declared only for @p dim>=2).
  *
- *  @item @p{active_quad_iterator}: loop over all active quads (declared only for
- *  @p{dim}>=2).
- *  @end{itemize}
+ *  <li> @p active_quad_iterator: loop over all active quads (declared only for
+ *  @p dim>=2).
+ *  </ul>
  *
- *  Additionaly, for @p{dim}==1, the following identities hold:
- *  @begin{verbatim}
+ *  Additionaly, for @p dim==1, the following identities hold:
+ *  @verbatim
  *    typedef raw_line_iterator    raw_cell_iterator;
  *    typedef line_iterator        cell_iterator;
  *    typedef active_line_iterator active_cell_iterator;
- *  @end{verbatim}
- *  while for @p{dim}==2
- *  @begin{verbatim}
+ *  @endverbatim
+ *  while for @p dim==2
+ *  @verbatim
  *    typedef quad_line_iterator   raw_cell_iterator;    
  *    typedef quad_iterator        cell_iterator;
  *    typedef active_quad_iterator active_cell_iterator;
@@ -699,7 +699,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *    typedef raw_line_iterator    raw_face_iterator;
  *    typedef line_iterator        face_iterator;
  *    typedef active_line_iterator active_face_iterator;    
- *  @end{verbatim}
+ *  @endverbatim
  *
  *  By using the cell iterators, you can write code nearly independent of
  *  the spatial dimension. The same applies for substructure iterators,
@@ -707,15 +707,15 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *  cell is be a vertex in 1D and a line in 2D; however, vertices are
  *  handled in a different way and therefore lines have no faces.
  *
- *  The @ref{Triangulation} class offers functions like @p{begin_active} which gives
+ *  The Triangulation class offers functions like @p begin_active which gives
  *  you an iterator to the first active cell. There are quite a lot of functions
  *  returning iterators. Take a look at the class doc to get an overview.
  *
  *  Usage of these iterators works mostly like with the STL iterators. Some
- *  examples taken from the @ref{Triangulation} source code follow.
- *  @begin{itemize}
- *  @item <em>Counting the number of cells on a specific level</em>
- *    @begin{verbatim}
+ *  examples taken from the Triangulation source code follow.
+ *  <ul>
+ *  <li> <em>Counting the number of cells on a specific level</em>
+ *    @verbatim
  *     template <int dim>
  *     int Triangulation<dim>::n_cells (const int level) const {
  *        cell_iterator cell = begin (level),
@@ -725,9 +725,9 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *          ++n;
  *        return n;
  *      };
- *    @end{verbatim}
- *    Another way which uses the STL @p{distance} function would be to write
- *    @begin{verbatim}
+ *    @endverbatim
+ *    Another way which uses the STL @p distance function would be to write
+ *    @verbatim
  *      template <int dim>
  *      int Triangulation<dim>::n_cells (const int level) const {
  *        int n=0;
@@ -738,10 +738,10 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *                  n);
  *        return n;
  *      };  
- *    @end{verbatim}
+ *    @endverbatim
  *    
- *  @item <em>Refining all cells of a triangulation</em>
- *    @begin{verbatim}
+ *  <li> <em>Refining all cells of a triangulation</em>
+ *    @verbatim
  *      template <int dim>
  *      void Triangulation<dim>::refine_global () {
  *        active_cell_iterator cell = begin_active(),
@@ -751,15 +751,15 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *          cell->set_refine_flag ();
  *        execute_coarsening_and_refinement ();
  *      };
- *    @end{verbatim}
- *  @end{itemize}
+ *    @endverbatim
+ *  </ul>
  *
  *
  *  @sect3{Usage}
  *
- *  Usage of a @ref{Triangulation} is mainly done through the use of iterators.
+ *  Usage of a Triangulation is mainly done through the use of iterators.
  *  An example probably shows best how to use it:
- *  @begin{verbatim}
+ *  @verbatim
  *  void main () {
  *    Triangulation<2> tria;
  *
@@ -796,30 +796,30 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *    ofstream out("grid.1");
  *    GridOut::write_gnuplot (tria, out);
  *  };  
- *  @end{verbatim}
+ *  @endverbatim
  *
  *  
  *  @sect3{Creating a triangulation}
  *
  *  There are several possibilities to create a triangulation:
- *  @begin{itemize}
- *    @item The most common domains, such as hypercubes (i.e. lines, squares,
+ *  <ul>
+ *    <li> The most common domains, such as hypercubes (i.e. lines, squares,
  *       cubes, etc), hyper-balls (circles, balls, ...) and some other, more
  *       weird domains such as the L-shape region and higher dimensional
- *       generalizations and others, are provided by the @ref{GridGenerator}
+ *       generalizations and others, are provided by the GridGenerator
  *       class which takes a triangulation and fills it by a division
  *       of the required domain.
  *   
- *     @item Reading in a triangulation: By using an object of the @ref{GridIn}
+ *     <li> Reading in a triangulation: By using an object of the GridIn
  *        class, you can read in fairly general triangulations. See there for
  *        more information. The mentioned class uses the interface described
  *        directly below to transfer the data into the triangulation.
  *
- *     @item Explicitely creating a triangulation: you can create a triangulation
+ *     <li> Explicitely creating a triangulation: you can create a triangulation
  *        by providing a list of vertices and a list of cells. Each such cell
  *        consists of a vector storing the indices of the vertices of this cell
  *        in the vertex list. To see how this works, you can take a look at the
- *        @ref{GridIn}@p{<dim>::read_*} functions. The appropriate function to be
+ *        GridIn@p{<dim>::read_*} functions. The appropriate function to be
  *        called is @p{Triangulation<dim>::create_triangulation ()}.
  *
  *        Creating the hierarchical information needed for this
@@ -855,16 +855,16 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *        the data read from an UCD or any other input file, but also
  *        for the data passed to the
  *        @p{Triangulation<dim>::create_triangulation ()}
- *        function. See the documentation for the @ref{GridIn} class
+ *        function. See the documentation for the GridIn class
  *        for more details on this, and above all to the
- *        @ref{GridReordering} class that explains many of the
+ *        GridReordering class that explains many of the
  *        problems and an algorithm to reorder cells such that they
  *        satisfy the conditions outlined above.
  *
- *     @item Copying a triangulation: when computing on time dependent meshes
+ *     <li> Copying a triangulation: when computing on time dependent meshes
  *        of when using adaptive refinement, you will often want to create a
  *        new triangulation to be the same as another one. This is facilitated
- *        by the @p{copy_triangulation} function.
+ *        by the @p copy_triangulation function.
  *
  *        It is guaranteed that vertex, line or cell numbers in the two
  *        triangulations are the same and that two iterators walking on the
@@ -875,7 +875,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *        operation but guaranteeing some parallelity in the two triangulations
  *        seems more important since usually data will have to be transferred
  *        between the grids.
- *   @end{itemize}
+ *   </ul>
  *
  *   The material id for each cell must be specified upon construction of
  *   a triangulation. (There is a special section on material identifier and
@@ -934,15 +934,15 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   @sect3{Refinement and coarsening of a triangulation}
  *
  *   Refinement of a triangulation may be done through several ways. The most
- *   low-level way is directly through iterators: let @p{i} be an iterator to
+ *   low-level way is directly through iterators: let @p i be an iterator to
  *   an active cell (i.e. the cell pointed to has no children), then the
  *   function call @p{i->set_refine_flag()} marks the respective cell for
  *   refinement. Marking non-active cells results in an error.
  *
  *   After all the cells you wanted to mark for refinement, call the
- *   @p{execute_coarsening_and_refinement} function to actually perform
+ *   @p execute_coarsening_and_refinement function to actually perform
  *   the refinement. This function itself first calls the
- *   @p{prepare_coarsening_and_refinement} function to regularize the resulting
+ *   @p prepare_coarsening_and_refinement function to regularize the resulting
  *   triangulation: since a face between two adjacent cells may only
  *   be subdivided once (i.e. the levels of two adjacent cells may
  *   differ by one at most; it is not possible to have a cell refined
@@ -955,7 +955,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   step than one needed by the finite element method.
  *
  *   To coarsen a grid, the same way as above is possible by using
- *   @p{i->set_coarsen_flag} and calling @p{execute_coarsening_and_refinement}.
+ *   @p{i->set_coarsen_flag} and calling @p execute_coarsening_and_refinement.
  *
  *   The reason for first coarsening, then refining is that the
  *   refinement usually adds some additional cells to keep the triangulation
@@ -972,22 +972,22 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   they do exactly these things). There are more advanced functions,
  *   however, which are more suitable for automatic generation of hierarchical
  *   grids in the context of a-posteriori error estimation and adaptive finite
- *   elements. These functions can be found in the @ref{GridRefinement} class.
+ *   elements. These functions can be found in the GridRefinement class.
  *
  *
  *   @sect3{Smoothing of a triangulation}
  *
  *   Some degradation of approximation properties has been observed
  *   for grids which are too unstructured. Therefore, the
- *   @p{prepare_coarsening_and_refinement} function which is automatically called
- *   by the @p{execute_coarsening_and_refinement} function can do some
+ *   @p prepare_coarsening_and_refinement function which is automatically called
+ *   by the @p execute_coarsening_and_refinement function can do some
  *   smoothing of the triangulation. Note that mesh smoothing is only
  *   done for two or more space dimensions, no smoothing is available
  *   at present for one spatial dimension. In the sequel, let
- *   @p{execute_*} stand for @p{execute_coarsening_and_refinement}.
+ *   @p{execute_*} stand for @p execute_coarsening_and_refinement.
  *
  *   For the purpose of smoothing, the
- *   @ref{Triangulation} constructor takes an argument specifying whether a
+ *   Triangulation constructor takes an argument specifying whether a
  *   smoothing step shall be performed on the grid each time @p{execute_*}
  *   is called. The default is that such a step not be done, since this results
  *   in additional cells being produced, which may not be necessary in all
@@ -1004,12 +1004,12 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   The parameter taken by the constructor is an integer which may be composed
  *   bitwise by the constants defined in the @p{enum MeshSmoothing}. The meaning
  *   of these constants is explained in the following:
- *   @begin{itemize}
- *   @item @p{limit_level_difference_at_vertices}:
+ *   <ul>
+ *   <li> @p limit_level_difference_at_vertices:
  *     It can be shown, that degradation of approximation occurs if the
  *     triangulation contains vertices which are member of cells with levels
  *     differing by more than one. One such example is the following:
- *     @begin{verbatim}
+ *     @verbatim
  *       |     |     |     |
  *       x-----x-----x--x--x--
  *       |     |     |  |  |
@@ -1024,7 +1024,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *       |           |     |
  *       |           |     |
  *       x-----------x-----x--
- *     @end{verbatim}
+ *     @endverbatim
  *     It seems that in two space dimensions, the maximum jump in levels between
  *     cells sharing a common vertex is two (as in the example above). This is
  *     not true if more than four cells meet at a vertex. It is not uncommon
@@ -1046,17 +1046,17 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     of this cell (but with a less degree of deviation from the true value).
  *
  *     If the smoothing indicator given to the constructor contains the bit for
- *     @p{limit_level_difference_at_vertices}, situations as the above one are
+ *     @p limit_level_difference_at_vertices, situations as the above one are
  *     eliminated by also marking the lower left cell for refinement.
  *
- *   @item @p{eliminate_unrefined_islands}:
+ *   <li> @p eliminate_unrefined_islands:
  *     Single cells which are not refined and are surrounded by cells which are
  *     refined usually also lead to a sharp decline in approximation properties
  *     locally. The reason is that the nodes on the faces between unrefined and
  *     refined cells are not real degrees of freedom but carry constraints. The
  *     patch without additional degrees of freedom is thus significantly larger
  *     then the unrefined cell itself. If in the parameter passed to the
- *     constructor the bit for @p{eliminate_unrefined_islands} is set, all cells
+ *     constructor the bit for @p eliminate_unrefined_islands is set, all cells
  *     which are not flagged for refinement but which are surrounded by more
  *     refined cells than unrefined cells are flagged for refinement. Cells
  *     which are not yet refined but flagged for that are accounted for the
@@ -1068,10 +1068,10 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     name of the flag may indicate. However, no better name came to mind to
  *     the author by now.
  *
- *   @item @p{eliminate_refined_*_islands}:
+ *   <li> @p{eliminate_refined_*_islands}:
  *     This algorithm seeks for isolated cells which are refined or flagged
  *     for refinement. This definition is unlike that for
- *     @p{eliminate_unrefined_islands}, which would mean that an island is
+ *     @p eliminate_unrefined_islands, which would mean that an island is
  *     defined as a cell which
  *     is refined but more of its neighbors are not refined than are refined.
  *     For example, in 2D, a cell's refinement would be reverted if at most
@@ -1091,7 +1091,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     refinement flag.
  *
  *     Actually there are two versions of this flag,
- *     @p{eliminate_refined_inner_islands} and @p{eliminate_refined_boundary_islands}.
+ *     @p eliminate_refined_inner_islands and @p eliminate_refined_boundary_islands.
  *     There first eliminates islands defined by the definition above which are
  *     in the interior of the domain, while the second eliminates only those
  *     islands if the cell is at the boundary. The reason for this split of
@@ -1100,36 +1100,36 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     refines the mesh according to a criterion associated with a boundary
  *     integral or if one has rough boundary data.
  *
- *   @item @p{do_not_produce_unrefined_islands}:
+ *   <li> @p do_not_produce_unrefined_islands:
  *     This flag prevents the occurrence of unrefined islands. In more detail:
  *     It prohibits the coarsening of a cell if 'most of the neighbors' will
  *     be refined after the step.
  *
- *   @item @p{patch_level_1}:
+ *   <li> @p patch_level_1:
  *     Ensures patch level 1. As result the triangulation consists of
  *     patches, i.e. of cells that are refined once. It follows that
  *     if at least one of the children of a cell is or will be refined
- *     than all children need to be refined. If the @p{patch_level_1} flag
- *     is set, than the flags @p{eliminate_unrefined_islands},
- *     @p{eliminate_refined_inner_islands} and
- *     @p{eliminate_refined_boundary_islands} will be ignored as they will
+ *     than all children need to be refined. If the @p patch_level_1 flag
+ *     is set, than the flags @p eliminate_unrefined_islands,
+ *     @p eliminate_refined_inner_islands and
+ *     @p eliminate_refined_boundary_islands will be ignored as they will
  *     be fulfilled automatically.
  *
- *   @item @p{smoothing_on_refinement}:
+ *   <li> @p smoothing_on_refinement:
  *     This flag sums up all smoothing algorithms which may be performed upon
  *     refinement by flagging some more cells for refinement.
  *
- *   @item @p{smoothing_on_coarsening}:
+ *   <li> @p smoothing_on_coarsening:
  *     This flag sums up all smoothing algorithms which may be performed upon
  *     coarsening by flagging some more cells for coarsening.
  *
- *   @item @p{maximum_smoothing}:
+ *   <li> @p maximum_smoothing:
  *     This flag includes all the above ones and therefore combines all
  *     smoothing algorithms implemented.
  *
- *   @item @p{none}:
+ *   <li> @p none:
  *     Select no smoothing at all.
- *   @end{itemize}
+ *   </ul>
  *
  *
  *   @sect3{Material and boundary information}
@@ -1174,9 +1174,9 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   @sect3{History of a triangulation}
  *
  *   It is possible to reconstruct a grid from its refinement history, which
- *   can be stored and loaded through the @p{save_refine_flags} and
- *   @p{load_refine_flags} functions. Normally, the code will look like this:
- *   @begin{verbatim}
+ *   can be stored and loaded through the @p save_refine_flags and
+ *   @p load_refine_flags functions. Normally, the code will look like this:
+ *   @verbatim
  *                                 // open output file
  *     ofstream history("mesh.history");
  *                                 // do 10 refinement steps
@@ -1187,10 +1187,10 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *       tria.save_refine_flags (history);
  *       tria.execute_coarsening_and_refinement ();
  *     };        
- *   @end{verbatim}
+ *   @endverbatim
  *
  *   If you want to re-create the grid from the stored information, you write:
- *   @begin{verbatim}
+ *   @verbatim
  *                                 // open input file
  *     ifstream history("mesh.history");
  *                                 // do 10 refinement steps
@@ -1198,7 +1198,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *       tria.load_refine_flags (history);
  *       tria.execute_coarsening_and_refinement ();
  *     };        
- *   @end{verbatim}
+ *   @endverbatim
  *
  *   The same scheme is employed for coarsening and the coarsening flags.
  *
@@ -1227,18 +1227,18 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   used if an algorithm walks over all cells and needs information whether
  *   another cell, e.g. a neighbor, has already been processed. It can also
  *   be used to flag the lines subject to constraints in 2D, as for example the
- *   functions in the @ref{DoFHandler} classes do.
+ *   functions in the DoFHandler classes do.
  *
- *   There are two functions, @p{save_user_flags} and @p{load_user_flags} which
+ *   There are two functions, @p save_user_flags and @p load_user_flags which
  *   write and read these flags to and from a stream. Unlike
- *   @p{save_refine_flags} and @p{load_refine_flags}, these two functions store
+ *   @p save_refine_flags and @p load_refine_flags, these two functions store
  *   and read the flags of all used lines, quads, etc, not only of the
  *   active ones (well, activity is a concept which really only applies to
  *   cells, not for example to lines in 2D, so the abovementioned generalization
  *   to <em>all</em> lines, quads, etc seems plausible).
  *
  *   If you want to store more specific user flags, you can use the functions
- *   @p{save_user_flags_line} and @p{load_user_flags_line} and the generalizations
+ *   @p save_user_flags_line and @p load_user_flags_line and the generalizations
  *   for quads, etc.
  *
  *   As for the refinement and coarsening flags, there exist two versions of these
@@ -1258,13 +1258,13 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   line, quad, etc. You can access these user pointers through the
  *   functions @p{user_pointer()}, @p{clear_user_pointer()} and
  *   @p{set_user_pointer(p)} in the accessor classes. These pointers are
- *   neither used nor changed by the library and are @p{NULL} by
+ *   neither used nor changed by the library and are @p NULL by
  *   default. Thus, their handling is the sole responsibility of the
  *   application program.  Especially, the pointers are not inherited
  *   to children upon refinement. Still, after a remeshing they are
  *   available on all cells, where they were set on the previous mesh.
  *
- *   The usual warning about the missing type safety of @p{void} pointers are
+ *   The usual warning about the missing type safety of @p void pointers are
  *   obviously in place here; responsibility for correctness of types etc
  *   lies entirely with the user of the pointer.
  *
@@ -1278,11 +1278,11 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   component. If a new vertex is created on a side or face at the
  *   boundary, this function is used to compute where it will be
  *   placed. The boundary indicator of the face will be used to
- *   determine the proper component. See @ref{Boundary} for the
- *   details. Usage with the @ref{Triangulation} object is then like this
- *   (let @p{Ball} be a class derived from @ref{Boundary}@p{<2>}):
+ *   determine the proper component. See Boundary for the
+ *   details. Usage with the Triangulation object is then like this
+ *   (let @p Ball be a class derived from Boundary@p{<2>}):
  * 
- *   @begin{verbatim}
+ *   @verbatim
  *     void main () {
  *       Triangulation<2> tria;
  *                                        // set the boundary function
@@ -1309,7 +1309,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *           tria.execute_coarsening_and_refinement();
  *         };
  *     };            
- *   @end{verbatim}
+ *   @endverbatim
  *
  *   You should take note of one caveat: if you have concave
  *   boundaries, you must make sure that a new boundary vertex does
@@ -1335,13 +1335,13 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   further the assumptions also hold.
  *
  *   The regularization and smoothing is done in the
- *   @p{prepare_coarsening_and_refinement} function, which is called by
- *   @p{execute_coarsening_and_refinement} at the very beginning.  It
+ *   @p prepare_coarsening_and_refinement function, which is called by
+ *   @p execute_coarsening_and_refinement at the very beginning.  It
  *   decides which additional cells to flag for refinement by looking
  *   at the old grid and the refinement flags for each cell.
  *
- *   @begin{itemize}
- *   @item <em>Regularization:</em> The algorithm walks over all cells checking
+ *   <ul>
+ *   <li> <em>Regularization:</em> The algorithm walks over all cells checking
  *     whether the present cell is flagged for refinement and a neighbor of the
  *     present cell is refined once less than the present one. If so, flag the
  *     neighbor for refinement. Because of the induction above, there may be no
@@ -1355,9 +1355,9 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     on lower levels, but if these induce more refinement needed, this is
  *     performed later on when we visit them in out backward running loop.
  *
- *   @item <em>Smoothing:</em>
- *     @begin{itemize}
- *     @item @p{limit_level_difference_at_vertices}:
+ *   <li> <em>Smoothing:</em>
+ *     <ul>
+ *     <li> @p limit_level_difference_at_vertices:
  *       First a list is set up which stores for each vertex
  *       the highest level one of the adjacent cells belongs to. Now, since we did
  *       smoothing in the previous refinement steps also, each cell may only have
@@ -1371,7 +1371,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *       refinement, but these are on lower levels, as above, which is why we
  *       may do all kinds of additional flagging in one loop only.
  *
- *     @item @p{eliminate_unrefined_islands}:
+ *     <li> @p eliminate_unrefined_islands:
  *       For each cell we count the number of neighbors which are refined or
  *       flagged for refinement. If this exceeds the total number of neighbors
  *       (which is the number of faces minus the number of faces of this cell
@@ -1380,7 +1380,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *       will need refinement, we will need additional loops of regularization
  *       and smoothing over all cells until nothing changes any more.
  *
- *     @item @p{eliminate_refined_*_islands}:
+ *     <li> @p{eliminate_refined_*_islands}:
  *       This one does much the same as the above one, but for coarsening. If
  *       a cell is flagged for refinement or if all of its children are active
  *       and if the number of neighbors which are either active and not flagged
@@ -1394,8 +1394,8 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *       of this classes description.
  *
  *       The same applies as above: several loops may be necessary.
- *     @end{itemize}
- *   @end{itemize}
+ *     </ul>
+ *   </ul>
  *
  *   Regularization and smoothing are a bit complementary in that we check
  *   whether we need to set additional refinement flags when being on a cell
@@ -1414,7 +1414,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   2D. The direction of a line is the direction of point 0 towards point 1. We
  *   define, that allowed cells contain of lines of which the direction is
  *   as follows:
- *   @begin{verbatim}
+ *   @verbatim
  *          2
  *      3--->---2
  *      |       |
@@ -1422,7 +1422,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *      |       |
  *      0--->---1
  *          0
- *   @end{verbatim}
+ *   @endverbatim
  *   The number of the vertices and lines is also indicated. This orientation of
  *   lines has to be checked/generated upon construction of a grid and is
  *   preserved upon refinement.
@@ -1437,7 +1437,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *
  *   Note that information about several of these conventions can be
  *   extracted at run- or compile-time from the member functions and
- *   variables of the @ref{GeometryInfo} classes.
+ *   variables of the GeometryInfo classes.
  *
  *
  *   @sect4{Coordinate systems}
@@ -1445,14 +1445,14 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   When explicit coordinates are required for points in a cell (e.g for
  *   quadrature formulae or the point of definition of trial functions), we
  *   define the following coordinate system for the unit cell:
- *   @begin{verbatim}
+ *   @verbatim
  *    y^   3-------2
  *     |   |       |
  *     |   |       |
  *     |   |       |
  *     |   0-------1
  *     *-------------->x
- *   @end{verbatim}
+ *   @endverbatim
  *   with vertex 0 being the origin of the coordinate system, vertex 1 having
  *   coordinates @p{(1,0)}, vertex 2 at @p{(1,1)} and vertex 3 at @p{(0,1)}.
  *
@@ -1464,7 +1464,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   dimensions. Before giving these conventions we declare the
  *   following sketch to be the standard way of drawing 3d pictures of
  *   hexahedra: 
- *   @begin{verbatim}
+ *   @verbatim
  *         *-------*        *-------*
  *        /|       |       /       /|
  *       / |       |      /       / |
@@ -1475,14 +1475,14 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     | /       /      |       | /
  *     |/       /       |       |/
  *     *-------*        *-------*
- *   @end{verbatim}
+ *   @endverbatim
  *   The left part of the picture shows the left, bottom and back face of the
  *   cube, while the right one shall be the top, right and front face. You may
  *   recover the whole cube by moving the two parts together into one.
  *
  *   Note again that information about several of the following
  *   conventions can be extracted at run- or compile-time from the
- *   member functions and variables of the @ref{GeometryInfo} classes.
+ *   member functions and variables of the GeometryInfo classes.
  *
  *
  *   @sect4{Vertices}
@@ -1491,7 +1491,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   the vertices on a quadrilateral. The vertices on the back face are numbered
  *   similarly by moving the front face to the back (no turning, no twisting, 
  *   just a shift):
- *   @begin{verbatim}
+ *   @verbatim
  *         7-------6        7-------6
  *        /|       |       /       /|
  *       / |       |      /       / |
@@ -1502,14 +1502,14 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     | /       /      |       | /
  *     |/       /       |       |/
  *     0-------1        0-------1
- *   @end{verbatim}
+ *   @endverbatim
  *
  *   @sect4{Lines}
  *
  *   Here, the same holds as for the vertices: the lines of the front face are
  *   numbered as for the quadrilateral, for the back face they are just shifted.
  *   Finally, the four lines connecting front and back face are numbered:
- *   @begin{verbatim}
+ *   @verbatim
  *         *---6---*        *---6---*
  *        /|       |       /       /|
  *      11 |       5      11     10 5
@@ -1520,10 +1520,10 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     3 8       9      3       | 9
  *     |/       /       |       |/
  *     *---0---*        *---0---*
- *   @end{verbatim}
+ *   @endverbatim
  *   The directions of the front and back lines is as for the respective faces, while
  *   the connecting lines always point to the back:
- *   @begin{verbatim}
+ *   @verbatim
  *         *--->---*        *--->---*
  *        /|       |       /       /|
  *       ^ |       ^      ^       ^ ^
@@ -1534,7 +1534,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     ^ ^       ^      ^       | ^
  *     |/       /       |       |/
  *     *--->---*        *--->---*
- *   @end{verbatim}
+ *   @endverbatim
  *
  *   The fact that edges (just as vertices and faces) are entities
  *   that are stored in their own right rather than constructed from
@@ -1546,7 +1546,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   class for creation of a triangulation, you therefore have to make
  *   sure that cells are oriented in a compatible fashion, so that
  *   edge directions are globally according to above
- *   convention. However, the @ref{GridReordering} class can do this
+ *   convention. However, the GridReordering class can do this
  *   for you, by reorienting cells and edges of an arbitrary list of
  *   input cells that need not be already sorted.
  *   
@@ -1554,7 +1554,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *
  *   The faces are numbered in the same order as the lines were numbered: front
  *   face, back face, then the four side faces:
- *   @begin{verbatim}
+ *   @verbatim
  *         *-------*        *-------*
  *        /|       |       /       /|
  *       / |   1   |      /   4   / |
@@ -1565,13 +1565,13 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     | /   2   /      |   0   | /
  *     |/       /       |       |/
  *     *-------*        *-------*
- *   @end{verbatim}
+ *   @endverbatim
  *
  *   The <em>standard</em> direction of the faces is determined by the
  *   numbers the lines have within a given face. This is like follows:
- *   @begin{itemize}
- *   @item Faces 0 and 1:
- *    @begin{verbatim}
+ *   <ul>
+ *   <li> Faces 0 and 1:
+ *    @verbatim
  *          *---2---*        *-------*
  *         /|       |       /       /|
  *        / |       1      /       / |
@@ -1582,10 +1582,10 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *      | /       /      3       | /
  *      |/       /       |       |/
  *      *-------*        *---0---*
- *    @end{verbatim}
+ *    @endverbatim
  * 
- *   @item Faces 2 and 4:
- *    @begin{verbatim}
+ *   <li> Faces 2 and 4:
+ *    @verbatim
  *          *-------*        *---2---*
  *         /|       |       /       /|
  *        / |       |      3       1 |
@@ -1596,10 +1596,10 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *      | 3       1      |       | /
  *      |/       /       |       |/
  *      *---0---*        *-------*
- *    @end{verbatim} 
+ *    @endverbatim 
  * 
- *   @item Faces 3 and 5:
- *    @begin{verbatim}
+ *   <li> Faces 3 and 5:
+ *    @verbatim
  *          *-------*        *-------*
  *         /|       |       /       /|
  *        2 1       |      /       2 1
@@ -1610,25 +1610,25 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *      | 0       /      |       | 0
  *      |/       /       |       |/
  *      *-------*        *-------*
- *    @end{verbatim}
- *   @end{itemize}
+ *    @endverbatim
+ *   </ul>
  * 
  *   Due to this numbering, the following lines are identical in the
  *   standard orientation:
- *   @begin{itemize}
- *   @item Line 0 of face 0, and line 0 of face 2;
- *   @item Line 1 of face 0, and line 3 of face 3;
- *   @item Line 2 of face 0, and line 0 of face 4;
- *   @item Line 3 of face 0, and line 3 of face 5;
- *   @item Line 0 of face 1, and line 2 of face 2;
- *   @item Line 1 of face 1, and line 1 of face 3;
- *   @item Line 2 of face 1, and line 2 of face 4;
- *   @item Line 3 of face 1, and line 1 of face 5;
- *   @item Line 3 of face 2, and line 0 of face 5;
- *   @item Line 1 of face 2, and line 0 of face 3;
- *   @item Line 1 of face 4, and line 2 of face 3;
- *   @item Line 3 of face 4, and line 2 of face 5.
- *   @end{itemize}
+ *   <ul>
+ *   <li> Line 0 of face 0, and line 0 of face 2;
+ *   <li> Line 1 of face 0, and line 3 of face 3;
+ *   <li> Line 2 of face 0, and line 0 of face 4;
+ *   <li> Line 3 of face 0, and line 3 of face 5;
+ *   <li> Line 0 of face 1, and line 2 of face 2;
+ *   <li> Line 1 of face 1, and line 1 of face 3;
+ *   <li> Line 2 of face 1, and line 2 of face 4;
+ *   <li> Line 3 of face 1, and line 1 of face 5;
+ *   <li> Line 3 of face 2, and line 0 of face 5;
+ *   <li> Line 1 of face 2, and line 0 of face 3;
+ *   <li> Line 1 of face 4, and line 2 of face 3;
+ *   <li> Line 3 of face 4, and line 2 of face 5.
+ *   </ul>
  *
  *   This standard orientation of faces in 3d can also be depicted by
  *   assigning a normal vector to each face. The direction of this
@@ -1656,7 +1656,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   orders, and the above line equivalences would not hold any
  *   more. You can ask a cell whether a given face has standard
  *   orientation by calling @p{cell->face_orientation(face_no)}: if
- *   the result is @p{true}, then the face has standard orientation,
+ *   the result is @p true, then the face has standard orientation,
  *   otherwise its normal vector is pointing the other
  *   direction. There are not very many places in application programs
  *   where you need this information actually, but a few places in the
@@ -1665,7 +1665,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   @sect4{Children}
  *
  *   The eight children of a cell are numbered as follows:
- *   @begin{verbatim}
+ *   @verbatim
  *         *-------*        *-------*
  *        /| 7   6 |       / 7   6 /|
  *       /7|       |      /       /6|
@@ -1676,19 +1676,19 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     |0/       /      |       |1/
  *     |/0    1 /       | 0   1 |/
  *     *-------*        *-------*
- *   @end{verbatim}
+ *   @endverbatim
  *
  *   Taking into account the orientation of the faces, the following
  *   children are adjacent to the respective faces:
- *   @begin{itemize}
- *   @item Face 0: children 0, 1, 2, 3;
- *   @item Face 1: children 4, 5, 6, 7;
- *   @item Face 2: children 0, 1, 5, 4;
- *   @item Face 3: children 1, 5, 6, 2;
- *   @item Face 4: children 3, 2, 6, 7;
- *   @item Face 5: children 0, 4, 7, 3.
- *   @end{itemize}
- *   You can get these numbers using the @ref{GeometryInfo<3>}@p{::child_cell_on_face}
+ *   <ul>
+ *   <li> Face 0: children 0, 1, 2, 3;
+ *   <li> Face 1: children 4, 5, 6, 7;
+ *   <li> Face 2: children 0, 1, 5, 4;
+ *   <li> Face 3: children 1, 5, 6, 2;
+ *   <li> Face 4: children 3, 2, 6, 7;
+ *   <li> Face 5: children 0, 4, 7, 3.
+ *   </ul>
+ *   You can get these numbers using the @ref{GeometryInfo<3>}@p ::child_cell_on_face
  *   function. Each child is adjacent to the vertex with the same number.
  *
  *   Note that, again, the above list only holds for faces in their
@@ -1699,7 +1699,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   The information which child cell is at which position of which
  *   face is most often used when computing jump terms across faces
  *   with hanging nodes, using objects of type
- *   @ref{FESubfaceValues}. Sitting on one cell, you would look at
+ *   FESubfaceValues. Sitting on one cell, you would look at
  *   face and figure out which child of the neighbor is sitting on a
  *   given subface between the present and the neighboring cell. To
  *   avoid having to query the standard orientation of the faces of
@@ -1717,7 +1717,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *
  *   We define the following coordinate system for the explicit coordinates of
  *   the vertices of the unit cell:
- *   @begin{verbatim}
+ *   @verbatim
  *                         7-------6        7-------6
  *                        /|       |       /       /|
  *                       / |       |      /       / |
@@ -1728,31 +1728,31 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *    | /              | /       /      |       | /
  *    |/               |/       /       |       |/
  *    *------>x        0-------1        0-------1
- *   @end{verbatim}
+ *   @endverbatim
  *   This convention in conjunction with the numbering of the vertices is a bit
  *   unfortunate, since the vertices 0 through 3 have the coordinates @p{(x,0,z)}
- *   with @p{x} and @p{z} being the same as the @p{x} and @p{y} coordinates of a quad
+ *   with @p x and @p z being the same as the @p x and @p y coordinates of a quad
  *   in the plane; more intuitive would have been if they had the coordinates
  *   @p{(x,y,0)}. However, the vertex numbering was historically chosen as shown.
  *
  *   By the convention laid down as above, the vertices have the following
  *   coordinates:
- *   @begin{itemize}
- *      @item Vertex 0: @p{(0,0,0)};
- *      @item Vertex 1: @p{(1,0,0)};
- *      @item Vertex 2: @p{(1,0,1)};
- *      @item Vertex 3: @p{(0,0,1)};
- *      @item Vertex 4: @p{(0,1,0)};
- *      @item Vertex 5: @p{(1,1,0)};
- *      @item Vertex 6: @p{(1,1,1)};
- *      @item Vertex 7: @p{(0,1,1)}.
- *   @end{itemize}
+ *   <ul>
+ *      <li> Vertex 0: @p{(0,0,0)};
+ *      <li> Vertex 1: @p{(1,0,0)};
+ *      <li> Vertex 2: @p{(1,0,1)};
+ *      <li> Vertex 3: @p{(0,0,1)};
+ *      <li> Vertex 4: @p{(0,1,0)};
+ *      <li> Vertex 5: @p{(1,1,0)};
+ *      <li> Vertex 6: @p{(1,1,1)};
+ *      <li> Vertex 7: @p{(0,1,1)}.
+ *   </ul>
  *
  *
  *   @sect3{Warning}
  *
- *   It seems impossible to preserve @p{const}ness of a triangulation through
- *   iterator usage. Thus, if you declare pointers to a @p{const} triangulation
+ *   It seems impossible to preserve @p constness of a triangulation through
+ *   iterator usage. Thus, if you declare pointers to a @p const triangulation
  *   object, you should be well aware that you might involuntarily alter the
  *   data stored in the triangulation.
  *
@@ -1768,7 +1768,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Default boundary object. This
                                      * declaration is used for the
                                      * default argument in
-                                     * @p{set_boundary}.
+                                     * @p set_boundary.
                                      *
                                      * The proper way would have been
                                      * to use a static object here,
@@ -1776,19 +1776,19 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * object. However, we have to
                                      * work around a bug in gcc2.95,
                                      * where the compiler tries to
-                                     * instantiate @p{Triangulation}
+                                     * instantiate @p Triangulation
                                      * while instantiating
-                                     * @p{Boundary} (which it needs
+                                     * @p Boundary (which it needs
                                      * to do, since local typedefs
                                      * are involved), but then tries
                                      * to in turn instantiate
-                                     * @p{StraightBoundary} because
+                                     * @p StraightBoundary because
                                      * of this member variable. This
                                      * is not needed since the member
                                      * variable is a static one, but
                                      * the compiler tries anyway and
                                      * finds that it can't since the
-                                     * base class @p{Boundary} is not
+                                     * base class @p Boundary is not
                                      * yet complete...
                                      */
     static const StraightBoundary<dim> *straight_boundary;
@@ -1800,7 +1800,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * for mesh smoothing
                                      * algorithms. The meaning of
                                      * these flags is documented in
-                                     * the @ref{Triangulation} class.
+                                     * the Triangulation class.
                                      */
     enum MeshSmoothing
     {
@@ -1852,7 +1852,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Copy constructor. You should really
-                                     *  use the @p{copy_triangulation} function,
+                                     *  use the @p copy_triangulation function,
                                      *  so we declare this function but let
                                      *  it throw an internal error. The
                                      *  reason for this is that we may use
@@ -1878,7 +1878,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *
                                      * Note that this operation is only allowed
                                      * if no subscriptions to this object exist
-                                     * any more, such as @ref{DoFHandler} objects
+                                     * any more, such as DoFHandler objects
                                      * using it.
                                      */
     void clear ();
@@ -1886,7 +1886,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /**                                        
                                      * Assign a boundary object to
                                      * the triangulation. If a face
-                                     * with boundary number @p{number}
+                                     * with boundary number @p number
                                      * is refined, this object is
                                      * used to find the location of
                                      * new vertices on the
@@ -1912,15 +1912,15 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * and are accessed with accessor
                                      * functions of that name.
                                      *
-                                     * The @p{boundary_object} is not
+                                     * The @p boundary_object is not
                                      * copied and MUST persist until
                                      * the triangulation is
                                      * destroyed. Otherwise, the
-                                     * @ref{Subscriptor} class will issue
-                                     * @p{ExcObjectInUse}.  This is
+                                     * Subscriptor class will issue
+                                     * @p ExcObjectInUse.  This is
                                      * also true for triangulations
                                      * generated from this one by
-                                     * @p{copy_triangulation}.
+                                     * @p copy_triangulation.
                                      *
                                      * It is possible to remove or
                                      * replace the boundary object
@@ -1945,7 +1945,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * a boundary object used for
                                      * this triangulation.  Number is
                                      * the same as in
-                                     * @p{set_boundary}
+                                     * @p set_boundary
                                      */
     const Boundary<dim> & get_boundary (const unsigned int number) const;
     
@@ -1965,7 +1965,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  function also copies the
                                      *  pointer to the boundary
                                      *  descriptor previously set by
-                                     *  the @p{set_boundary}
+                                     *  the @p set_boundary
                                      *  function. You must therefore
                                      *  also guarantee that the
                                      *  boundary objects has a
@@ -1976,7 +1976,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  empty beforehand.
                                      *
                                      *  The function is made
-                                     *  @p{virtual} since some
+                                     *  @p virtual since some
                                      *  derived classes might want to
                                      *  disable or extend the
                                      *  functionality of this
@@ -1996,19 +1996,19 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * (connected domain, etc.).
                                      *
                                      * Material data for the cells is
-                                     * given within the @p{cells}
+                                     * given within the @p cells
                                      * array, while boundary
                                      * information is given in the
-                                     * @p{subcelldata} field.
+                                     * @p subcelldata field.
                                      *
                                      * The numbering of vertices
-                                     * within the @p{cells} array is
+                                     * within the @p cells array is
                                      * subject to some constraints;
                                      * see the general class
                                      * documentation for this.
                                      *
                                      * This function is made
-                                     * @p{virtual} to allow derived
+                                     * @p virtual to allow derived
                                      * classes to set up some data
                                      * structures as well.
                                      *
@@ -2016,8 +2016,8 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * function can generate a valid
                                      * triangulation, see the
                                      * documentation of this class,
-                                     * and the @ref{GridIn} and
-                                     * @ref{GridReordering} class.
+                                     * and the GridIn and
+                                     * GridReordering class.
                                      */
     virtual void create_triangulation (const std::vector<Point<dim> >    &vertices,
                                       const std::vector<CellData<dim> > &cells,
@@ -2029,15 +2029,15 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * of the grid.  The direction of
                                      * moving is random, while the
                                      * length of the shift vector has
-                                     * a value of @p{factor} times
+                                     * a value of @p factor times
                                      * the minimal length of the
                                      * active lines adjacent to this
-                                     * vertex. Note that @p{factor}
+                                     * vertex. Note that @p factor
                                      * should obviously be well below
                                      * @p{0.5}.
                                      *
-                                     * If @p{keep_boundary} is set to
-                                     * @p{true} (which is the
+                                     * If @p keep_boundary is set to
+                                     * @p true (which is the
                                      * default), then boundary
                                      * vertices are not moved.
                                      */
@@ -2064,7 +2064,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
     void set_all_refine_flags ();
 
                                     /**
-                                     *  Refine all cells @p{times}
+                                     *  Refine all cells @p times
                                      *  times, by alternatingly
                                      *  calling
                                      *  @p{set_all_refine_flags()}
@@ -2075,7 +2075,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  you have no way to store the
                                      *  refinement flags unless you
                                      *  overload the
-                                     *  @p{execute_coarsening_and_refinement}
+                                     *  @p execute_coarsening_and_refinement
                                      *  function.
                                      */
     void refine_global (const unsigned int times);
@@ -2094,7 +2094,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                       * information.
                                      *
                                      * Note that this function is
-                                     * @p{virtual} to allow derived
+                                     * @p virtual to allow derived
                                      * classes to insert hooks, such
                                      * as saving refinement flags and
                                      * the like.
@@ -2130,7 +2130,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * independent. However, for some
                                      * dimension dependent things, it
                                      * calls
-                                     * @p{prepare_refinement_dim_dependent}.
+                                     * @p prepare_refinement_dim_dependent.
                                      *
                                      * Regarding the coarsening part,
                                      * flagging and deflagging cells
@@ -2171,7 +2171,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /**
                                      *  Save the addresses of the
                                      *  cells which are flagged for
-                                     *  refinement to @p{out}.  For
+                                     *  refinement to @p out.  For
                                      *  usage, read the general
                                      *  documentation for this class.
                                      */
@@ -2185,18 +2185,18 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Read the information stored by
-                                     *  @p{save_refine_flags}.
+                                     *  @p save_refine_flags.
                                      */
     void load_refine_flags (std::istream &in);
 
                                     /**
                                      *  Read the information stored by
-                                     *  @p{save_refine_flags}.
+                                     *  @p save_refine_flags.
                                      */
     void load_refine_flags (const std::vector<bool> &v);
 
                                     /**
-                                     * Analogue to @p{save_refine_flags}.
+                                     * Analogue to @p save_refine_flags.
                                      */
     void save_coarsen_flags (std::ostream &out) const;
 
@@ -2207,12 +2207,12 @@ class Triangulation : public TriaDimensionInfo<dim>,
     void save_coarsen_flags (std::vector<bool> &v) const;
 
                                     /**
-                                     * Analogue to @p{load_refine_flags}.
+                                     * Analogue to @p load_refine_flags.
                                      */
     void load_coarsen_flags (std::istream &out);
 
                                     /**
-                                     * Analogue to @p{load_refine_flags}.
+                                     * Analogue to @p load_refine_flags.
                                      */
     void load_coarsen_flags (const std::vector<bool> &v);
 
@@ -2232,7 +2232,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Save all user flags. See the general
                                      *  documentation for this class
                                      *  and the documentation for the
-                                     *  @p{save_refine_flags} for more
+                                     *  @p save_refine_flags for more
                                      *  details.
                                      */
     void save_user_flags (std::ostream &out) const;
@@ -2247,13 +2247,13 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Read the information stored by
-                                     *  @p{save_user_flags}.
+                                     *  @p save_user_flags.
                                      */
     void load_user_flags (std::istream &in);
 
                                     /**
                                      *  Read the information stored by
-                                     *  @p{save_user_flags}.
+                                     *  @p save_user_flags.
                                      */
     void load_user_flags (const std::vector<bool> &v);
 
@@ -2341,7 +2341,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Read the information stored by
-                                     * @p{save_user_pointers}.
+                                     * @p save_user_pointers.
                                      */
     void load_user_pointers (const std::vector<void *> &v);
 
@@ -2391,30 +2391,30 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /*@{*/
                                     /**
                                      *  Iterator to the first cell, used
-                                     *  or not, on level @p{level}. If a level
+                                     *  or not, on level @p level. If a level
                                      *  has no cells, a past-the-end iterator
                                      *  is returned.
                                      *
-                                     *  This function calls @p{begin_raw_line}
-                                     *  in 1D and @p{begin_raw_quad} in 2D.
+                                     *  This function calls @p begin_raw_line
+                                     *  in 1D and @p begin_raw_quad in 2D.
                                      */
     raw_cell_iterator    begin_raw   (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first used cell
-                                     *  on level @p{level}.
+                                     *  on level @p level.
                                      *
-                                     *  This function calls @p{begin_line}
-                                     *  in 1D and @p{begin_quad} in 2D.
+                                     *  This function calls @p begin_line
+                                     *  in 1D and @p begin_quad in 2D.
                                      */
     cell_iterator        begin       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  cell on level @p{level}.
+                                     *  cell on level @p level.
                                      *
-                                     *  This function calls @p{begin_active_line}
-                                     *  in 1D and @p{begin_active_quad} in 2D.
+                                     *  This function calls @p begin_active_line
+                                     *  in 1D and @p begin_active_quad in 2D.
                                      */
     active_cell_iterator begin_active(const unsigned int level = 0) const;
 
@@ -2424,14 +2424,14 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  iterators with past-the-end or
                                      *  before-the-beginning states.
                                      *
-                                     *  This function calls @p{end_line}
-                                     *  in 1D and @p{end_quad} in 2D.
+                                     *  This function calls @p end_line
+                                     *  in 1D and @p end_quad in 2D.
                                      */
     raw_cell_iterator    end () const;
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2439,7 +2439,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2447,7 +2447,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If @p{level}
+                                     * first iterator not on level. If @p level
                                      * is the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2458,17 +2458,17 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Return an iterator pointing to the
                                      *  last cell, used or not.
                                      *
-                                     *  This function calls @p{last_raw_line}
-                                     *  in 1D and @p{last_raw_quad} in 2D.
+                                     *  This function calls @p last_raw_line
+                                     *  in 1D and @p last_raw_quad in 2D.
                                      */
     raw_cell_iterator    last_raw () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  cell of the level @p{level}, used or not.
+                                     *  cell of the level @p level, used or not.
                                      *
-                                     *  This function calls @p{last_raw_line}
-                                     *  in 1D and @p{last_raw_quad} in 2D.
+                                     *  This function calls @p last_raw_line
+                                     *  in 1D and @p last_raw_quad in 2D.
                                      */
     raw_cell_iterator    last_raw (const unsigned int level) const;
 
@@ -2476,17 +2476,17 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Return an iterator pointing to the last
                                      *  used cell.
                                      *
-                                     *  This function calls @p{last_line}
-                                     *  in 1D and @p{last_quad} in 2D.
+                                     *  This function calls @p last_line
+                                     *  in 1D and @p last_quad in 2D.
                                      */
     cell_iterator        last () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used cell on level @p{level}.
+                                     *  used cell on level @p level.
                                      *
-                                     *  This function calls @p{last_line}
-                                     *  in 1D and @p{last_quad} in 2D.
+                                     *  This function calls @p last_line
+                                     *  in 1D and @p last_quad in 2D.
                                      */
     cell_iterator        last (const unsigned int level) const;
 
@@ -2494,17 +2494,17 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Return an iterator pointing to the last
                                      *  active cell.
                                      *
-                                     *  This function calls @p{last_active_line}
-                                     *  in 1D and @p{last_active_quad} in 2D.
+                                     *  This function calls @p last_active_line
+                                     *  in 1D and @p last_active_quad in 2D.
                                      */
     active_cell_iterator last_active () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active cell on level @p{level}.
+                                     *  active cell on level @p level.
                                      *
-                                     *  This function calls @p{last_active_line}
-                                     *  in 1D and @p{last_active_quad} in 2D.
+                                     *  This function calls @p last_active_line
+                                     *  in 1D and @p last_active_quad in 2D.
                                      */
     active_cell_iterator last_active (const unsigned int level) const;
                                     /*@}*/
@@ -2518,30 +2518,30 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /*@{*/
                                     /**
                                      *  Iterator to the first face, used
-                                     *  or not, on level @p{level}. If a level
+                                     *  or not, on level @p level. If a level
                                      *  has no faces, a past-the-end iterator
                                      *  is returned.
                                      *
-                                     *  This function calls @p{begin_raw_line}
-                                     *  in 2D and @p{begin_raw_quad} in 3D.
+                                     *  This function calls @p begin_raw_line
+                                     *  in 2D and @p begin_raw_quad in 3D.
                                      */
     raw_face_iterator    begin_raw_face   (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first used face
-                                     *  on level @p{level}.
+                                     *  on level @p level.
                                      *
-                                     *  This function calls @p{begin_line}
-                                     *  in 2D and @p{begin_quad} in 3D.
+                                     *  This function calls @p begin_line
+                                     *  in 2D and @p begin_quad in 3D.
                                      */
     face_iterator        begin_face       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  face on level @p{level}.
+                                     *  face on level @p level.
                                      *
-                                     *  This function calls @p{begin_active_line}
-                                     *  in 2D and @p{begin_active_quad} in 3D.
+                                     *  This function calls @p begin_active_line
+                                     *  in 2D and @p begin_active_quad in 3D.
                                      */
     active_face_iterator begin_active_face(const unsigned int level = 0) const;
 
@@ -2551,14 +2551,14 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  iterators with past-the-end or
                                      *  before-the-beginning states.
                                      *
-                                     *  This function calls @p{end_line}
-                                     *  in 2D and @p{end_quad} in 3D.
+                                     *  This function calls @p end_line
+                                     *  in 2D and @p end_quad in 3D.
                                      */
     raw_face_iterator    end_face () const;
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2566,7 +2566,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2574,7 +2574,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If @p{level}
+                                     * first iterator not on level. If @p level
                                      * is the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2584,17 +2584,17 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Return an iterator pointing to the
                                      *  last face, used or not.
                                      *
-                                     *  This function calls @p{last_raw_line}
-                                     *  in 2D and @p{last_raw_quad} in 3D.
+                                     *  This function calls @p last_raw_line
+                                     *  in 2D and @p last_raw_quad in 3D.
                                      */
     raw_face_iterator    last_raw_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  face of the level @p{level}, used or not.
+                                     *  face of the level @p level, used or not.
                                      *
-                                     *  This function calls @p{last_raw_line}
-                                     *  in 2D and @p{last_raw_quad} in 3D.
+                                     *  This function calls @p last_raw_line
+                                     *  in 2D and @p last_raw_quad in 3D.
                                      */
     raw_face_iterator    last_raw_face (const unsigned int level) const;
 
@@ -2602,17 +2602,17 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Return an iterator pointing to the last
                                      *  used face.
                                      *
-                                     *  This function calls @p{last_line}
-                                     *  in 2D and @p{last_quad} in 3D.
+                                     *  This function calls @p last_line
+                                     *  in 2D and @p last_quad in 3D.
                                      */
     face_iterator        last_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used face on level @p{level}.
+                                     *  used face on level @p level.
                                      *
-                                     *  This function calls @p{last_line}
-                                     *  in 2D and @p{last_quad} in 3D.
+                                     *  This function calls @p last_line
+                                     *  in 2D and @p last_quad in 3D.
                                      */
     face_iterator        last_face (const unsigned int level) const;
 
@@ -2620,17 +2620,17 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Return an iterator pointing to the last
                                      *  active face.
                                      *
-                                     *  This function calls @p{last_active_line}
-                                     *  in 2D and @p{last_active_quad} in 3D.
+                                     *  This function calls @p last_active_line
+                                     *  in 2D and @p last_active_quad in 3D.
                                      */
     active_face_iterator last_active_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active face on level @p{level}.
+                                     *  active face on level @p level.
                                      *
-                                     *  This function calls @p{last_active_line}
-                                     *  in 2D and @p{last_active_quad} in 3D.
+                                     *  This function calls @p last_active_line
+                                     *  in 2D and @p last_active_quad in 3D.
                                      */
     active_face_iterator last_active_face (const unsigned int level) const;
                                     /*@}*/
@@ -2644,7 +2644,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /*@{*/
                                     /**
                                      *  Iterator to the first line, used
-                                     *  or not, on level @p{level}. If a level
+                                     *  or not, on level @p level. If a level
                                      *  has no lines, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -2653,14 +2653,14 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Iterator to the first used line
-                                     *  on level @p{level}.
+                                     *  on level @p level.
                                      */
     line_iterator
     begin_line       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  line on level @p{level}.
+                                     *  line on level @p level.
                                      */
     active_line_iterator
     begin_active_line(const unsigned int level = 0) const;
@@ -2676,7 +2676,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2684,7 +2684,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2692,7 +2692,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If @p{level}
+                                     * first iterator not on level. If @p level
                                      * is the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2707,7 +2707,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  line of the level @p{level}, used or not.
+                                     *  line of the level @p level, used or not.
 
                                      */
     raw_line_iterator
@@ -2722,7 +2722,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used line on level @p{level}.
+                                     *  used line on level @p level.
                                      */
     line_iterator
     last_line (const unsigned int level) const;
@@ -2736,7 +2736,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active line on level @p{level}.
+                                     *  active line on level @p level.
                                      */
     active_line_iterator
     last_active_line (const unsigned int level) const;
@@ -2751,7 +2751,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      */
                                     /**
                                      *  Iterator to the first quad, used
-                                     *  or not, on level @p{level}. If a level
+                                     *  or not, on level @p level. If a level
                                      *  has no quads, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -2760,14 +2760,14 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Iterator to the first used quad
-                                     *  on level @p{level}.
+                                     *  on level @p level.
                                      */
     quad_iterator
     begin_quad       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  quad on level @p{level}.
+                                     *  quad on level @p level.
                                      */
     active_quad_iterator
     begin_active_quad(const unsigned int level = 0) const;
@@ -2783,7 +2783,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2791,7 +2791,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2799,7 +2799,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If @p{level}
+                                     * first iterator not on level. If @p level
                                      * is the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2814,7 +2814,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  quad of the level @p{level}, used or not.
+                                     *  quad of the level @p level, used or not.
 
                                      */
     raw_quad_iterator
@@ -2829,7 +2829,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used quad on level @p{level}.
+                                     *  used quad on level @p level.
                                      */
     quad_iterator
     last_quad (const unsigned int level) const;
@@ -2843,7 +2843,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active quad on level @p{level}.
+                                     *  active quad on level @p level.
                                      */
     active_quad_iterator
     last_active_quad (const unsigned int level) const;
@@ -2858,7 +2858,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      */
                                     /**
                                      *  Iterator to the first hex, used
-                                     *  or not, on level @p{level}. If a level
+                                     *  or not, on level @p level. If a level
                                      *  has no hexs, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -2867,14 +2867,14 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Iterator to the first used hex
-                                     *  on level @p{level}.
+                                     *  on level @p level.
                                      */
     hex_iterator
     begin_hex       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  hex on level @p{level}.
+                                     *  hex on level @p level.
                                      */
     active_hex_iterator
     begin_active_hex(const unsigned int level = 0) const;
@@ -2890,7 +2890,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2898,7 +2898,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If @p{level} is
+                                     * iterator not on level. If @p level is
                                      * the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2906,7 +2906,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If @p{level}
+                                     * first iterator not on level. If @p level
                                      * is the last level, then this returns
                                      * @p{end()}.
                                      */
@@ -2921,7 +2921,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  hex of the level @p{level}, used or not.
+                                     *  hex of the level @p level, used or not.
 
                                      */
     raw_hex_iterator
@@ -2936,7 +2936,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used hex on level @p{level}.
+                                     *  used hex on level @p level.
                                      */
     hex_iterator
     last_hex (const unsigned int level) const;
@@ -2950,7 +2950,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active hex on level @p{level}.
+                                     *  active hex on level @p level.
                                      */
     active_hex_iterator
     last_active_hex (const unsigned int level) const;
@@ -2970,7 +2970,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
                                     /**
                                      *  Return total number of used lines,
-                                     *  active or not on level @p{level}.
+                                     *  active or not on level @p level.
                                      */
     unsigned int n_lines (const unsigned int level) const;
     
@@ -2981,7 +2981,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
                                     /**
                                      *  Return total number of active lines,
-                                     *  on level @p{level}.
+                                     *  on level @p level.
                                      */
     unsigned int n_active_lines (const unsigned int level) const;
     
@@ -2993,7 +2993,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return total number of used quads,
-                                     *  active or not on level @p{level}.
+                                     *  active or not on level @p level.
                                      */
     unsigned int n_quads (const unsigned int level) const;
     
@@ -3005,7 +3005,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
                                     /**
                                      *  Return total number of active quads,
-                                     *  active or not on level @p{level}.
+                                     *  active or not on level @p level.
                                      */
     unsigned int n_active_quads (const unsigned int level) const;
     
@@ -3017,7 +3017,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return total number of used hexahedra,
-                                     *  active or not on level @p{level}.
+                                     *  active or not on level @p level.
                                      */
     unsigned int n_hexs(const unsigned int level) const;
     
@@ -3029,7 +3029,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
                                     /**
                                      *  Return total number of active hexahedra,
-                                     *  active or not on level @p{level}.
+                                     *  active or not on level @p level.
                                      */
     unsigned int n_active_hexs(const unsigned int level) const;
 
@@ -3043,7 +3043,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return total number of used cells,
-                                     *  active or not, on level @p{level}.
+                                     *  active or not, on level @p level.
                                      *  Maps to @p{n_lines(level)} in one space
                                      *  dimension and so on.
                                      */
@@ -3058,7 +3058,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Return total number of active cells
-                                     * on level @p{level}.
+                                     * on level @p level.
                                      * Maps to @p{n_active_lines(level)} in one
                                      * space dimension and so on.
                                      */
@@ -3088,7 +3088,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * holes in the numbers of used
                                      * vertices.  You can get the
                                      * number of used vertices using
-                                     * @p{n_used_vertices} function.
+                                     * @p n_used_vertices function.
                                      */
     unsigned int n_vertices () const;
 
@@ -3107,7 +3107,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * once. You can find out about
                                      * which vertices are actually
                                      * used by the function
-                                     * @ref{get_used_vertices}.
+                                     * get_used_vertices().
                                      */
     const std::vector<Point<dim> > &
     get_vertices () const;
@@ -3122,7 +3122,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Return a constant reference to
-                                     * the array of @p{bool}s
+                                     * the array of @p bools
                                      * indicating whether an entry in
                                      * the vertex array is used or
                                      * not.
@@ -3290,11 +3290,11 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  as ASCII text.
                                      *
                                      *  The flags are stored in a binary
-                                     *  format: for each @p{true}, a @p{1}
-                                     *  bit is stored, a @p{0} bit otherwise.
+                                     *  format: for each @p true, a @p 1
+                                     *  bit is stored, a @p 0 bit otherwise.
                                      *  The bits are stored as @p{unsigned char},
                                      *  thus avoiding endianess. They are
-                                     *  written to @p{out} in plain text, thus
+                                     *  written to @p out in plain text, thus
                                      *  amounting to 3.6 bits per active cell
                                      *  on the overage. Other information
                                      *  (magic numbers ans number of elements)
@@ -3309,7 +3309,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Re-read a vector of bools previously
-                                     * written by @p{write_bool_vector} and
+                                     * written by @p write_bool_vector and
                                      * compare with the magic numbers.
                                      */
     static void read_bool_vector (const unsigned int       magic_number1,
@@ -3339,7 +3339,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * it children, which is the
                                      * main step for the coarsening process.
                                      * This is the dimension dependent part
-                                     * of @p{execute_coarsening}.
+                                     * of @p execute_coarsening.
                                      */
     void delete_children (cell_iterator &cell);
 
@@ -3356,7 +3356,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * otherwise to steps of interpolation
                                      * would be necessary. This would make
                                      * the processes implemented in the
-                                     * @p{ConstraintMatrix} class much more
+                                     * @p ConstraintMatrix class much more
                                      * complex, since these two steps of
                                      * interpolation do not commute.
                                      */
@@ -3373,9 +3373,9 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Re-compute the number of
                                      * lines, quads, etc. This
                                      * function is called by
-                                     * @p{execute_coarsening_and_refinement}
+                                     * @p execute_coarsening_and_refinement
                                      * and by
-                                     * @p{create_triangulation} after
+                                     * @p create_triangulation after
                                      * the grid was changed.
                                      *
                                      * This function simply delegates
index 1e6f00320ec497b756862431d4b3c978e627817e..5521b0b7463afe234509685f3073db3b8a2ecb0e 100644 (file)
@@ -112,7 +112,7 @@ class TriaAccessor
                                      * classes. Since the pure
                                      * triangulation iterators need
                                      * no additional data, this data
-                                     * type is @p{void}.
+                                     * type is @p void.
                                      */
     typedef void AccessorData;
 
@@ -144,8 +144,8 @@ class TriaAccessor
                                      *  used in a context like
                                      *  @p{iterator a,b;  *a=*b;}. Since
                                      *  the meaning is to copy the object
-                                     *  pointed to by @p{b} to the object
-                                     *  pointed to by @p{a} and since
+                                     *  pointed to by @p b to the object
+                                     *  pointed to by @p a and since
                                      *  accessors are not real but
                                      *  virtual objects, this operation
                                      *  is not useful for iterators on
@@ -206,7 +206,7 @@ class TriaAccessor
                                      *  iterator.  For the different
                                      *  states an accessor can be in,
                                      *  refer to the
-                                     *  @ref{TriaRawIterator}
+                                     *  TriaRawIterator
                                      *  documentation.
                                      */
     IteratorState::IteratorStates state () const;
@@ -307,9 +307,9 @@ class TriaAccessor
 
 /**
  * Common template for line, quad, hex accessors.  According to
- * @p{celldim} objects of this class represent lines, quadrilaterals,
- * or hexahedra in @p{dim} space dimensions. Concrete implementations
- * are done for specialized @p{celldim} template parameter. For easier
+ * @p celldim objects of this class represent lines, quadrilaterals,
+ * or hexahedra in @p dim space dimensions. Concrete implementations
+ * are done for specialized @p celldim template parameter. For easier
  * access, we nevertheless document all functions of the specialized
  * classes here as well. However, they are not implemented.
  *
@@ -362,7 +362,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      *  convention regarding the
                                      *  numbering of vertices is laid
                                      *  down in the documentation of
-                                     *  the @ref{Triangulation}
+                                     *  the Triangulation
                                      *  class.
                                      *
                                      *  Note that the returned value is only
@@ -370,19 +370,19 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      *  vertex. It has nothing to do with
                                      *  possible degrees of freedom
                                      *  associated with it. For this, see the
-                                     *  @p{DoFAccessor::vertex_dof_index}
+                                     *  @p DoFAccessor::vertex_dof_index
                                      *  functions.
                                      */ 
     int vertex_index (const unsigned int i) const;
 
                                     /**
                                      *  Return a reference to the
-                                     *  @p{i}th vertex.
+                                     *  @p ith vertex.
                                      */
     Point<dim> & vertex (const unsigned int i) const;
 
                                     /**
-                                     *  Pointer to the @p{i}th line
+                                     *  Pointer to the @p ith line
                                      *  bounding this object.
                                      *
                                      * Implemented only for @p{celldim>1}.
@@ -391,7 +391,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
     line (const unsigned int i) const;
 
                                     /**
-                                     * Line index of the @p{i}th
+                                     * Line index of the @p ith
                                      * line. The level is naturally
                                      * the same as that of the
                                      * object.
@@ -401,7 +401,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
     unsigned int line_index (const unsigned int i) const;
     
                                     /**
-                                     *  Pointer to the @p{i}th quad
+                                     *  Pointer to the @p ith quad
                                      *  bounding this object.
                                      *
                                      * Implemented only for @p{celldim>2}.
@@ -410,7 +410,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
     quad (const unsigned int i) const;
 
                                     /**
-                                     * Quad index of the @p{i}th
+                                     * Quad index of the @p ith
                                      * quad. The level is naturally
                                      * the same as that of the object.
                                      *
@@ -421,11 +421,11 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                     /**
                                      *  Test for the element being
                                      *  used or not.  The return
-                                     *  value is @p{true} for all
+                                     *  value is @p true for all
                                      *  iterators that are either
                                      *  normal iterators or active
                                      *  iterators, only raw iterators
-                                     *  can return @p{false}. Since
+                                     *  can return @p false. Since
                                      *  raw iterators are only used
                                      *  in the interiors of the
                                      *  library, you will not usually
@@ -434,7 +434,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
     bool used () const;
 
                                     /**
-                                     *  Set the @p{used} flag. You
+                                     *  Set the @p used flag. You
                                      *  should know quite exactly
                                      *  what you are doing of you
                                      *  touch this function. It is
@@ -444,7 +444,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
     void set_used_flag () const;
 
                                     /**
-                                     *  Clear the @p{used} flag. You
+                                     *  Clear the @p used flag. You
                                      *  should know quite exactly
                                      *  what you are doing of you
                                      *  touch this function. It is
@@ -482,13 +482,13 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
 
                                     /**
                                      * Set the user pointer
-                                     * to @p{p}.
+                                     * to @p p.
                                      */
     void set_user_pointer (void *p) const;
 
                                     /**
                                      * Reset the user pointer
-                                     * to a @p{NULL} pointer.
+                                     * to a @p NULL pointer.
                                      */
     void clear_user_pointer () const;
     
@@ -540,20 +540,20 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      * object and all of its
                                      * descendants. The same holds as
                                      * said for the
-                                     * @ref{recursively_set_user_pointer}
+                                     * recursively_set_user_pointer()
                                      * function.
                                      */
     void recursively_clear_user_pointer () const;
 
                                     /**
-                                     *  Pointer to the @p{i}th
+                                     *  Pointer to the @p ith
                                      *  child.
                                      */
     TriaIterator<dim,TriaObjectAccessor<celldim,dim> >
     child (const unsigned int i) const;
 
                                     /**
-                                     *  Index of the @p{i}th child.
+                                     *  Index of the @p ith child.
                                      *  The level of the child is one
                                      *  higher than that of the
                                      *  present cell.  If the child
@@ -594,7 +594,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      * object is refined. Note that
                                      * not all its children are
                                      * refined that often (which is
-                                     * why we prepend @p{max_}), the
+                                     * why we prepend @p max_), the
                                      * returned number is rather the
                                      * maximum number of refinement
                                      * in any branch of children of
@@ -648,7 +648,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      * for @p{dim>celldim}; however,
                                      * for @p{dim==celldim}, an
                                      * object is a cell and the
-                                     * @ref{CellAccessor} class
+                                     * CellAccessor class
                                      * offers another possibility to
                                      * determine whether a cell is at
                                      * the boundary or not.
@@ -718,20 +718,20 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
 
                                      /**
                                       * Return whether the face with
-                                      * index @p{face} has its normal
+                                      * index @p face has its normal
                                       * pointing in the standard
-                                      * direction (@p{true}) or
+                                      * direction (@p true) or
                                       * whether it is the opposite
-                                      * (@p{false}). Which is the
+                                      * (@p false). Which is the
                                       * standard direction is
                                       * documented with the
-                                      * @ref{Triangulation} class. In
+                                      * Triangulation class. In
                                       * 1d and 2d, this is always
-                                      * @p{true}, but in 3d it may be
+                                      * @p true, but in 3d it may be
                                       * different, see the respective
                                       * discussion in the
                                       * documentation of the
-                                      * @ref{Triangulation} class.
+                                      * Triangulation class.
                                       *
                                       * This function is really only
                                       * for internal use in the
@@ -746,8 +746,8 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      *  used in a context like
                                      *  @p{iterator a,b;  *a=*b;}. Since
                                      *  the meaning is to copy the object
-                                     *  pointed to by @p{b} to the object
-                                     *  pointed to by @p{a} and since
+                                     *  pointed to by @p b to the object
+                                     *  pointed to by @p a and since
                                      *  accessors are not real but
                                      *  virtual objects, this operation
                                      *  is not useful for iterators on
@@ -833,7 +833,7 @@ class TriaObjectAccessor<0, dim> : public TriaAccessor<dim>
 
 /**
  *   Accessor to dereference the data of lines. This accessor is used
- *   to point to lines in @p{dim} space dimensions. There is a derived
+ *   to point to lines in @p dim space dimensions. There is a derived
  *   class for lines in one space dimension, in which case a line is
  *   also a cell and thus has much more functionality than in other
  *   dimensions.
@@ -873,25 +873,25 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      *  vertex. It has nothing to do with
                                      *  possible degrees of freedom
                                      *  associated with it. For this, see the
-                                     *  @p{DoFAccessor::vertex_dof_index}
+                                     *  @p DoFAccessor::vertex_dof_index
                                      *  functions.
                                      */ 
     int vertex_index (const unsigned int i) const;
 
                                     /**
                                      *  Return a reference to the
-                                     *  @p{i}th vertex.
+                                     *  @p ith vertex.
                                      */
     Point<dim> & vertex (const unsigned int i) const;
 
                                     /**
                                      *  Test for the element being
                                      *  used or not.  The return
-                                     *  value is @p{true} for all
+                                     *  value is @p true for all
                                      *  iterators that are either
                                      *  normal iterators or active
                                      *  iterators, only raw iterators
-                                     *  can return @p{false}. Since
+                                     *  can return @p false. Since
                                      *  raw iterators are only used
                                      *  in the interiors of the
                                      *  library, you will not usually
@@ -900,14 +900,14 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
     bool used () const;
 
                                     /**
-                                     *  Set the @p{used} flag. Only
+                                     *  Set the @p used flag. Only
                                      *  for internal use in the
                                      *  library.
                                      */
     void set_used_flag () const;
 
                                     /**
-                                     *  Clear the @p{used} flag. Only
+                                     *  Clear the @p used flag. Only
                                      *  for internal use in the
                                      *  library.
                                      */
@@ -947,7 +947,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
 
                                     /**
                                      * Set the user pointer of this
-                                     * line to @p{p}.
+                                     * line to @p p.
                                      */
     void set_user_pointer (void *p) const;
 
@@ -985,14 +985,14 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      * object and all of its
                                      * descendants. The same holds as
                                      * said for the
-                                     * @ref{recursively_set_user_pointer}
+                                     * recursively_set_user_pointer()
                                      * function.
                                      */
     void recursively_clear_user_pointer () const;
 
                                     /**
                                      * Reset the user pointer of this
-                                     * line to a @p{NULL} pointer.
+                                     * line to a @p NULL pointer.
                                      */
     void clear_user_pointer () const;
 
@@ -1012,14 +1012,14 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
     
                                     /**
                                      *  Return a pointer to the
-                                     *  @p{i}th child.
+                                     *  @p ith child.
                                      */
     TriaIterator<dim,TriaObjectAccessor<1, dim> >
     child (const unsigned int i) const;
 
                                     /**
                                      *  Return the index of the
-                                     *  @p{i}th child.  The level of
+                                     *  @p ith child.  The level of
                                      *  the child is one higher than
                                      *  that of the present cell.  If
                                      *  the child does not exist, -1
@@ -1060,7 +1060,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      * refined. Note that not all its
                                      * children are refined that
                                      * often (which is why we prepend
-                                     * @p{max_}), the returned number
+                                     * @p max_), the returned number
                                      * is rather the maximum number
                                      * of refinement in any branch of
                                      * children of this object.
@@ -1114,7 +1114,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      * only possible for @p{dim>1};
                                      * however, for @p{dim==1}, a
                                      * line is a cell and the
-                                     * @ref{CellAccessor} class
+                                     * CellAccessor class
                                      * offers another possibility to
                                      * determine whether a cell is at
                                      * the boundary or not.
@@ -1155,7 +1155,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      * Return the barycenter of the
                                      * line, which is the
                                      * midpoint. The same applies as
-                                     * for the @p{center} function
+                                     * for the @p center function
                                      * with regard to lines at the
                                      * boundary.
                                      */
@@ -1164,7 +1164,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                     /**
                                      * Return the length of the line.
                                      * The same applies as for the
-                                     * @p{center} function with
+                                     * @p center function with
                                      * regard to lines at the
                                      * boundary.
                                      */
@@ -1190,20 +1190,20 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
     
                                      /**
                                       * Return whether the face with
-                                      * index @p{face} has its normal
+                                      * index @p face has its normal
                                       * pointing in the standard
-                                      * direction (@p{true}) or
+                                      * direction (@p true) or
                                       * whether it is the opposite
-                                      * (@p{false}). Which is the
+                                      * (@p false). Which is the
                                       * standard direction is
                                       * documented with the
-                                      * @ref{Triangulation} class. In
+                                      * Triangulation class. In
                                       * 1d and 2d, this is always
-                                      * @p{true}, but in 3d it may be
+                                      * @p true, but in 3d it may be
                                       * different, see the respective
                                       * discussion in the
                                       * documentation of the
-                                      * @ref{Triangulation} class.
+                                      * Triangulation class.
                                       *
                                       * This function is really only
                                       * for internal use in the
@@ -1218,8 +1218,8 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      *  used in a context like
                                      *  @p{iterator a,b;  *a=*b;}. Since
                                      *  the meaning is to copy the object
-                                     *  pointed to by @p{b} to the object
-                                     *  pointed to by @p{a} and since
+                                     *  pointed to by @p b to the object
+                                     *  pointed to by @p a and since
                                      *  accessors are not real but
                                      *  virtual objects, this operation
                                      *  is not useful for iterators on
@@ -1275,7 +1275,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
 
 /**
  *   Accessor to dereference the data of quads. This accessor is used
- *   to point to quads in @p{dim} space dimensions (only @p{dim>=2}
+ *   to point to quads in @p dim space dimensions (only @p{dim>=2}
  *   seems reasonable to me). There is a derived class for quads in
  *   two space dimension, in which case a quad is also a cell and thus
  *   has much more functionality than in other dimensions.
@@ -1327,21 +1327,21 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
 
                                     /**
                                      *  Return a reference to the
-                                     *  @p{i}th vertex.
+                                     *  @p ith vertex.
                                      */
     Point<dim> & vertex (const unsigned int i) const;
 
                                     /**
                                      *  Return a pointer to the
-                                     *  @p{i}th line bounding this
-                                     *  @ref{Quad}.
+                                     *  @p ith line bounding this
+                                     *  Quad.
                                      */
     TriaIterator<dim,TriaObjectAccessor<1, dim> >
     line (const unsigned int i) const;
 
                                     /**
                                      * Return the line index of the
-                                     * @p{i}th side (a line). The
+                                     * @p ith side (a line). The
                                      * level is naturally the same as
                                      * that of the quad.
                                      */
@@ -1350,11 +1350,11 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                     /**
                                      *  Test for the element being
                                      *  used or not.  The return
-                                     *  value is @p{true} for all
+                                     *  value is @p true for all
                                      *  iterators that are either
                                      *  normal iterators or active
                                      *  iterators, only raw iterators
-                                     *  can return @p{false}. Since
+                                     *  can return @p false. Since
                                      *  raw iterators are only used
                                      *  in the interiors of the
                                      *  library, you will not usually
@@ -1363,7 +1363,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
     bool used () const;
 
                                     /**
-                                     *  Set the @p{used} flag. You
+                                     *  Set the @p used flag. You
                                      *  should know quite exactly
                                      *  what you are doing of you
                                      *  touch this function. It is
@@ -1373,7 +1373,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
     void set_used_flag () const;
 
                                     /**
-                                     *  Clear the @p{used} flag. You
+                                     *  Clear the @p used flag. You
                                      *  should know quite exactly
                                      *  what you are doing of you
                                      *  touch this function. It is
@@ -1417,13 +1417,13 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
 
                                     /**
                                      * Set the user pointer of this
-                                     * quad to @p{p}.
+                                     * quad to @p p.
                                      */
     void set_user_pointer (void *p) const;
 
                                     /**
                                      * Reset the user pointer of this
-                                     * quad to a @p{NULL} pointer.
+                                     * quad to a @p NULL pointer.
                                      */
     void clear_user_pointer () const;
 
@@ -1475,20 +1475,20 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      * object and all of its
                                      * descendants. The same holds as
                                      * said for the
-                                     * @ref{recursively_set_user_pointer}
+                                     * recursively_set_user_pointer()
                                      * function.
                                      */
     void recursively_clear_user_pointer () const;
 
                                     /**
-                                     *  Return a pointer to the @p{i}th
+                                     *  Return a pointer to the @p ith
                                      *  child.
                                      */
     TriaIterator<dim,TriaObjectAccessor<2, dim> > child (const unsigned int i) const;
 
                                     /**
                                      *  Return the index of the
-                                     *  @p{i}th child.  The level of
+                                     *  @p ith child.  The level of
                                      *  the child is one higher than
                                      *  that of the present cell.  If
                                      *  the child does not exist, -1
@@ -1529,7 +1529,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      * refined. Note that not all its
                                      * children are refined that
                                      * often (which is why we prepend
-                                     * @p{max_}), the returned number
+                                     * @p max_), the returned number
                                      * is rather the maximum number
                                      * of refinement in any branch of
                                      * children of this object.
@@ -1583,7 +1583,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      * function is only useful for
                                      * @p{dim>2}; however, for
                                      * @p{dim==2}, a quad is a cell
-                                     * and the @ref{CellAccessor}
+                                     * and the CellAccessor
                                      * class offers another
                                      * possibility to determine
                                      * whether a cell is at the
@@ -1644,7 +1644,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                     /**
                                      * Return the barycenter of the
                                      * qaud. The same applies as for
-                                     * the @p{center} function with
+                                     * the @p center function with
                                      * regard to quads at the
                                      * boundary.
                                      */
@@ -1685,20 +1685,20 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
 
                                      /**
                                       * Return whether the face with
-                                      * index @p{face} has its normal
+                                      * index @p face has its normal
                                       * pointing in the standard
-                                      * direction (@p{true}) or
+                                      * direction (@p true) or
                                       * whether it is the opposite
-                                      * (@p{false}). Which is the
+                                      * (@p false). Which is the
                                       * standard direction is
                                       * documented with the
-                                      * @ref{Triangulation} class. In
+                                      * Triangulation class. In
                                       * 1d and 2d, this is always
-                                      * @p{true}, but in 3d it may be
+                                      * @p true, but in 3d it may be
                                       * different, see the respective
                                       * discussion in the
                                       * documentation of the
-                                      * @ref{Triangulation} class.
+                                      * Triangulation class.
                                       *
                                       * This function is really only
                                       * for internal use in the
@@ -1714,8 +1714,8 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      * like <tt>iterator a,b;
                                      * *a=*b;</tt>. Since the meaning
                                      * is to copy the object pointed
-                                     * to by @p{b} to the object
-                                     * pointed to by @p{a} and since
+                                     * to by @p b to the object
+                                     * pointed to by @p a and since
                                      * accessors are not real but
                                      * virtual objects, this
                                      * operation is not useful for
@@ -1770,7 +1770,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
 
 /**
  *   Accessor to dereference the data of hexahedra. This accessor is
- *   used to point to hexs in @p{dim} space dimensions (only
+ *   used to point to hexs in @p dim space dimensions (only
  *   @p{dim>=3} seems reasonable to me). There is a derived class for
  *   hexs in three space dimension, in which case a hex is also a cell
  *   and thus has much more functionality than in other dimensions.
@@ -1814,28 +1814,28 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      *  vertex. It has nothing to do with
                                      *  possible degrees of freedom
                                      *  associated with it. For this, see the
-                                     *  @p{DoFAccessor::vertex_dof_index}
+                                     *  @p DoFAccessor::vertex_dof_index
                                      *  functions.
                                      */ 
     int vertex_index (const unsigned int i) const;
 
                                     /**
                                      *  Return a reference to the
-                                     *  @p{i}th vertex.
+                                     *  @p ith vertex.
                                      */
     Point<dim> & vertex (const unsigned int i) const;
 
                                     /**
                                      *  Return a pointer to the
-                                     *  @p{i}th line bounding this
-                                     *  @p{Hex}.
+                                     *  @p ith line bounding this
+                                     *  @p Hex.
                                      */
     TriaIterator<dim,TriaObjectAccessor<1, dim> >
     line (const unsigned int i) const;
 
                                     /**
                                      * Return the line index of the
-                                     * @p{i}th line. The level is
+                                     * @p ith line. The level is
                                      * naturally the same as that of
                                      * the hex.
                                      */
@@ -1843,15 +1843,15 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
     
                                     /**
                                      *  Return a pointer to the
-                                     *  @p{i}th quad bounding this
-                                     *  @p{Hex}.
+                                     *  @p ith quad bounding this
+                                     *  @p Hex.
                                      */
     TriaIterator<dim,TriaObjectAccessor<2, dim> >
     quad (const unsigned int i) const;
 
                                     /**
                                      * Return the quad index of the
-                                     * @p{i}th side (a quad). The
+                                     * @p ith side (a quad). The
                                      * level is naturally the same as
                                      * that of the hex.
                                      */
@@ -1860,11 +1860,11 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                     /**
                                      *  Test for the element being
                                      *  used or not.  The return
-                                     *  value is @p{true} for all
+                                     *  value is @p true for all
                                      *  iterators that are either
                                      *  normal iterators or active
                                      *  iterators, only raw iterators
-                                     *  can return @p{false}. Since
+                                     *  can return @p false. Since
                                      *  raw iterators are only used
                                      *  in the interiors of the
                                      *  library, you will not usually
@@ -1873,7 +1873,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
     bool used () const;
 
                                     /**
-                                     *  Set the @p{used} flag. You
+                                     *  Set the @p used flag. You
                                      *  should know quite exactly
                                      *  what you are doing of you
                                      *  touch this function. It is
@@ -1883,7 +1883,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
     void set_used_flag () const;
 
                                     /**
-                                     *  Clear the @p{used} flag. You
+                                     *  Clear the @p used flag. You
                                      *  should know quite exactly
                                      *  what you are doing of you
                                      *  touch this function. It is
@@ -1927,13 +1927,13 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
 
                                     /**
                                      * Set the user pointer of this
-                                     * hex to @p{p}.
+                                     * hex to @p p.
                                      */
     void set_user_pointer (void *p) const;
 
                                     /**
                                      * Reset the user pointer of this
-                                     * hex to a @p{NULL} pointer.
+                                     * hex to a @p NULL pointer.
                                      */
     void clear_user_pointer () const;
 
@@ -1985,21 +1985,21 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      * object and all of its
                                      * descendants. The same holds as
                                      * said for the
-                                     * @ref{recursively_set_user_pointer}
+                                     * recursively_set_user_pointer()
                                      * function.
                                      */
     void recursively_clear_user_pointer () const;
 
                                     /**
                                      *  Return a pointer to the
-                                     *  @p{i}th child.
+                                     *  @p ith child.
                                      */
     TriaIterator<dim,TriaObjectAccessor<3, dim> >
     child (const unsigned int i) const;
 
                                     /**
                                      *  Return the index of the
-                                     *  @p{i}th child.  The level of
+                                     *  @p ith child.  The level of
                                      *  the child is one higher than
                                      *  that of the present cell.  If
                                      *  the child does not exist, -1
@@ -2040,7 +2040,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      * refined. Note that not all its
                                      * children are refined that
                                      * often (which is why we prepend
-                                     * @p{max_}), the returned number
+                                     * @p max_), the returned number
                                      * is rather the maximum number
                                      * of refinement in any branch of
                                      * children of this object.
@@ -2095,7 +2095,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      * possible for @p{dim>3};
                                      * however, for @p{dim==3}, a hex
                                      * is a cell and the
-                                     * @ref{CellAccessor} class
+                                     * CellAccessor class
                                      * offers another possibility to
                                      * determine whether a cell is at
                                      * the boundary or not.
@@ -2178,20 +2178,20 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
 
                                      /**
                                       * Return whether the face with
-                                      * index @p{face} has its normal
+                                      * index @p face has its normal
                                       * pointing in the standard
-                                      * direction (@p{true}) or
+                                      * direction (@p true) or
                                       * whether it is the opposite
-                                      * (@p{false}). Which is the
+                                      * (@p false). Which is the
                                       * standard direction is
                                       * documented with the
-                                      * @ref{Triangulation} class.  In
+                                      * Triangulation class.  In
                                       * 1d and 2d, this is always
-                                      * @p{true}, but in 3d it may be
+                                      * @p true, but in 3d it may be
                                       * different, see the respective
                                       * discussion in the
                                       * documentation of the
-                                      * @ref{Triangulation} class.
+                                      * Triangulation class.
                                       *
                                       * This function is really only
                                       * for internal use in the
@@ -2202,14 +2202,14 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
 
                                      /**
                                       * Set whether the quad with
-                                      * index @p{face} has its normal
+                                      * index @p face has its normal
                                       * pointing in the standard
-                                      * direction (@p{true}) or
+                                      * direction (@p true) or
                                       * whether it is the opposite
-                                      * (@p{false}). Which is the
+                                      * (@p false). Which is the
                                       * standard direction is
                                       * documented with the
-                                      * @ref{Triangulation} class.
+                                      * Triangulation class.
                                       *
                                       * This function is only for
                                       * internal use in the
@@ -2228,9 +2228,9 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      *  used in a context like
                                      *  @p{iterator a,b;  *a=*b;}. Since
                                      *  the meaning is to copy the
-                                     *  object pointed to by @p{b} to
+                                     *  object pointed to by @p b to
                                      *  the object pointed to by
-                                     *  @p{a} and since accessors are
+                                     *  @p a and since accessors are
                                      *  not real but virtual objects,
                                      *  this operation is not useful
                                      *  for iterators on
@@ -2317,7 +2317,7 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
 
                                     /**
                                      *  Return a pointer to the
-                                     *  @p{i}th neighbor.  If the
+                                     *  @p ith neighbor.  If the
                                      *  neighbor does not exist, an
                                      *  invalid iterator is returned.
                                      */
@@ -2326,7 +2326,7 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
 
                                     /**
                                      *  Return the index of the
-                                     *  @p{i}th neighbor.  If the
+                                     *  @p ith neighbor.  If the
                                      *  neighbor does not exist, its
                                      *  index is -1.
                                      */
@@ -2334,16 +2334,16 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
 
                                     /**
                                      *  Return the level of the
-                                     *  @p{i}th neighbor.  If the
+                                     *  @p ith neighbor.  If the
                                      *  neighbor does not exist, its
                                      *  level is -1.
                                      */
     int neighbor_level (const unsigned int i) const;
 
                                     /**
-                                     *  Set the neighbor @p{i} of
+                                     *  Set the neighbor @p i of
                                      *  this cell to the cell pointed
-                                     *  to by @p{pointer}.  This line
+                                     *  to by @p pointer.  This line
                                      *  must be used.
                                      */
     void set_neighbor (const unsigned int i,
@@ -2353,7 +2353,7 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                                      * Return the how-many'th
                                      * neighbor this cell is of
                                      * @p{cell->neighbor(neighbor)},
-                                     * i.e. return the number @p{n}
+                                     * i.e. return the number @p n
                                      * such that
                                      * @p{cell->neighbor(neighbor)->neighbor(n)==cell}. This
                                      * function is the right one if
@@ -2368,7 +2368,7 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                                      * (i.e. @p{cell->neighbor(neighbor)->level()}
                                      * needs to be equal to
                                      * @p{cell->level()}. Use the
-                                     * @p{neighbor_of_coarser_neighbor}
+                                     * @p neighbor_of_coarser_neighbor
                                      * function in that case.
                                      */
     unsigned int neighbor_of_neighbor (const unsigned int neighbor) const;
@@ -2376,7 +2376,7 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                                     /**
                                      * This function is a
                                      * generalization of the
-                                     * @p{neighbor_of_neighbor}
+                                     * @p neighbor_of_neighbor
                                      * function for the case of a
                                      * coarser neighbor. It returns a
                                      * pair of numbers, face_no and
@@ -2391,11 +2391,11 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
     neighbor_of_coarser_neighbor (const unsigned int neighbor) const;
     
                                     /**
-                                     *  Return whether the @p{i}th
+                                     *  Return whether the @p ith
                                      *  vertex or face (depending on
                                      *  the dimension) is part of the
                                      *  boundary. This is true, if
-                                     *  the @p{i}th neighbor does not
+                                     *  the @p ith neighbor does not
                                      *  exist.
                                      */
     bool at_boundary (const unsigned int i) const;
@@ -2414,7 +2414,7 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                                      *  interiors of all faces are in
                                      *  the interior of the
                                      *  domain. For the latter case,
-                                     *  the @p{has_boundary_lines}
+                                     *  the @p has_boundary_lines
                                      *  function is the right one to
                                      *  ask.
                                      */
@@ -2422,7 +2422,7 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
 
                                     /**
                                      * This is a slight variation to
-                                     * the @p{at_boundary} function:
+                                     * the @p at_boundary function:
                                      * for 1 and 2 space dimensions,
                                      * it is equivalent, for three
                                      * space dimensions it returns
@@ -2475,7 +2475,7 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
 
                                     /**
                                      *  Return a pointer to the
-                                     *  @p{i}th child. Overloaded
+                                     *  @p ith child. Overloaded
                                      *  version which returns a more
                                      *  reasonable iterator class.
                                      */
@@ -2484,7 +2484,7 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
 
                                     /**
                                      * Return an iterator to the
-                                     * @p{i}th face of this cell.
+                                     * @p ith face of this cell.
                                      *
                                      * This function is not
                                      * implemented in 1D, and maps to
@@ -2516,17 +2516,17 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                                       * of the neighbor cell the
                                       * present cell is bordering on
                                       * (this is what the
-                                      * @p{neighbor_of_neighbor}
+                                      * @p neighbor_of_neighbor
                                       * function does), and then
                                       * asking
-                                      * @p{GeometryInfo::child_cell_on_subface}
+                                      * @p GeometryInfo::child_cell_on_subface
                                       * for the index of the
                                       * child. However, the function
                                       * is more complicated in 3d,
                                       * since there faces may have
                                       * more than one orientation, and
                                       * we have to use
-                                      * @p{face_orientation} for both
+                                      * @p face_orientation for both
                                       * this and the neighbor cell to
                                       * figure out which cell we want
                                       * to have.
@@ -2575,7 +2575,7 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
     bool active () const;
 
                                     /**
-                                     * Test whether the point @p{p}
+                                     * Test whether the point @p p
                                      * is inside this cell. Points on
                                      * the boundary are counted as
                                      * being inside the cell.
@@ -2615,8 +2615,8 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                                      *  like <tt>iterator a,b;
                                      *  *a=*b;</tt>. Since the meaning is
                                      *  to copy the object pointed to
-                                     *  by @p{b} to the object
-                                     *  pointed to by @p{a} and since
+                                     *  by @p b to the object
+                                     *  pointed to by @p a and since
                                      *  accessors are not real but
                                      *  virtual objects, this
                                      *  operation is not useful for
index d70059e6b985efa326b88d688844c09e010c0d22..76c1ae4a5e8b4841ec68924deb08db8c19003bee 100644 (file)
@@ -1183,7 +1183,7 @@ CellAccessor<dim>::refine_flag_set () const
 {
   Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
                                   // cells flagged for refinement must be active
-                                  // (the @p{set_refine_flag} function checks this,
+                                  // (the @p set_refine_flag function checks this,
                                   // but activity may change when refinement is
                                   // executed and for some reason the refine
                                   // flag is not cleared).
@@ -1226,7 +1226,7 @@ CellAccessor<dim>::coarsen_flag_set () const
 {
   Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
                                   // cells flagged for coarsening must be active
-                                  // (the @p{set_refine_flag} function checks this,
+                                  // (the @p set_refine_flag function checks this,
                                   // but activity may change when refinement is
                                   // executed and for some reason the refine
                                   // flag is not cleared).
index ca37e6aaa8e11c2561f89e53ecd434af30e50a4c..63ec56d09f5c0e78a702c0ef5b376c6220ebade2 100644 (file)
@@ -31,17 +31,17 @@ template <int dim> class Triangulation;
  *   When a triangulation creates a new vertex on the boundary of the
  *   domain, it determines the new vertex' coordinates through the
  *   following code (here in two dimensions):
- *   @begin{verbatim}
+ *   @verbatim
  *     ...
  *     Point<2> new_vertex = boundary.get_new_point_on_line (line);
  *     ...
- *   @end{verbatim}
- *   @p{line} denotes the line at the boundary that shall be refined
+ *   @endverbatim
+ *   @p line denotes the line at the boundary that shall be refined
  *   and for which we seek the common point of the two child lines.
  *
  *   In 3D, a new vertex may be placed on the middle of a line or on
  *   the middle of a side. Respectively, the library calls
- *   @begin{verbatim}
+ *   @verbatim
  *     ...
  *     Point<3> new_line_vertices[4]
  *       = { boundary.get_new_point_on_line (face->line(0)),
@@ -49,14 +49,14 @@ template <int dim> class Triangulation;
  *           boundary.get_new_point_on_line (face->line(2)),
  *           boundary.get_new_point_on_line (face->line(3))  };
  *     ...
- *   @end{verbatim}
+ *   @endverbatim
  *   to get the four midpoints of the lines bounding the quad at the
  *   boundary, and after that
- *   @begin{verbatim}
+ *   @verbatim
  *     ...
  *     Point<3> new_quad_vertex = boundary.get_new_point_on_quad (face);
  *     ...
- *   @end{verbatim}
+ *   @endverbatim
  *   to get the midpoint of the face. It is guaranteed that this order
  *   (first lines, then faces) holds, so you can use information from
  *   the children of the four lines of a face, since these already exist
@@ -66,9 +66,9 @@ template <int dim> class Triangulation;
  *   about boundary indicators and the like, as well as all other information
  *   provided by these objects.
  *
- *   There are specialisations, @ref{StraightBoundary}, which places
+ *   There are specialisations, StraightBoundary, which places
  *   the new point right into the middle of the given points, and
- *   @ref{HyperBallBoundary} creating a hyperball with given radius
+ *   HyperBallBoundary creating a hyperball with given radius
  *   around a given center point.
  *
  *   @author Wolfgang Bangerth, 1999, 2001, Ralf Hartmann, 2001
@@ -137,7 +137,7 @@ class Boundary : public Subscriptor
                                      *
                                      * This function is called after
                                      * the four lines bounding the
-                                     * given @p{quad} are refined, so
+                                     * given @p quad are refined, so
                                      * you may want to use the
                                      * information provided by
                                      * @p{quad->line(i)->child(j)},
@@ -159,19 +159,19 @@ class Boundary : public Subscriptor
                                       *
                                      * The number of points requested
                                      * is given by the size of the
-                                     * vector @p{points}. It is the
+                                     * vector @p points. It is the
                                      * task of the derived classes to
                                      * arrange the points in
                                      * approximately equal distances.
                                      *
                                      * This function is called by the
-                                     * @p{MappingQ} class. This
+                                     * @p MappingQ class. This
                                      * happens on each face line of a
                                      * cells that has got at least
                                      * one boundary line.
                                      *
                                      * As this function is not needed
-                                     * for @p{MappingQ1}, it is not
+                                     * for @p MappingQ1, it is not
                                      * made pure virtual, to avoid
                                      * the need to overload it.  The
                                      * default implementation throws
@@ -188,7 +188,7 @@ class Boundary : public Subscriptor
                                      *
                                      * The number of points requested
                                      * is given by the size of the
-                                     * vector @p{points}. It is
+                                     * vector @p points. It is
                                      * required that this number is a
                                      * square of another integer,
                                      * i.e. @p{n=points.size()=m*m}. It
@@ -205,7 +205,7 @@ class Boundary : public Subscriptor
                                      * least one boundary face quad.
                                      *
                                      * As this function is not needed
-                                     * for @p{MappingQ1}, it is not
+                                     * for @p MappingQ1, it is not
                                      * made pure virtual, to avoid
                                      * the need to overload it.  The
                                      * default implementation throws
@@ -264,7 +264,7 @@ class Boundary : public Subscriptor
 
 
 /**
- *   Specialisation of @ref{Boundary}<dim>, which places the new point
+ *   Specialisation of Boundary<dim>, which places the new point
  *   right into the middle of the given points. The middle is defined
  *   as the arithmetic mean of the points.
  *
index d76b097107733a3b696a0f49c7eec80b5bc36d1d..f308cbab686f34fdea997d224bb14e6741ec118f 100644 (file)
 
 /**
  * Boundary object for the hull of a cylinder.  In three dimensions,
- * points are projected on a circular tube along the @p{x}-axis. The
- * radius of the tube can be set. Similar to @ref{HyperBallBoundary},
+ * points are projected on a circular tube along the @p x-axis. The
+ * radius of the tube can be set. Similar to HyperBallBoundary,
  * new points are projected by dividing the straight line between the
- * old two points and adjusting the radius in the @p{yz}-plane.
+ * old two points and adjusting the radius in the @p yz-plane.
  *
  * This class was developed to be used in conjunction with the
- * @p{cylinder} function of @ref{GridGenerator}. It should be used for
+ * @p cylinder function of GridGenerator. It should be used for
  * the hull of the cylinder only (boundary indicator 0).
  *
- *   This class is derived from @ref{StraightBoundary} rather than from
- *   @ref{Boundary}, which would seem natural, since this way we can use the
- *   @ref{StraightBoundary}@p{<dim>::in_between(neighbors)} function.
+ *   This class is derived from StraightBoundary rather than from
+ *   Boundary, which would seem natural, since this way we can use the
+ *   StraightBoundary@p{<dim>::in_between(neighbors)} function.
  *
  *   @author Guido Kanschat, 2001
  */
@@ -67,7 +67,7 @@ class CylinderBoundary : public StraightBoundary<dim>
                                      * base class.
                                      *
                                      * Calls
-                                     * @p{get_intermediate_points_between_points}.
+                                     * @p get_intermediate_points_between_points.
                                      */
     virtual void
     get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
@@ -107,8 +107,8 @@ class CylinderBoundary : public StraightBoundary<dim>
 
                                     /**
                                      * Exception. Thrown by the
-                                     * @p{get_radius} if the
-                                     * @p{compute_radius_automatically},
+                                     * @p get_radius if the
+                                     * @p compute_radius_automatically,
                                      * see below, flag is set true.
                                      */
     DeclException0 (ExcRadiusNotSet);
@@ -124,13 +124,13 @@ class CylinderBoundary : public StraightBoundary<dim>
 
                                     /**
                                      * Called by
-                                     * @p{get_intermediate_points_on_line}
+                                     * @p get_intermediate_points_on_line
                                      * and by
-                                     * @p{get_intermediate_points_on_quad}.
+                                     * @p get_intermediate_points_on_quad.
                                      *
                                      * Refer to the general
                                      * documentation of
-                                     * @p{get_intermediate_points_on_line}
+                                     * @p get_intermediate_points_on_line
                                      * in the documentation of the
                                      * base class.
                                      */
@@ -141,7 +141,7 @@ class CylinderBoundary : public StraightBoundary<dim>
 
 
 /**
- *   Specialisation of @ref{Boundary}<dim>, which places the new point on
+ *   Specialisation of Boundary<dim>, which places the new point on
  *   the boundary of a ball in arbitrary dimension. It works by projecting
  *   the point in the middle of the old points onto the ball. The middle is
  *   defined as the arithmetic mean of the points. 
@@ -149,9 +149,9 @@ class CylinderBoundary : public StraightBoundary<dim>
  *   The center of the ball and its radius may be given upon construction of
  *   an object of this type. They default to the origin and a radius of 1.0.
  *
- *   This class is derived from @ref{StraightBoundary} rather than from
- *   @ref{Boundary}, which would seem natural, since this way we can use the
- *   @ref{StraightBoundary}@p{<dim>::in_between(neighbors)} function.
+ *   This class is derived from StraightBoundary rather than from
+ *   Boundary, which would seem natural, since this way we can use the
+ *   StraightBoundary@p{<dim>::in_between(neighbors)} function.
  *
  *   @author Wolfgang Bangerth, 1998, Ralf Hartmann, 2001
  */
@@ -188,7 +188,7 @@ class HyperBallBoundary : public StraightBoundary<dim>
                                      * base class.
                                      *
                                      * Calls
-                                     * @p{get_intermediate_points_between_points}.
+                                     * @p get_intermediate_points_between_points.
                                      */
     virtual void
     get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
@@ -233,8 +233,8 @@ class HyperBallBoundary : public StraightBoundary<dim>
 
                                     /**
                                      * Exception. Thrown by the
-                                     * @p{get_radius} if the
-                                     * @p{compute_radius_automatically},
+                                     * @p get_radius if the
+                                     * @p compute_radius_automatically,
                                      * see below, flag is set true.
                                      */
     DeclException0 (ExcRadiusNotSet);
@@ -253,14 +253,14 @@ class HyperBallBoundary : public StraightBoundary<dim>
     const double radius;
 
                                     /**
-                                     * This flag is @p{false} for
+                                     * This flag is @p false for
                                      * this class and for all derived
                                      * classes that set the radius by
                                      * the constructor. For example
-                                     * this flag is @p{false} for the
-                                     * @ref{HalfHyperBallBoundary}
-                                     * class but it is @p{true} for
-                                     * the @ref{HyperShellBoundary}
+                                     * this flag is @p false for the
+                                     * HalfHyperBallBoundary
+                                     * class but it is @p true for
+                                     * the HyperShellBoundary
                                      * class, for example.  The
                                      * latter class doesn't get its
                                      * radii by the constructor but
@@ -275,13 +275,13 @@ class HyperBallBoundary : public StraightBoundary<dim>
 
                                     /**
                                      * Called by
-                                     * @p{get_intermediate_points_on_line}
+                                     * @p get_intermediate_points_on_line
                                      * and by
-                                     * @p{get_intermediate_points_on_quad}.
+                                     * @p get_intermediate_points_on_quad.
                                      *
                                      * Refer to the general
                                      * documentation of
-                                     * @p{get_intermediate_points_on_line}
+                                     * @p get_intermediate_points_on_line
                                      * in the documentation of the
                                      * base class.
                                      */
@@ -292,7 +292,7 @@ class HyperBallBoundary : public StraightBoundary<dim>
 
 
 /**
- * Variant of @ref{HyperBallBoundary} which denotes a half hyper ball
+ * Variant of HyperBallBoundary which denotes a half hyper ball
  * where the first coordinate is restricted to the range $x>=0$ (or
  * $x>=center(0)$). In two dimensions, this equals the right half
  * circle, in three space dimensions it is a half ball. This class
@@ -334,7 +334,7 @@ class HalfHyperBallBoundary : public HyperBallBoundary<dim>
                                      * base class.
                                      *
                                      * Calls
-                                     * @p{get_intermediate_points_between_points}.
+                                     * @p get_intermediate_points_between_points.
                                      */
     virtual void
     get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
@@ -388,7 +388,7 @@ class HyperShellBoundary : public HyperBallBoundary<dim>
                                      * origin.
                                      *
                                      * Calls the constructor of its
-                                     * base @p{HyperBallBoundary}
+                                     * base @p HyperBallBoundary
                                      * class with a dummy radius as
                                      * argument. This radius will be
                                      * ignored
@@ -399,7 +399,7 @@ class HyperShellBoundary : public HyperBallBoundary<dim>
 
 
 /**
- * Variant of @ref{HyperShellBoundary} which denotes a half hyper shell
+ * Variant of HyperShellBoundary which denotes a half hyper shell
  * where the first coordinate is restricted to the range $x>=0$ (or
  * $x>=center(0)$). In two dimensions, this equals the right half arc,
  * in three space dimensions it is a half shell. This class might be
@@ -438,7 +438,7 @@ class HalfHyperShellBoundary : public HyperShellBoundary<dim>
                                      * base class.
                                      *
                                      * Calls
-                                     * @p{get_intermediate_points_between_points}.
+                                     * @p get_intermediate_points_between_points.
                                      */
     virtual void
     get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
index 5dcd50ccfc0d21461b26f64a910a747f196098d8..6241e8e7cb45a02392fcd02ef8328485a48b98db 100644 (file)
@@ -18,7 +18,7 @@
 #include <base/exceptions.h>
 
 /**
- *   @p{Hexahedron}s denote the fundamental entities of triangulations
+ *   @p Hexahedrons denote the fundamental entities of triangulations
  *   in three dimensions. They are characterized by the (global)
  *   indices of the six bounding quadrilaterals.
  *
@@ -30,7 +30,7 @@
  *
  *   For conventions on the numbering of faces, lines and vertices
  *   within a hexahedron, refer to the documentation of the
- *   @ref{Triangulation} class.
+ *   Triangulation class.
  *
  *   @author Wolfgang Bangerth, 1998
  */
@@ -40,8 +40,8 @@ class Hexahedron
 
                                     /**
                                      *  Construct a Hex with quad
-                                     *  indices @p{i0} through
-                                     *  @p{i5}. By default, indices
+                                     *  indices @p i0 through
+                                     *  @p i5. By default, indices
                                      *  are set to -1, i.e. an
                                      *  invalid value.
                                      *
@@ -57,13 +57,13 @@ class Hexahedron
     
                                     /**
                                      *  Return the index of quad
-                                     *  @p{i}=0 through 5.
+                                     *  @p i=0 through 5.
                                      */
     int quad (const int i) const;
     
                                     /**
-                                     *  Set the index of the @p{i}th
-                                     *  quad to @p{index}. @p{i}=0
+                                     *  Set the index of the @p ith
+                                     *  quad to @p index. @p i=0
                                      *  through 5.
                                      */
     void set_quad (const int i, const int index);
index 821de54d5d0b1e475e393fbfff7fe308844d2f16..c21598446fe9254e822df354389bfe2647fe0baf 100644 (file)
@@ -217,11 +217,11 @@ class TriaRawIterator :
                                      * Through this constructor, it is also
                                      * possible to construct objects for
                                      * derived iterators:
-                                     * @begin{verbatim}
+                                     * @verbatim
                                      * DoFCellAccessor dof_accessor;
                                      * Triangulation::active_cell_iterator cell
                                      *   = accessor;
-                                     * @end{verbatim}
+                                     * @endverbatim
                                      */
     TriaRawIterator (const Accessor &a);
     
@@ -244,17 +244,17 @@ class TriaRawIterator :
                                      * iterator type and copies the data;
                                      * this conversion works, if there is
                                      * a conversion path from the
-                                     * @p{OtherAccessor} class to the @p{Accessor}
+                                     * @p OtherAccessor class to the @p Accessor
                                      * class of this object. One such path
                                      * would be derived class to base class,
                                      * which for example may be used to get
-                                     * a @ref{Triangulation}@p{::raw_cell_iterator} from
-                                     * a @ref{DoFHandler}@p{::raw_cell_iterator}, since
-                                     * the @ref{DoFAccessor} class is derived from
-                                     * the @ref{TriaAccessor} class.
+                                     * a Triangulation@p ::raw_cell_iterator from
+                                     * a DoFHandler@p ::raw_cell_iterator, since
+                                     * the DoFAccessor class is derived from
+                                     * the TriaAccessor class.
                                      *
-                                     * Since @ref{TriaIterator} and
-                                     * @ref{TriaActiveIterator} are derived classes
+                                     * Since TriaIterator and
+                                     * TriaActiveIterator are derived classes
                                      * of this class, this constructor also
                                      * serves to convert these iterators with
                                      * other accessor classes.
@@ -273,7 +273,7 @@ class TriaRawIterator :
                                      *
                                      *  This function has to be specialized
                                      *  explicitly for the different
-                                     *  @p{Pointee}s, to allow an
+                                     *  @p Pointees, to allow an
                                      *  @p{iterator<1,TriangulationLevel<1>::LinesData>}
                                      *  to point to @p{tria->lines.lines[index]} while
                                      *  for one dimension higher it has
@@ -285,7 +285,7 @@ class TriaRawIterator :
     const Accessor & operator * () const;
     
                                     /**
-                                     *  Dereferencing operator, non-@p{const}
+                                     *  Dereferencing operator, non-@p const
                                      *  version.
                                      */
     Accessor & operator * ();
@@ -295,13 +295,13 @@ class TriaRawIterator :
                                      *  reference of the cell pointed to.
                                      *  Usage is thus like @p{i->index ();}
                                      *
-                                     *  There is a @p{const} and a non-@p{const}
+                                     *  There is a @p const and a non-@p const
                                      *  version.
                                      */
     const Accessor * operator -> () const;
         
                                     /**
-                                     *  Dereferencing operator, non-@p{const}
+                                     *  Dereferencing operator, non-@p const
                                      *  version.
                                      */
     Accessor * operator -> ();
@@ -324,11 +324,11 @@ class TriaRawIterator :
 
                                     /**
                                      * Offer a weak ordering of iterators,
-                                     * which is needed to make @p{map}s with
+                                     * which is needed to make @p maps with
                                      * iterators being keys. An iterator
-                                     * pointing to an element @p{a} is
+                                     * pointing to an element @p a is
                                      * less than another iterator pointing
-                                     * to an element @p{b} if
+                                     * to an element @p b if
                                      * level(a)<level(b) or
                                      * (level(a)==level(b) and index(a)<index(b)).
                                      *
@@ -365,7 +365,7 @@ class TriaRawIterator :
                                      *  priviously pointed to. Since this
                                      *  involves a temporary and a copy
                                      *  operation and since an
-                                     *  @p{iterator} is quite a large
+                                     *  @p iterator is quite a large
                                      *  object for a pointer, use the
                                      *  prefix operator @p{++i} whenever
                                      *  possible, especially in the head
@@ -377,7 +377,7 @@ class TriaRawIterator :
     TriaRawIterator operator ++ (int);
 
                                     /**
-                                     *  Prefix @p{--} operator: @p{--i}. This
+                                     *  Prefix @p -- operator: @p --i. This
                                      *  operator advances the iterator to
                                      *  the previous element and returns
                                      *  a reference to @p{*this}.
@@ -391,16 +391,16 @@ class TriaRawIterator :
     TriaRawIterator & operator -- ();
     
                                     /**
-                                     *  Postfix @p{--} operator: @p{i--}. This
+                                     *  Postfix @p -- operator: @p i--. This
                                      *  operator advances the iterator to
                                      *  the previous element, but
                                      *  returns an iterator to the element
                                      *  priviously pointed to. Since this
                                      *  involves a temporary and a copy
                                      *  operation and since an
-                                     *  @p{iterator} is quite a large
+                                     *  @p iterator is quite a large
                                      *  object for a pointer, use the
-                                     *  prefix operator @p{--i} whenever
+                                     *  prefix operator @p --i whenever
                                      *  possible, especially in the head
                                      *  of for loops
                                      *  (@p{for (; i!=end; --i)}) since there
@@ -416,7 +416,7 @@ class TriaRawIterator :
     IteratorState::IteratorStates state () const;
 
                                     /**
-                                     * Print the iterator to @p{out}. The
+                                     * Print the iterator to @p out. The
                                      * format is like @p{level.index}.
                                      */
     void print (std::ostream &out) const;
@@ -554,16 +554,16 @@ class TriaIterator : public TriaRawIterator<dim,Accessor>
                                      * iterator type and copies the data;
                                      * this conversion works, if there is
                                      * a conversion path from the
-                                     * @p{OtherAccessor} class to the @p{Accessor}
+                                     * @p OtherAccessor class to the @p Accessor
                                      * class of this object. One such path
                                      * would be derived class to base class,
                                      * which for example may be used to get
-                                     * a @ref{Triangulation}@p{::cell_iterator} from
-                                     * a @ref{DoFHandler}@p{::cell_iterator}, since
-                                     * the @ref{DoFAccessor} class is derived from
-                                     * the @ref{TriaAccessor} class.
+                                     * a Triangulation@p ::cell_iterator from
+                                     * a DoFHandler@p ::cell_iterator, since
+                                     * the DoFAccessor class is derived from
+                                     * the TriaAccessor class.
                                      *
-                                     * Since @ref{TriaActiveIterator} is a derived
+                                     * Since TriaActiveIterator is a derived
                                      * class of this class, this constructor
                                      * also serves to convert these iterators 
                                      * with other accessor classes.
@@ -613,7 +613,7 @@ class TriaIterator : public TriaRawIterator<dim,Accessor>
                                      *  previously pointed to. Since this
                                      *  involves a temporary and a copy
                                      *  operation and since an
-                                     *  @p{active_iterator} is quite a large
+                                     *  @p active_iterator is quite a large
                                      *  object for a pointer, use the
                                      *  prefix operator @p{++i} whenever
                                      *  possible, especially in the head
@@ -625,7 +625,7 @@ class TriaIterator : public TriaRawIterator<dim,Accessor>
     TriaIterator<dim,Accessor> operator ++ (int);
 
                                     /**
-                                     *  Prefix @p{--} operator: @p{--i}. This
+                                     *  Prefix @p -- operator: @p --i. This
                                      *  operator advances the iterator to
                                      *  the previous used element and returns
                                      *  a reference to @p{*this}.
@@ -633,7 +633,7 @@ class TriaIterator : public TriaRawIterator<dim,Accessor>
     TriaIterator<dim,Accessor> & operator -- ();
 
                                     /**
-                                     *  Postfix @p{--} operator: @p{i--}.
+                                     *  Postfix @p -- operator: @p i--.
                                      */
     TriaIterator<dim,Accessor> operator -- (int);
                                     /*@}*/
@@ -714,14 +714,14 @@ class TriaActiveIterator : public TriaIterator<dim,Accessor>
                                      * iterator type and copies the data;
                                      * this conversion works, if there is
                                      * a conversion path from the
-                                     * @p{OtherAccessor} class to the @p{Accessor}
+                                     * @p OtherAccessor class to the @p Accessor
                                      * class of this object. One such path
                                      * would be derived class to base class,
                                      * which for example may be used to get
-                                     * a @ref{Triangulation}@p{::active_cell_iterator} from
-                                     * a @ref{DoFHandler}@p{::active_cell_iterator}, since
-                                     * the @ref{DoFAccessor} class is derived from
-                                     * the @ref{TriaAccessor} class.
+                                     * a Triangulation@p ::active_cell_iterator from
+                                     * a DoFHandler@p ::active_cell_iterator, since
+                                     * the DoFAccessor class is derived from
+                                     * the TriaAccessor class.
                                      */
     template <typename OtherAccessor>
     TriaActiveIterator (const TriaActiveIterator<dim,OtherAccessor> &i);
@@ -781,7 +781,7 @@ class TriaActiveIterator : public TriaIterator<dim,Accessor>
                                      *  previously pointed to. Since this
                                      *  involves a temporary and a copy
                                      *  operation and since an
-                                     *  @p{active_iterator} is quite a large
+                                     *  @p active_iterator is quite a large
                                      *  object for a pointer, use the
                                      *  prefix operator @p{++i} whenever
                                      *  possible, especially in the head
@@ -793,7 +793,7 @@ class TriaActiveIterator : public TriaIterator<dim,Accessor>
     TriaActiveIterator<dim,Accessor> operator ++ (int);
 
                                     /**
-                                     *  Prefix @p{--} operator: @p{--i}. This
+                                     *  Prefix @p -- operator: @p --i. This
                                      *  operator advances the iterator to
                                      *  the previous active element and
                                      *  returns a reference to @p{*this}.
@@ -801,7 +801,7 @@ class TriaActiveIterator : public TriaIterator<dim,Accessor>
     TriaActiveIterator<dim,Accessor> & operator -- ();
 
                                     /**
-                                     *  Postfix @p{--} operator: @p{i--}.
+                                     *  Postfix @p -- operator: @p i--.
                                      */
     TriaActiveIterator<dim,Accessor> operator -- (int);
                                     /*@}*/
@@ -1016,8 +1016,8 @@ TriaActiveIterator<dim,Accessor>::TriaActiveIterator (const TriaRawIterator<dim,
 
 
 /**
- * Print the address to which this iterator points to @p{out}. The
- * address is given by the pair @p{(level,index)}, where @p{index} is
+ * Print the address to which this iterator points to @p out. The
+ * address is given by the pair @p{(level,index)}, where @p index is
  * an index relative to the level in which the object is that is
  * pointed to.
  *
@@ -1035,8 +1035,8 @@ std::ostream & operator << (std::ostream                        &out,
 
 
 /**
- * Print the address to which this iterator points to @p{out}. The
- * address is given by the pair @p{(level,index)}, where @p{index} is
+ * Print the address to which this iterator points to @p out. The
+ * address is given by the pair @p{(level,index)}, where @p index is
  * an index relative to the level in which the object is that is
  * pointed to.
  *
@@ -1054,8 +1054,8 @@ std::ostream & operator << (std::ostream                     &out,
 
 
 /**
- * Print the address to which this iterator points to @p{out}. The
- * address is given by the pair @p{(level,index)}, where @p{index} is
+ * Print the address to which this iterator points to @p out. The
+ * address is given by the pair @p{(level,index)}, where @p index is
  * an index relative to the level in which the object is that is
  * pointed to.
  *
index 3febb1c641c746fad26b8c3240f6a1f677a4f2c8..d2d84fcf909f3e96934d04d314e62e2423e66c3a 100644 (file)
@@ -64,8 +64,8 @@ class TriangulationLevel<0>
                                      *  vector depends on the dimension: in
                                      *  one dimension, the length of this
                                      *  vector equals the length of the
-                                     *  @p{lines} vector, in two dimensions
-                                     *  that of the @p{quads} vector, etc.
+                                     *  @p lines vector, in two dimensions
+                                     *  that of the @p quads vector, etc.
                                      */
     std::vector<bool> refine_flags;
 
@@ -79,7 +79,7 @@ class TriangulationLevel<0>
                                     /**
                                      *  Levels and indices of the neighbors
                                      *  of the cells. Convention is, that the
-                                     *  neighbors of the cell with index @p{i}
+                                     *  neighbors of the cell with index @p i
                                      *  are stored in the fields following
                                      *  $i*(2*real_space_dimension)$, e.g. in
                                      *  one spatial dimension, the neighbors
@@ -97,10 +97,10 @@ class TriangulationLevel<0>
                                      *  is set.
                                      *
                                      *  <em>Conventions:</em> The
-                                     *  @p{i}th neighbor of a cell is
+                                     *  @p ith neighbor of a cell is
                                      *  the one which shares the
-                                     *  @p{i}th face (@p{Line} in 2D,
-                                     *  @p{Quad} in 3D) of this cell.
+                                     *  @p ith face (@p Line in 2D,
+                                     *  @p Quad in 3D) of this cell.
                                      *
                                      *  The neighbor of a cell has at most the
                                      *  same level as this cell, i.e. it may
@@ -141,8 +141,8 @@ class TriangulationLevel<0>
     
                                     /**
                                      *  Reserve enough space to accomodate
-                                     *  @p{total_cells} cells on this level.
-                                     *  Since there are no @p{used} flags on this
+                                     *  @p total_cells cells on this level.
+                                     *  Since there are no @p used flags on this
                                      *  level, you have to give to total number
                                      *  of cells, not only the number of newly
                                      *  to accomodate ones, like in the
@@ -160,10 +160,10 @@ class TriangulationLevel<0>
                                     /**
                                      *  Check the memory consistency of the
                                      *  different containers. Should only be
-                                     *  called with the prepro flag @p{DEBUG}
+                                     *  called with the prepro flag @p DEBUG
                                      *  set. The function should be called from
                                      *  the functions of the higher
-                                     *  @ref{TriangulationLevel} classes.
+                                     *  TriangulationLevel classes.
                                      */
     void monitor_memory (const unsigned int true_dimension) const;
 
@@ -198,7 +198,7 @@ class TriangulationLevel<0>
  *  
  *  In one dimension, this is a list of the lines associated with this level,
  *  as well as a list with the indices of the children of these lines.
- *  The @ref{TriangulationsLevel} objects of higher dimensions are derived from
+ *  The TriangulationsLevel objects of higher dimensions are derived from
  *  this one.
  *
  *  @author Wolfgang Bangerth, 1998
@@ -239,22 +239,22 @@ class TriangulationLevel<1> : public TriangulationLevel<0>
                                          *  stored in this list. A line is
                                          *  called active if it has no
                                          *  children. The function
-                                         *  @ref{TriaIterator}@p{::active()}
+                                         *  TriaIterator@p{::active()}
                                          *  tests for this.
                                          */
        std::vector<int>  children;
        
                                         /**
                                          *  Vector storing whether a line is
-                                         *  used in the @p{lines} vector.
+                                         *  used in the @p lines vector.
                                          *
                                          *  Since it is difficult to delete
-                                         *  elements in a @p{vector}, when an
+                                         *  elements in a @p vector, when an
                                          *  element is not needed any more
                                          *  (e.g. after derefinement), it is
                                          *  not deleted from the list, but
-                                         *  rather the according @p{used} flag
-                                         *  is set to @p{false}.
+                                         *  rather the according @p used flag
+                                         *  is set to @p false.
                                          */
        std::vector<bool> used;
 
@@ -267,7 +267,7 @@ class TriangulationLevel<1> : public TriangulationLevel<0>
                                          *  already been processed.
                                          *
                                          *  You can clear all used flags using
-                                         *  @ref{Triangulation}@p{::clear_user_flags()}.
+                                         *  Triangulation@p{::clear_user_flags()}.
                                          */
        std::vector<bool> user_flags;
 
@@ -311,7 +311,7 @@ class TriangulationLevel<1> : public TriangulationLevel<0>
 
                                     /**
                                      *  Assert that enough space is allocated
-                                     *  to accomodate @p{new_lines} new lines.
+                                     *  to accomodate @p new_lines new lines.
                                      *  This function does not only call
                                      *  @p{vector::reserve()}, but does really
                                      *  append the needed elements.
@@ -322,7 +322,7 @@ class TriangulationLevel<1> : public TriangulationLevel<0>
                                      *  between the number of new quads and
                                      *  the number of new lines, etc.). Also
                                      *  don't forget to call the
-                                     *  @ref{TriangulationLevel<0>}@p{::reserve_space}
+                                     *  @ref{TriangulationLevel<0>}@p ::reserve_space
                                      *  function.
                                      */
     void reserve_space (const unsigned int new_lines);
@@ -330,10 +330,10 @@ class TriangulationLevel<1> : public TriangulationLevel<0>
                                     /**
                                      *  Check the memory consistency of the
                                      *  different containers. Should only be
-                                     *  called with the prepro flag @p{DEBUG}
+                                     *  called with the prepro flag @p DEBUG
                                      *  set. The function should be called from
                                      *  the functions of the higher
-                                     *  @ref{TriangulationLevel} classes.
+                                     *  TriangulationLevel classes.
                                      */
     void monitor_memory (const unsigned int true_dimension) const;
 
@@ -369,17 +369,17 @@ class TriangulationLevel<2> :  public TriangulationLevel<1>
                                      *
                                      *  It is fully analogous to the
                                      *  @ref{TriangulationLevel<1>::LinesData} structure inherited from
-                                     *  @ref{Triangulation}@p{<1>}.
+                                     *  Triangulation@p{<1>}.
                                      */
     struct QuadsData
     {
                                         /**
-                                         *  Same as for the @p{lines} array.
+                                         *  Same as for the @p lines array.
                                          */
        std::vector<Quad> quads;
                                         /**
                                          *  Same as for the
-                                         *  @ref{TriangulationLevel<1>::LinesData}@p{::chilren}
+                                         *  @ref{TriangulationLevel<1>::LinesData}@p ::chilren
                                          *  array, but since there
                                          *  are four children, the
                                          *  index points to the first
@@ -391,13 +391,13 @@ class TriangulationLevel<2> :  public TriangulationLevel<1>
 
                                         /**
                                          *  Same as for
-                                         *  @ref{TriangulationLevel<1>::LinesData}@p{::used}.
+                                         *  @ref{TriangulationLevel<1>::LinesData}@p ::used.
                                          */
        std::vector<bool> used;
 
                                         /**
                                          *  Same as for
-                                         *  @ref{TriangulationLevel<1>::LinesData}@p{::used}.
+                                         *  @ref{TriangulationLevel<1>::LinesData}@p ::used.
                                          */
        std::vector<bool> user_flags;
 
@@ -442,17 +442,17 @@ class TriangulationLevel<2> :  public TriangulationLevel<1>
 
                                     /**
                                      *  Assert that enough space is allocated
-                                     *  to accomodate @p{new_quads} new quads.
+                                     *  to accomodate @p new_quads new quads.
                                      */
     void reserve_space (const unsigned int new_quads);
 
                                     /**
                                      *  Check the memory consistency of the
                                      *  different containers. Should only be
-                                     *  called with the prepro flag @p{DEBUG}
+                                     *  called with the prepro flag @p DEBUG
                                      *  set. The function should be called from
                                      *  the functions of the higher
-                                     *  @ref{TriangulationLevel} classes.
+                                     *  TriangulationLevel classes.
                                      */
     void monitor_memory (const unsigned int true_dimension) const;
 
@@ -498,13 +498,13 @@ class TriangulationLevel<3> :  public TriangulationLevel<2>
     struct HexesData
     {
                                         /**
-                                         *  Same as for the @p{lines} array.
+                                         *  Same as for the @p lines array.
                                          */
        std::vector<Hexahedron> hexes;
         
                                         /**
                                          *  Same as for the
-                                         *  @ref{TriangulationLevel<1>::LinesData}@p{::chilren}
+                                         *  @ref{TriangulationLevel<1>::LinesData}@p ::chilren
                                          *  array, but since there
                                          *  are four children, the
                                          *  index points to the first
@@ -516,13 +516,13 @@ class TriangulationLevel<3> :  public TriangulationLevel<2>
 
                                         /**
                                          *  Same as for
-                                         *  @ref{TriangulationLevel<1>::LinesData}@p{::used}.
+                                         *  @ref{TriangulationLevel<1>::LinesData}@p ::used.
                                          */
        std::vector<bool> used;
 
                                         /**
                                          *  Same as for
-                                         *  @ref{TriangulationLevel<1>::LinesData}@p{::used}.
+                                         *  @ref{TriangulationLevel<1>::LinesData}@p ::used.
                                          */
        std::vector<bool> user_flags;
 
@@ -602,8 +602,8 @@ class TriangulationLevel<3> :  public TriangulationLevel<2>
                                           * follows this convention or
                                           * not. If this is so, then
                                           * this variable stores a
-                                          * @p{true} value, otherwise
-                                          * a @p{false} value.
+                                          * @p true value, otherwise
+                                          * a @p false value.
                                           *
                                           * In effect, this field has
                                           * @p{6*n_cells} elements,
@@ -622,7 +622,7 @@ class TriangulationLevel<3> :  public TriangulationLevel<2>
 
                                     /**
                                      *  Assert that enough space is allocated
-                                     *  to accomodate @p{new_quads} new quads.
+                                     *  to accomodate @p new_quads new quads.
                                      */
     void reserve_space (const unsigned int new_quads);
 
@@ -631,10 +631,10 @@ class TriangulationLevel<3> :  public TriangulationLevel<2>
                                      *  of the different
                                      *  containers. Should only be
                                      *  called with the prepro flag
-                                     *  @p{DEBUG} set. The function
+                                     *  @p DEBUG set. The function
                                      *  should be called from the
                                      *  functions of the higher
-                                     *  @ref{TriangulationLevel}
+                                     *  TriangulationLevel
                                      *  classes.
                                      */
     void monitor_memory (const unsigned int true_dimension) const;
index 17ad9d51d0fe4b36ab975646a5848930768a6580..e544a8e999fc8f43946fb565418f46b47a88bfd1 100644 (file)
@@ -34,7 +34,7 @@ class Line
   public:
                                     /**
                                      *  Construct a line with end point
-                                     *  indices @p{i0} and @p{i1}. By default,
+                                     *  indices @p i0 and @p i1. By default,
                                      *  indices are set to -1, i.e. an
                                      *  invalid value.
                                      */
@@ -42,14 +42,14 @@ class Line
          const int i1 = -1);
     
                                     /**
-                                     *  Return the index of end point @p{i}=0
+                                     *  Return the index of end point @p i=0
                                      *  or 1.
                                      */
     int vertex (const int i) const;
     
                                     /**
-                                     *  Set the index of the @p{i}th vertex to
-                                     *  @p{index}. @p{i}=0 or 1.
+                                     *  Set the index of the @p ith vertex to
+                                     *  @p index. @p i=0 or 1.
                                      */
     void set_vertex (const int i, const int index);
     
index 162672d70ba2c2a9b1a4ac35e4499bde298ec2f6..8f2f272d3bcd000cd440200f5460e9a6fd5caa47 100644 (file)
@@ -19,7 +19,7 @@
 
 
 /**
- *   @p{Quad}s denote the fundamental entities of triangulations in two dimensions
+ *   @p Quads denote the fundamental entities of triangulations in two dimensions
  *   and the boundaries of hexaeders in three dimensions. They are
  *   characterized by the (global) indices of the dour bounding lines.
  *
@@ -37,7 +37,7 @@ class Quad
 
                                     /**
                                      *  Construct a Quad with line
-                                     *  indices @p{i0} through @p{i3}. By default,
+                                     *  indices @p i0 through @p i3. By default,
                                      *  indices are set to -1, i.e. an
                                      *  invalid value.
                                      *
@@ -50,14 +50,14 @@ class Quad
          const int i3 = -1);
     
                                     /**
-                                     *  Return the index of line @p{i}=0
+                                     *  Return the index of line @p i=0
                                      *  through 3.
                                      */
     int line (const int i) const;
     
                                     /**
-                                     *  Set the index of the @p{i}th line to
-                                     *  @p{index}. @p{i}=0 through 3.
+                                     *  Set the index of the @p ith line to
+                                     *  @p index. @p i=0 through 3.
                                      */
     void set_line (const int i, const int index);
     
index 93003f881e43fde313000db7c8e21f3f73637282..10a8e4d4d475ecf658c65eff78afcc0f6fd2c01a 100644 (file)
@@ -23,8 +23,8 @@
  * This is a little wrapper, transforming a triplet of iterative
  * solver, matrix and preconditioner into a coarse grid solver.
  *
- * The type of the matrix (i.e. the template parameter @p{MATRIX})
- * should be derived from @p{Subscriptor} to allow for the use of a
+ * The type of the matrix (i.e. the template parameter @p MATRIX)
+ * should be derived from @p Subscriptor to allow for the use of a
  * smart pointer to it.
  *
  * @author Guido Kanschat, 1999, Ralf Hartmann, 2002.
@@ -102,7 +102,7 @@ class MGCoarseGridLACIteration :  public MGCoarseGridBase<VECTOR>
  * Coarse grid solver by QR factorization
  *
  * This is a direct solver for possibly indefinite coarse grid
- * problems, using the @p{least_squares} function of the class
+ * problems, using the @p least_squares function of the class
  * FullMatrix.
  *
  * Since the currently implemented Householder algorithm transforms
index b1b5396b2aedd234623b385fd12c96381eabb2e0..a9da3d12a1e3c3c48ad0f551e522072014f70869 100644 (file)
@@ -31,14 +31,14 @@ template <int dim>              class MGDoFObjectAccessor<3, dim>;
  * a multigrid DoF handler object.
  *
  * Note that it is allowed to construct an object of which the
- * @p{mg_dof_handler} pointer is a Null pointer. Such an object would
+ * @p mg_dof_handler pointer is a Null pointer. Such an object would
  * 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 @ref{DoFHandler} pointer is that
+ * constructor which gets passed the 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
- * @ref{DoFHandler} object to be used upon construction of that object.
+ * (like in the @p FEValues class) if we did not know about the
+ * 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.
@@ -47,7 +47,7 @@ template <int dim>              class MGDoFObjectAccessor<3, dim>;
  * which has an invalid dof handler pointer. This is to guarantee
  * that every iterator which is once assigned to is a valid
  * object. However, this assertion only holds in debug mode, when
- * the @p{Assert} macro is switched on.
+ * the @p Assert macro is switched on.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -63,7 +63,7 @@ class MGDoFAccessor {
 
                                     /**
                                      * This should be the default constructor.
-                                     * We cast away the @p{const}ness of the
+                                     * We cast away the @p constness of the
                                      * pointer which clearly is EVIL but
                                      * we can't help without making all
                                      * functions which could somehow use
@@ -97,7 +97,7 @@ class MGDoFAccessor {
 
   protected:
                                     /**
-                                     * Store the address of the @p{MGDoFHandler} object
+                                     * Store the address of the @p MGDoFHandler object
                                      * to be accessed.
                                      */
     MGDoFHandler<dim> *mg_dof_handler;  
@@ -107,14 +107,14 @@ class MGDoFAccessor {
 /* -------------------------------------------------------------------------- */
 
 /**
- * This is a switch class which only declares a @p{typdef}. It is meant to
- * determine which class a @p{MGDoFObjectAccessor} class is to be derived
+ * This is a switch class which only declares a @p typdef. It is meant to
+ * determine which class a @p MGDoFObjectAccessor class is to be derived
  * from. By default, @p{MGDoFObjectAccessor<celldim,dim>} derives from
- * the @p{typedef} in the general @p{MGDoFObjectAccessor_Inheritance<celldim,dim>}
+ * the @p typedef in the general @p{MGDoFObjectAccessor_Inheritance<celldim,dim>}
  * class, which is @p{DoFObjectAccessor<celldim,dim>},
  * but if @p{celldim==dim}, then the specialization @p{MGDoFObjectAccessor_Inheritance<dim,dim>}
  * is used which declares its local type to be @p{DoFCellAccessor<dim>}. Therefore,
- * the inheritance is automatically chosen to be from @p{DoFCellAccessor} if the
+ * the inheritance is automatically chosen to be from @p DoFCellAccessor if the
  * object under consideration has full dimension, i.e. constitutes a cell.
  *
  * @author Wolfgang Bangerth, 1999
@@ -124,7 +124,7 @@ class MGDoFObjectAccessor_Inheritance
 {
   public:
                                     /**
-                                     * Declaration of the @p{typedef}.
+                                     * Declaration of the @p typedef.
                                      * See the full documentation for
                                      * more information.
                                      */
@@ -133,14 +133,14 @@ class MGDoFObjectAccessor_Inheritance
 
 
 /**
- * This is a switch class which only declares a @p{typdef}. It is meant to
- * determine which class a @p{DoFObjectAccessor} class is to be derived
+ * This is a switch class which only declares a @p typdef. It is meant to
+ * determine which class a @p DoFObjectAccessor class is to be derived
  * from. By default, @p{DoFObjectAccessor<celldim,dim>} derives from
- * the @p{typedef} in the general @p{DoFObjectAccessor_Inheritance<celldim,dim>}
+ * the @p typedef in the general @p{DoFObjectAccessor_Inheritance<celldim,dim>}
  * class, which is @p{TriaObjectAccessor<celldim,dim>},
  * but if @p{celldim==dim}, then the specialization @p{TriaObjectAccessor<dim,dim>}
  * is used which declares its local type to be @p{CellAccessor<dim>}. Therefore,
- * the inheritance is automatically chosen to be from @p{CellAccessor} if the
+ * the inheritance is automatically chosen to be from @p CellAccessor if the
  * object under consideration has full dimension, i.e. constitutes a cell.
  *
  * @author Wolfgang Bangerth, 1999
@@ -150,7 +150,7 @@ class MGDoFObjectAccessor_Inheritance<dim,dim>
 {
   public:
                                     /**
-                                     * Declaration of the @p{typedef}.
+                                     * Declaration of the @p typedef.
                                      * See the full documentation for
                                      * more information.
                                      */
@@ -201,7 +201,7 @@ class MGDoFObjectAccessor<0, dim>
 /**
  * Grant access to the degrees of freedom located on lines.
  * This class follows mainly the route laid out by the accessor library
- * declared in the triangulation library (@ref{TriaAccessor}). It enables
+ * declared in the triangulation library (TriaAccessor). It enables
  * the user to access the degrees of freedom on the lines (there are similar
  * versions for the DoFs on quads, etc), where the dimension of the underlying
  * triangulation does not really matter (i.e. this accessor works with the
@@ -210,7 +210,7 @@ class MGDoFObjectAccessor<0, dim>
  *
  * @sect3{Usage}
  *
- * The @ref{DoFDimensionInfo} classes inherited by the @ref{DoFHandler} classes
+ * The DoFDimensionInfo classes inherited by the DoFHandler classes
  * declare typedefs to iterators using the accessors declared in this class
  * hierarchy tree. Usage is best to happens through these typedefs, since they
  * are more secure to changes in the class naming and template interface as well
@@ -221,7 +221,7 @@ class MGDoFObjectAccessor<0, dim>
  *
  * Inheritance from @p{MGDoFObjectAccessor_Inheritance<1,dim>::BaseClass} yields
  * inheritance from @p{DoFCellAccessor<1>} if @p{dim==1} and from
- * @p{TriaObjectAccessor<1,dim>} for all other @p{dim} values. Thus, an object
+ * @p{TriaObjectAccessor<1,dim>} for all other @p dim values. Thus, an object
  * of this class shares all features of cells in one dimension, but behaves
  * like an ordinary line in all other cases.
  *
@@ -246,7 +246,7 @@ class MGDoFObjectAccessor<1, dim> :  public MGDoFAccessor<dim>,
     MGDoFObjectAccessor ();
     
                                     /**
-                                     * Constructor. The @p{local_data}
+                                     * Constructor. The @p local_data
                                      * argument is assumed to be a pointer
                                      * to a @p{MGDoFHandler<dim>} object.
                                      */
@@ -256,31 +256,31 @@ class MGDoFObjectAccessor<1, dim> :  public MGDoFAccessor<dim>,
                         const AccessorData       *local_data);
     
                                     /**
-                                     * Return the index of the @p{i}th degree
+                                     * Return the index of the @p ith degree
                                      * of freedom of this line on the level
                                      * this line lives on.
                                      */
     unsigned int mg_dof_index (const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the @p{i}th degree
+                                     * Set the index of the @p ith degree
                                      * of freedom of this line on the
-                                     * level this line lives on to @p{index}.
+                                     * level this line lives on to @p index.
                                      */
     void set_mg_dof_index (const unsigned int i,
                           const unsigned int index) const;
 
                                     /**
-                                     * Return the index of the @p{i}th degree
-                                     * on the @p{vertex}th vertex for the
+                                     * Return the index of the @p ith degree
+                                     * on the @p vertexth vertex for the
                                      * level this line lives on.
                                      */
     unsigned int mg_vertex_dof_index (const unsigned int vertex,
                                      const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the @p{i}th degree
-                                     * on the @p{vertex}th vertex to @p{index}
+                                     * Set the index of the @p ith degree
+                                     * on the @p vertexth vertex to @p index
                                      * for the level this line lives on.
                                      */
     void set_mg_vertex_dof_index (const unsigned int vertex,
@@ -322,7 +322,7 @@ class MGDoFObjectAccessor<1, dim> :  public MGDoFAccessor<dim>,
                            Vector<number>       &dof_values) const;
 
                                     /**
-                                     * Return the @p{i}th child as a MGDoF line
+                                     * Return the @p ith child as a MGDoF line
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a line accessor without
@@ -362,9 +362,9 @@ class MGDoFObjectAccessor<2, dim> :  public MGDoFAccessor<dim>,
     MGDoFObjectAccessor ();
 
                                     /**
-                                     * Constructor. The @p{local_data}
+                                     * Constructor. The @p local_data
                                      * argument is assumed to be a pointer
-                                     * to a @ref{DoFHandler} object.
+                                     * to a DoFHandler object.
                                      */
     MGDoFObjectAccessor (const Triangulation<dim> *tria,
                         const int                 level,
@@ -372,32 +372,32 @@ class MGDoFObjectAccessor<2, dim> :  public MGDoFAccessor<dim>,
                         const AccessorData       *local_data);
     
                                     /**
-                                     * Return the index of the @p{i}th degree
+                                     * Return the index of the @p ith degree
                                      * of freedom of this quad on the level
                                      * this quad lives on.
                                      */
     unsigned int mg_dof_index (const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the @p{i}th degree
+                                     * Set the index of the @p ith degree
                                      * of freedom of this quad on the
-                                     * level this quad lives on to @p{index}.
+                                     * level this quad lives on to @p index.
                                      */
     void set_mg_dof_index (const unsigned int i,
                           const unsigned int index) const;
 
                                     /**
-                                     * Return the index of the @p{i}th degree
-                                     * on the @p{vertex}th vertex for the level
+                                     * Return the index of the @p ith degree
+                                     * on the @p vertexth vertex for the level
                                      * this quad lives on.
                                      */
     unsigned int mg_vertex_dof_index (const unsigned int vertex,
                                      const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the @p{i}th degree
-                                     * on the @p{vertex}th vertex for the
-                                     * level this quad lives on to @p{index}.
+                                     * Set the index of the @p ith degree
+                                     * on the @p vertexth vertex for the
+                                     * level this quad lives on to @p index.
                                      */
     void set_mg_vertex_dof_index (const unsigned int vertex,
                                  const unsigned int i,
@@ -439,14 +439,14 @@ class MGDoFObjectAccessor<2, dim> :  public MGDoFAccessor<dim>,
                            Vector<number>       &dof_values) const;
 
                                     /**
-                                     * Return a pointer to the @p{i}th line
-                                     * bounding this @p{Quad}.
+                                     * Return a pointer to the @p ith line
+                                     * bounding this @p Quad.
                                      */
     TriaIterator<dim,MGDoFObjectAccessor<1, dim> >
     line (const unsigned int i) const;
 
                                     /**
-                                     * Return the @p{i}th child as a DoF quad
+                                     * Return the @p ith child as a DoF quad
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a quad accessor without
@@ -487,9 +487,9 @@ class MGDoFObjectAccessor<3, dim> :  public MGDoFAccessor<dim>,
     MGDoFObjectAccessor ();
 
                                     /**
-                                     * Constructor. The @p{local_data}
+                                     * Constructor. The @p local_data
                                      * argument is assumed to be a pointer
-                                     * to a @ref{DoFHandler} object.
+                                     * to a DoFHandler object.
                                      */
     MGDoFObjectAccessor (const Triangulation<dim> *tria,
                         const int                 level,
@@ -497,32 +497,32 @@ class MGDoFObjectAccessor<3, dim> :  public MGDoFAccessor<dim>,
                         const AccessorData       *local_data);
     
                                     /**
-                                     * Return the index of the @p{i}th degree
+                                     * Return the index of the @p ith degree
                                      * of freedom of this hex on the level
                                      * this quad lives on.
                                      */
     unsigned int mg_dof_index (const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the @p{i}th degree
+                                     * Set the index of the @p ith degree
                                      * of freedom of this hex on the
-                                     * level this hex lives on to @p{index}.
+                                     * level this hex lives on to @p index.
                                      */
     void set_mg_dof_index (const unsigned int i,
                           const unsigned int index) const;
 
                                     /**
-                                     * Return the index of the @p{i}th degree
-                                     * on the @p{vertex}th vertex for the level
+                                     * Return the index of the @p ith degree
+                                     * on the @p vertexth vertex for the level
                                      * this hex lives on.
                                      */
     unsigned int mg_vertex_dof_index (const unsigned int vertex,
                                      const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the @p{i}th degree
-                                     * on the @p{vertex}th vertex for the
-                                     * level this hex lives on to @p{index}.
+                                     * Set the index of the @p ith degree
+                                     * on the @p vertexth vertex for the
+                                     * level this hex lives on to @p index.
                                      */
     void set_mg_vertex_dof_index (const unsigned int vertex,
                                  const unsigned int i,
@@ -564,21 +564,21 @@ class MGDoFObjectAccessor<3, dim> :  public MGDoFAccessor<dim>,
                            Vector<number>       &dof_values) const;
 
                                     /**
-                                     * Return a pointer to the @p{i}th line
-                                     * bounding this @p{Hex}.
+                                     * Return a pointer to the @p ith line
+                                     * bounding this @p Hex.
                                      */
     TriaIterator<dim,MGDoFObjectAccessor<1, dim> >
     line (const unsigned int i) const;
 
                                     /**
-                                     * Return a pointer to the @p{i}th quad
-                                     * bounding this @p{Hex}.
+                                     * Return a pointer to the @p ith quad
+                                     * bounding this @p Hex.
                                      */
     TriaIterator<dim,MGDoFObjectAccessor<2, dim> >
     quad (const unsigned int i) const;
 
                                     /**
-                                     * Return the @p{i}th child as a DoF quad
+                                     * Return the @p ith child as a DoF quad
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a hex accessor without
@@ -601,8 +601,8 @@ class MGDoFObjectAccessor<3, dim> :  public MGDoFAccessor<dim>,
  * one and two, respectively, this class only collects the pieces
  * together by deriving from the appropriate @p{DoF*Accessor} and the
  * right @p{CellAccessor<dim>} 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 @p DoFCellAccessor objects
+ * rather than @p CellAccessor objects (the latter function was inherited
  * from the @p{CellAccessor<dim>} class).
  *
  * @author Wolfgang Bangerth, 1998
@@ -633,7 +633,7 @@ class MGDoFCellAccessor :  public MGDoFObjectAccessor<dim, dim> {
                    MGDoFObjectAccessor<dim, dim> (tria,level,index,local_data) {};
 
                                     /**
-                                     * Return the @p{i}th neighbor as a MGDoF cell
+                                     * Return the @p ith neighbor as a MGDoF cell
                                      * iterator. This function is needed since
                                      * the neighbor function of the base
                                      * class returns a cell accessor without
@@ -642,7 +642,7 @@ class MGDoFCellAccessor :  public MGDoFObjectAccessor<dim, dim> {
     TriaIterator<dim,MGDoFCellAccessor<dim> > neighbor (const unsigned int) const;
 
                                     /**
-                                     * Return the @p{i}th child as a MGDoF cell
+                                     * Return the @p ith child as a MGDoF cell
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a cell accessor without
@@ -651,7 +651,7 @@ class MGDoFCellAccessor :  public MGDoFObjectAccessor<dim, dim> {
     TriaIterator<dim,MGDoFCellAccessor<dim> > child (const unsigned int) const;
 
                                     /**
-                                     * Return an iterator to the @p{i}th face
+                                     * Return an iterator to the @p ith face
                                      * of this cell.
                                      *
                                      * This function is not implemented in 1D,
@@ -662,7 +662,7 @@ class MGDoFCellAccessor :  public MGDoFObjectAccessor<dim, dim> {
 
                                     /**
                                      * Return the result of the
-                                     * @p{neighbor_child_on_subface}
+                                     * @p neighbor_child_on_subface
                                      * function of the base class,
                                      * but convert it so that one can
                                      * also access the MGDoF data (the
index ec86cf3b9cab92ce95ef6c00e0b4edfa27a46dc5..465be0c3a697e6dc8c0754058d226a7d61e7db3c 100644 (file)
@@ -197,7 +197,7 @@ class MGDoFDimensionInfo<3>
 
 /**
  * This class manages degrees of freedom for a multilevel hierarchy of
- * grids. It does mostly the same as does the @p{DoDHandler} class,
+ * grids. It does mostly the same as does the @p DoDHandler class,
  * but it uses a separate enumeration of the degrees of freedom on
  * each level. For example, a vertex has several DoF numbers, one for
  * each level of the triangulation on which it exists.
@@ -233,7 +233,7 @@ class MGDoFHandler : public DoFHandler<dim>
     typedef typename MGDoFDimensionInfo<dim>::active_face_iterator active_face_iterator;
 
                                     /**
-                                     * Constructor. Take @p{tria} as
+                                     * Constructor. Take @p tria as
                                      * the triangulation to work on.
                                      */
     MGDoFHandler (const Triangulation<dim> &tria);
@@ -250,7 +250,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * finite element according to
                                      * the given distribution
                                      * method. We first call the
-                                     * @ref{DoFHandler}'s function
+                                     * DoFHandler's function
                                      * and then distribute the
                                      * levelwise numbers.
                                      *
@@ -272,7 +272,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * based on a list of new dof
                                      * numbers for all the dofs.
                                      *
-                                     * @p{new_numbers} is an array of
+                                     * @p new_numbers is an array of
                                      * integers with size equal to
                                      * the number of dofs on the
                                      * present level. It stores the
@@ -285,7 +285,7 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      * Redeclare this function of the
-                                     * @ref{DoFHandler} basis class
+                                     * DoFHandler basis class
                                      * as otherwise it is hidden from
                                      * the function with the same
                                      * name, see above.
@@ -301,33 +301,33 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Iterator to the first cell,
                                      * used or not, on level
-                                     * @p{level}. If a level has no
+                                     * @p level. If a level has no
                                      * cells, a past-the-end iterator
                                      * is returned.
                                      *
                                      * This function calls
-                                     * @p{begin_raw_line} in 1D and
-                                     * @p{begin_raw_quad} in 2D.
+                                     * @p begin_raw_line in 1D and
+                                     * @p begin_raw_quad in 2D.
                                      */
     raw_cell_iterator    begin_raw   (const unsigned int level = 0) const;
 
                                     /**
                                      * Iterator to the first used
-                                     * cell on level @p{level}.
+                                     * cell on level @p level.
                                      *
                                      * This function calls
-                                     * @p{begin_line} in 1D and
-                                     * @p{begin_quad} in 2D.
+                                     * @p begin_line in 1D and
+                                     * @p begin_quad in 2D.
                                      */
     cell_iterator        begin       (const unsigned int level = 0) const;
 
                                     /**
                                      * Iterator to the first active
-                                     * cell on level @p{level}.
+                                     * cell on level @p level.
                                      *
                                      * This function calls
-                                     * @p{begin_active_line} in 1D
-                                     * and @p{begin_active_quad} in
+                                     * @p begin_active_line in 1D
+                                     * and @p begin_active_quad in
                                      * 2D.
                                      */
     active_cell_iterator begin_active(const unsigned int level = 0) const;
@@ -340,15 +340,15 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * before-the-beginning states.
                                      *
                                      * This function calls
-                                     * @p{end_line} in 1D and
-                                     * @p{end_quad} in 2D.
+                                     * @p end_line in 1D and
+                                     * @p end_quad in 2D.
                                      */
     raw_cell_iterator    end () const;
 
                                     /**
                                      * Return an iterator which is
                                      * the first iterator not on
-                                     * level. If @p{level} is the
+                                     * level. If @p level is the
                                      * last level, then this returns
                                      * @p{end()}.
                                      */
@@ -357,7 +357,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return a raw iterator which is
                                      * the first iterator not on
-                                     * level. If @p{level} is the
+                                     * level. If @p level is the
                                      * last level, then this returns
                                      * @p{end()}.
                                      */
@@ -366,7 +366,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an active iterator
                                      * which is the first iterator
-                                     * not on level. If @p{level} is
+                                     * not on level. If @p level is
                                      * the last level, then this
                                      * returns @p{end()}.
                                      */
@@ -377,19 +377,19 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the last cell, used or not.
                                      *
                                      * This function calls
-                                     * @p{last_raw_line} in 1D and
-                                     * @p{last_raw_quad} in 2D.
+                                     * @p last_raw_line in 1D and
+                                     * @p last_raw_quad in 2D.
                                      */
     raw_cell_iterator    last_raw () const;
 
                                     /**
                                      * Return an iterator pointing to
                                      * the last cell of the level
-                                     * @p{level}, used or not.
+                                     * @p level, used or not.
                                      *
                                      * This function calls
-                                     * @p{last_raw_line} in 1D and
-                                     * @p{last_raw_quad} in 2D.
+                                     * @p last_raw_line in 1D and
+                                     * @p last_raw_quad in 2D.
                                      */
     raw_cell_iterator    last_raw (const unsigned int level) const;
 
@@ -398,19 +398,19 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the last used cell.
                                      *
                                      * This function calls
-                                     * @p{last_line} in 1D and
-                                     * @p{last_quad} in 2D.
+                                     * @p last_line in 1D and
+                                     * @p last_quad in 2D.
                                      */
     cell_iterator        last () const;
 
                                     /**
                                      * Return an iterator pointing to
                                      * the last used cell on level
-                                     * @p{level}.
+                                     * @p level.
                                      *
                                      * This function calls
-                                     * @p{last_line} in 1D and
-                                     * @p{last_quad} in 2D.
+                                     * @p last_line in 1D and
+                                     * @p last_quad in 2D.
                                      */
     cell_iterator        last (const unsigned int level) const;
 
@@ -419,19 +419,19 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the last active cell.
                                      *
                                      * This function calls
-                                     * @p{last_active_line} in 1D and
-                                     * @p{last_active_quad} in 2D.
+                                     * @p last_active_line in 1D and
+                                     * @p last_active_quad in 2D.
                                      */
     active_cell_iterator last_active () const;
 
                                     /**
                                      * Return an iterator pointing to
                                      * the last active cell on level
-                                     * @p{level}.
+                                     * @p level.
                                      *
                                      * This function calls
-                                     * @p{last_active_line} in 1D and
-                                     * @p{last_active_quad} in 2D.
+                                     * @p last_active_line in 1D and
+                                     * @p last_active_quad in 2D.
                                      */
     active_cell_iterator last_active (const unsigned int level) const;
                                     //@}
@@ -445,33 +445,33 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Iterator to the first face,
                                      * used or not, on level
-                                     * @p{level}. If a level has no
+                                     * @p level. If a level has no
                                      * faces, a past-the-end iterator
                                      * is returned.
                                      *
                                      * This function calls
-                                     * @p{begin_raw_line} in 2D and
-                                     * @p{begin_raw_quad} in 3D.
+                                     * @p begin_raw_line in 2D and
+                                     * @p begin_raw_quad in 3D.
                                      */
     raw_face_iterator    begin_raw_face   (const unsigned int level = 0) const;
 
                                     /**
                                      * Iterator to the first used
-                                     * face on level @p{level}.
+                                     * face on level @p level.
                                      *
                                      * This function calls
-                                     * @p{begin_line} in 2D and
-                                     * @p{begin_quad} in 3D.
+                                     * @p begin_line in 2D and
+                                     * @p begin_quad in 3D.
                                      */
     face_iterator        begin_face       (const unsigned int level = 0) const;
 
                                     /**
                                      * Iterator to the first active
-                                     * face on level @p{level}.
+                                     * face on level @p level.
                                      *
                                      * This function calls
-                                     * @p{begin_active_line} in 2D
-                                     * and @p{begin_active_quad} in
+                                     * @p begin_active_line in 2D
+                                     * and @p begin_active_quad in
                                      * 3D.
                                      */
     active_face_iterator begin_active_face(const unsigned int level = 0) const;
@@ -484,15 +484,15 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * before-the-beginning states.
                                      *
                                      * This function calls
-                                     * @p{end_line} in 2D and
-                                     * @p{end_quad} in 3D.
+                                     * @p end_line in 2D and
+                                     * @p end_quad in 3D.
                                      */
     raw_face_iterator    end_face () const;
 
                                     /**
                                      * Return an iterator which is
                                      * the first iterator not on
-                                     * level. If @p{level} is the
+                                     * level. If @p level is the
                                      * last level, then this returns
                                      * @p{end()}.
                                      */
@@ -501,7 +501,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return a raw iterator which is
                                      * the first iterator not on
-                                     * level. If @p{level} is the
+                                     * level. If @p level is the
                                      * last level, then this returns
                                      * @p{end()}.
                                      */
@@ -510,7 +510,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an active iterator
                                      * which is the first iterator
-                                     * not on level. If @p{level} is
+                                     * not on level. If @p level is
                                      * the last level, then this
                                      * returns @p{end()}.
                                      */
@@ -521,19 +521,19 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the last face, used or not.
                                      *
                                      * This function calls
-                                     * @p{last_raw_line} in 2D and
-                                     * @p{last_raw_quad} in 3D.
+                                     * @p last_raw_line in 2D and
+                                     * @p last_raw_quad in 3D.
                                      */
     raw_face_iterator    last_raw_face () const;
 
                                     /**
                                      * Return an iterator pointing to
                                      * the last face of the level
-                                     * @p{level}, used or not.
+                                     * @p level, used or not.
                                      *
                                      * This function calls
-                                     * @p{last_raw_line} in 2D and
-                                     * @p{last_raw_quad} in 3D.
+                                     * @p last_raw_line in 2D and
+                                     * @p last_raw_quad in 3D.
                                      */
     raw_face_iterator    last_raw_face (const unsigned int level) const;
 
@@ -542,19 +542,19 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the last used face.
                                      *
                                      * This function calls
-                                     * @p{last_line} in 2D and
-                                     * @p{last_quad} in 3D.
+                                     * @p last_line in 2D and
+                                     * @p last_quad in 3D.
                                      */
     face_iterator        last_face () const;
 
                                     /**
                                      * Return an iterator pointing to
                                      * the last used face on level
-                                     * @p{level}.
+                                     * @p level.
                                      *
                                      * This function calls
-                                     * @p{last_line} in 2D and
-                                     * @p{last_quad} in 3D.
+                                     * @p last_line in 2D and
+                                     * @p last_quad in 3D.
                                      */
     face_iterator        last_face (const unsigned int level) const;
 
@@ -563,19 +563,19 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the last active face.
                                      *
                                      * This function calls
-                                     * @p{last_active_line} in 2D and
-                                     * @p{last_active_quad} in 3D.
+                                     * @p last_active_line in 2D and
+                                     * @p last_active_quad in 3D.
                                      */
     active_face_iterator last_active_face () const;
 
                                     /**
                                      * Return an iterator pointing to
                                      * the last active face on level
-                                     * @p{level}.
+                                     * @p level.
                                      *
                                      * This function calls
-                                     * @p{last_active_line} in 2D and
-                                     * @p{last_active_quad} in 3D.
+                                     * @p last_active_line in 2D and
+                                     * @p last_active_quad in 3D.
                                      */
     active_face_iterator last_active_face (const unsigned int level) const;
                                     //@}
@@ -590,7 +590,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Iterator to the first line,
                                      * used or not, on level
-                                     * @p{level}. If a level has no
+                                     * @p level. If a level has no
                                      * lines, a past-the-end iterator
                                      * is returned.
                                      */
@@ -598,13 +598,13 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      * Iterator to the first used
-                                     * line on level @p{level}.
+                                     * line on level @p level.
                                      */
     line_iterator     begin_line (const unsigned int level = 0) const;
 
                                     /**
                                      * Iterator to the first active
-                                     * line on level @p{level}.
+                                     * line on level @p level.
                                      */
     active_line_iterator begin_active_line(const unsigned int level = 0) const;
 
@@ -620,7 +620,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an iterator which is
                                      * the first iterator not on
-                                     * level. If @p{level} is the
+                                     * level. If @p level is the
                                      * last level, then this returns
                                      * @p{end()}.
                                      */
@@ -629,7 +629,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return a raw iterator which is
                                      * the first iterator not on
-                                     * level. If @p{level} is the
+                                     * level. If @p level is the
                                      * last level, then this returns
                                      * @p{end()}.
                                      */
@@ -638,7 +638,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an active iterator
                                      * which is the first iterator
-                                     * not on level. If @p{level} is
+                                     * not on level. If @p level is
                                      * the last level, then this
                                      * returns @p{end()}.
                                      */
@@ -654,7 +654,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an iterator pointing to
                                      * the last line of the level
-                                     * @p{level}, used or not.
+                                     * @p level, used or not.
                                      */
     raw_line_iterator    last_raw_line (const unsigned int level) const;
 
@@ -667,7 +667,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an iterator pointing to
                                      * the last used line on level
-                                     * @p{level}.
+                                     * @p level.
                                      */
     line_iterator        last_line (const unsigned int level) const;
 
@@ -680,7 +680,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an iterator pointing to
                                      * the last active line on level
-                                     * @p{level}.
+                                     * @p level.
                                      */
     active_line_iterator last_active_line (const unsigned int level) const;
                                     /*@}*/       
@@ -694,7 +694,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Iterator to the first quad,
                                      * used or not, on level
-                                     * @p{level}. If a level has no
+                                     * @p level. If a level has no
                                      * quads, a past-the-end iterator
                                      * is returned.
                                      */
@@ -702,13 +702,13 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      * Iterator to the first used
-                                     * quad on level @p{level}.
+                                     * quad on level @p level.
                                      */
     quad_iterator        begin_quad       (const unsigned int level = 0) const;
 
                                     /**
                                      * Iterator to the first active
-                                     * quad on level @p{level}.
+                                     * quad on level @p level.
                                      */
     active_quad_iterator begin_active_quad(const unsigned int level = 0) const;
 
@@ -724,7 +724,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an iterator which is
                                      * the first iterator not on
-                                     * level. If @p{level} is the
+                                     * level. If @p level is the
                                      * last level, then this returns
                                      * @p{end()}.
                                      */
@@ -733,7 +733,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return a raw iterator which is
                                      * the first iterator not on
-                                     * level. If @p{level} is the
+                                     * level. If @p level is the
                                      * last level, then this returns
                                      * @p{end()}.
                                      */
@@ -742,7 +742,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an active iterator
                                      * which is the first iterator
-                                     * not on level. If @p{level} is
+                                     * not on level. If @p level is
                                      * the last level, then this
                                      * returns @p{end()}.
                                      */
@@ -758,7 +758,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an iterator pointing to
                                      * the last quad of the level
-                                     * @p{level}, used or not.
+                                     * @p level, used or not.
                                      */
     raw_quad_iterator    last_raw_quad (const unsigned int level) const;
 
@@ -771,7 +771,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an iterator pointing to
                                      * the last used quad on level
-                                     * @p{level}.
+                                     * @p level.
                                      */
     quad_iterator        last_quad (const unsigned int level) const;
 
@@ -784,7 +784,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an iterator pointing to
                                      * the last active quad on level
-                                     * @p{level}.
+                                     * @p level.
                                      */
     active_quad_iterator last_active_quad (const unsigned int level) const;
                                     /*@}*/
@@ -798,7 +798,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Iterator to the first hex,
                                      * used or not, on level
-                                     * @p{level}. If a level has no
+                                     * @p level. If a level has no
                                      * hexs, a past-the-end iterator
                                      * is returned.
                                      */
@@ -806,13 +806,13 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      * Iterator to the first used hex
-                                     * on level @p{level}.
+                                     * on level @p level.
                                      */
     hex_iterator        begin_hex       (const unsigned int level = 0) const;
 
                                     /**
                                      * Iterator to the first active
-                                     * hex on level @p{level}.
+                                     * hex on level @p level.
                                      */
     active_hex_iterator begin_active_hex(const unsigned int level = 0) const;
 
@@ -828,7 +828,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an iterator which is
                                      * the first iterator not on
-                                     * level. If @p{level} is the
+                                     * level. If @p level is the
                                      * last level, then this returns
                                      * @p{end()}.
                                      */
@@ -837,7 +837,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return a raw iterator which is
                                      * the first iterator not on
-                                     * level. If @p{level} is the
+                                     * level. If @p level is the
                                      * last level, then this returns
                                      * @p{end()}.
                                      */
@@ -846,7 +846,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an active iterator
                                      * which is the first iterator
-                                     * not on level. If @p{level} is
+                                     * not on level. If @p level is
                                      * the last level, then this
                                      * returns @p{end()}.
                                      */
@@ -862,7 +862,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an iterator pointing to
                                      * the last hex of the level
-                                     * @p{level}, used or not.
+                                     * @p level, used or not.
                                      */
     raw_hex_iterator    last_raw_hex (const unsigned int level) const;
 
@@ -875,7 +875,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an iterator pointing to
                                      * the last used hex on level
-                                     * @p{level}.
+                                     * @p level.
                                      */
     hex_iterator        last_hex (const unsigned int level) const;
 
@@ -888,7 +888,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Return an iterator pointing to
                                      * the last active hex on level
-                                     * @p{level}.
+                                     * @p level.
                                      */
     active_hex_iterator last_active_hex (const unsigned int level) const;
                                     /*@}*/
@@ -908,7 +908,7 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      * Redeclare this function of the
-                                     * @ref{DoFHandler} basis class
+                                     * DoFHandler basis class
                                      * as otherwise it is hidden from
                                      * the function with the same
                                      * name, see above.
@@ -960,14 +960,14 @@ class MGDoFHandler : public DoFHandler<dim>
                                          * vector<>'s and still
                                          * construct the object using
                                          * the constructor. Use the
-                                         * @p{init} function to
+                                         * @p init function to
                                          * really allocate memory.
                                          */
        MGVertexDoFs ();
 
                                         /**
                                          * Allocate memory and set
-                                         * all indices to @p{-1}.
+                                         * all indices to @p -1.
                                          */
        void init (const unsigned int coarsest_level,
                   const unsigned int finest_level,
@@ -980,8 +980,8 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                         /**
                                          * Set the index with number
-                                         * @p{dof_number} of this
-                                         * vertex on @p{level} to the
+                                         * @p dof_number of this
+                                         * vertex on @p level to the
                                          * given index. To compute
                                          * the position in the array,
                                          * one has to specify how
@@ -1002,9 +1002,9 @@ class MGDoFHandler : public DoFHandler<dim>
        
                                         /**
                                          * Return the index with
-                                         * number @p{dof_number} of
+                                         * number @p dof_number of
                                          * this vertex on
-                                         * @p{level}. To compute the
+                                         * @p level. To compute the
                                          * position in the array, one
                                          * has to specify how many
                                          * dofs per vertex there
@@ -1067,7 +1067,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                          * used for error checking
                                          * but can also be accessed
                                          * by the function
-                                         * @p{get_finest_level}.
+                                         * @p get_finest_level.
                                          */
        unsigned int finest_level;
 
@@ -1082,15 +1082,15 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * Distribute dofs on the given
                                      * cell, with new dofs starting
                                      * with index
-                                     * @p{next_free_dof}. Return the
+                                     * @p next_free_dof. Return the
                                      * next unused index number. The
                                      * finite element used is the one
-                                     * given to @p{distribute_dofs},
+                                     * given to @p distribute_dofs,
                                      * which is copied to
-                                     * @p{selected_fe}.
+                                     * @p selected_fe.
                                      *
                                      * This function is excluded from
-                                     * the @p{distribute_dofs}
+                                     * the @p distribute_dofs
                                      * function since it can not be
                                      * implemented dimension
                                      * independent.
@@ -1117,9 +1117,9 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /**
                                      * Space to store the DoF numbers
                                      * for the different
-                                     * levels. Unlike the @p{levels}
+                                     * levels. Unlike the @p levels
                                      * object in the
-                                     * @ref{DoFHandler}, these are
+                                     * DoFHandler, these are
                                      * not global numbers but rather
                                      * are numbers which start from
                                      * zero on each level.
index 3976262247c1fd0675fa632628ef169772199ca2..e729bf9411674fd663a43ff55dea81d749ba7b53 100644 (file)
@@ -28,13 +28,13 @@ template <class number> class FullMatrix;
 /**
  * This is a collection of functions operating on, and manipulating
  * the numbers of degrees of freedom in a multilevel triangulation. It
- * is similar in purpose and function to the @p{DoFTools} class, but
- * operates on @p{MGDoFHandler} objects instead of @ref{DoFHandler}
+ * is similar in purpose and function to the @p DoFTools class, but
+ * operates on @p MGDoFHandler objects instead of DoFHandler
  * objects. See there and the documentation of the member functions
  * for more information.
  *
  * All member functions are static, so there is no need to create an
- * object of class @p{MGTools}.
+ * object of class @p MGTools.
  *
  * @author Wolfgang Bangerth, Guido Kanschat, 1999-2003
  */
@@ -44,7 +44,7 @@ class MGTools
                                     /**
                                      * Write the sparsity structure
                                      * of the matrix belonging to the
-                                     * specified @p{level}. The sparsity pattern
+                                     * specified @p level. The sparsity pattern
                                      * is not compressed, so before 
                                      * creating the actual matrix
                                      * you have to compress the
@@ -78,10 +78,10 @@ class MGTools
                                      * the fluxes at refinement
                                      * edges. The matrix maps a
                                      * function of the fine level
-                                     * space @p{level} to the coarser
+                                     * space @p level to the coarser
                                      * space.
                                      *
-                                     * @ref{make_flux_sparsity_pattern}
+                                     * make_flux_sparsity_pattern()
                                      */
     template <int dim, class SparsityPattern>
     static void
@@ -136,7 +136,7 @@ class MGTools
                                      * correct size.  Here, we just
                                      * count the numbers of degrees
                                      * of freedom on each level and
-                                     * @p{reinit} each level vector
+                                     * @p reinit each level vector
                                      * to this length.
                                      */
     template <int dim, typename number>
@@ -150,16 +150,16 @@ class MGTools
                                      * the numbers of degrees of
                                      * freedom on each level
                                      * component-wise. Then, assign
-                                     * each block of @p{vector} the
+                                     * each block of @p vector the
                                      * corresponding size.
                                      *
-                                     * The boolean field @p{selected}
+                                     * The boolean field @p selected
                                      * allows restricting this
                                      * operation to certain
                                      * components. In this case,
-                                     * @p{vector} will only have as
+                                     * @p vector will only have as
                                      * many blocks as there are true
-                                     * values in @p{selected} (no
+                                     * values in @p selected (no
                                      * blocks of length zero are
                                      * padded in).
                                      *
@@ -169,10 +169,10 @@ class MGTools
                                      * from this function.
                                      *
                                      * The argument
-                                     * @p{target_component} allows to
+                                     * @p target_component allows to
                                      * re-sort and groupt components
                                      * as in
-                                     * @p{DoFRenumbering::component_wise}.
+                                     * @p DoFRenumbering::component_wise.
                                      */
     template <int dim, typename number>
       static void
@@ -186,14 +186,14 @@ class MGTools
                                      * numbers of degrees of freedom
                                      * on each level component-wise
                                      * in a single component. Then,
-                                     * assign @p{vector} the
+                                     * assign @p vector the
                                      * corresponding size.
                                      *
-                                     * The boolean field @p{selected}
+                                     * The boolean field @p selected
                                      * may be nonzero in a single
                                      * component, indicating the
                                      * block of a block vector the
-                                     * argument @p{v} corresponds to.
+                                     * argument @p v corresponds to.
                                      *
                                      * Degrees of freedom must be
                                      * sorted by component in order
@@ -201,10 +201,10 @@ class MGTools
                                      * from this function.
                                      *
                                      * The argument
-                                     * @p{target_component} allows to
+                                     * @p target_component allows to
                                      * re-sort and groupt components
                                      * as in
-                                     * @p{DoFRenumbering::component_wise}.
+                                     * @p DoFRenumbering::component_wise.
                                      */
     template <int dim, typename number>
       static void
index 431c77a2e87aba1edb48a14dc008912d39b173d3..f0a84233950519e1ed59f3548e535eb1cf944d65 100644 (file)
@@ -46,13 +46,13 @@ class MGLevelObject : public Subscriptor
                   const unsigned int maxlevel = 0);
     
                                     /**
-                                     * Access object on level @p{level}.
+                                     * Access object on level @p level.
                                      */
     Object & operator[] (const unsigned int level);
     
                                     /**
                                      * Access object on level
-                                     * @p{level}. Constant version.
+                                     * @p level. Constant version.
                                      */
     const Object & operator[] (const unsigned int level) const;
 
@@ -60,17 +60,17 @@ class MGLevelObject : public Subscriptor
                                      * Delete all previous contents
                                      * of this object and reset its
                                      * size according to the values
-                                     * of @p{new_minlevel} and
-                                     * @p{new_maxlevel}.
+                                     * of @p new_minlevel and
+                                     * @p new_maxlevel.
                                      */
     void resize (const unsigned int new_minlevel,
                 const unsigned int new_maxlevel);
     
                                     /**
-                                     * Call @p{clear} on all objects
+                                     * Call @p clear on all objects
                                      * stored by this object. This
                                      * function is only implemented
-                                     * for some @p{Object} classes,
+                                     * for some @p Object classes,
                                      * most notably for vectors and
                                      * matrices. Note that if
                                      * <tt>Object==Vector@<T@></tt>,
index 8cd9349d095ee3c93043d0de540801766505dc1a..ca97f82f388bd98274926db2dfa6fc105b1875d4 100644 (file)
@@ -19,7 +19,7 @@
 
 /**
  * Multilevel matrix. This class implements the interface defined by
- * @ref{MGMatrixBase}, using @ref{MGLevelObject} of an arbitrary
+ * MGMatrixBase, using MGLevelObject of an arbitrary
  * matrix class.
  *
  * @author Guido Kanschat, 2002
@@ -31,10 +31,10 @@ class MGMatrix : public MGMatrixBase<VECTOR>
                                     /**
                                      * Constructor. The argument is
                                      * handed over to the
-                                     * @p{SmartPointer}
+                                     * @p SmartPointer
                                      * constructor. The matrix object
                                      * must exist longer as the
-                                     * @p{MGMatrix} object, since
+                                     * @p MGMatrix object, since
                                      * only a pointer is stored.
                                      */
     MGMatrix (MGLevelObject<MATRIX>* = 0);
@@ -43,7 +43,7 @@ class MGMatrix : public MGMatrixBase<VECTOR>
                                      * Set the matrix object to be
                                      * used. The matrix object must
                                      * exist longer as the
-                                     * @p{MGMatrix} object, since
+                                     * @p MGMatrix object, since
                                      * only a pointer is stored.
                                      */
     void set_matrix (MGLevelObject<MATRIX>* M);
@@ -94,11 +94,11 @@ private:
 
 /**
  * Multilevel matrix selecting from block matrices. This class
- * implements the interface defined by @ref{MGMatrixBase}.  The
- * template parameter @p{MATRIX} should be a block matrix class like
- * @ref{BlockSparseMatrix} or @p{BlockSparseMatrixEZ}. Then, this
- * class stores a pointer to a @ref{MGLevelObject} of this matrix
- * class. In each @p{vmult}, the block selected on initialization will
+ * implements the interface defined by MGMatrixBase.  The
+ * template parameter @p MATRIX should be a block matrix class like
+ * BlockSparseMatrix or @p BlockSparseMatrixEZ. Then, this
+ * class stores a pointer to a MGLevelObject of this matrix
+ * class. In each @p vmult, the block selected on initialization will
  * be multiplied with the vector provided.
  *
  * @author Guido Kanschat, 2002
@@ -108,11 +108,11 @@ class MGMatrixSelect : public MGMatrixBase<Vector<number> >
 {
   public:
                                     /**
-                                     * Constructor. @p{row} and
-                                     * @p{col} are the coordinate of
+                                     * Constructor. @p row and
+                                     * @p col are the coordinate of
                                      * the selected block. The other
                                      * argument is handed over to the
-                                     * @p{SmartPointer} constructor.
+                                     * @p SmartPointer constructor.
                                      */
     MGMatrixSelect (const unsigned int row = 0,
                    const unsigned int col = 0,
@@ -122,7 +122,7 @@ class MGMatrixSelect : public MGMatrixBase<Vector<number> >
                                      * Set the matrix object to be
                                      * used. The matrix object must
                                      * exist longer as the
-                                     * @p{MGMatrix} object, since
+                                     * @p MGMatrix object, since
                                      * only a pointer is stored.
                                      */
     void set_matrix (MGLevelObject<MATRIX>* M);
index e8fa3ec764504761bbb4f144611f85d7c138c240..3c574f0f9f29829b6bc998e4d91305fde11bd31f 100644 (file)
@@ -42,7 +42,7 @@ class MGSmootherIdentity : public MGSmootherBase<VECTOR>
   public:
                                     /**
                                      * Implementation of the
-                                     * interface for @p{Multigrid}.
+                                     * interface for @p Multigrid.
                                      * This function does nothing,
                                      * which by comparison with the
                                      * definition of this function
@@ -86,7 +86,7 @@ class MGSmootherContinuous : public MGSmootherBase<VECTOR>
                                      * on the interior boundaries between
                                      * the different levels, which are
                                      * needed by the function
-                                     * @p{set_zero_interior_boundaries}.
+                                     * @p set_zero_interior_boundaries.
                                      *
                                      * Since this function is
                                      * implemented a bit different in
@@ -110,11 +110,11 @@ class MGSmootherContinuous : public MGSmootherBase<VECTOR>
                                      * boundaries between the
                                      * different levels, which are
                                      * needed by the function
-                                     * @p{set_zero_interior_boundaries}.
+                                     * @p set_zero_interior_boundaries.
                                      *
                                      * The parameter steps indicates
                                      * the number of smoothing steps
-                                     * to be executed by @p{smooth}.
+                                     * to be executed by @p smooth.
                                      */
     template <int dim>
     MGSmootherContinuous (const MGDoFHandler<dim> &mg_dof,
@@ -124,7 +124,7 @@ class MGSmootherContinuous : public MGSmootherBase<VECTOR>
                                      * Reset the values of the degrees of
                                      * freedom on interior boundaries between
                                      * different levels to zero in the given
-                                     * data vector @p{u}.
+                                     * data vector @p u.
                                      *
                                      * Since the coarsest level (@p{level==0})
                                      * has no interior boundaries, this
@@ -170,32 +170,32 @@ class MGSmootherContinuous : public MGSmootherBase<VECTOR>
  *
  * This class performs smoothing on each level. The operation can be
  * controlled by several parameters. First, the relaxation parameter
- * @p{omega} is used in the underlying relaxation method. @p{steps} is
+ * @p omega is used in the underlying relaxation method. @p steps is
  * the number of relaxation steps on the finest level (on all levels
- * if @p{variable} is off). If @p{variable} is @p{true}, the number of
+ * if @p variable is off). If @p variable is @p true, the number of
  * smoothing steps is doubled on each coarser level. This results in a
  * method having the complexity of the W-cycle, but saving grid
  * transfers. This is the method proposed by Bramble at al.
  *
- * The option @p{symmetric} switches on alternating between the
+ * The option @p symmetric switches on alternating between the
  * smoother and its transpose in each step as proposed by Bramble.
  *
- * @p{transpose} and @p{reverse} are similar in the effect that
+ * @p transpose and @p reverse are similar in the effect that
  * instead of the smoother the transposed is used. Typically, this is
  * off for pre-smoothing and on for post-smoothing. While
- * @p{transpose} is the true transposed smoothing operation,
- * @p{reverse} just uses the transposed of the smoother, but the
+ * @p transpose is the true transposed smoothing operation,
+ * @p reverse just uses the transposed of the smoother, but the
  * non-transposed matrix-vector multiplication; this can be used to
  * invert the direction of the Gauss-Seidel method.
  *
- * If you are using block matrices, the second @p{initialize} function
+ * If you are using block matrices, the second @p initialize function
  * offers the possibility to extract a single block for smoothing. In
  * this case, the multigrid method must be used only with the vector
  * associated to that single block.
  *
  * The library contains instantiation for @p{SparseMatrix<.>} and
  * @p{Vector<.>}, where the template arguments are all combinations of
- * @p{float} and @p{double}. Additional instantiations may be created
+ * @p float and @p double. Additional instantiations may be created
  * by including the file mg_smoother.templates.h.
  * 
  * @author Guido Kanschat, 2003
@@ -217,20 +217,20 @@ class MGSmootherRelaxation : public MGSmootherBase<VECTOR>
 
                                     /**
                                      * Initialize for matrices. The
-                                     * parameter @p{matrices} can be
+                                     * parameter @p matrices can be
                                      * any object having functions
                                      * @p{get_minlevel()} and
                                      * @p{get_maxlevel()} as well as
                                      * an @p{operator[]} returning a
-                                     * reference to @p{MATRIX}. This
+                                     * reference to @p MATRIX. This
                                      * function stores pointers to
                                      * the level matrices and
                                      * initializes the smoothing
                                      * operator for each level.
                                      *
-                                     * @p{additional_data} is an
+                                     * @p additional_data is an
                                      * object of type
-                                     * @p{RELAX::AdditionalData} and
+                                     * @p RELAX::AdditionalData and
                                      * is handed to the
                                      * initialization function of the
                                      * relaxation method.
@@ -242,26 +242,26 @@ class MGSmootherRelaxation : public MGSmootherBase<VECTOR>
                                     /**
                                      * Initialize for single blocks
                                      * of matrices. The parameter
-                                     * @p{matrices} can be any object
+                                     * @p matrices can be any object
                                      * having functions
                                      * @p{get_minlevel()} and
                                      * @p{get_maxlevel()} as well as
                                      * an @p{operator[]} returning a
                                      * reference to a block matrix
                                      * where each block is of type
-                                     * @p{MATRIX}. Of this block
+                                     * @p MATRIX. Of this block
                                      * matrix, the block indicated by
-                                     * @p{block_row} and
-                                     * @p{block_col} is selected on
+                                     * @p block_row and
+                                     * @p block_col is selected on
                                      * each level.  This function
                                      * stores pointers to the level
                                      * matrices and initializes the
                                      * smoothing operator for each
                                      * level.
                                      *
-                                     * @p{additional_data} is an
+                                     * @p additional_data is an
                                      * object of type
-                                     * @p{RELAX::AdditionalData} and
+                                     * @p RELAX::AdditionalData and
                                      * is handed to the
                                      * initialization function of the
                                      * relaxation method.
@@ -298,14 +298,14 @@ class MGSmootherRelaxation : public MGSmootherBase<VECTOR>
                                     /**
                                      * Switch on/off transposed. This
                                      * is mutually exclusive with
-                                     * @ref{reverse}.
+                                     * reverse().
                                      */
     void set_transpose (const bool);
     
                                     /**
                                      * Switch on/off reversed. This
                                      * is mutually exclusive with
-                                     * @ref{transpose}.
+                                     * transpose().
                                      */
     void set_reverse (const bool);
 
index 1f2f62ff532f1668626f0961e2539bf3d5cf7016..d7715cfd65ba7ab790aaaea3e790ce989ad183e6 100644 (file)
@@ -75,7 +75,7 @@ class MGTransferPrebuilt : public MGTransferBase<VECTOR>
                                      * Transfer from a vector on the
                                      * global grid to vectors defined
                                      * on each of the levels
-                                     * separately, i.a. an @p{MGVector}.
+                                     * separately, i.a. an @p MGVector.
                                      */
     template <int dim, class InVector>
     void
@@ -122,7 +122,7 @@ class MGTransferPrebuilt : public MGTransferBase<VECTOR>
     DeclException0(ExcNoProlongation);
     
                                     /**
-                                     * Call @p{build_matrices}
+                                     * Call @p build_matrices
                                      * function first.
                                      */
     DeclException0(ExcMatricesNotBuilt);
@@ -171,9 +171,9 @@ class MGTransferPrebuilt : public MGTransferBase<VECTOR>
                                     /**
                                      * Structure that is used to
                                      * disambiguate calls to
-                                     * @p{copy_to_mg} for 1d and
+                                     * @p copy_to_mg for 1d and
                                      * non-1d. We provide two
-                                     * functions of @p{copy_to_mg},
+                                     * functions of @p copy_to_mg,
                                      * where the 1d function takes an
                                      * argument of type
                                      * @p{is_1d<true>} and the other
@@ -360,14 +360,14 @@ class MGTransferBlockBase
  * problems, please contact Guido Kanschat.
  *
  * In addition to the functionality of
- * @ref{MGTransferPrebuilt}, the operation may be restricted to
+ * MGTransferPrebuilt, the operation may be restricted to
  * certain blocks of the vector.
  *
  * If the restricted mode is chosen, block vectors used in the
  * transfer routines may only have as many components as there are
- * @p{true}s in the selected-field.
+ * @p trues in the selected-field.
  *
- * See @ref{MGTransferBase} to find out which of the transfer classes
+ * See MGTransferBase to find out which of the transfer classes
  * is best for your needs.
  *
  * @author Guido Kanschat, 2001, 2002
@@ -500,9 +500,9 @@ class MGTransferBlock : public MGTransferBase<BlockVector<number> >,
                                     /**
                                      * Structure that is used to
                                      * disambiguate calls to
-                                     * @p{copy_to_mg} for 1d and
+                                     * @p copy_to_mg for 1d and
                                      * non-1d. We provide two
-                                     * functions of @p{copy_to_mg},
+                                     * functions of @p copy_to_mg,
                                      * where the 1d function takes an
                                      * argument of type
                                      * @p{is_1d<true>} and the other
@@ -512,7 +512,7 @@ class MGTransferBlock : public MGTransferBase<BlockVector<number> >,
 
                                     /**
                                      * Implementation of the
-                                     * @p{copy_to_mg} function for
+                                     * @p copy_to_mg function for
                                      * 1d. We have to resort to some
                                      * template trickery because we
                                      * can't specialize template
index 1479067d357b9b35038008b69bca0027f95a5336..e8590281dfe0c03e2c4af6f586ca72b254a82dcd 100644 (file)
@@ -40,7 +40,7 @@
  * meet on conferences seem to deny this.
  *
  * The function actually performing a multi-level cycle,
- * @p{level_mgstep}, as well as the function @p{vcycle}, calling it,
+ * @p level_mgstep, as well as the function @p vcycle, calling it,
  * require several helper classes handed over as template parameters.
  * These classes have to meet the following requirements:
  *
@@ -77,15 +77,15 @@ class Multigrid : public Subscriptor
   
                                     /**
                                      * Constructor. The
-                                     * @p{MGDoFHandler} is used to
+                                     * @p MGDoFHandler is used to
                                      * determine the highest possible
-                                     * level. @p{transfer} is an
+                                     * level. @p transfer is an
                                      * object performing prolongation
                                      * and restriction.
                                      *
                                      * The V-cycle will start on
-                                     * level @p{maxlevel} and goes
-                                     * down to level @p{minlevel},
+                                     * level @p maxlevel and goes
+                                     * down to level @p minlevel,
                                      * where the coarse grid solver
                                      * will be used.
                                      *
@@ -110,7 +110,7 @@ class Multigrid : public Subscriptor
 
                                     /**
                                      * Reinit this class according to
-                                     * @p{minlevel} and @p{maxlevel}.
+                                     * @p minlevel and @p maxlevel.
                                      */
     void reinit (const unsigned int minlevel,
                 const unsigned int maxlevel);
@@ -119,21 +119,21 @@ class Multigrid : public Subscriptor
                                      * Execute one step of the
                                      * v-cycle algorithm.  This
                                      * function assumes, that the
-                                     * vector @p{defect} is properly
+                                     * vector @p defect is properly
                                      * filled with the residual in
                                      * the outer defect correction
                                      * scheme (usually performed by
-                                     * @ref{PreconditionMG}). After
+                                     * PreconditionMG). After
                                      * execution of @p{vcycle()}, the
                                      * result is in the vector
-                                     * @p{solution}. See
+                                     * @p solution. See
                                      * @p{copy_*_mg} in class
-                                     * @p{MGTools} if you want to use
+                                     * @p MGTools if you want to use
                                      * these vectors yourself.
                                      *
                                      * The actual work for this
                                      * function is done in
-                                     * @p{level_mgstep}.
+                                     * @p level_mgstep.
                                      */
     void vcycle();
 
@@ -149,13 +149,13 @@ class Multigrid : public Subscriptor
     
                                     /**
                                      * The actual v-cycle multigrid method.
-                                     * @p{level} is the level the
+                                     * @p level is the level the
                                      * function should work on. It
                                      * will usually be called for the
                                      * highest level from outside,
                                      * but will then call itself
-                                     * recursively for @p{level-1},
-                                     * unless we are on @p{minlevel}
+                                     * recursively for @p level-1,
+                                     * unless we are on @p minlevel
                                      * where instead of recursing
                                      * deeper, the coarse grid solver
                                      * is used to solve the matrix of
@@ -244,10 +244,10 @@ class Multigrid : public Subscriptor
  * Here, we collect all information needed for multi-level preconditioning
  * and provide the standard interface for LAC iterative methods.
  *
- * The template parameter class @p{MG} is required to inherit @p{MGBase}.
+ * The template parameter class @p MG is required to inherit @p MGBase.
  * Furthermore, it needs functions @p{void copy_to_mg(const VECTOR&)}
- * to store @p{src} in the right hand side of the multi-level method and
- * @p{void copy_from_mg(VECTOR&)} to store the result of the v-cycle in @p{dst}.
+ * to store @p src in the right hand side of the multi-level method and
+ * @p{void copy_from_mg(VECTOR&)} to store the result of the v-cycle in @p dst.
  *
  * @author Guido Kanschat, 1999, 2000, 2001, 2002
  */
@@ -272,8 +272,8 @@ class PreconditionMG : public Subscriptor
     
                                     /**
                                      * Preconditioning operator.
-                                     * Calls the @p{vcycle} function
-                                     * of the @p{MG} object passed to
+                                     * Calls the @p vcycle function
+                                     * of the @p MG object passed to
                                      * the constructor.
                                      *
                                      * This is the operator used by
@@ -285,8 +285,8 @@ class PreconditionMG : public Subscriptor
     
                                     /**
                                      * Preconditioning operator.
-                                     * Calls the @p{vcycle} function
-                                     * of the @p{MG} object passed to
+                                     * Calls the @p vcycle function
+                                     * of the @p MG object passed to
                                      * the constructor.
                                      */
     template<class VECTOR2>
@@ -315,7 +315,7 @@ class PreconditionMG : public Subscriptor
     
   private:
                                     /**
-                                     * Associated @p{MGDoFHandler}.
+                                     * Associated @p MGDoFHandler.
                                      */
     SmartPointer<const MGDoFHandler<dim> > mg_dof_handler;
 
index a37f209fe007970960fcad5ce2038c08d241231c..0abac4f45e5e6e87be5528d22536942a5cc10eac 100644 (file)
@@ -30,7 +30,7 @@ template <int>      class FEValuesBase;
 /**
  * This is an abstract class which provides the functionality to generate
  * patches for output by base classes from data vectors on a grid. It allows
- * to store a pointer to a @ref{DoFHandler} object and one or more pointers to
+ * to store a pointer to a DoFHandler object and one or more pointers to
  * node and cell data denoting functions on the grid which shall later
  * be written in any of the implemented data formats.
  *
@@ -38,11 +38,11 @@ template <int>      class FEValuesBase;
  * @sect3{User visible interface}
  *
  * The user visible interface of this class consists of functions which allow
- * a user to make a @ref{DoFHandler} object known to this class and to add data
+ * a user to make a DoFHandler object known to this class and to add data
  * vectors which will later be written to a file in some format. Instead of
  * pondering about the different functions, an example is probably the best
  * way:
- * @begin{verbatim}
+ * @verbatim
  *   ...
  *   ...   // compute solution, which contains nodal values
  *   ...
@@ -63,10 +63,10 @@ template <int>      class FEValuesBase;
  *   data_out.write_xxx (output_file);
  *
  *   data_out.clear();
- * @end{verbatim}
+ * @endverbatim
  *
- * @p{attach_dof_handler} tells this class that all future operations are to take
- * place with the @ref{DoFHandler} object and the triangulation it lives on. We then
+ * @p attach_dof_handler tells this class that all future operations are to take
+ * place with the DoFHandler object and the triangulation it lives on. We then
  * add the solution vector and the error estimator; note that they have different
  * dimensions, because the solution is a nodal vector, here consisting of two
  * components ("x-displacement" and "y-displacement") while the error estimator
@@ -74,32 +74,32 @@ template <int>      class FEValuesBase;
  * to give a name to each component of the vector, which is done through an object
  * of type @p{vector<string>} as second argument; if only one component is in the
  * vector, for example if we are adding cell data as in the second case, or if
- * the finite element used by the @ref{DoFHandler} has only one component, then you
- * can use the second @p{add_data_vector} function which takes a @p{string} instead
+ * the finite element used by the DoFHandler has only one component, then you
+ * can use the second @p add_data_vector function which takes a @p string instead
  * of the @p{vector<string>}.
  *
  * You should note that this class does not copy the vector given to it through
- * the @p{add_data_vector} functions, for memory consumption reasons. It only
+ * the @p add_data_vector functions, for memory consumption reasons. It only
  * stores a reference to it, so it is in your responsibility to make sure that
  * the data vectors exist long enough.
  *
  * After adding all data vectors, you need to call a function which generates
  * the patches for output from the stored data. This function is here called
- * @p{build_patches}, but the naming is up to the derived class that actually
+ * @p build_patches, but the naming is up to the derived class that actually
  * implements this.
  *
- * Finally, you write the data in one format or other, indicated by @p{write_xxx},
+ * Finally, you write the data in one format or other, indicated by @p write_xxx,
  * to a file and may want to clear this object as soon as possible to reduce
  * memory requirements.
  *
- * Please note, that in the example above, an object of type @ref{DataOut} was
+ * Please note, that in the example above, an object of type DataOut was
  * used, i.e. an object of a derived class. This is necessary since this
  * class does not provide means to actually generate the patches, only aids to
  * store and access data.
  *
- * Note that the base class of this class, @ref{DataOutInterface} offers several
+ * Note that the base class of this class, DataOutInterface offers several
  * functions to ease programming with run-time determinable output formats
- * (i.e. you need not use a fixed format by calling @p{write_xxx} in the above
+ * (i.e. you need not use a fixed format by calling @p write_xxx in the above
  * example, but you can select it by a run-time parameter without having
  * to write the @p{if () ... else ...} clauses yourself), and also functions
  * and classes offering ways to control the appearance of the output by
@@ -124,8 +124,8 @@ template <int>      class FEValuesBase;
  * possible in this respect.
  *
  * For this reason, it is left to a derived class to provide a
- * function, named usually @p{build_patches} or the like, which fills
- * the @p{patches} array of this class.
+ * function, named usually @p build_patches or the like, which fills
+ * the @p patches array of this class.
  *
  * Regarding the templates of this class, it needs three values: first
  * the space dimension in which the triangulation and the DoF handler
@@ -135,7 +135,7 @@ template <int>      class FEValuesBase;
  * the result of a computation exploiting rotational symmetry in the
  * original domain (in which the space dimension of the output would
  * be one higher than that of the DoF handler, see the
- * @ref{DataOut_Rotation} class), or one might conceive that one could
+ * DataOut_Rotation() class), or one might conceive that one could
  * write a class that only outputs the solution on a cut through the
  * domain, in which case the space dimension of the output is less
  * than that of the DoF handler. The last template argument denotes
@@ -143,7 +143,7 @@ template <int>      class FEValuesBase;
  * usually, this dimension is the same as the dimensio of the patches
  * themselves (which is also the default value of the template
  * parameter), but there might be cases where this is not so. For
- * example, in the @ref{DataOut_Faces} class, patches are generated
+ * example, in the DataOut_Faces() class, patches are generated
  * from faces of the triangulation. Thus, the dimension of the patch
  * is one less than the dimension of the embedding space, which is, in
  * this case, equal to the dimension of the triangulation and DoF
@@ -162,20 +162,20 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                     /**
                                      * Type describing what the
                                      * vector given to
-                                     * @ref{add_data_vector} is: a
+                                     * add_data_vector() is: a
                                      * vector that has one entry per
                                      * degree of freedom in a
-                                     * @ref{DoFHandler} object (such
+                                     * DoFHandler object (such
                                      * as solution vectors), or one
                                      * entry per cell in the
                                      * triangulation underlying the
-                                     * @ref{DoFHandler} object (such
+                                     * DoFHandler object (such
                                      * as error per cell data). The
-                                     * value @p{type_automatic} tells
-                                     * @ref{add_data_vector} to find
+                                     * value @p type_automatic tells
+                                     * add_data_vector() to find
                                      * out itself (see the
                                      * documentation of
-                                     * @p{add_data_vector} for the
+                                     * @p add_data_vector for the
                                      * method used).
                                      */
     enum DataVectorType {
@@ -242,8 +242,8 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                      * case, you can change the last
                                      * argument of the function from
                                      * its default value
-                                     * @p{type_automatic} to either
-                                     * @p{type_dof_data} or @p{type_cell_data},
+                                     * @p type_automatic to either
+                                     * @p type_dof_data or @p type_cell_data,
                                      * depending on what the vector
                                      * represents. Apart from this
                                      * corner case, you can leave the
@@ -268,16 +268,16 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                      * shall only contain characters
                                      * which are letters, underscore
                                      * and a few other ones. Refer to
-                                     * the @p{ExcInvalidCharacter}
+                                     * the @p ExcInvalidCharacter
                                      * exception declared in this
                                      * class to see which characters
                                      * are valid and which are not.
                                      *
                                      * The actual type for the template
                                      * argument may be any vector type from
-                                     * which @ref{FEValue} can extract values
+                                     * which FEValue can extract values
                                      * on a cell using the
-                                     * @p{get_function_values} function.
+                                     * @p get_function_values function.
                                      */
     template <class VECTOR>
     void add_data_vector (const VECTOR                   &data,
@@ -295,24 +295,24 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                      * what this function takes. It
                                      * simply relays its arguments
                                      * after a conversion of the
-                                     * @p{name} to a vector of
+                                     * @p name to a vector of
                                      * strings, to the other
-                                     * @p{add_data_vector} function
+                                     * @p add_data_vector function
                                      * above.
                                      *
-                                     * If @p{data} is a vector with
+                                     * If @p data is a vector with
                                      * multiple components this
                                      * function will generate
                                      * distinct names for all
                                      * components by appending an
                                      * underscore and the number of
-                                     * each component to @p{name}
+                                     * each component to @p name
                                      *
                                      * The actual type for the template
                                      * argument may be any vector type from
-                                     * which @ref{FEValue} can extract values
+                                     * which FEValue can extract values
                                      * on a cell using the
-                                     * @p{get_function_values} function.
+                                     * @p get_function_values function.
                                      */
     template <class VECTOR>
     void add_data_vector (const VECTOR         &data,
@@ -325,7 +325,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                      * output of a new set of vectors
                                      * without supplying the DoF
                                      * handler again. Therefore, the
-                                     * @ref{DataOut} object can be used
+                                     * DataOut object can be used
                                      * in an algebraic context. Note
                                      * that besides the data vectors
                                      * also the patches already
@@ -339,7 +339,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                      * to data vectors and to the DoF
                                      * handler object. This function
                                      * may be useful when you have
-                                     * called the @p{build_patches}
+                                     * called the @p build_patches
                                      * function of derived class,
                                      * since then the patches are
                                      * built and the input data is no
@@ -359,7 +359,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                       * This function can be used to
                                       * merge the patches that were
                                       * created using the
-                                      * @p{build_patches} function of
+                                      * @p build_patches function of
                                       * the object given as argument
                                       * into the list of patches
                                       * created by this object. This
@@ -367,7 +367,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                       * for example, a domain
                                       * decomposition algorithm where
                                       * each block is represented by a
-                                      * @ref{DoFHandler} of its own,
+                                      * DoFHandler of its own,
                                       * but one wants to output the
                                       * solution on all the blocks at
                                       * the same time.
@@ -383,7 +383,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                       * both objects overlap in space.
                                       *
                                       * If you call
-                                      * @ref{build_patches} for this
+                                      * build_patches() for this
                                       * object after merging in
                                       * patches, the previous state is
                                       * overwritten, and the merged-in
@@ -412,7 +412,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                      * data vectors and the DoF
                                      * handler. You have to set all
                                      * data entries again using the
-                                     * @p{add_data_vector}
+                                     * @p add_data_vector
                                      * function. The pointer to the
                                      * dof handler is cleared as
                                      * well, along with all other
@@ -481,7 +481,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
   protected:
                                     /**
                                       * For each vector that has been added
-                                      * through the @ref{add_data_vector}
+                                      * through the add_data_vector()
                                       * functions, we need to keep track of a
                                       * pointer to it, and allow data
                                       * extraction from it when we generate
@@ -526,7 +526,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
         get_cell_data_value (const unsigned int cell_number) const = 0;
 
                                          /**
-                                          * Given a @p{FEValuesBase} object,
+                                          * Given a @p FEValuesBase object,
                                           * extract the values on the present
                                           * cell from the vector we actually
                                           * store.
@@ -537,7 +537,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                              std::vector<double>             &patch_values) const = 0;
         
                                          /**
-                                          * Given a @p{FEValuesBase} object,
+                                          * Given a @p FEValuesBase object,
                                           * extract the values on the present
                                           * cell from the vector we actually
                                           * store. This function does the same
@@ -600,7 +600,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
         get_cell_data_value (const unsigned int cell_number) const;
 
                                          /**
-                                          * Given a @p{FEValuesBase} object,
+                                          * Given a @p FEValuesBase object,
                                           * extract the values on the present
                                           * cell from the vector we actually
                                           * store.
@@ -611,7 +611,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                              std::vector<double>             &patch_values) const;
         
                                          /**
-                                          * Given a @p{FEValuesBase} object,
+                                          * Given a @p FEValuesBase object,
                                           * extract the values on the present
                                           * cell from the vector we actually
                                           * store. This function does the same
@@ -650,7 +650,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
 
                                     /**
                                      * Abbreviate the somewhat lengthy
-                                     * name for the @p{Patch} class.
+                                     * name for the @p Patch class.
                                      */
     typedef ::DataOutBase::Patch<patch_dim,patch_space_dim> Patch;
 
@@ -673,7 +673,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
 
                                     /**
                                      * This is a list of patches that is
-                                     * created each time @p{build_patches}
+                                     * created each time @p build_patches
                                      * is called. These patches are used
                                      * in the output routines of the base
                                      * classes.
@@ -700,7 +700,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                     /**
                                      * Make all template siblings
                                      * friends. Needed for the
-                                     * @p{merge_patches} function.
+                                     * @p merge_patches function.
                                      */
     template <int,int,int> friend class DataOut_DoFData;
 
@@ -735,13 +735,13 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
 
 /**
  * This class is an actual implementation of the functionality proposed by
- * the @ref{DataOut_DoFData} class. It offers a function @p{build_patches} that
+ * the DataOut_DoFData() class. It offers a function @p build_patches that
  * generates the patches to be written in some graphics format from the data
  * stored in the base class. Most of the interface and an example of its
  * use is described in the documentation of the base class.
  *
- * The only thing this class offers is the function @p{build_patches} which
- * loops over all cells of the triangulation stored by the @p{attach_dof_handler}
+ * The only thing this class offers is the function @p build_patches which
+ * loops over all cells of the triangulation stored by the @p attach_dof_handler
  * function of the base class and convert the data on these to actual patches
  * which are the objects that are later output by the functions of the
  * base classes. You can give a parameter to the function which determines
@@ -750,7 +750,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
  * for quadratic elements you may want to choose two, for cubic elements three,
  * and so on.
  *
- * Note that after having called @p{build_patches} once, you can call one or
+ * Note that after having called @p build_patches once, you can call one or
  * more of the @p{write_*} functions of the base classes. You can therefore
  * output the same data in more than one format without having to rebuild
  * the patches.
@@ -758,13 +758,13 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
  *
  * @sect3{User interface information}
  *
- * The base classes of this class, @ref{DataOutBase}, @ref{DataOutInterface} and
- * @ref{DataOut_DoFData} offer several interfaces of their own. Refer to the
- * @ref{DataOutBase} class's documentation for a discussion of the different
- * output formats presently supported, @ref{DataOutInterface} for ways of
+ * The base classes of this class, DataOutBase, DataOutInterface and
+ * DataOut_DoFData() offer several interfaces of their own. Refer to the
+ * DataOutBase class's documentation for a discussion of the different
+ * output formats presently supported, DataOutInterface for ways of
  * selecting which format to use upon output at run-time and without
  * the need to adapt your program when new formats become available, as
- * well as for flags to determine aspects of output. The @ref{DataOut_DoFData}
+ * well as for flags to determine aspects of output. The DataOut_DoFData()
  * class's documentation has an example of using nodal data to generate
  * output.
  *
@@ -776,11 +776,11 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
  * small to be seen individually) or because you only want to see a certain
  * region of the domain, or for some other reason.
  *
- * For this, internally the @p{build_patches} function does not generate
+ * For this, internally the @p build_patches function does not generate
  * the sequence of cells to be converted into patches itself, but relies
- * on the two functions @p{first_cell} and @p{next_cell}. By default, they
+ * on the two functions @p first_cell and @p next_cell. By default, they
  * return the first active cell, and the next active cell, respectively.
- * Since they are @p{virtual} functions, you may overload them to select other
+ * Since they are @p virtual functions, you may overload them to select other
  * cells for output. If cells are not active, interpolated values are taken
  * for output instead of the exact values on active cells.
  *
@@ -829,7 +829,7 @@ class DataOut : public DataOut_DoFData<dim,dim>
     
                                     /**
                                      * Return the next cell after
-                                     * @p{cell} which we want output
+                                     * @p cell which we want output
                                      * for.  If there are no more
                                      * cells, @p{dofs->end()} shall
                                      * be returned.
@@ -840,9 +840,9 @@ class DataOut : public DataOut_DoFData<dim,dim>
                                      * other cells in a derived
                                      * class. Note that the default
                                      * implementation assumes that
-                                     * the given @p{cell} is active,
+                                     * the given @p cell is active,
                                      * which is guaranteed as long as
-                                     * @p{first_cell} is also used
+                                     * @p first_cell is also used
                                      * from the default
                                      * implementation. Overloading
                                      * only one of the two functions
@@ -867,12 +867,12 @@ class DataOut : public DataOut_DoFData<dim,dim>
                                      * globally to avoid allocation
                                      * of memory in the threads.
                                      *
-                                     * The @p{index_to_patch_map} is
+                                     * The @p index_to_patch_map is
                                      * an array that stores for index
                                      * @p{[i][j]} the number of the
                                      * patch that associated with the
-                                     * cell with index @p{j} on level
-                                     * @p{i}. This information is set
+                                     * cell with index @p j on level
+                                     * @p i. This information is set
                                      * up prior to generation of the
                                      * patches, and is needed to
                                      * generate neighborship
@@ -891,7 +891,7 @@ class DataOut : public DataOut_DoFData<dim,dim>
         std::vector<std::vector<unsigned int> > *cell_to_patch_index_map;
     };
                                     /**
-                                     * Builds every @p{n_threads}'s
+                                     * Builds every @p n_threads's
                                      * patch. This function may be
                                      * called in parallel.
                                      * If multithreading is not
index e2a063ad9cc9af5482eb71fde84fdf1478484055..752d1f7434c9baecb7a9c1c86c3b1eb0a7057bb6 100644 (file)
@@ -25,33 +25,33 @@ template <int dim> class DoFHandler;
 
 /**
  * This class generates output from faces of a triangulation rather
- * than from cells, as do for example the @ref{DataOut} and
- * @ref{DataOut_Rotation} classes. It might be used to generate output
+ * than from cells, as do for example the DataOut and
+ * DataOut_Rotation() classes. It might be used to generate output
  * only for the surface of the triangulation (this is the default of
  * this class), or for another arbitrary set of faces. The output of
  * this class is a set of patches (as defined by the class
- * @ref{DataOutBase::Patch}), one for each face for which output is to
+ * DataOutBase::Patch()), one for each face for which output is to
  * be generated. These patches can then be written in several
  * graphical data formats by the functions of the underlying classes.
  *
  * @sect3{Interface}
  *
- * The interface of this class is copied from the @ref{DataOut}
+ * The interface of this class is copied from the DataOut
  * class. Furthermore, they share the common parent class
- * @ref{DataOut_DoFData}. See the reference of these two classes for a
+ * DataOut_DoFData(). See the reference of these two classes for a
  * discussion of the interface.
  *
  *
  * @sect3{Extending this class}
  *
  * The sequence of faces to generate patches from is generated in the
- * same way as in the @ref{DataOut} class, see there for a description
+ * same way as in the DataOut class, see there for a description
  * of the respective interface. For obvious reasons, the functions
  * generating the sequence of faces which shall be used to generate
- * output, are called @p{first_face} and @p{next_face} in this class,
- * rather than @p{first_cell} and @p{next_cell}.
+ * output, are called @p first_face and @p next_face in this class,
+ * rather than @p first_cell and @p next_cell.
  *
- * Since we need to initialize objects of type @ref{FEValues} with the
+ * Since we need to initialize objects of type FEValues with the
  * faces generated from these functions, it is not sufficient that
  * they only return face iterators. Rather, we need a pair of cell and
  * the number of the face, as the values of finite element fields need
@@ -59,10 +59,10 @@ template <int dim> class DoFHandler;
  * elements, where the value of the finite element field depend on the
  * direction from which you approach a face, thus it is necessary to
  * use a pair of cell and face, rather than only a face
- * iterator). Therefore, this class defines a @p{typedef} which
- * creates a type @p{FaceDescriptor} that is an abbreviation for a
- * pair of cell iterator and face number. The functions @p{first_face}
- * and @p{next_face} operate on objects of this type.
+ * iterator). Therefore, this class defines a @p typedef which
+ * creates a type @p FaceDescriptor that is an abbreviation for a
+ * pair of cell iterator and face number. The functions @p first_face
+ * and @p next_face operate on objects of this type.
  *
  * Extending this class might, for example, be useful if you only want
  * output from certain portions of the boundary, e.g. as indicated by
@@ -109,10 +109,10 @@ class DataOutFaces : public DataOut_DoFData<dim,dim-1,dim>
                                      * generate output for. The usual
                                      * way would, of course, be to
                                      * use an object of type
-                                     * @ref{DoFHandler}@p{<dim>::fec_iterator},
+                                     * DoFHandler@p{<dim>::fec_iterator},
                                      * but since we have to describe
                                      * faces to objects of type
-                                     * @ref{FEValues}, we can only
+                                     * FEValues, we can only
                                      * represent faces by pairs of a
                                      * cell and the number of the
                                      * face. This pair is here
@@ -135,7 +135,7 @@ class DataOutFaces : public DataOut_DoFData<dim,dim-1,dim>
     
                                     /**
                                      * Return the next face after
-                                     * @p{face} which we want output
+                                     * @p face which we want output
                                      * for.  If there are no more
                                      * face, @p{dofs->end()} shall be
                                      * returned as the first
@@ -147,9 +147,9 @@ class DataOutFaces : public DataOut_DoFData<dim,dim-1,dim>
                                      * want to return other faces in
                                      * a derived class. Note that the
                                      * default implementation assumes
-                                     * that the given @p{face} is
+                                     * that the given @p face is
                                      * active, which is guaranteed as
-                                     * long as @p{first_face} is also
+                                     * long as @p first_face is also
                                      * used from the default
                                      * implementation. Overloading
                                      * only one of the two functions
@@ -192,7 +192,7 @@ class DataOutFaces : public DataOut_DoFData<dim,dim-1,dim>
          {}
     };
                                     /**
-                                     * Builds every @p{n_threads}'s
+                                     * Builds every @p n_threads's
                                      * patch. This function may be
                                      * called in parallel.
                                      * If multithreading is not
index 68815a224905b2e596a86cbefcd4ba878d90a228..40f210789538e8772e7dc93571fd82db8931897d 100644 (file)
@@ -27,9 +27,9 @@ template <int dim> class DoFHandler;
  * This class generates output in the full domain of computations that
  * were done using rotational symmetry of domain and solution. In
  * particular, if a computation of a three dimensional problem with
- * rotational symmetry around the @p{z}-axis (i.e. in the
- * @p{r-z}-plane) was done, then this class can be used to generate
- * the output in the original @p{x-y-z} space. In order to do so, it
+ * rotational symmetry around the @p z-axis (i.e. in the
+ * @p r-z-plane) was done, then this class can be used to generate
+ * the output in the original @p x-y-z space. In order to do so, it
  * generates from each cell in the computational mesh a cell in the
  * space with dimension one greater than that of the DoFHandler
  * object. The resulting output will then consist of hexahedra forming
@@ -37,16 +37,16 @@ template <int dim> class DoFHandler;
  * graphical programs can not represent ring-like structures, the
  * angular (rotation) variable is discretized into a finite number of
  * intervals as well; the number of these intervals must be given to
- * the @p{build_patches} function. It is noted, however, that while
+ * the @p build_patches function. It is noted, however, that while
  * this function generates nice pictures of the whole domain, it often
  * produces <em>very</em> large output files.
  *
  *
  * @sect3{Interface}
  *
- * The interface of this class is copied from the @ref{DataOut}
+ * The interface of this class is copied from the DataOut
  * class. Furthermore, they share the common parent class
- * @ref{DataOut_DoFData}. See the reference of these two classes for a
+ * DataOut_DoFData(). See the reference of these two classes for a
  * discussion of the interface and how to extend it by deriving
  * further classes from this class.
  *
@@ -54,7 +54,7 @@ template <int dim> class DoFHandler;
  * @sect3{Details for 1d computations}
  *
  * The one coordinate in the triangulation used by the
- * @ref{DoFHandler} object passed to this class is taken as the radial
+ * DoFHandler object passed to this class is taken as the radial
  * variable, and the output will then be either a circle or a ring
  * domain. It is in the user's responsibility to assure that the
  * radial coordinate only attains non-negative values.
@@ -62,12 +62,12 @@ template <int dim> class DoFHandler;
  *
  * @sect3{Details for 2d computations}
  *
- * We consider the computation (represented by the @ref{DoFHandler}
+ * We consider the computation (represented by the DoFHandler
  * object that is attached to this class) to have happened in the
- * @p{r-z}-plane, where @p{r} is the radial variable and @p{z} denotes
+ * @p r-z-plane, where @p r is the radial variable and @p z denotes
  * the axis of revolution around which the solution is symmetric. The
- * output is in @p{x-y-z} space, where the radial dependence is
- * transformed to the @p{x-y} plane. At present, it is not possible to
+ * output is in @p x-y-z space, where the radial dependence is
+ * transformed to the @p x-y plane. At present, it is not possible to
  * exchange the meaning of the first and second variable of the plane
  * in which the simulation was made, i.e. generate output from a
  * simulation where the first variable denoted the symmetry axis, and
@@ -96,7 +96,7 @@ class DataOutRotation : public DataOut_DoFData<dim,dim+1>
                                      * In addition to the same
                                      * parameters as found in the
                                      * respective function of the
-                                     * @ref{DataOut} class, the first
+                                     * DataOut class, the first
                                      * parameter denotes into how
                                      * many intervals the angular
                                      * (rotation) variable is to be
@@ -127,7 +127,7 @@ class DataOutRotation : public DataOut_DoFData<dim,dim+1>
     first_cell ();
     
                                     /**
-                                     * Return the next cell after @p{cell} which
+                                     * Return the next cell after @p cell which
                                      * we want output for.
                                      * If there are no more cells,
                                      * @p{dofs->end()} shall be returned.
@@ -138,8 +138,8 @@ class DataOutRotation : public DataOut_DoFData<dim,dim+1>
                                      * to return other cells in a derived
                                      * class. Note that the default
                                      * implementation assumes that
-                                     * the given @p{cell} is active, which
-                                     * is guaranteed as long as @p{first_cell}
+                                     * the given @p cell is active, which
+                                     * is guaranteed as long as @p first_cell
                                      * is also used from the default
                                      * implementation. Overloading only one
                                      * of the two functions might not be
@@ -185,7 +185,7 @@ class DataOutRotation : public DataOut_DoFData<dim,dim+1>
          {}
     };
                                     /**
-                                     * Builds every @p{n_threads}'s
+                                     * Builds every @p n_threads's
                                      * patch. This function may be
                                      * called in parallel.
                                      * If multithreading is not
index e009a46675d162e894b347336d0dd2d03e5e2d09..d1e2140e7da809cd107e11d8666d47e01be21192 100644 (file)
@@ -32,7 +32,7 @@ template <int dim> class DoFHandler;
  * space-time output file, or for example to connect the results of
  * solutions of a parameter dependent equation for several parameter
  * value together into one. The interface is mostly modelled after the
- * @ref{DataOut} class.
+ * DataOut class.
  *
  * We will explain the concept for a time dependent problem, but
  * instead of the time any parameter can be substituted. In our
@@ -56,11 +56,11 @@ template <int dim> class DoFHandler;
  *
  * The following little example shall illustrate the different steps
  * of use of this class. It is assumed that the finite element used is
- * composed of two components, @p{u} and @p{v}, that the solution vector
- * is named @p{solution} and that a vector @p{error} is computed which
+ * composed of two components, @p u and @p v, that the solution vector
+ * is named @p solution and that a vector @p error is computed which
  * contains an error indicator for each spatial cell.
  *
- * Note that unlike for the @ref{DataOut} class it is necessary to first
+ * Note that unlike for the DataOut class it is necessary to first
  * declare data vectors and the names of the components before first
  * use. This is because on all time levels the same data should be
  * present to produce reasonable time-space output. The output is
@@ -68,7 +68,7 @@ template <int dim> class DoFHandler;
  * which is suitable for quadratic finite elements in space, for
  * example.
  *
- * @begin{verbatim}
+ * @verbatim
  *   DataOutStack<dim> data_out_stack;
  *
  *                                  // first declare the vectors
@@ -96,7 +96,7 @@ template <int dim> class DoFHandler;
  *       data_out_stack.build_patches (2);
  *       data_out_stack.finish_parameter_value ();
  *     };
- * @end{verbatim}
+ * @endverbatim
  *
  * @author Wolfgang Bangerth, 1999
  */
@@ -113,16 +113,16 @@ class DataOutStack : public DataOutInterface<dim+1>
 
                                     /**
                                      * Destructor. Only declared to make
-                                     * it @p{virtual}.
+                                     * it @p virtual.
                                      */
     virtual ~DataOutStack ();
     
                                     /**
                                      * Start the next set of data for a
                                      * specific parameter value. The argument
-                                     * @p{parameter_step} denotes the interval
+                                     * @p parameter_step denotes the interval
                                      * (in backward direction, counted from
-                                     * @p{parameter_value}) with which the
+                                     * @p parameter_value) with which the
                                      * output will be extended in parameter
                                      * direction, i.e. orthogonal to the
                                      * space directions.
@@ -134,7 +134,7 @@ class DataOutStack : public DataOutInterface<dim+1>
                                      * Attach the DoF handler for the
                                      * grid and data associated with the
                                      * parameter previously set by
-                                     * @p{new_parameter_value}.
+                                     * @p new_parameter_value.
                                      *
                                      * This has to happen before adding
                                      * data vectors for the present
@@ -143,14 +143,14 @@ class DataOutStack : public DataOutInterface<dim+1>
     void attach_dof_handler (const DoFHandler<dim> &dof_handler);
 
                                     /**
-                                     * Declare a data vector. The @p{vector_type}
+                                     * Declare a data vector. The @p vector_type
                                      * argument determines whether the data
                                      * vector will be considered as DoF or
                                      * cell data.
                                      *
                                      * This version may be called if the
                                      * finite element presently used by the
-                                     * @ref{DoFHandler} (and previously attached
+                                     * DoFHandler (and previously attached
                                      * to this object) has only one component
                                      * and therefore only one name needs to
                                      * be given.
@@ -159,14 +159,14 @@ class DataOutStack : public DataOutInterface<dim+1>
                              const VectorType   vector_type);
 
                                     /**
-                                     * Declare a data vector. The @p{vector_type}
+                                     * Declare a data vector. The @p vector_type
                                      * argument determines whether the data
                                      * vector will be considered as DoF or
                                      * cell data.
                                      *
                                      * This version must be called if the
                                      * finite element presently used by the
-                                     * @ref{DoFHandler} (and previously attached
+                                     * DoFHandler (and previously attached
                                      * to this object) has more than one
                                      * component and therefore more than one
                                      * name needs to be given. However, you
@@ -185,18 +185,18 @@ class DataOutStack : public DataOutInterface<dim+1>
                                      *
                                      * This version may be called if the
                                      * finite element presently used by the
-                                     * @ref{DoFHandler} (and previously attached
+                                     * DoFHandler (and previously attached
                                      * to this object) has only one component
                                      * and therefore only one name needs to
                                      * be given.
                                      *
                                      * The data vector must have been
-                                     * registered using the @p{declare_data_vector}
+                                     * registered using the @p declare_data_vector
                                      * function before actually using it the
                                      * first time.
                                      *
                                      * Note that a copy of this vector is
-                                     * stored until @p{finish_parameter_value}
+                                     * stored until @p finish_parameter_value
                                      * is called the next time, so if you are
                                      * short of memory you may want to call
                                      * this function only after all
@@ -213,7 +213,7 @@ class DataOutStack : public DataOutInterface<dim+1>
                                      *
                                      * This version must be called if the
                                      * finite element presently used by the
-                                     * @ref{DoFHandler} (and previously attached
+                                     * DoFHandler (and previously attached
                                      * to this object) has more than one
                                      * component and therefore more than one
                                      * name needs to be given. However, you
@@ -223,12 +223,12 @@ class DataOutStack : public DataOutInterface<dim+1>
                                      * only one component.
                                      *
                                      * The data vector must have been
-                                     * registered using the @p{declare_data_vector}
+                                     * registered using the @p declare_data_vector
                                      * function before actually using it the
                                      * first time.
                                      *
                                      * Note that a copy of this vector is
-                                     * stored until @p{finish_parameter_value}
+                                     * stored until @p finish_parameter_value
                                      * is called the next time, so if you are
                                      * short of memory you may want to call
                                      * this function only after all
@@ -243,10 +243,10 @@ class DataOutStack : public DataOutInterface<dim+1>
                                      * Actually build the patches for output
                                      * by the base classes from the data
                                      * stored in the data vectors and using
-                                     * the previously attached @ref{DoFHandler}
+                                     * the previously attached DoFHandler
                                      * object.
                                      *
-                                     * By @p{n_subdivisions} you can decide
+                                     * By @p n_subdivisions you can decide
                                      * into how many subdivisions (in each
                                      * space and parameter direction) each
                                      * patch is divided. This is useful
@@ -260,11 +260,11 @@ class DataOutStack : public DataOutInterface<dim+1>
 
                                     /**
                                      * Release all data that is no
-                                     * more needed once @p{build_patches}
+                                     * more needed once @p build_patches
                                      * was called and all other transactions
                                      * for a given parameter value are done.
                                      *
-                                     * Couterpart of @p{new_parameter_value}.
+                                     * Couterpart of @p new_parameter_value.
                                      */
     void finish_parameter_value ();
 
@@ -409,8 +409,8 @@ class DataOutStack : public DataOutInterface<dim+1>
                                      * This is the function through
                                      * which derived classes propagate
                                      * preprocessed data in the form of
-                                     * @ref{Patch} structures (declared in
-                                     * the base class @ref{DataOutBase}) to
+                                     * Patch structures (declared in
+                                     * the base class DataOutBase) to
                                      * the actual output function.
                                      */
     virtual const std::vector< ::DataOutBase::Patch<dim+1,dim+1> > & get_patches () const;
index d2e134ee5bc294e761aeaa698111c9a69d4ee0ab..06258464bb19f77668010b68e620f9b16a044c08 100644 (file)
@@ -57,7 +57,7 @@
  *                             \frac{u_h(x_{K'}) - u_h(x_K)}{ \|y_{K'}\| }
  *                      \right).$
  * This is a quantity that is easily computed. The value returned for
- * each cell when calling the @p{approximate_gradient} function of
+ * each cell when calling the @p approximate_gradient function of
  * this class is the $l_2$ norm of this approximation to the
  * gradient. To make this a useful quantity, you may want to scale
  * each element by the correct power of the respective cell size.
  * these operations that are dependent on the actual order of the
  * derivatives to be approximated, as well as the computation of the
  * quantities entering the difference quotient, have been separated
- * into auxiliary nested classes (names @p{Gradient} and
- * @p{SecondDerivative}) and the main algorithm is simply passed one
+ * into auxiliary nested classes (names @p Gradient and
+ * @p SecondDerivative) and the main algorithm is simply passed one
  * or the other data types and asks them to perform the order
  * dependent operations. The main framework that is independent of
  * this, such as finding all active neighbors, or setting up the
- * matrix $Y$ is done in the main function @p{approximate}.
+ * matrix $Y$ is done in the main function @p approximate.
  *
  * Due to this way of operation, the class may be easily extended for
  * higher oder derivatives than are presently implemented. Basically,
  * only an additional class along the lines of the derivative
- * descriptor classes @p{Gradient} and @p{SecondDerivative} has to be
+ * descriptor classes @p Gradient and @p SecondDerivative has to be
  * implemented, with the respective typedefs and functions replaced by
  * the appropriate analogues for the derivative that is to be
  * approximated.
@@ -193,7 +193,7 @@ class DerivativeApproximation
                          const unsigned int     component = 0);
 
                                     /**
-                                     * Calls the @p{interpolate}
+                                     * Calls the @p interpolate
                                      * function, see above, with
                                      * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
@@ -240,7 +240,7 @@ class DerivativeApproximation
                                   const unsigned int     component = 0);
     
                                     /**
-                                     * Calls the @p{interpolate}
+                                     * Calls the @p interpolate
                                      * function, see above, with
                                      * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
@@ -284,7 +284,7 @@ class DerivativeApproximation
                                         /**
                                          * Declare which data fields have
                                          * to be updated for the function
-                                         * @p{get_projected_derivative}
+                                         * @p get_projected_derivative
                                          * to work.
                                          */
        static const UpdateFlags update_flags;
@@ -305,7 +305,7 @@ class DerivativeApproximation
        typedef double        ProjectedDerivative;
 
                                         /**
-                                         * Given an @ref{FEValues} object
+                                         * Given an FEValues object
                                          * initialized to a cell, and a
                                          * solution vector, extract the
                                          * desired derivative at the
@@ -365,7 +365,7 @@ class DerivativeApproximation
                                         /**
                                          * Declare which data fields have
                                          * to be updated for the function
-                                         * @p{get_projected_derivative}
+                                         * @p get_projected_derivative
                                          * to work.
                                          */
        static const UpdateFlags update_flags;
@@ -386,7 +386,7 @@ class DerivativeApproximation
        typedef Tensor<1,dim> ProjectedDerivative;
 
                                         /**
-                                         * Given an @ref{FEValues} object
+                                         * Given an FEValues object
                                          * initialized to a cell, and a
                                          * solution vector, extract the
                                          * desired derivative at the
@@ -451,14 +451,14 @@ class DerivativeApproximation
                                      * this class with the correct
                                      * template first argument and
                                      * then simply calls the
-                                     * @p{approximate} function,
+                                     * @p approximate function,
                                      * after setting up several
                                      * threads and doing some
                                      * administration that is
                                      * independent of the actual
                                      * derivative to be computed.
                                      *
-                                     * The @p{component} argument
+                                     * The @p component argument
                                      * denotes which component of the
                                      * solution vector we are to work
                                      * on.
index de66214a70b71eb47970956e2305548f6b278292..d3ba08ec8926b00533d34448eeae095481c9b08d 100644 (file)
@@ -33,8 +33,8 @@
 /**
  * Print intermediate solutions in solvers.  This is derived from a
  * solver class provided as template argument.  It implements the
- * @p{print_vector} function of the solver using a
- * @ref{DoFHandler}. This way, the intermediate vectors can be viewed
+ * @p print_vector function of the solver using a
+ * DoFHandler. This way, the intermediate vectors can be viewed
  * as finite element functions. This class might be used first to
  * understand how solvers work (for example to visualize the smoothing
  * properties of various solvers, e.g. in a multigrid context), and
@@ -45,7 +45,7 @@
  * template argument, and with a file name (as a string), with which a
  * new file is constructed in each iteration (named
  * @p{basename.[step].[suffix]}) and into which the solution is
- * written as a finite element field using the @ref{DataOut} class.
+ * written as a finite element field using the DataOut class.
  * Please note that this class may produce enormous amounts of data!
  *
  * @author Guido Kanschat, 2000
@@ -57,7 +57,7 @@ class DoFPrintSolverStep : public SOLVER
                                     /**
                                      * Constructor.  First, we take
                                      * the arguments needed for the
-                                     * solver. @p{data_out} is the
+                                     * solver. @p data_out is the
                                      * object doing the output as a
                                      * finite element function.
                                      *
index ad7e9b052852102d6b299b5eab7864e139513ce1..e0cd6f62c00fe5ca8b088e204965300a39727db0 100644 (file)
@@ -49,8 +49,8 @@ template <int dim> class FESubfaceValues;
  *  the conormal derivative $a\frac{du}{dn} = g$.
  *
  *  The error estimator returns a vector of estimated errors per cell which
- *  can be used to feed the @ref{Triangulation}@p{<dim>::refine_*} functions. This
- *  vector contains elements of data type @p{float}, rather than @p{double},
+ *  can be used to feed the Triangulation@p{<dim>::refine_*} functions. This
+ *  vector contains elements of data type @p float, rather than @p double,
  *  since accuracy is not so important here, and since this can save rather
  *  a lot of memory, when using many cells.
  *
@@ -69,8 +69,8 @@ template <int dim> class FESubfaceValues;
  *  is considered, but may lead to wrong results. You may scale the vector
  *  appropriately afterwards.
  *
- *  To perform the integration, use is made of the @ref{FEFaceValues} and
- *  @ref{FESubfaceValues} classes. The integration is performed by looping
+ *  To perform the integration, use is made of the FEFaceValues and
+ *  FESubfaceValues classes. The integration is performed by looping
  *  over all cells and integrating over faces that are not yet treated.
  *  This way we avoid integration on faces twice, once for each time we
  *  visit one of the adjacent cells. In a second loop over all cells, we
@@ -79,10 +79,10 @@ template <int dim> class FESubfaceValues;
  *
  *  The integration is done using a quadrature formula on the face.
  *  For linear trial functions (@ref{FEQ1}), the @ref{QGauss2} or even the
- *  @ref{QMidpoint} rule will suffice. For higher order elements, it is
+ *  QMidpoint rule will suffice. For higher order elements, it is
  *  necessary to utilize higher order quadrature formulae as well.
  *
- *  We store the contribution of each face in a @p{map}, as provided by the
+ *  We store the contribution of each face in a @p map, as provided by the
  *  C++ standard library, with the iterator pointing to that face being the
  *  key into the map. In fact, we do not store the indicator per face, but
  *  only the integral listed above. When looping the second time over all
@@ -105,7 +105,7 @@ template <int dim> class FESubfaceValues;
  *  components at the same time. The main function of this class takes
  *  a list of flags denoting the components for which components the
  *  error estimator is to be applied; by default, it is a list of only
- *  @p{true}s, meaning that all variables shall be treated.
+ *  @p trues, meaning that all variables shall be treated.
  *
  *  In case the different components of a field have different
  *  physical meaning (for example velocity and pressure in the Stokes
@@ -123,8 +123,8 @@ template <int dim> class FESubfaceValues;
  *  
  *  If the face is at the boundary, i.e. there is no neighboring cell to which
  *  the jump in the gradiend could be computed, there are two possibilities:
- *  @begin{itemize}
- *  @item The face belongs to a Dirichlet boundary. Then the face is not
+ *  <ul>
+ *  <li> The face belongs to a Dirichlet boundary. Then the face is not
  *    considered, which can be justified looking at a dual problem technique and
  *    should hold exactly if the boundary can be approximated exactly by the
  *    finite element used (i.e. it is a linear boundary for linear finite elements,
@@ -141,15 +141,15 @@ template <int dim> class FESubfaceValues;
  *    store a zero for this face, which makes summing up the contributions of
  *    the different faces to the cells easier.
  *
- *  @item The face belongs to a Neumann boundary.  In this case, the
+ *  <li> The face belongs to a Neumann boundary.  In this case, the
  *    contribution of the face $F\in\partial K$ looks like
  *    \f[ \int_F \left|g-a\frac{\partial u_h}{\partial n}\right|^2 ds \f]
  *    where $g$ is the Neumann boundary function. If the finite element is
  *    vector-valued, then obviously the function denoting the Neumann boundary
  *    conditions needs to be vector-valued as well.
  *
- *  @item No other boundary conditions are considered.
- *  @end{itemize}
+ *  <li> No other boundary conditions are considered.
+ *  </ul>
  *  The object describing the boundary conditions is obtained from the
  *  triangulation.
  *
@@ -161,7 +161,7 @@ template <int dim> class FESubfaceValues;
  *  
  *  The integration along faces with hanging nodes is quite tricky, since one
  *  of the elements has to be shifted one level up or down. See the
- *  documentation for the @ref{FESubFaceValues} class for more information about
+ *  documentation for the FESubFaceValues class for more information about
  *  technical issues regarding this topic.
  *
  *  In praxi, since we integrate over each face only once, we do this when we
@@ -191,14 +191,14 @@ template <int dim> class FESubfaceValues;
  *  then call the functions of this class several times for each
  *  solution. However, it is observed that the largest factor in the
  *  computation of the error estimates (in terms of computing time) is
- *  initialization of @ref{FEFaceValues} and @ref{FESubFaceValues}
+ *  initialization of FEFaceValues and FESubFaceValues
  *  objects, and iterating through all faces and subfaces. If the
  *  solution vectors live on the same grid, this effort can be reduced
  *  significantly by treating all solution vectors at the same time,
- *  initializing the @ref{FEFaceValues} objects only once per cell and
+ *  initializing the FEFaceValues objects only once per cell and
  *  for all solution vectors at once, and also only looping through
  *  the triangulation only once. For this reason, besides the
- *  @p{estimate} function in this class that takes a single input
+ *  @p estimate function in this class that takes a single input
  *  vector and returns a single output vector, there is also a
  *  function that accepts several in- and output vectors at the same
  *  time. 
@@ -232,11 +232,11 @@ class KellyErrorEstimator
                                      * components you want to
                                      * evaluate, in case the finite
                                      * element used by the
-                                     * @ref{DoFHandler} object is
+                                     * DoFHandler object is
                                      * vector-valued. You then have
                                      * to set those entries to true
                                      * in the bit-vector
-                                     * @p{component_mask} for which the
+                                     * @p component_mask for which the
                                      * respective component is to be
                                      * used in the error
                                      * estimator. The default is to
@@ -304,7 +304,7 @@ class KellyErrorEstimator
                           const unsigned int       subdomain_id = deal_II_numbers::invalid_unsigned_int);
 
                                     /**
-                                     * Calls the @p{estimate}
+                                     * Calls the @p estimate
                                      * function, see above, with
                                      * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */    
@@ -359,7 +359,7 @@ class KellyErrorEstimator
                           const unsigned int           subdomain_id = deal_II_numbers::invalid_unsigned_int);
 
                                     /**
-                                     * Calls the @p{estimate}
+                                     * Calls the @p estimate
                                      * function, see above, with
                                      * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
@@ -601,7 +601,7 @@ class KellyErrorEstimator
                                      * becomes clear when looking at
                                      * the source code. This function
                                      * is only externalized from
-                                     * @p{estimate_error} to avoid
+                                     * @p estimate_error to avoid
                                      * ending up with a function of
                                      * 500 lines of code.
                                      */
@@ -626,7 +626,7 @@ class KellyErrorEstimator
                                      * The same applies as for the
                                      * function above, except that
                                      * integration is over face
-                                     * @p{face_no} of @p{cell}, where
+                                     * @p face_no of @p cell, where
                                      * the respective neighbor is
                                      * refined, so that the
                                      * integration is a bit more
@@ -656,7 +656,7 @@ class KellyErrorEstimator
                                      * class. Nevertheless, some
                                      * compilers don't implement this
                                      * resolution yet, so we have to
-                                     * make them @p{friend}, which
+                                     * make them @p friend, which
                                      * doesn't hurt on the other
                                      * compilers as well.
                                      */
@@ -703,11 +703,11 @@ class KellyErrorEstimator<1>
                                      * components you want to
                                      * evaluate, in case the finite
                                      * element used by the
-                                     * @ref{DoFHandler} object is
+                                     * DoFHandler object is
                                      * vector-valued. You then have
                                      * to set those entries to true
                                      * in the bit-vector
-                                     * @p{component_mask} for which the
+                                     * @p component_mask for which the
                                      * respective component is to be
                                      * used in the error
                                      * estimator. The default is to
@@ -743,7 +743,7 @@ class KellyErrorEstimator<1>
                           const unsigned int       subdomain_id = deal_II_numbers::invalid_unsigned_int);
 
                                     /**
-                                     * Calls the @p{estimate}
+                                     * Calls the @p estimate
                                      * function, see above, with
                                      * @p{mapping=MappingQ1<1>()}.
                                      */    
@@ -798,7 +798,7 @@ class KellyErrorEstimator<1>
                           const unsigned int           subdomain_id = deal_II_numbers::invalid_unsigned_int);
 
                                     /**
-                                     * Calls the @p{estimate}
+                                     * Calls the @p estimate
                                      * function, see above, with
                                      * @p{mapping=MappingQ1<1>()}.
                                      */
index 56e9bd5bd89e20e6fae62fb707151c2925ad2357..d5961bf1bcd4456c795eb297c6344ec1e98e9110 100644 (file)
  * @sect3{Ways to generate the intervals}
  *
  * At present, the following schemes for interval spacing are implemented:
- * @begin{itemize}
- * @item Linear spacing: The intervals are distributed in constant steps
+ * <ul>
+ * <li> Linear spacing: The intervals are distributed in constant steps
  *    between the minimum and maximum values of the data.
- * @item Logaritmic spacing: The intervals are distributed in constant
+ * <li> Logaritmic spacing: The intervals are distributed in constant
  *    steps between the minimum and maximum values of the logs of the values.
  *    This scheme is only useful if the data has only positive values.
  *    Negative and zero values are sorted into the leftmost interval.
- * @end{itemize}
+ * </ul>
  *
  * To keep programs extendible, you can use the two functions
- * @p{get_interval_spacing_names} and @p{parse_interval_spacing}, which always
+ * @p get_interval_spacing_names and @p parse_interval_spacing, which always
  * give you a complete list of spacing formats presently supported and are
- * able to generate the respective value of the @p{enum}. If you use them,
+ * able to generate the respective value of the @p enum. If you use them,
  * you can write your program in a way such that it only needs to be
  * recompiled to take effect of newly added formats, without changing your
  * code.
@@ -89,21 +89,21 @@ class Histogram
                                      * and the number of values in each
                                      * interval will be the y-range (for
                                      * 2d plots) or the z-range (for 3d
-                                     * plots). For 3d plots, the @p{y_values}
+                                     * plots). For 3d plots, the @p y_values
                                      * parameter is used to assign each
                                      * data set a value in the y direction,
                                      * which is the depth coordinate in the
                                      * resulting plot. For 2d plots,
-                                     * the @p{y_values} are ignored.
+                                     * the @p y_values are ignored.
                                      *
                                      * If you give only one data set, i.e.
                                      * @p{values.size()==1}, then the
                                      * resulting histogram will be a 2d
                                      * one.
                                      *
-                                     * @p{n_intervals} denotes the number of
+                                     * @p n_intervals denotes the number of
                                      * intervals into which the data will be
-                                     * sorted; @p{interval_spacing} denotes
+                                     * sorted; @p interval_spacing denotes
                                      * the way the bounds of the intervals
                                      * are computed. Refer to the general
                                      * documentation for more information
@@ -127,7 +127,7 @@ class Histogram
 
                                     /**
                                      * Write the histogram computed by
-                                     * the @p{evaluate} function to a
+                                     * the @p evaluate function to a
                                      * stream in a format suitable to
                                      * the GNUPLOT program. The function
                                      * generates 2d or 3d histograms.
@@ -145,7 +145,7 @@ class Histogram
                                      * Get a string containing one of the
                                      * names returned by the above function
                                      * and return the respective value of
-                                     * @p{IntervalSpacing}. Throw an error
+                                     * @p IntervalSpacing. Throw an error
                                      * if the string is no valid one.
                                      */
     static IntervalSpacing parse_interval_spacing (const std::string &name);
@@ -233,7 +233,7 @@ class Histogram
                                      * logarithmic case interval spacing
                                      * scheme.
                                      *
-                                     * Return @p{true}, if (@p{n1<n2},
+                                     * Return @p true, if (@p{n1<n2},
                                      * and (@p{n1>0} or @p{n2<0})), or
                                      * (n2<n1 and n1>0 and n2<=0). This
                                      * in effect sorts all negativ
@@ -247,13 +247,13 @@ class Histogram
                                     /**
                                      * Vector holding one set of intervals
                                      * for each data set given to the
-                                     * @p{evaluate} function.
+                                     * @p evaluate function.
                                      */
     std::vector<std::vector<Interval> > intervals;
 
                                     /**
                                      * Values for the depth axis of 3d
-                                     * histograms. Stored in the @p{evaluate}
+                                     * histograms. Stored in the @p evaluate
                                      * function.
                                      */
     std::vector<double>            y_values;
index 978fa0baa108ab036c65890f9e4d0beaf985dc01..1a0147d38480ebe6eadf22de32e17940543a45a4 100644 (file)
@@ -54,27 +54,27 @@ namespace PETScWrappers
  *
  * @sect3{Conventions for all functions}
  *
- * There exist two versions of each function. One with a @ref{Mapping}
+ * There exist two versions of each function. One with a Mapping
  * argument and one without. If a code uses a mapping different from
  * @ref{MappingQ1} the functions <em>with</em> mapping argument should
  * be used. Code that uses only @ref{MappingQ1} may also use the
- * functions <em>without</em> @ref{Mapping} argument. Each of these
+ * functions <em>without</em> Mapping argument. Each of these
  * latter functions create a @ref{MappingQ1} object and just call the
  * respective functions with that object as mapping argument. The
- * functions without @ref{Mapping} argument still exist to ensure
+ * functions without Mapping argument still exist to ensure
  * backward compatibility. Nevertheless it is advised to change the
- * user's codes to store a specific @ref{Mapping} object and to use
- * the functions that take this @p{Mapping} object as argument. This
+ * user's codes to store a specific Mapping object and to use
+ * the functions that take this @p Mapping object as argument. This
  * gives the possibility to easily extend the user codes to work also
  * on mappings of higher degree, this just by exchanging
- * @ref{MappingQ1} by, for example, a @ref{MappingQ} or another
- * @ref{Mapping} object of interest.
+ * @ref{MappingQ1} by, for example, a MappingQ or another
+ * Mapping object of interest.
  *
  * All functions take a sparse matrix object to hold the matrix to be
  * created. The functions assume that the matrix is initialized with a
- * sparsity pattern (@ref{SparsityPattern}) corresponding to the given degree
+ * sparsity pattern (SparsityPattern) corresponding to the given degree
  * of freedom handler, i.e. the sparsity structure is already as needed.
- * You can do this by calling the @ref{DoFHandler}@p{<dim>::make_sparsity_pattern}
+ * You can do this by calling the DoFHandler@p{<dim>::make_sparsity_pattern}
  * function.
  *
  * Furthermore it is assumed that no relevant data is in the matrix. All
@@ -89,7 +89,7 @@ namespace PETScWrappers
  * want to add several matrices and could then condense afterwards
  * only once, instead of for every matrix. To actually do computations
  * with these matrices, you have to condense the matrix using the
- * @ref{ConstraintMatrix}@p{::condense} function; you also have to
+ * ConstraintMatrix@p ::condense function; you also have to
  * condense the right hand side accordingly and distribute the
  * solution afterwards.
  *
@@ -102,8 +102,8 @@ namespace PETScWrappers
  * @sect3{Supported matrices}
  *
  * At present there are functions to create the following matrices:
- * @begin{itemize}
- * @item @p{create_mass_matrix}: create the matrix with entries
+ * <ul>
+ * <li> @p create_mass_matrix: create the matrix with entries
  *   $m_{ij} = \int_\Omega \phi_i(x) \phi_j(x) dx$ by numerical
  *   quadrature. Here, the $\phi_i$ are the basis functions of the
  *   finite element space given.
@@ -111,20 +111,20 @@ namespace PETScWrappers
  *   A coefficient may be given to evaluate
  *   $m_{ij} = \int_\Omega a(x) \phi_i(x) \phi_j(x) dx$ instead.
  *
- * @item @p{create_laplace_matrix}: create the matrix with entries
+ * <li> @p create_laplace_matrix: create the matrix with entries
  *   $m_{ij} = \int_\Omega \nabla\phi_i(x) \nabla\phi_j(x) dx$ by
  *   numerical quadrature.
  *
  *   Again, a coefficient may be given to evaluate
  *   $m_{ij} = \int_\Omega a(x) \nabla\phi_i(x) \phi_j(x) dx$ instead.
- * @end{itemize}
+ * </ul>
  *
- * Make sure that the order of the @ref{Quadrature} formula given to these
+ * Make sure that the order of the Quadrature formula given to these
  * functions is sufficiently high to compute the matrices with the
  * required accuracy. For the choice of this quadrature rule you need
- * to take into account the polynomial degree of the @ref{FiniteElement}
- * basis functions, the roughness of the coefficient @p{a}, as well as
- * the degree of the given @p{Mapping}.
+ * to take into account the polynomial degree of the FiniteElement
+ * basis functions, the roughness of the coefficient @p a, as well as
+ * the degree of the given @p Mapping.
  *
  * Note, that for system elements the mass matrix and the laplace
  * matrix is implemented such that each components couples only with
@@ -141,19 +141,19 @@ namespace PETScWrappers
  *
  * @sect3{Matrices on the boundary}
  *
- * The @p{create_boundary_mass_matrix} creates the matrix with entries
+ * The @p create_boundary_mass_matrix creates the matrix with entries
  * $m_{ij} = \int_{\Gamma} \phi_i \phi_j dx$, where $\Gamma$ is the
  * union of boundary parts with indicators contained in a
- * @ref{FunctioMap}@p{::FunctionMap} passed to the function (i.e. if
+ * FunctioMap@p ::FunctionMap passed to the function (i.e. if
  * you want to set up the mass matrix for the parts of the boundary
  * with indicators zero and 2, you pass the function a map of
- * @p{unsigned char}s as parameter @p{boundary_functions} containing
+ * @p{unsigned char}s as parameter @p boundary_functions containing
  * the keys zero and 2). The $\phi_i$ are the basis functions which
  * have at least part of their support on $\Gamma$. The mapping
- * @p{dof_to_boundary_mapping} required by this function maps global
+ * @p dof_to_boundary_mapping required by this function maps global
  * DoF numbers to a numbering of the degrees of freedom located on the
  * boundary, and can be obtained using the function
- * @p{DoFTools::map_dof_to_boundary_indices}.
+ * @p DoFTools::map_dof_to_boundary_indices.
  *
  * Since in most cases we are not interested in the pure mass matrix on the
  * boundary, but rather need it to compute the projection of a function to
@@ -162,7 +162,7 @@ namespace PETScWrappers
  * This function needs to get passed a matrix object to hold the resulting sparse
  * matrix. This object is supposed to be initialized with a suitable sparsity
  * pattern, which can be created using the
- * @ref{DoFHandler}@p{::make_boundary_sparsity_pattern} function.
+ * DoFHandler@p ::make_boundary_sparsity_pattern function.
  *
  * The object describing the exact form of the boundary is obtained from the
  * triangulation object.
@@ -176,7 +176,7 @@ namespace PETScWrappers
  * exists in two versions, one only building the matrix and one also
  * building the right hand side vector. If you want to create a right
  * hand side vector without creating a matrix, you can use the
- * @ref{VectorTools::create_right_hand_side} function. The use of the
+ * VectorTools::create_right_hand_side() function. The use of the
  * latter may be useful if you want to create many right hand side
  * vectors.
  *
@@ -190,7 +190,7 @@ namespace PETScWrappers
  * once.
  *
  * All functions in this collection use the finite element given to
- * the @ref{DoFHandler} object the last time that the degrees of
+ * the DoFHandler object the last time that the degrees of
  * freedom were distributed on the triangulation.
  *
  * @author Wolfgang Bangerth, 1998, Ralf Hartmann, 2001
@@ -273,7 +273,7 @@ class MatrixCreator
                                      * The matrix is assumed to
                                      * already be initialized with a
                                      * suiting sparsity pattern (the
-                                     * @ref{DoFHandler} provides an
+                                     * DoFHandler provides an
                                      * appropriate function).
                                      *
                                      * If the library is configured
@@ -446,7 +446,7 @@ class MatrixCreator
     
                                     /**
                                      * Version of the same function
-                                     * (without suffix @p{_1}) with
+                                     * (without suffix @p _1) with
                                      * the same argument list that
                                      * operates only on an interval
                                      * of iterators. Used for
@@ -466,7 +466,7 @@ class MatrixCreator
 
                                     /**
                                      * Version of the same function
-                                     * (without suffix @p{_2}) with
+                                     * (without suffix @p _2) with
                                      * the same argument list that
                                      * operates only on an interval
                                      * of iterators. Used for
@@ -488,7 +488,7 @@ class MatrixCreator
 
                                     /**
                                      * Version of the same function
-                                     * (without suffix @p{_1}) with
+                                     * (without suffix @p _1) with
                                      * the same argument list that
                                      * operates only on an interval
                                      * of iterators. Used for
@@ -508,7 +508,7 @@ class MatrixCreator
 
                                     /**
                                      * Version of the same function
-                                     * (without suffix @p{_2}) with
+                                     * (without suffix @p _2) with
                                      * the same argument list that
                                      * operates only on an interval
                                      * of iterators. Used for
@@ -530,7 +530,7 @@ class MatrixCreator
 
                                     /**
                                      * Version of the same function
-                                     * (without suffix @p{_1}) with
+                                     * (without suffix @p _1) with
                                      * the same argument list that
                                      * operates only on an interval
                                      * of iterators. Used for
@@ -562,12 +562,12 @@ class MatrixCreator
  *
  * @sect3{Boundary conditions}
  *
- * The @p{apply_boundary_values} function inserts boundary conditions
+ * The @p apply_boundary_values function inserts boundary conditions
  * of into a system of equations.  To actually do this you have to
  * specify a list of degree of freedom indices along with the values
  * these degrees of freedom shall assume. To see how to get such a
  * list, see the discussion of the
- * @ref{VectorTools}@p{::interpolate_boundary_values} function.
+ * VectorTools@p ::interpolate_boundary_values function.
  *
  * There are two ways to incorporate fixed degrees of freedom such as boundary
  * nodes into a linear system, as discussed below.
@@ -607,7 +607,7 @@ class MatrixCreator
  * solver which can handle nonsymmetric matrices in any case, so there
  * may be no need to do the Gauss elimination anyway. In fact, this is
  * the way the function works: it takes a parameter
- * (@p{elininate_columns}) that specifies whether the sparsity pattern
+ * (@p elininate_columns) that specifies whether the sparsity pattern
  * is symmetric; if so, then the column is eliminated and the right
  * hand side is also modified accordingly. If not, then only the row
  * is deleted and the column is not touched at all, and all right hand
@@ -615,17 +615,17 @@ class MatrixCreator
  * remain unchanged.
  *
  * If the sparsity pattern for your matrix is non-symmetric, you must
- * set the value of this parameter to @p{false} in any case, since then
+ * set the value of this parameter to @p false in any case, since then
  * we can't eliminate the column without searching all rows, which
- * would be too expensive (if @p{N} be the number of rows, and @p{m} the
+ * would be too expensive (if @p N be the number of rows, and @p m the
  * number of nonzero elements per row, then eliminating one column is
  * an @p{O(N*log(m))} operation, since searching in each row takes
  * @p{log(m)} operations). If your sparsity pattern is symmetric, but
- * your matrix is not, then you might specify @p{false} as well. If your
+ * your matrix is not, then you might specify @p false as well. If your
  * sparsity pattern and matrix are both symmetric, you might want to
- * specify @p{true} (the complexity of eliminating one row is then
- * @p{O(m*log(m))}, since we only have to search @p{m} rows for the
- * respective element of the column). Given the fact that @p{m} is
+ * specify @p true (the complexity of eliminating one row is then
+ * @p{O(m*log(m))}, since we only have to search @p m rows for the
+ * respective element of the column). Given the fact that @p m is
  * roughly constant, irrespective of the discretization, and that the
  * number of boundary nodes is @p{sqrt(N)} in 2d, the algorithm for
  * symmetric sparsity patterns is @p{O(sqrt(N)*m*log(m))}, while it
@@ -665,9 +665,9 @@ class MatrixCreator
  * values. However, since the modification for boundary values of the
  * right hand side vector depends on the original matrix, this is not
  * possible without storing the original matrix somewhere and applying
- * the @p{apply_boundary_conditions} function to a copy of it each
+ * the @p apply_boundary_conditions function to a copy of it each
  * time we want to solve. In that case, you can use the
- * @ref{FilteredMatrix} class in the @p{LAC} sublibrary. There you can
+ * FilteredMatrix class in the @p LAC sublibrary. There you can
  * also find a formal (mathematical) description of the process of
  * modifying the matrix and right hand side vectors for boundary
  * values.
@@ -702,8 +702,8 @@ class MatrixTools : public MatrixCreator
                                      *
                                      * For a replacement function,
                                      * see the documentation of the
-                                     * @ref{FilteredMatrix} class in
-                                     * the @p{LAC} sublibrary, or use the
+                                     * FilteredMatrix class in
+                                     * the @p LAC sublibrary, or use the
                                      * local_apply_boundary_values()
                                      * function..
                                      */
@@ -726,8 +726,8 @@ class MatrixTools : public MatrixCreator
                                      *
                                      * For a replacement function, see the
                                      * documentation of the
-                                     * @ref{FilteredMatrix} class in the
-                                     * @p{LAC} sublibrary, or use the
+                                     * FilteredMatrix class in the
+                                     * @p LAC sublibrary, or use the
                                      * local_apply_boundary_values()
                                      * function.
                                      */
index bf7e39410df83f5c1a59c5e23064706b9d21188a..05a2396b8f25be4af90fd9d1ef14352820c16abc 100644 (file)
  * As the interpolation while
  * coarsening is much more complicated to organize 
  * (see further documentation below) than interpolation while pure refinement,
- * @p{SolutionTransfer} offers two possible usages.
- * @begin{itemize}
- * @item If the grid will only be purely refined
- * (i.e. not locally coarsened) then use @p{SolutionTransfer} as follows
- * @begin{verbatim}
+ * @p SolutionTransfer offers two possible usages.
+ * <ul>
+ * <li> If the grid will only be purely refined
+ * (i.e. not locally coarsened) then use @p SolutionTransfer as follows
+ * @verbatim
  * SolutionTransfer<dim, double> soltrans(*dof_handler);
  *                                     // flag some cells for refinement, e.g.
  * GridRefinement::refine_and_coarsen_fixed_fraction(
  * tria->execute_coarsening_and_refinement();
  *                                     // and redistribute dofs.
  * dof_handler->distribute_dofs (fe);
- * @end{verbatim}
+ * @endverbatim
  *
  * Then there are three different possibilities of how to proceed. Either
- * @begin{verbatim}
+ * @verbatim
  *                                     // resize and interpolate a solution
  *                                     // vector `in-place'
  * soltrans.refine_interpolate(solution);
- * @end{verbatim}
+ * @endverbatim
  * or, when the old solution vector is still needed,
- * @begin{verbatim}
+ * @verbatim
  *                                     // take a copy of the solution vector
  * Vector<double> solution_old(solution);
  *                                     // resize solution vector to the correct
- *                                     // size, as the @p{refine_interpolate}
+ *                                     // size, as the @p refine_interpolate
  *                                     // function requires the vectors to be
  *                                     // of right sizes
  * solution.reinit(dof_handler->n_dofs());
  *                                     // and finally interpolate
  * soltrans.refine_interpolate(solution_old, solution);
- * @end{verbatim}
+ * @endverbatim
  *
- * Although the @p{refine_interpolate} functions are allowed to be
+ * Although the @p refine_interpolate functions are allowed to be
  * called multiple times, e.g. for interpolating several solution
  * vectors, there is following possibility of interpolating several
  * functions simultaneously.
- * @begin{verbatim}
+ * @verbatim
  * vector<Vector<double> > solutions_old(n_vectors, Vector<double> (n));
  * ...
  * vector<Vector<double> > solutions(n_vectors, Vector<double> (n));
  * soltrans.refine_interpolate(solutions_old, solutions);
- * @end{verbatim}
- * @item If the grid will be refined AND coarsened
- * then use @p{SolutionTransfer} as follows
- * @begin{verbatim}
+ * @endverbatim
+ * <li> If the grid will be refined AND coarsened
+ * then use @p SolutionTransfer as follows
+ * @verbatim
  * SolutionTransfer<dim, double> soltrans(*dof_handler);
  *                                     // flag some cells for refinement
  *                                     // and coarsening, e.g.
  *                                     // and interpolate the solution
  * Vector<double> interpolate_solution(dof_handler->n_dofs());
  * soltrans.interpolate(solution, interpolated_solution);
- * @end{verbatim}
+ * @endverbatim
  *
  * Multiple calls to the function 
  * @p{interpolate (const Vector<number> &in, Vector<number> &out)}
  * are NOT allowed. Interpolating several functions can be performed in one step
  * by using 
  * @p{void interpolate (const vector<Vector<number> >&all_in, vector<Vector<number> >&all_out) const},
- * and using the respective @p{prepare_for_coarsening_and_refinement} function 
+ * and using the respective @p prepare_for_coarsening_and_refinement function 
  * taking several vectors as input before actually refining and coarsening the
  * triangulation (see there).
- * @end{itemize}
+ * </ul>
  *
- * For deleting all stored data in @p{SolutionTransfer} and reinitializing it
+ * For deleting all stored data in @p SolutionTransfer and reinitializing it
  * use the @p{clear()} function.
  *
- * Note that the @p{user_pointer} of some cells are used. 
+ * Note that the @p user_pointer of some cells are used. 
  * Be sure that you don't need them otherwise.
  *
- * The template argument @p{number} denotes the data type of the vectors you want
+ * The template argument @p number denotes the data type of the vectors you want
  * to transfer.
  *
  *
  * @sect3{Implementation}
  *
- * @begin{itemize}
- * @item Solution transfer while pure refinement. Assume that we have got a
+ * <ul>
+ * <li> Solution transfer while pure refinement. Assume that we have got a
  * solution vector on the current (original) grid.
  * Each entry of this vector belongs to one of the
  * DoFs of the discretisation. If we now refine the grid then the calling of
- * @ref{DoFHandler}@p{::distribute_dofs(...)} will change at least some of the
+ * DoFHandler@p{::distribute_dofs(...)} will change at least some of the
  * DoF indices. Hence we need to store the DoF indices of all active cells
- * before the refinement. The @p{user_pointer} of each active cell
+ * before the refinement. The @p user_pointer of each active cell
  * is used to point to the vector of these DoF indices of that cell, all other
- * @p{user_pointers} are cleared. All this is
+ * @p user_pointers are cleared. All this is
  * done by @p{prepare_for_pure_refinement()}.
  *
  * In the function @p{refine_interpolate(in,out)} and on each cell where the
- * @p{user_pointer} is set (i.e. the cells that were active in the original grid)
- * we can now access the local values of the solution vector @p{in}
+ * @p user_pointer is set (i.e. the cells that were active in the original grid)
+ * we can now access the local values of the solution vector @p in
  * on that cell by using the stored DoF indices. These local values are
- * interpolated and set into the vector @p{out} that is at the end the
- * discrete function @p{in} interpolated on the refined mesh.
+ * interpolated and set into the vector @p out that is at the end the
+ * discrete function @p in interpolated on the refined mesh.
  *
  * The @p{refine_interpolate(in,out)} function can be called multiply for
  * arbitrary many discrete functions (solution vectors) on the original grid. 
  *
- * @item Solution transfer while coarsening and refinement. After 
- * calling @ref{Triangulation}@p{::prepare_coarsening_and_refinement} the
+ * <li> Solution transfer while coarsening and refinement. After 
+ * calling Triangulation@p ::prepare_coarsening_and_refinement the
  * coarsen flags of either all or none of the children of a 
  * (father-)cell are set. While coarsening 
- * (@ref{Triangulation}@p{::execute_coarsening_and_refinement})
- * the cells that are not needed any more will be deleted from the @ref{Triangulation}.
+ * (Triangulation@p ::execute_coarsening_and_refinement)
+ * the cells that are not needed any more will be deleted from the Triangulation.
  * 
  * For the interpolation from the (to be coarsenend) children to their father
  * the children cells are needed. Hence this interpolation
  * and the storing of the interpolated values of each of the discrete functions
  * that we want to interpolate needs to take place before these children cells
- * are coarsened (and deleted!!). Again the @p{user_pointers} of the cells are
+ * are coarsened (and deleted!!). Again the @p user_pointers of the cells are
  * set to point to these values (see below). 
  * Additionally the DoF indices of the cells
  * that will not be coarsened need to be stored according to the solution
  *
  * As we need two different kinds of pointers (@p{vector<unsigned int> *} for the Dof
  * indices and @p{vector<Vector<number> > *} for the interpolated DoF values)
- * we use the @p{Pointerstruct} that includes both of these pointers and
- * the @p{user_pointer} of each cell points to these @p{Pointerstructs}
+ * we use the @p Pointerstruct that includes both of these pointers and
+ * the @p user_pointer of each cell points to these @p Pointerstructs
  * On each cell only one of the two different pointers is used at one time 
  * hence we could use the
  * @p{void * user_pointer} as @p{vector<unsigned int> *} at one time and as 
- * @p{vector<Vector<number> > *} at the other but using this @p{Pointerstruct}
+ * @p{vector<Vector<number> > *} at the other but using this @p Pointerstruct
  * in between makes the use of these pointers more safe and gives better
  * possibility to expand their usage.
  * 
  * to the solution transfer while pure refinement. Additionally, on each
  * cell that is coarsened (hence previously was a father cell), 
  * the values of the discrete
- * functions in @p{all_out} are set to the stored local interpolated values 
+ * functions in @p all_out are set to the stored local interpolated values 
  * that are accessible due to the 'vector<Vector<number> > *' pointer in 
- * @p{Pointerstruct} that is pointed to by the @p{user_pointer} of that cell.
+ * @p Pointerstruct that is pointed to by the @p user_pointer of that cell.
  * It is clear that @p{interpolate(all_in, all_out)} only can be called with
  * the @p{vector<Vector<number> > all_in} that previously was the parameter
  * of the @p{prepare_for_coarsening_and_refinement(all_in)} function. Hence 
  * @p{interpolate(all_in, all_out)} can (in contrast to 
  * @p{refine_interpolate(in, out)}) only be called once.
- * @end{itemize}
+ * </ul>
  *
  * @author Ralf Hartmann, 1999
  */
@@ -208,7 +208,7 @@ class SolutionTransfer
   public:
     
                                     /**
-                                     * Constructor, takes the current @ref{DoFHandler}
+                                     * Constructor, takes the current DoFHandler
                                      * as argument.
                                      */
     SolutionTransfer(const DoFHandler<dim> &dof);
@@ -226,22 +226,22 @@ class SolutionTransfer
     void clear();
 
                                     /**
-                                     * Prepares the @p{SolutionTransfer} for
+                                     * Prepares the @p SolutionTransfer for
                                      * pure refinement. It
                                      * stores the dof indices of each cell.
                                      * After calling this function 
-                                     * only calling the @p{refine_interpolate}
+                                     * only calling the @p refine_interpolate
                                      * functions is allowed.
                                      */
     void prepare_for_pure_refinement();
 
                                     /**
-                                     * Prepares the @p{SolutionTransfer} for
+                                     * Prepares the @p SolutionTransfer for
                                      * coarsening and refinement. It
                                      * stores the dof indices of each cell and
                                      * stores the dof values of the vectors in
-                                     * @p{all_in} in each cell that'll be coarsened.
-                                     * @p{all_in} includes all vectors
+                                     * @p all_in in each cell that'll be coarsened.
+                                     * @p all_in includes all vectors
                                      * that are to be interpolated
                                      * onto the new (refined and/or
                                      * coarsenend) grid.
@@ -257,16 +257,16 @@ class SolutionTransfer
                      
                                     /**
                                      * This function
-                                     * interpolates the discrete function @p{in},
+                                     * interpolates the discrete function @p in,
                                      * which is a vector on the grid before the
-                                     * refinement, to the function @p{out}
+                                     * refinement, to the function @p out
                                      * which then is a vector on the refined grid.
                                      * It assumes the vectors having the
                                      * right sizes (i.e. @p{in.size()==n_dofs_old},
                                      * @p{out.size()==n_dofs_refined})
                                              *
                                      * Calling this function is allowed only
-                                     * if @p{prepare_for_pure_refinement} is called
+                                     * if @p prepare_for_pure_refinement is called
                                      * and the refinement is
                                      * executed before.
                                      * Multiple calling of this function is
@@ -279,7 +279,7 @@ class SolutionTransfer
                                     /**
                                      * Same as @p{interpolate(in,out)}
                                      * but it interpolates
-                                     * just 'in-place'. Therefore @p{vec} will be
+                                     * just 'in-place'. Therefore @p vec will be
                                      * reinitialized to the new needed vector
                                      * dimension.
                                      */
@@ -288,22 +288,22 @@ class SolutionTransfer
                                     /**
                                      * This function
                                      * interpolates the discrete functions
-                                     * that are stored in @p{all_out} onto
+                                     * that are stored in @p all_out onto
                                      * the refined and/or coarsenend grid.
-                                     * It assumes the vectors in @p{all_in}
+                                     * It assumes the vectors in @p all_in
                                      * denote the same vectors
-                                     * as in @p{all_in} as parameter of
+                                     * as in @p all_in as parameter of
                                      * @p{prepare_for_refinement_and_coarsening(all_in)}.
                                      * However, there is no way of verifying
                                      * this internally, so be careful here.
                                      *
                                      * Calling this function is
                                      * allowed only if first
-                                     * @ref{Triangulation}@p{::prepare_coarsening_and_refinement},
+                                     * Triangulation@p ::prepare_coarsening_and_refinement,
                                      * second
-                                     * @p{SolutionTransfer::prepare_for_coarsening_and_refinement},
+                                     * @p SolutionTransfer::prepare_for_coarsening_and_refinement,
                                      * an then third
-                                     * @ref{Triangulation}@p{::execute_coarsening_and_refinement}
+                                     * Triangulation@p ::execute_coarsening_and_refinement
                                      * are called before. Multiple
                                      * calling of this function is
                                      * NOT allowed. Interpolating
@@ -316,7 +316,7 @@ class SolutionTransfer
                                      * vectors. Also, the sizes of
                                      * the output vectors are assumed
                                      * to be of the right size
-                                     * (@p{n_dofs_refined}). Otherwise
+                                     * (@p n_dofs_refined). Otherwise
                                      * an assertion will be thrown.
                                      */
     void interpolate (const std::vector<Vector<number> >&all_in,
@@ -399,10 +399,10 @@ class SolutionTransfer
 
                                     /**
                                      * Declaration of
-                                     * @p{PreparationState} that
+                                     * @p PreparationState that
                                      * denotes the three possible
                                      * states of the
-                                     * @p{SolutionTransfer}: being
+                                     * @p SolutionTransfer: being
                                      * prepared for 'pure
                                      * refinement', prepared for
                                      * 'coarsening and refinement' or
@@ -419,9 +419,9 @@ class SolutionTransfer
 
 
                                     /**
-                                     * Is used for @p{prepare_for_refining}
+                                     * Is used for @p prepare_for_refining
                                      * (of course also for
-                                     * @p{repare_for_refining_and_coarsening})
+                                     * @p repare_for_refining_and_coarsening)
                                      * and stores all dof indices
                                      * of the cells that'll be refined
                                      */
@@ -432,7 +432,7 @@ class SolutionTransfer
                                      * the dof values)
                                      * should be accessable from each cell.
                                      * As each cell has got only one
-                                     * @p{user_pointer}, multiple pointers to the
+                                     * @p user_pointer, multiple pointers to the
                                      * data need to be packetized in a structure.
                                      * Note that in our case on each cell
                                      * either the
@@ -440,10 +440,10 @@ class SolutionTransfer
                                      * will be refined) or the
                                      * @p{vector<double> dof_values} (if the
                                      * children of this cell will be deleted)
-                                     * is needed, hence one @p{user_pointer} should
+                                     * is needed, hence one @p user_pointer should
                                      * be sufficient, but to allow some errorchecks
                                      * and to preserve the user from making
-                                     * user errors the @p{user_pointer} will be
+                                     * user errors the @p user_pointer will be
                                      * 'multiplied' by this structure.
                                      */
     struct Pointerstruct {
@@ -454,7 +454,7 @@ class SolutionTransfer
     };
 
                                     /**
-                                     * Vector of all @p{Pointerstructs} (cf. there).
+                                     * Vector of all @p Pointerstructs (cf. there).
                                      * It makes it
                                      * easier to delete all these structs
                                      * (without going over all @p{cell->user_pointer})
@@ -466,7 +466,7 @@ class SolutionTransfer
 
                                     /**
                                      * Is used for
-                                     * @p{prepare_for_refining_and_coarsening}
+                                     * @p prepare_for_refining_and_coarsening
                                      * The interpolated dof values
                                      * of all cells that'll be coarsened
                                      * will be stored in this vector.
index 040bb5aaec7437d89523be9ac1999ca690386fa7..5c8ddb9d2e2b27835331b9a0d6d28f6b02d3d923 100644 (file)
@@ -74,7 +74,7 @@ template <int dim> class Triangulation;
  * perform another sweep on these refined meshes. A total run will therefore
  * often be a sequence of several sweeps. The global setup therefore looks
  * like this:
- * @begin{verbatim}
+ * @verbatim
  *    for sweep=0 to n_sweeps-1
  *    {
  *      for i=0 to n_timesteps-1
@@ -102,7 +102,7 @@ template <int dim> class Triangulation;
  *        notify timestep i of the end of the sweep, e.g. for cleanups,
  *        deletion of temporary files, etc.
  *    }
- * @end{verbatim}
+ * @endverbatim
  * The user may specify that a loop shall run forward or backward (the latter
  * being needed for the solution of global dual problems, for example).
  *
@@ -120,8 +120,8 @@ template <int dim> class Triangulation;
  * stepping scheme which needs to look ahead one time step and needs the
  * data of the last two time steps, the following pseudocode described
  * what the centeral loop function of this class will do when we move
- * from timestep @p{n-1} to timestep @p{n}:
- * @begin{verbatim}
+ * from timestep @p n-1 to timestep @p n:
+ * @verbatim
  *   wake up timestep n+1 with signal 1
  *   wake up timestep n with signal 0
  *   do computation on timestep n
@@ -130,10 +130,10 @@ template <int dim> class Triangulation;
  *   let timestep n-2 sleep with signal 2
  *
  *   move from n to n+1
- * @end{verbatim}
+ * @endverbatim
  * The signal number here denotes the distance of the timestep being sent
  * the signal to the timestep where computations are done on. The calls to
- * the @p{wake_up} and @p{sleep} functions with signal 0 could in principle
+ * the @p wake_up and @p sleep functions with signal 0 could in principle
  * be absorbed into the function doing the computation; we use these
  * redundant signals, however, in order to separate computations and data
  * management from each other, allowing to put all stuff around grid
@@ -142,29 +142,29 @@ template <int dim> class Triangulation;
  *
  * In the example above, possible actions might be: timestep @p{n+1} rebuilds
  * the computational grid (there is a specialized class which can do this
- * for you); timestep @p{n} builds matrices sets solution vectors to the right
+ * for you); timestep @p n builds matrices sets solution vectors to the right
  * size, maybe using an initial guess; then it does the computations; then
  * it deletes the matrices since they are not needed by subsequent timesteps;
- * timestep @p{n-1} deletes those data vectors which are only needed by one
- * timestep ahead; timestep @p{n-2} deletes the remaining vectors and deletes
+ * timestep @p n-1 deletes those data vectors which are only needed by one
+ * timestep ahead; timestep @p n-2 deletes the remaining vectors and deletes
  * the computational grid, somewhere storing information how to rebuild it
  * eventually.
  *
  * From the given sketch above, it is clear that each time step object sees
  * the following sequence of events:
- * @begin{verbatim}
+ * @verbatim
  *   wake up with signal 1
  *   wake up signal 0
  *   do computation
  *   sleep with signal 0
  *   sleep with signal 1
  *   sleep with signal 2
- * @end{verbatim}
+ * @endverbatim
  * This pattern is repeated for each loop in each sweep.
  *
  * For the different loops within each sweep, the numbers of timesteps
- * to look ahead (i.e. the maximum signal number to the @p{wake_up} function)
- * and the look-behind (i.e. the maximum signal number to the @p{sleep}
+ * to look ahead (i.e. the maximum signal number to the @p wake_up function)
+ * and the look-behind (i.e. the maximum signal number to the @p sleep
  * function) can be chosen separately. For example, it is usually only
  * needed to look one time step behind when computing error estimation
  * (in some cases, it may vene be possible to not look ahead or back
@@ -173,9 +173,9 @@ template <int dim> class Triangulation;
  *
  * Finally, a note on the direction of look-ahead and look-back is in
  * place: look-ahead always refers to the direction the loop is running
- * in, i.e. for loops running forward, @p{wake_up} is called for timestep
+ * in, i.e. for loops running forward, @p wake_up is called for timestep
  * objects with a greater time value than the one previously computed on,
- * while @p{sleep} is called for timesteps with a lower time. If the loop
+ * while @p sleep is called for timesteps with a lower time. If the loop
  * runs in the opposite direction, e.g. when solving a global dual
  * problem, this order is reversed.
  *
@@ -185,7 +185,7 @@ template <int dim> class Triangulation;
  * The main loop of a program using this class will usually look like
  * the following one, taken modified from an application program that
  * isn't distributed as part of the library:
- * @begin{verbatim}
+ * @verbatim
  *   template <int dim>
  *   void TimeDependent_Wave<dim>::run_sweep (const unsigned int sweep_no)
  *   {
@@ -214,15 +214,15 @@ template <int dim> class Triangulation;
  *     for (unsigned int sweep=0; sweep<number_of_sweeps; ++sweep)
  *       timestep_manager.run_sweep (sweep);
  *   };
- * @end{verbatim}
- * Here, @p{timestep_manager} is an object of type @ref{TimeDependent_Wave}, which
- * is a class derived from @ref{TimeDependent}. @p{start_sweep}
- * @p{solve_primal_problem}, @p{solve_dual_problem}, @p{postprocess} and @p{end_sweep}
+ * @endverbatim
+ * Here, @p timestep_manager is an object of type TimeDependent_Wave(), which
+ * is a class derived from TimeDependent. @p start_sweep
+ * @p solve_primal_problem, @p solve_dual_problem, @p postprocess and @p end_sweep
  * are functions inherited from this class. They all do a loop over all 
  * timesteps within this object and call the respective function on each of
  * these objects. For example, here are two of the functions as they are
  * implemented by the library:
- * @begin{verbatim}
+ * @verbatim
  *   void TimeDependent::start_sweep (const unsigned int s) 
  *   {
  *     sweep_no = s;
@@ -253,28 +253,28 @@ template <int dim> class Triangulation;
  *             timestepping_data_primal,
  *             forward);
  *   };
- * @end{verbatim}
+ * @endverbatim
  * The latter function shows rather clear how most of the loops are
- * invoked (@p{solve_primal_problem}, @p{solve_dual_problem}, @p{postprocess},
- * @p{refine_grids} and @p{write_statistics} all have this form, where the
+ * invoked (@p solve_primal_problem, @p solve_dual_problem, @p postprocess,
+ * @p refine_grids and @p write_statistics all have this form, where the
  * latter two give functions of the derived timestep class, rather than
- * from the base class). The function @ref{TimeStepBase}@p{::init_for_primal_problem}
+ * from the base class). The function TimeStepBase@p ::init_for_primal_problem
  * and the respective ones for the other operations defined by that class
  * are only used to store the type of operation which the loop presently
  * performed will do.
  *
- * As can be seen, most of the work is done by the @p{do_loop} function of
+ * As can be seen, most of the work is done by the @p do_loop function of
  * this class, which takes the addresses of two functions which are used
  * to initialize all timestep objects for the loop and to actually perform
  * some action. The next parameter gives some information on the look-ahead
  * and look-back and the last one denotes in which direction the loop is
  * to be run.
  *
- * Using function pointers through the @p{mem_fun} functions provided by
+ * Using function pointers through the @p mem_fun functions provided by
  * the @p{C++} standard library, it is possible to do neat tricks, like
  * the following, also taken from the wave program, in this case from
- * the function @p{refine_grids}:
- * @begin{verbatim}
+ * the function @p refine_grids:
+ * @verbatim
  *   ...
  *   compute the thresholds for refinement
  *   ...
@@ -285,20 +285,20 @@ template <int dim> class Triangulation;
  *                                                            bottom_threshold)),
  *            TimeDependent::TimeSteppingData (0,1),
  *            TimeDependent::forward);
- * @end{verbatim}
- * @ref{TimeStepBase_Wave}@p{::refine_grid} is a function taking an argument, unlike
+ * @endverbatim
+ * TimeStepBase_Wave()@p ::refine_grid is a function taking an argument, unlike
  * all the other functions used above within the loops. However, in this special
  * case the parameter was the same for all timesteps and known before the loop
  * was started, so we fixed it and made a function object which to the outside
  * world does not take parameters.
  *
  * Since it is the central function of this class, we finally present a
- * stripped down version of the @p{do_loop} method, which is shown in order
+ * stripped down version of the @p do_loop method, which is shown in order
  * to provide a better understanding of the internals of this class. For
  * brevity we have omitted the parts that deal with backward running loops
  * as well as the checks whether wake-up and sleep operations act on timesteps
  * outside @p{0..n_timesteps-1}.
- * @begin{verbatim}
+ * @verbatim
  *   template <typename InitFunctionObject, typename LoopFunctionObject>
  *   void TimeDependent::do_loop (InitFunctionObject      init_function,
  *                          LoopFunctionObject      loop_function,
@@ -340,7 +340,7 @@ template <int dim> class Triangulation;
  *       for (int look_back=0; look_back<=timestepping_data.look_back; ++look_back)
  *         timesteps[step-look_back]->sleep(look_back);
  *   };
- * @end{verbatim}
+ * @endverbatim
  *
  *
  * @author Wolfgang Bangerth, 1999
@@ -355,7 +355,7 @@ class TimeDependent
                                      * ahead of the present one we shall
                                      * start waking up timestep objects
                                      * and how many timesteps behind
-                                     * we shall call their @p{sleep}
+                                     * we shall call their @p sleep
                                      * method.
                                      */
     struct TimeSteppingData
@@ -394,7 +394,7 @@ class TimeDependent
                                          * The value of this number determines,
                                          * how many time steps ahead the
                                          * time step manager start to call
-                                         * the @p{wake_up} function for each
+                                         * the @p wake_up function for each
                                          * time step.
                                          */
        const unsigned int look_ahead;
@@ -416,7 +416,7 @@ class TimeDependent
                                          * steps after having done
                                          * computations on a tim level
                                          * the time step manager will
-                                         * call the @p{sleep} function for
+                                         * call the @p sleep function for
                                          * each time step.
                                          */
        const unsigned int look_back;
@@ -425,7 +425,7 @@ class TimeDependent
                                     /**
                                      * Enum offering the different directions
                                      * in which a loop executed by
-                                     * @p{do_loop} may be run.
+                                     * @p do_loop may be run.
                                      */
     enum Direction {
          forward, backward
@@ -443,7 +443,7 @@ class TimeDependent
                                      * Destructor. This will delete the
                                      * objects pointed to by the pointers
                                      * given to the @p{insert_*} and
-                                     * @p{add_timestep} functions, i.e.
+                                     * @p add_timestep functions, i.e.
                                      * it will delete the objects doing
                                      * the computations on each time step.
                                      */
@@ -454,19 +454,19 @@ class TimeDependent
                                      * position is a pointer to an existing
                                      * time step object, or a null pointer
                                      * denoting the end of the timestep
-                                     * sequence. If @p{position} is non-null,
+                                     * sequence. If @p position is non-null,
                                      * the new time step will be inserted
                                      * before the respective element.
                                      *
                                      * Note that by giving an object
                                      * to this function, the
-                                     * @ref{TimeDependent} object assumes
+                                     * TimeDependent object assumes
                                      * ownership of the object; it will
                                      * therefore also take care of
                                      * deletion of the objects its manages.
                                      *
                                      * There is another function,
-                                     * @p{add_timestep}, which inserts a
+                                     * @p add_timestep, which inserts a
                                      * time step at the end of the list.
                                      *
                                      * Note that this function does not
@@ -474,7 +474,7 @@ class TimeDependent
                                      * within the other timestep objects,
                                      * nor does it set the timestep number
                                      * of this new timestep. This is only
-                                     * done upon calling the @p{start_sweep}
+                                     * done upon calling the @p start_sweep
                                      * function. In not changing the timestep
                                      * numbers, it is simpler to operate
                                      * on a space-time triangulation since
@@ -485,15 +485,15 @@ class TimeDependent
                          TimeStepBase       *new_timestep);
 
                                     /**
-                                     * Just like @p{insert_timestep}, but
+                                     * Just like @p insert_timestep, but
                                      * insert at the end.
                                      *
                                      * This mechanism usually will result
                                      * in a set-up loop like this
-                                     * @begin{verbatim}
+                                     * @verbatim
                                      * for (i=0; i<N; ++i)
                                      *   manager.add_timestep(new MyTimeStep());
-                                     * @end{verbatim}
+                                     * @endverbatim
                                      */
     void add_timestep (TimeStepBase *new_timestep);
 
@@ -513,7 +513,7 @@ class TimeDependent
                                      * numbers stored within the
                                      * other timestep objects. This
                                      * is only done upon calling the
-                                     * @p{start_sweep} function. In not
+                                     * @p start_sweep function. In not
                                      * changing the timestep numbers,
                                      * it is simpler to operate on a
                                      * space-time triangulation since
@@ -525,54 +525,54 @@ class TimeDependent
     
                                     /**
                                      * Solve the primal problem; uses the
-                                     * functions @p{init_for_primal_problem}
-                                     * and @p{solve_primal_problem} of the
-                                     * @ref{TimeStepBase} class through the
-                                     * @p{do_loop} function of this class.
+                                     * functions @p init_for_primal_problem
+                                     * and @p solve_primal_problem of the
+                                     * TimeStepBase class through the
+                                     * @p do_loop function of this class.
                                      *
                                      * Look ahead and look back are
-                                     * determined by the @p{timestepping_data_primal}
+                                     * determined by the @p timestepping_data_primal
                                      * object given to the constructor.
                                      */
     void solve_primal_problem ();
 
                                     /**
                                      * Solve the dual problem; uses the
-                                     * functions @p{init_for_dual_problem}
-                                     * and @p{solve_dual_problem} of the
-                                     * @ref{TimeStepBase} class through the
-                                     * @p{do_loop} function of this class.
+                                     * functions @p init_for_dual_problem
+                                     * and @p solve_dual_problem of the
+                                     * TimeStepBase class through the
+                                     * @p do_loop function of this class.
                                      *
                                      * Look ahead and look back are
-                                     * determined by the @p{timestepping_data_dual}
+                                     * determined by the @p timestepping_data_dual
                                      * object given to the constructor.
                                      */
     void solve_dual_problem ();
 
                                     /**
                                      * Do a postprocessing round; uses the
-                                     * functions @p{init_for_postprocessing}
-                                     * and @p{postprocess} of the
-                                     * @ref{TimeStepBase} class through the
-                                     * @p{do_loop} function of this class.
+                                     * functions @p init_for_postprocessing
+                                     * and @p postprocess of the
+                                     * TimeStepBase class through the
+                                     * @p do_loop function of this class.
                                      *
                                      * Look ahead and look back are
-                                     * determined by the @p{timestepping_data_postprocess}
+                                     * determined by the @p timestepping_data_postprocess
                                      * object given to the constructor.
                                      */
     void postprocess ();
     
                                     /**
                                      * Do a loop over all timesteps, call the
-                                     * @p{init_function} at the beginning and
-                                     * the @p{loop_function} of each time step.
-                                     * The @p{timestepping_data} determine how
+                                     * @p init_function at the beginning and
+                                     * the @p loop_function of each time step.
+                                     * The @p timestepping_data determine how
                                      * many timesteps in front and behind
-                                     * the present one the @p{wake_up} and
-                                     * @p{sleep} functions are called.
+                                     * the present one the @p wake_up and
+                                     * @p sleep functions are called.
                                      *
                                      * To see how this function work, note that
-                                     * the function @p{solve_primal_problem} only
+                                     * the function @p solve_primal_problem only
                                      * consists of a call to
                                      * <tt>do_loop (mem_fun(&TimeStepBase::init_for_primal_problem),
                                      *    mem_fun(&TimeStepBase::solve_primal_problem),
@@ -580,21 +580,21 @@ class TimeDependent
                                      *
                                      * Note also, that the given class from which
                                      * the two functions are taken needs not
-                                     * necessarily be @ref{TimeStepBase}, but it
+                                     * necessarily be TimeStepBase, but it
                                      * could also be a derived class, that is
-                                     * @p{static_cast}able from a @ref{TimeStepBase}.
+                                     * @p static_castable from a TimeStepBase.
                                      * The function may be a virtual function
                                      * (even a pure one) of that class, which
                                      * should help if the actual class where it
                                      * is implemented is one which is derived
                                      * through virtual base classes and thus
-                                     * unreachable by @p{static_cast} from the
-                                     * @ref{TimeStepBase} class.
+                                     * unreachable by @p static_cast from the
+                                     * TimeStepBase class.
                                      *
                                      * Instead of using the above form, you can
                                      * equally well use
                                      * @p{bind2nd(mem_fun1(&X::unary_function), arg)} 
-                                     * which lets the @p{do_loop}
+                                     * which lets the @p do_loop
                                      * function call teh given function with
                                      * the specified parameter. Note that you
                                      * need to bind the second parameter since
@@ -619,7 +619,7 @@ class TimeDependent
                                      * deleted) and transmit the number of
                                      * the present sweep to these objects.
                                      *
-                                     * It also calls the @p{init_for_sweep}
+                                     * It also calls the @p init_for_sweep
                                      * function of each time step object,
                                      * after the numbers above are set.
                                      *
@@ -633,22 +633,22 @@ class TimeDependent
                                      * should be called bottom-up.
                                      *
                                      * The default implementation of this
-                                     * function calls @p{start_sweep} on all
+                                     * function calls @p start_sweep on all
                                      * time step objects.
                                      */
     virtual void start_sweep (const unsigned int sweep_no);
 
                                     /**
                                      * Analogon to the above
-                                     * function, calling @p{end_sweep}
+                                     * function, calling @p end_sweep
                                      * of each time step object. The
                                      * same applies with respect to
-                                     * the @p{virtual}ness of this
+                                     * the @p virtualness of this
                                      * function as for the previous
                                      * one.
                                      *
                                      * This function does not
-                                     * guarantee that @p{end_sweep} is
+                                     * guarantee that @p end_sweep is
                                      * called for successive time
                                      * steps, rather the order of
                                      * time steps for which the
@@ -658,7 +658,7 @@ class TimeDependent
                                      * function has been called for
                                      * previous time steps
                                      * already. If in multithread
-                                     * mode, the @p{end_sweep} function
+                                     * mode, the @p end_sweep function
                                      * of several time steps is
                                      * called at once, so you should
                                      * use synchronization
@@ -701,14 +701,14 @@ class TimeDependent
 
                                     /**
                                      * Number of the present sweep. This is
-                                     * reset by the @p{start_sweep} function
+                                     * reset by the @p start_sweep function
                                      * called at the outset of each sweep.
                                      */
     unsigned int sweep_no;
 
                                     /**
                                      * Some flags telling the
-                                     * @p{solve_primal_problem} function what to
+                                     * @p solve_primal_problem function what to
                                      * do. See the documentation of this struct
                                      * for more information.
                                      */
@@ -716,7 +716,7 @@ class TimeDependent
 
                                     /**
                                      * Some flags telling the
-                                     * @p{solve_dual_problem} function what to
+                                     * @p solve_dual_problem function what to
                                      * do. See the documentation of this struct
                                      * for more information.
                                      */
@@ -724,7 +724,7 @@ class TimeDependent
 
                                     /**
                                      * Some flags telling the
-                                     * @p{postprocess} function what to
+                                     * @p postprocess function what to
                                      * do. See the documentation of this struct
                                      * for more information.
                                      */
@@ -746,7 +746,7 @@ class TimeDependent
 /**
  * Base class for a time step in time dependent problems. This class provides
  * barely more than the basic framework, defining the necessary virtual
- * functions (namely @p{sleep} and @p{wake_up}), the interface to previous
+ * functions (namely @p sleep and @p wake_up), the interface to previous
  * and following grids, and some functions to be called before a new loop
  * over all time steps is started.
  *
@@ -807,7 +807,7 @@ class TimeStepBase : public Subscriptor
 
                                     /**
                                      * This is the opposite function
-                                     * to @p{wake_up}. It is used to
+                                     * to @p wake_up. It is used to
                                      * delete data or save it to disk
                                      * after they are no more needed
                                      * for the present sweep. Typical
@@ -832,7 +832,7 @@ class TimeStepBase : public Subscriptor
                                      * and so on. You should take good care,
                                      * however, not to install large objects,
                                      * which should be deferred until the
-                                     * @p{wake_up} function is called.
+                                     * @p wake_up function is called.
                                      *
                                      * A typical action of this function
                                      * would be sorting out names of
@@ -840,7 +840,7 @@ class TimeStepBase : public Subscriptor
                                      * process of solving, etc.
                                      *
                                      * At the time this function is called,
-                                     * the values of @p{timestep_no}, @p{sweep_no}
+                                     * the values of @p timestep_no, @p sweep_no
                                      * and the pointer to the previous and
                                      * next time step object already have
                                      * their correct value.
@@ -866,7 +866,7 @@ class TimeStepBase : public Subscriptor
                                      * function is called (i.e. before the
                                      * solution takes place on the first
                                      * time level). By default, this function
-                                     * sets the @p{next_action} variable of
+                                     * sets the @p next_action variable of
                                      * this class. You may overload this
                                      * function, but you should call this
                                      * function within your own one.
@@ -890,8 +890,8 @@ class TimeStepBase : public Subscriptor
                                      * manager object when solving the
                                      * primal problem on this time level
                                      * is needed. It is called after
-                                     * the @p{wake_up} function was
-                                     * called and before the @p{sleep}
+                                     * the @p wake_up function was
+                                     * called and before the @p sleep
                                      * function will be called. There
                                      * is no default implementation for
                                      * obvious reasons, so you have
@@ -904,8 +904,8 @@ class TimeStepBase : public Subscriptor
                                      * manager object when solving the
                                      * dual problem on this time level
                                      * is needed. It is called after
-                                     * the @p{wake_up} function was
-                                     * called and before the @p{sleep}
+                                     * the @p wake_up function was
+                                     * called and before the @p sleep
                                      * function will be called. There
                                      * is a default implementation
                                      * doing plain nothing since some
@@ -922,8 +922,8 @@ class TimeStepBase : public Subscriptor
                                      * manager object when postprocessing
                                      * this time level
                                      * is needed. It is called after
-                                     * the @p{wake_up} function was
-                                     * called and before the @p{sleep}
+                                     * the @p wake_up function was
+                                     * called and before the @p sleep
                                      * function will be called. There
                                      * is a default implementation
                                      * doing plain nothing since some
@@ -967,7 +967,7 @@ class TimeStepBase : public Subscriptor
                                      * value to return in that case would
                                      * not be zero, since valid computation
                                      * can be done with that, but would
-                                     * be a denormalized value such as @p{NaN}.
+                                     * be a denormalized value such as @p NaN.
                                      * However, there is not much difference
                                      * in finding that the results of a
                                      * computation are all denormalized values
@@ -1133,7 +1133,7 @@ class TimeStepBase : public Subscriptor
 
 /**
  * Namespace in which some classes are declared that encapsulate flags
- * for the @ref{TimeStepBase_Tria} class. These used to be local data
+ * for the TimeStepBase_Tria() class. These used to be local data
  * types of that class, but some compilers choked on some aspects, so
  * we put them into a namespace of their own.
  *
@@ -1142,7 +1142,7 @@ class TimeStepBase : public Subscriptor
 namespace TimeStepBase_Tria_Flags
 {
 /**
- * This structure is used to tell the @ref{TimeStepBase_Tria} class how grids should
+ * This structure is used to tell the TimeStepBase_Tria() class how grids should
  * be handled. It has flags defining the moments where grids shall be
  * re-made and when they may be deleted. Also, one variable states whether
  * grids should be kept in memory or should be deleted between to uses to
@@ -1169,8 +1169,8 @@ namespace TimeStepBase_Tria_Flags
       
                                       /**
                                        * This flag determines whether
-                                       * the @p{sleep} and
-                                       * @p{wake_up} functions shall
+                                       * the @p sleep and
+                                       * @p wake_up functions shall
                                        * delete and rebuild the
                                        * triangulation.  While for
                                        * small problems, this is not
@@ -1193,19 +1193,19 @@ namespace TimeStepBase_Tria_Flags
 
                                       /**
                                        * This number denotes the
-                                       * parameter to the @p{wake_up}
+                                       * parameter to the @p wake_up
                                        * function at which it shall
                                        * rebuild the grid. Obviously,
                                        * it shall be less than or
-                                       * equal to the @p{look_ahead}
+                                       * equal to the @p look_ahead
                                        * number passed to the time
                                        * step management object; if
                                        * it is equal, then the grid
                                        * is rebuilt the first time
-                                       * the @p{wake_up} function is
+                                       * the @p wake_up function is
                                        * called. If
-                                       * @p{delete_and_rebuild_tria}
-                                       * is @p{false}, this number
+                                       * @p delete_and_rebuild_tria
+                                       * is @p false, this number
                                        * has no meaning.
                                        */
       const unsigned int wakeup_level_to_build_grid;
@@ -1213,7 +1213,7 @@ namespace TimeStepBase_Tria_Flags
                                       /**
                                        * This is the opposite flag to
                                        * the one above: it determines
-                                       * at which call to * @p{sleep}
+                                       * at which call to * @p sleep
                                        * the grid shall be deleted.
                                        */
       const unsigned int sleep_level_to_delete_grid;
@@ -1229,26 +1229,26 @@ namespace TimeStepBase_Tria_Flags
 
 
 /**
- * This structure is used to tell the @ref{TimeStepBase_Tria} class how grids should
+ * This structure is used to tell the TimeStepBase_Tria() class how grids should
  * be refined. Before we explain all the different variables, fist some terminology:
- * @begin{itemize}
- * @item Correction: after having flagged some cells of the triangulation for
+ * <ul>
+ * <li> Correction: after having flagged some cells of the triangulation for
  *   following some given criterion, we may want to change the number of flagged
  *   cells on this grid according to another criterion that the number of cells
  *   may be only a certain fraction more or less then the number of cells on
  *   the previous grid. This change of refinement flags will be called
  *   "correction" in the sequel.
- * @item Adaption: in order to make the change between one grid and the next not
+ * <li> Adaption: in order to make the change between one grid and the next not
  *   to large, we may want to flag some additional cells on one of the two
  *   grids such that there are not too grave differences. This process will
  *   be called "adaption".
- * @end{itemize}
+ * </ul>
  *
  *
  * @sect3{Description of flags}
  *
- * @begin{itemize}
- * @item @p{max_refinement_level}: Cut the refinement of cells at a given level.
+ * <ul>
+ * <li> @p max_refinement_level: Cut the refinement of cells at a given level.
  *   This flag does not influence the flagging of cells, so not more cells
  *   on the coarser levels are flagged than usual. Rather, the flags are all
  *   set, but when it comes to the actual refinement, the maximum refinement
@@ -1258,7 +1258,7 @@ namespace TimeStepBase_Tria_Flags
  *   refinement with adaptive refinement when you don't want the latter
  *   to refine more than the global refinement.
  *
- * @item @p{first_sweep_with_correction}: When using cell number correction
+ * <li> @p first_sweep_with_correction: When using cell number correction
  *   as defined above, it may be worth while to start with this only in
  *   later sweeps, not already in the first one. If this variable is
  *   zero, then start with the first sweep, else with a higher one. The
@@ -1267,21 +1267,21 @@ namespace TimeStepBase_Tria_Flags
  *   the sweeps where we start to be interested in the actual results of
  *   the computations.
  *
- * @item @p{min_cells_for_correction}: If we want a more free process of
+ * <li> @p min_cells_for_correction: If we want a more free process of
  *   grid development, we may want to impose less rules for grids with few
  *   cells also. This variable sets a lower bound for the cell number of
  *   grids where corrections are to be performed.
  *
- * @item @p{cell_number_corridor_top}: Fraction of the number of cells by
+ * <li> @p cell_number_corridor_top: Fraction of the number of cells by
  *   which the number of cells of one grid may be higher than that on the
  *   previous grid. Common values are 10 per cent (i.e. 0.1). The naming
  *   of the variable results from the goal to define a target corridor
  *   for the number of cells after refinement has taken place.
  *
- * @item @p{cell_number_corridor_bottom}: Fraction of the number of cells by
+ * <li> @p cell_number_corridor_bottom: Fraction of the number of cells by
  *   which the number of cells of one grid may be lower than that on the
  *   previous grid. Common values are 5 per cent (i.e. 0.05). Usually this
- *   number will be smaller than @p{cell_number_corridor_top} since an
+ *   number will be smaller than @p cell_number_corridor_top since an
  *   increase of the number of cells is not harmful (though it increases
  *   the numerical amount of work needed to solve the problem) while a
  *   sharp decrease may reduce the accuracy of the final result even if
@@ -1292,8 +1292,8 @@ namespace TimeStepBase_Tria_Flags
  *   direction is reversed, so the two values defining the cell number
  *   corridor should be about equal.
  *
- * @item @p{correction_relaxations}: This is a list of pairs of number with the
- *   following meaning: just as for @p{min_cells_for_correction}, it may be
+ * <li> @p correction_relaxations: This is a list of pairs of number with the
+ *   following meaning: just as for @p min_cells_for_correction, it may be
  *   worth while to reduce the requirements upon grids if the have few cells.
  *   The present variable stores a list of cell numbers along with some values
  *   which tell us that the cell number corridor should be enlarged by a
@@ -1303,17 +1303,17 @@ namespace TimeStepBase_Tria_Flags
  *   are applied, for cell numbers below 200 they are to be multiplied by 3,
  *   and so on.
  *
- *   @p{correction_relaxations} is actually a vector of such list. Each entry
+ *   @p correction_relaxations is actually a vector of such list. Each entry
  *   in this vector denotes the relaxation rules for one sweep. The last
  *   entry defines the relaxation rules for all following sweeps. This
  *   scheme is adopted to allow for stricter corrections in later sweeps
  *   while the relaxations may be more generous in the first sweeps.
  *
- *   There is a static variable @p{default_correction_relaxations} which you
+ *   There is a static variable @p default_correction_relaxations which you
  *   can use as a default value. It is an empty list and thus defines no
  *   relaxations.
  *
- * @item @p{cell_number_correction_steps}: Usually, if you want the number of
+ * <li> @p cell_number_correction_steps: Usually, if you want the number of
  *   cells to be corrected, the target corridor for the cell number is computed
  *   and some additional cells are flagged or flags are removed. But since
  *   the cell number resulting after flagging and deflagging can not be
@@ -1324,7 +1324,7 @@ namespace TimeStepBase_Tria_Flags
  *   regularly. Setting the variable to zero will result in no correction
  *   steps at all.
  *
- * @item @p{mirror_flags_to_previous_grid}: If a cell on the present grid is
+ * <li> @p mirror_flags_to_previous_grid: If a cell on the present grid is
  *   flagged for refinement, also flag the corresponding cell on the previous
  *   grid. This is useful if, for example, error indicators are computed for
  *   space-time cells, but are stored for the second grid only. Now, since the
@@ -1332,7 +1332,7 @@ namespace TimeStepBase_Tria_Flags
  *   may be useful to flag both if necessary. This is done if the present
  *   variable is set.
  *
- * @item @p{adapt_grids}: adapt the present grid to the previous one in the sense
+ * <li> @p adapt_grids: adapt the present grid to the previous one in the sense
  *   defined above. What is actually done here is the following: if going from
  *   the previous to the present grid would result in double refinement or
  *   double coarsening of some cells, then we try to flag these cells for
@@ -1346,7 +1346,7 @@ namespace TimeStepBase_Tria_Flags
  *   by looping iteratively through all grids, back and forth, until nothing
  *   changes anymore, which is obviously impossible if there are many time steps
  *   with very large grids.
- * @end{itemize}
+ * </ul>
  */
   template <int dim>
   struct RefinementFlags
@@ -1507,7 +1507,7 @@ namespace TimeStepBase_Tria_Flags
  * Structure given to the actual refinement function, telling it which
  * thresholds to take for coarsening and refinement. The actual refinement
  * criteria are loaded by calling the virtual function
- * @p{get_tria_refinement_criteria}.
+ * @p get_tria_refinement_criteria.
  */
   template <int dim>
   struct RefinementData 
@@ -1552,11 +1552,11 @@ namespace TimeStepBase_Tria_Flags
 
 
 /**
- * Specialisation of @ref{TimeStepBase} which addresses some aspects of grid handling.
+ * Specialisation of TimeStepBase which addresses some aspects of grid handling.
  * In particular, this class is thought to make handling of grids available that
  * are adaptively refined on each time step separately or with a loose coupling
  * between time steps. It also takes care of deleting and rebuilding grids when
- * memory resources are a point, through the @p{sleep} and @p{wake_up} functions
+ * memory resources are a point, through the @p sleep and @p wake_up functions
  * declared in the base class.
  *
  * In addition to that, it offers functions which do some rather hairy refinement
@@ -1574,7 +1574,7 @@ class TimeStepBase_Tria : public TimeStepBase
   public:
                                     /**
                                      * Typedef the data types of the
-                                     * @ref{TimeStepBase_Tria_Flags}
+                                     * TimeStepBase_Tria_Flags()
                                      * namespace into local scope.
                                      */
     typedef typename TimeStepBase_Tria_Flags::Flags<dim>           Flags;
@@ -1657,15 +1657,15 @@ class TimeStepBase_Tria : public TimeStepBase
                                      * stored to disk, etc. By default,
                                      * this function rebuilds the triangulation
                                      * if the respective flag has been set to
-                                     * destroy it in the @p{sleep} function.
+                                     * destroy it in the @p sleep function.
                                      * It does so also the first time we
-                                     * hit this function and @p{wakeup_level}
+                                     * hit this function and @p wakeup_level
                                      * equals @p{flags.wakeup_level_to_build_grid},
                                      * independently of the value of the
                                      * mentioned flag. (Actually, it does so
                                      * whenever the triangulation pointer
                                      * equals the Null pointer and the
-                                     * value of @p{wakeup_level} is right.)
+                                     * value of @p wakeup_level is right.)
                                      *
                                      * Since this is an important task, you
                                      * should call this function from your
@@ -1680,7 +1680,7 @@ class TimeStepBase_Tria : public TimeStepBase
 
                                     /**
                                      * This is the opposite function
-                                     * to @p{wake_up}. It is used to
+                                     * to @p wake_up. It is used to
                                      * delete data or save it to disk
                                      * after they are no more needed
                                      * for the present sweep. Typical
@@ -1696,7 +1696,7 @@ class TimeStepBase_Tria : public TimeStepBase
                                      * in the flags for this object, the
                                      * triangulation is deleted and the
                                      * refinement history saved such that
-                                     * the respective @p{wake_up} function can
+                                     * the respective @p wake_up function can
                                      * rebuild it. You should therefore call
                                      * this function from your overloaded
                                      * version, preferrably at the end so
@@ -1733,8 +1733,8 @@ class TimeStepBase_Tria : public TimeStepBase
                                      * Respective init function for the
                                      * refinement loop; does nothing in
                                      * the default implementation, apart from
-                                     * setting @p{next_action} to
-                                     * @p{grid_refinement} but can
+                                     * setting @p next_action to
+                                     * @p grid_refinement but can
                                      * be overloaded.
                                      */
     virtual void init_for_refinement ();
@@ -1743,7 +1743,7 @@ class TimeStepBase_Tria : public TimeStepBase
                                      * Virtual function that should fill
                                      * the vector with the refinement
                                      * criteria for the present triangulation.
-                                     * It is used within the @p{refine_grid}
+                                     * It is used within the @p refine_grid
                                      * function to get the criteria for
                                      * the present time step, since they
                                      * can't be passed through its
@@ -1792,10 +1792,10 @@ class TimeStepBase_Tria : public TimeStepBase
                                      * base class. Note that the
                                      * triangulation is frequently
                                      * deleted and rebuilt by the
-                                     * functions @p{sleep} and
-                                     * @p{wake_up} to save memory, if
+                                     * functions @p sleep and
+                                     * @p wake_up to save memory, if
                                      * such a behaviour is specified
-                                     * in the @p{flags} structure.
+                                     * in the @p flags structure.
                                      */
     Triangulation<dim>       *tria;
 
index 8eca6dce517c2ce0ffb26604529551eabc362282..fc75dee92b409c66c391e44f37a59b60305d74f5 100644 (file)
@@ -133,7 +133,7 @@ class ConstraintMatrix;
  *
  *   The selection whether the projection to the boundary first is
  *   needed is done with the <tt>project_to_boundary_first</tt> flag
- *   passed to the function.  If @p{false} is given, the additional
+ *   passed to the function.  If @p false is given, the additional
  *   quadrature formula for faces is ignored.
  *
  *   You should be aware of the fact that if no projection to the boundary
@@ -142,22 +142,22 @@ class ConstraintMatrix;
  *   important case, which tells the function to enforce zero boundary values
  *   on the respective boundary parts. Since enforced zero boundary values
  *   could also have been reached through projection, but are more economically
- *   obtain using other methods, the @p{project_to_boundary_first} flag is
- *   ignored if the @p{enforce_zero_boundary} flag is set.
+ *   obtain using other methods, the @p project_to_boundary_first flag is
+ *   ignored if the @p enforce_zero_boundary flag is set.
  *
  *   The solution of the linear system is presently done using a simple CG
  *   method without preconditioning and without multigrid. This is clearly not
  *   too efficient, but sufficient in many cases and simple to implement. This
  *   detail may change in the future.
  *
- * @item Creation of right hand side vectors:
- *   The @p{create_right_hand_side} function computes the vector
+ * <li> Creation of right hand side vectors:
+ *   The @p create_right_hand_side function computes the vector
  *   $f_i = \int_\Omega f(x) \phi_i(x) dx$. This is the same as what the
- *   @ref{MatrixCreator}@p{::create_*} functions which take a right hand side do,
+ *   MatrixCreator@p{::create_*} functions which take a right hand side do,
  *   but without assembling a matrix.
  *
- * @item Creation of boundary right hand side vectors: The
- *   @p{create_boundary_right_hand_side} function computes the vector
+ * <li> Creation of boundary right hand side vectors: The
+ *   @p create_boundary_right_hand_side function computes the vector
  *   $f_i = \int_{\partial\Omega} g(x) \phi_i(x) dx$. This is the
  *   right hand side contribution of boundary forces when having
  *   inhomogeneous Neumann boundary values in Laplace's equation or
@@ -165,13 +165,13 @@ class ConstraintMatrix;
  *   optional argument denoting over which parts of the boundary the
  *   integration shall extend.
  *
- * @item Interpolation of boundary values:
- *   The @ref{MatrixTools}@p{::apply_boundary_values} function takes a list
+ * <li> Interpolation of boundary values:
+ *   The MatrixTools@p ::apply_boundary_values function takes a list
  *   of boundary nodes and their values. You can get such a list by interpolation
- *   of a boundary function using the @p{interpolate_boundary_values} function.
+ *   of a boundary function using the @p interpolate_boundary_values function.
  *   To use it, you have to
  *   specify a list of pairs of boundary indicators (of type @p{unsigned char};
- *   see the section in the documentation of the @ref{Triangulation} class for more
+ *   see the section in the documentation of the Triangulation class for more
  *   details) and the according functions denoting the dirichlet boundary values
  *   of the nodes on boundary faces with this boundary indicator.
  *
@@ -182,7 +182,7 @@ class ConstraintMatrix;
  *   Within this function, boundary values are interpolated, i.e. a node is given
  *   the point value of the boundary function. In some cases, it may be necessary
  *   to use the L2-projection of the boundary function or any other method. For
- *   this purpose we refer to the @ref{VectorTools}@p{::project_boundary_values}
+ *   this purpose we refer to the VectorTools@p ::project_boundary_values
  *   function below.
  *
  *   You should be aware that the boundary function may be evaluated at nodes
@@ -200,45 +200,45 @@ class ConstraintMatrix;
  *   index 1 in the map. The respective boundary functions are then evaluated at
  *   the place of the respective boundary point.
  *
- * @item Projection of boundary values:
- *   The @p{project_boundary_values} function acts similar to the
- *   @p{interpolate_boundary_values} function, apart from the fact that it does
+ * <li> Projection of boundary values:
+ *   The @p project_boundary_values function acts similar to the
+ *   @p interpolate_boundary_values function, apart from the fact that it does
  *   not get the nodal values of boundary nodes by interpolation but rather
  *   through the <i>L<sup>2</sup></i>-projection of the trace of the function to the boundary.
  *
  *   The projection takes place on all boundary parts with boundary
- *   indicators listed in the map (@ref{FunctioMap}@p{::FunctionMap})
+ *   indicators listed in the map (FunctioMap@p ::FunctionMap)
  *   of boundary functions. These boundary parts may or may not be
  *   continuous. For these boundary parts, the mass matrix is
  *   assembled using the
- *   @ref{MatrixTools}@p{::create_boundary_mass_matrix} function, as
+ *   MatrixTools@p ::create_boundary_mass_matrix function, as
  *   well as the appropriate right hand side. Then the resulting
  *   system of equations is solved using a simple CG method (without
  *   preconditioning), which is in most cases sufficient for the
  *   present purpose.
  *
- * @item Computing errors:
- *   The function @p{integrate_difference} performs the calculation of the error
+ * <li> Computing errors:
+ *   The function @p integrate_difference performs the calculation of the error
  *   between the finite element solution and a given (continuous) reference
  *   function in different norms. The integration is performed using a given
  *   quadrature formulae and assumes that the given finite element objects equals
  *   that used for the computation of the solution.
  * 
- *   The result is stored in a vector (named @p{difference}), where each entry
+ *   The result is stored in a vector (named @p difference), where each entry
  *   equals the given norm of the difference on a cell. The order of entries
- *   is the same as a @p{cell_iterator} takes when started with @p{begin_active} and
+ *   is the same as a @p cell_iterator takes when started with @p begin_active and
  *   promoted with the @p{++} operator.
  * 
- *   You can use the @p{distribute_cell_to_dof_vector} function of the
- *   @ref{DoFHandler} class to convert cell based data to a data
+ *   You can use the @p distribute_cell_to_dof_vector function of the
+ *   DoFHandler class to convert cell based data to a data
  *   vector with values on the degrees of freedom, which can then be
- *   added to a @ref{DataOut} object to be printed. But also you can
- *   add a cell based data vector itself to a @ref{DataOut} object,
- *   see the @p{DataOut::add_data_vector} functions.
+ *   added to a DataOut object to be printed. But also you can
+ *   add a cell based data vector itself to a DataOut object,
+ *   see the @p DataOut::add_data_vector functions.
  * 
  *   Presently, there is the possibility to compute the following values from the
- *   difference, on each cell: @p{mean}, @p{L1_norm}, @p{L2_norm}, @p{Linfty_norm},
- *   @p{H1_seminorm} and @p{H1_norm}, see @p{VectorTools::NormType}.
+ *   difference, on each cell: @p mean, @p L1_norm, @p L2_norm, @p Linfty_norm,
+ *   @p H1_seminorm and @p H1_norm, see @p VectorTools::NormType.
  *   For the mean difference value, the reference function minus the numerical
  *   solution is computed, not the other way round.
  *
@@ -267,24 +267,24 @@ class ConstraintMatrix;
  *   and the square of the <i>L<sup>2</sup></i> norm.
  * 
  *   To get the global <i>L<sup>1</sup></i> error, you have to sum up the
- *   entries in @p{difference}, e.g. using
- *   @ref{Vector}@p{<double>::l1_norm} function.  For the global <i>L<sup>2</sup></i>
+ *   entries in @p difference, e.g. using
+ *   Vector@p{<double>::l1_norm} function.  For the global <i>L<sup>2</sup></i>
  *   difference, you have to sum up the squares of the entries and
  *   take the root of the sum, e.g. using
- *   @ref{Vector}@p{<double>::l2_norm}.  These two operations
+ *   Vector@p{<double>::l2_norm}.  These two operations
  *   represent the $l_1$ and $l_2$ norms of the vectors, but you need
  *   not take the absolute value of each entry, since the cellwise
  *   norms are already positive.
  *  
  *   To get the global mean difference, simply sum up the elements as above.
  *   To get the $L_\infty$ norm, take the maximum of the vector elements, e.g.
- *   using the @ref{Vector}@p{<double>::linfty_norm} function.
+ *   using the Vector@p{<double>::linfty_norm} function.
  *
  *   For the global <i>H<sup>1</sup></i> norm and seminorm, the same rule applies as for the
  *   <i>L<sup>2</sup></i> norm: compute the $l_2$ norm of the cell error vector.
- * @end{itemize}
+ * </ul>
  *
- * All functions use the finite element given to the @ref{DoFHandler} object the last
+ * All functions use the finite element given to the DoFHandler object the last
  * time that the degrees of freedom were distributed over the triangulation. Also,
  * if access to an object describing the exact form of the boundary is needed, the
  * pointer stored within the triangulation object is accessed.
@@ -365,18 +365,18 @@ class VectorTools
     
                                     /**
                                      * Compute the interpolation of
-                                     * @p{function} at the support
+                                     * @p function at the support
                                      * points to the finite element
                                      * space. It is assumed that the
                                      * number of components of
-                                     * @p{function} matches that of
+                                     * @p function matches that of
                                      * the finite element used by
-                                     * @p{dof}.
+                                     * @p dof.
                                      *
                                      * Note that you may have to call
                                      * @p{hanging_nodes.distribute(vec)}
                                      * with the hanging nodes from
-                                     * space @p{dof} afterwards, to
+                                     * space @p dof afterwards, to
                                      * make the result continuous
                                      * again.
                                      *
@@ -391,7 +391,7 @@ class VectorTools
                             VECTOR                &vec);
     
                                     /**
-                                     * Calls the @p{interpolate}
+                                     * Calls the @p interpolate
                                      * function above with
                                      * <tt>mapping=MappingQ1@<dim>@()</tt>.
                                      */
@@ -404,19 +404,19 @@ class VectorTools
                                      * Interpolate different finite
                                      * element spaces. The
                                      * interpolation of vector
-                                     * @p{data_1} is executed from the
+                                     * @p data_1 is executed from the
                                      * FE space represented by
-                                     * @p{dof_1} to the vector @p{data_2}
-                                     * on FE space @p{dof_2}. The
+                                     * @p dof_1 to the vector @p data_2
+                                     * on FE space @p dof_2. The
                                      * interpolation on each cell is
                                      * represented by the matrix
-                                     * @p{transfer}. Curved boundaries
+                                     * @p transfer. Curved boundaries
                                      * are neglected so far.
                                      *
                                      * Note that you may have to call
                                      * @p{hanging_nodes.distribute(data_2)}
                                      * with the hanging nodes from
-                                     * space @p{dof_2} afterwards, to
+                                     * space @p dof_2 afterwards, to
                                      * make the result continuous
                                      * again.
                                      */
@@ -429,7 +429,7 @@ class VectorTools
                          
                                     /**
                                      * Compute the projection of
-                                     * @p{function} to the finite element space.
+                                     * @p function to the finite element space.
                                      *
                                      * By default, projection to the boundary
                                      * and enforcement of zero boundary values
@@ -445,9 +445,9 @@ class VectorTools
                                      * space on the present grid. To
                                      * this end, the mass matrix is
                                      * assembled exactly using the
-                                     * @p{create_mass_matrix}
+                                     * @p create_mass_matrix
                                      * function in the
-                                     * @ref{MatrixTools}
+                                     * MatrixTools
                                      * collection. This function
                                      * performs numerical quadrature
                                      * using the given quadrature
@@ -492,7 +492,7 @@ class VectorTools
                         const bool                project_to_boundary_first = false);
     
                                     /**
-                                     * Calls the @p{project}
+                                     * Calls the @p project
                                      * function, see above, with
                                      * @p{mapping=MappingQ1@<dim@>()}.
                                      */
@@ -509,7 +509,7 @@ class VectorTools
                                     /**
                                      * Create a right hand side
                                      * vector. Prior content of the
-                                     * given @p{rhs_vector} vector is
+                                     * given @p rhs_vector vector is
                                      * deleted.
                                      *
                                      * See the general documentation of this
@@ -523,7 +523,7 @@ class VectorTools
                                        Vector<double>        &rhs_vector);
     
                                     /**
-                                     * Calls the @p{create_right_hand_side}
+                                     * Calls the @p create_right_hand_side
                                      * function, see above, with
                                      * @p{mapping=MappingQ1@<dim@>()}.
                                      */
@@ -537,7 +537,7 @@ class VectorTools
                                      * Create a right hand side
                                      * vector from boundary
                                      * forces. Prior content of the
-                                     * given @p{rhs_vector} vector is
+                                     * given @p rhs_vector vector is
                                      * deleted.
                                      *
                                      * See the general documentation of this
@@ -567,7 +567,7 @@ class VectorTools
     
                                     /**
                                      * Calls the
-                                     * @p{create_boundary_right_hand_side}
+                                     * @p create_boundary_right_hand_side
                                      * function, see above, with
                                      * @p{mapping=MappingQ1@<dim@>()}.
                                      */
@@ -587,7 +587,7 @@ class VectorTools
                                      * be assigned to them, by
                                      * interpolation around the
                                      * boundary. If the
-                                     * @p{boundary_values} contained
+                                     * @p boundary_values contained
                                      * values before, the new ones
                                      * are added, or the old ones
                                      * overwritten if a node of the
@@ -596,15 +596,15 @@ class VectorTools
                                      * map of boundary values.
                                      *
                                      * The parameter
-                                     * @p{boundary_component}
+                                     * @p boundary_component
                                      * corresponds to the number
-                                     * @p{boundary_indicator} of the
+                                     * @p boundary_indicator of the
                                      * face.  255 is an illegal
                                      * value, since it is reserved
                                      * for interior faces.
                                      *
                                      * The flags in the last
-                                     * parameter, @p{component_mask}
+                                     * parameter, @p component_mask
                                      * denote which components of the
                                      * finite element space shall be
                                      * interpolated. If it is left as
@@ -625,9 +625,9 @@ class VectorTools
                                      *
                                      * It is assumed that the number
                                      * of components of the function
-                                     * in @p{boundary_function} matches that
+                                     * in @p boundary_function matches that
                                      * of the finite element used by
-                                     * @p{dof}.
+                                     * @p dof.
                                      *
                                      * If the finite element used has
                                      * shape functions that are
@@ -641,7 +641,7 @@ class VectorTools
                                      * corresponding to the
                                      * components of these
                                      * non-primitive shape functions
-                                     * must be @p{false}.
+                                     * must be @p false.
                                      *
                                      * See the general doc for more
                                      * information.
@@ -698,7 +698,7 @@ class VectorTools
     
                                     /**
                                      * Calls the other
-                                     * @p{interpolate_boundary_values}
+                                     * @p interpolate_boundary_values
                                      * function, see above, with
                                      * @p{mapping=MappingQ1@<dim@>()}.
                                      */
@@ -711,7 +711,7 @@ class VectorTools
 
                                     /**
                                      * Calls the other
-                                     * @p{interpolate_boundary_values}
+                                     * @p interpolate_boundary_values
                                      * function, see above, with
                                      * @p{mapping=MappingQ1@<dim@>()}.
                                      */
@@ -723,10 +723,10 @@ class VectorTools
 
     
                                     /**
-                                     * Project @p{function} to the boundary
+                                     * Project @p function to the boundary
                                      * of the domain, using the given quadrature
                                      * formula for the faces. If the
-                                     * @p{boundary_values} contained values
+                                     * @p boundary_values contained values
                                      * before, the new ones are added, or
                                      * the old one overwritten if a node
                                      * of the boundary part to be projected
@@ -734,9 +734,9 @@ class VectorTools
                                      *
                                      * It is assumed that the number
                                      * of components of
-                                     * @p{boundary_function}
+                                     * @p boundary_function
                                      * matches that of the finite
-                                     * element used by @p{dof}.
+                                     * element used by @p dof.
                                      *
                                      * See the general documentation of this
                                      * class for further information.
@@ -763,7 +763,7 @@ class VectorTools
                                         std::map<unsigned int,double> &boundary_values);
     
                                     /**
-                                     * Calls the @p{project_boundary_values}
+                                     * Calls the @p project_boundary_values
                                      * function, see above, with
                                      * @p{mapping=MappingQ1@<dim@>()}.
                                      */
@@ -781,12 +781,12 @@ class VectorTools
                                      * is given as a continuous function
                                      * object.
                                      *
-                                     * The value of @p{exponent} is
+                                     * The value of @p exponent is
                                      * used for computing $L^p$-norms
                                      * and $W^{1,p}$-norms.
                                      *
                                      * The additional argument
-                                     * @p{weight} allows to evaluate
+                                     * @p weight allows to evaluate
                                      * weighted norms.  The weight
                                      * function may be
                                      * one-dimensional, establishing
@@ -811,9 +811,9 @@ class VectorTools
                                      *
                                      * It is assumed that the number
                                      * of components of the function
-                                     * @p{exact_solution} matches that
+                                     * @p exact_solution matches that
                                      * of the finite element used by
-                                     * @p{dof}.
+                                     * @p dof.
                                      *
                                      * See the general documentation of this
                                      * class for more information.
@@ -830,7 +830,7 @@ class VectorTools
                                      const double exponent = 2.);
 
                                     /**
-                                     * Calls the @p{integrate_difference}
+                                     * Calls the @p integrate_difference
                                      * function, see above, with
                                      * @p{mapping=MappingQ1@<dim@>()}.
                                      */
@@ -882,7 +882,7 @@ class VectorTools
                                      * value zero. The mean value is
                                      * understood in the l1-sense.
                                      *
-                                     * Apart from the vector @p{v} to
+                                     * Apart from the vector @p v to
                                      * operate on, this function
                                      * takes a bit vector. This has a
                                      * true entry for every component
@@ -927,7 +927,7 @@ class VectorTools
                                      const unsigned int     component);
     
                                     /**
-                                     * Calls the @p{compute_mean_value}
+                                     * Calls the @p compute_mean_value
                                      * function, see above, with
                                      * @p{mapping=MappingQ1@<dim@>()}.
                                      */
index 9e71807e9e9b6b7e26c2e3e8c14d994eb8d60e09..b8736360f35b5d01db9e83bdf34d13a85dbdb042 100644 (file)
@@ -36,7 +36,7 @@ class BlockIndices
                                     /**
                                      * Default
                                      * constructor. Initialize for
-                                     * @p{n_blocks} blocks and set
+                                     * @p n_blocks blocks and set
                                      * all block sizes to zero.
                                      */
     BlockIndices (const unsigned int n_blocks = 0);
@@ -44,7 +44,7 @@ class BlockIndices
                                     /**
                                      * Constructor. Initialize the
                                      * number of entries in each
-                                     * block @p{i} as @p{n[i]}. The
+                                     * block @p i as @p{n[i]}. The
                                      * number of blocks will be the
                                      * size of the vector
                                      */
@@ -63,8 +63,8 @@ class BlockIndices
                                      * indices within each block from
                                      * the given argument. The number
                                      * of blocks will be adjusted to
-                                     * the size of @p{n} and the size
-                                     * of block @p{i} is set to
+                                     * the size of @p n and the size
+                                     * of block @p i is set to
                                      * @p{n[i]}.
                                      */
     inline void reinit (const std::vector<unsigned int> &n);
@@ -72,7 +72,7 @@ class BlockIndices
                                     /**
                                      * Return the block and the
                                      * index within that block
-                                     * for the global index @p{i}. The
+                                     * for the global index @p i. The
                                      * first element of the pair is
                                      * the block, the second the
                                      * index within it.
@@ -82,7 +82,7 @@ class BlockIndices
 
                                     /**
                                      * Return the global index of
-                                     * @p{index} in block @p{block}.
+                                     * @p index in block @p block.
                                      */
     unsigned int local_to_global (const unsigned int block,
                                  const unsigned int index) const;
@@ -102,7 +102,7 @@ class BlockIndices
     inline unsigned int total_size () const;
 
                                     /**
-                                     * Return the size of the @p{i}th
+                                     * Return the size of the @p ith
                                      * block.
                                      */
     unsigned int block_size (const unsigned int i) const;
@@ -313,7 +313,7 @@ BlockIndices::memory_consumption () const
 
 
 /**
- * Global function @p{swap} which overloads the default implementation
+ * Global function @p swap which overloads the default implementation
  * of the C++ standard library which uses a temporary object. The
  * function simply exchanges the data of the two objects.
  *
index 47c43cda79107b824a2c565a4d71eb0504f30868..5aac2c23d9d37de88300dd9d573d41005dd6d9bd 100644 (file)
 /**
  * A matrix with several copies of the same block on the diagonal.
  *
- * This matrix implements an @p{m} by @p{m} block matrix. Each
+ * This matrix implements an @p m by @p m block matrix. Each
  * diagonal block consists of the same (non-block) matrix, while
  * off-diagonal blocks are void.
  *
  * One special application is a one by one block matrix, allowing to
- * apply the @p{vmult} of the original matrix (or preconditioner) to a
+ * apply the @p vmult of the original matrix (or preconditioner) to a
  * block vector.
  *
  * @author Guido Kanschat, 2000
@@ -41,9 +41,9 @@ class BlockDiagonalMatrix : public Subscriptor
 {
   public:
                                      /**
-                                      * Constructor for an @p{n_blocks}
-                                      * by @p{n_blocks} matrix with
-                                      * diagonal blocks @p{M}.
+                                      * Constructor for an @p n_blocks
+                                      * by @p n_blocks matrix with
+                                      * diagonal blocks @p M.
                                       */
     BlockDiagonalMatrix (const MATRIX       &M,
                          const unsigned int  n_blocks);
index 2383ee10b077cc2b3a1d84c298d7e548f139ab51..10b86238469d8054cd2371f6403de5c2c572d120 100644 (file)
@@ -41,21 +41,21 @@ template <typename> class Vector;
 /**
  * Block matrix composed of different single matrices.
  *
- * Given a set of arbitrary matrices @p{A_i}, this class implements a
+ * Given a set of arbitrary matrices @p A_i, this class implements a
  * block matrix with block entries of the form @p{M_{jk} = s_{jk}A_i}.
- * Each @p{A_i} may be used several times with different prefix.
+ * Each @p A_i may be used several times with different prefix.
  *
- * Non-zero entries are registered by the function @p{enter}, zero
- * entries are not stored at all. Using @p{enter} with the same
+ * Non-zero entries are registered by the function @p enter, zero
+ * entries are not stored at all. Using @p enter with the same
  * location @p{(i,j)} several times will add the corresponding
  * matrices in matrix-vector multiplications.
  *
  * @sect3{Requirements}
  *
- * The template argument @p{MATRIX} is a class providing the the
- * matrix-vector multiplication functions @p{vmult} etc. defined in
- * this class, but with arguments of type @p{VECTOR} instead of
- * @p{BlockVector<VECTOR>}. @ref{SparseMatrix} is a possible entry
+ * The template argument @p MATRIX is a class providing the the
+ * matrix-vector multiplication functions @p vmult etc. defined in
+ * this class, but with arguments of type @p VECTOR instead of
+ * @p{BlockVector<VECTOR>}. SparseMatrix is a possible entry
  * type.
  *
  * @author Guido Kanschat, 2000, 2001
@@ -106,7 +106,7 @@ class BlockMatrixArray : public Subscriptor
   
                                     /**
                                      * Matrix-vector multiplication
-                                     * adding to @p{dst}.
+                                     * adding to @p dst.
                                      */
     template <class number>
     void vmult_add (BlockVector<number>& dst,
@@ -123,7 +123,7 @@ class BlockMatrixArray : public Subscriptor
                                     /**
                                      * Transposed matrix-vector
                                      * multiplication adding to
-                                     * @p{dst}.
+                                     * @p dst.
                                      */
     template <class number>
     void Tvmult_add (BlockVector<number>& dst,
@@ -140,7 +140,7 @@ class BlockMatrixArray : public Subscriptor
                                      * Internal data structure.
                                      *
                                      * For each entry of a
-                                     * @p{BlockMatrixArray}, its
+                                     * @p BlockMatrixArray, its
                                      * position, matrix, prefix and
                                      * optional transposition must be
                                      * stored. This structure
@@ -222,12 +222,12 @@ class BlockMatrixArray : public Subscriptor
  * matrix. Then, forward or backward insertion is performed
  * block-wise. The diagonal blocks are NOT inverted for this purpose!
  *
- * While block indices may be duplicated (see @ref{BlockMatrixArray})
+ * While block indices may be duplicated (see BlockMatrixArray)
  * to add blocks, this is not allowed on the diagonal. A short
  * computation reveals why.
  *
  * Like for all preconditioners, the preconditioning operation is
- * performed by the @p{vmult} member function.
+ * performed by the @p vmult member function.
  *
  * The implementation may be a little clumsy, but it should be
  * sufficient as long as the block sizes are much larger than the
@@ -258,7 +258,7 @@ class BlockTrianglePrecondition : private BlockMatrixArray<MATRIX>
   
                                     /**
                                      * Preconditioning
-                                     * adding to @p{dst}.
+                                     * adding to @p dst.
                                      */
     template <class number>
     void vmult_add (BlockVector<number>& dst,
@@ -273,7 +273,7 @@ class BlockTrianglePrecondition : private BlockMatrixArray<MATRIX>
   
                                     /**
                                      * Transposed preconditioning
-                                     * adding to @p{dst}.
+                                     * adding to @p dst.
                                      */
     template <class number>
     void Tvmult_add (BlockVector<number>& dst,
index 7b3cb813f0c255845aaae89c7974b296d312df67..6100e0bd713f5c6c457cbf3ae090e7e54c335998 100644 (file)
@@ -865,7 +865,7 @@ class BlockSparseMatrix : public Subscriptor
                                      * matrix. In order to guarantee
                                      * that it is not deleted while
                                      * still in use, we subscribe to
-                                     * it using the @p{SmartPointer}
+                                     * it using the @p SmartPointer
                                      * class.
                                      */
     SmartPointer<const BlockSparsityPattern> sparsity_pattern;
index d2e72be057aaab66f9f101d37c00d78f64fbfdad..17b6dfdca5eade977a61a93c1c1a47a227a61733 100644 (file)
@@ -30,11 +30,11 @@ template <typename Number> class BlockVector;
 
 
 /**
- * A block matrix consisting of blocks of type @p{SparseMatrixEZ}.
+ * A block matrix consisting of blocks of type @p SparseMatrixEZ.
  *
  * Like the other Block-objects, this matrix can be used like a
- * @p{SparseMatrixEZ}, when it comes to access to entries. Then, there
- * are functions for the multiplication with @p{BlockVector} and
+ * @p SparseMatrixEZ, when it comes to access to entries. Then, there
+ * are functions for the multiplication with @p BlockVector and
  * access to the individual blocks.
  *
  * @author Guido Kanschat, 2002, 2003
@@ -67,7 +67,7 @@ class BlockSparseMatrixEZ : public Subscriptor
                                      * of the same number of block
                                      * rows and columns. Since it
                                      * calls the copy constructor of
-                                     * @ref{SparseMatrixEZ}, the
+                                     * SparseMatrixEZ, the
                                      * block s must be empty.
                                      */
     BlockSparseMatrixEZ (const BlockSparseMatrixEZ<Number>&);
@@ -96,7 +96,7 @@ class BlockSparseMatrixEZ : public Subscriptor
                                      * initialized
                                      * subsequently. After setting
                                      * the sizes of the blocks,
-                                     * @ref{collect_sizes} must be
+                                     * collect_sizes() must be
                                      * called to update internal data
                                      * structures.
                                      */
@@ -196,7 +196,7 @@ class BlockSparseMatrixEZ : public Subscriptor
 
                                     /**
                                      * Set the element @p{(i,j)} to
-                                     * @p{value}.  Throws an error if
+                                     * @p value.  Throws an error if
                                      * the entry does not
                                      * exist. Still, it is allowed to
                                      * store zero values in
@@ -207,7 +207,7 @@ class BlockSparseMatrixEZ : public Subscriptor
              const Number value);
     
                                     /**
-                                     * Add @p{value} to the element
+                                     * Add @p value to the element
                                      * @p{(i,j)}.  Throws an error if
                                      * the entry does not
                                      * exist. Still, it is allowed to
@@ -232,7 +232,7 @@ class BlockSparseMatrixEZ : public Subscriptor
                                      * let $dst = M^T*src$ with $M$
                                      * being this matrix. This
                                      * function does the same as
-                                     * @p{vmult} but takes the
+                                     * @p vmult but takes the
                                      * transposed matrix.
                                      */
     template <typename somenumber>
@@ -254,7 +254,7 @@ class BlockSparseMatrixEZ : public Subscriptor
                                      * multiplication. Add $M^T*src$
                                      * to $dst$ with $M$ being this
                                      * matrix. This function does the
-                                     * same as @p{vmult_add} but takes
+                                     * same as @p vmult_add but takes
                                      * the transposed matrix.
                                      */
     template <typename somenumber>
@@ -263,8 +263,8 @@ class BlockSparseMatrixEZ : public Subscriptor
 
     
                                     /**
-                                     * Print statistics. If @p{full}
-                                     * is @p{true}, prints a
+                                     * Print statistics. If @p full
+                                     * is @p true, prints a
                                      * histogram of all existing row
                                      * lengths and allocated row
                                      * lengths. Otherwise, just the
index 77fb0726fc5c891d9c9a43dc22687a44a5ab5192..c1d1e1ca0735d8f6847cc5687f6f0daad0b379ca 100644 (file)
@@ -38,13 +38,13 @@ class CompressedBlockSparsityPattern;
  * and compressed sparsity pattern classes. It has not much
  * functionality, but only administrates an array of sparsity pattern
  * objects and delegates work to them. It has mostly the same
- * interface as has the @ref{SparsityPattern} and
- * @ref{CompressedSparsityPattern} classes, and simply transforms
+ * interface as has the SparsityPattern and
+ * CompressedSparsityPattern classes, and simply transforms
  * calls to its member functions to calls to the respective member
  * functions of the member sparsity patterns.
  *
- * The largest difference between the @ref{SparsityPattern} and
- * @ref{CompressedSparsityPattern} classes and this class is that
+ * The largest difference between the SparsityPattern and
+ * CompressedSparsityPattern classes and this class is that
  * mostly, the matrices have different properties and you will want to
  * work on the blocks making up the matrix rather than the whole
  * matrix. You can access the different blocks using the
@@ -70,14 +70,14 @@ class BlockSparsityPatternBase : public Subscriptor
                                     /**
                                      * Define a value which is used
                                      * to indicate that a certain
-                                     * value in the @p{colnums} array
+                                     * value in the @p colnums array
                                      * is unused, i.e. does not
                                      * represent a certain column
                                      * number index.
                                      *
                                      * This value is only an alias to
                                      * the respective value of the
-                                     * @p{SparsityPattern} class.
+                                     * @p SparsityPattern class.
                                      */
     static const unsigned int invalid_entry = SparsityPattern::invalid_entry;
     
@@ -89,7 +89,7 @@ class BlockSparsityPatternBase : public Subscriptor
                                      * member variables in other
                                      * classes. You can make the
                                      * structure usable by calling
-                                     * the @p{reinit} function.
+                                     * the @p reinit function.
                                      */
     BlockSparsityPatternBase ();
 
@@ -98,7 +98,7 @@ class BlockSparsityPatternBase : public Subscriptor
                                      * given number of block rows and
                                      * columns. The blocks themselves
                                      * are still empty, and you have
-                                     * to call @p{collect_sizes} after
+                                     * to call @p collect_sizes after
                                      * you assign them sizes.
                                      */
     BlockSparsityPatternBase (const unsigned int n_block_rows,
@@ -112,7 +112,7 @@ class BlockSparsityPatternBase : public Subscriptor
                                      * are no block allocated at
                                      * present. This is for the same
                                      * reason as for the
-                                     * @p{SparsityPattern}, see there
+                                     * @p SparsityPattern, see there
                                      * for the details.
                                      */
     BlockSparsityPatternBase (const BlockSparsityPatternBase &bsp);
@@ -130,10 +130,10 @@ class BlockSparsityPatternBase : public Subscriptor
                                      * unitialized ones, i.e. ones
                                      * for which also the sizes are
                                      * not yet set. You have to do
-                                     * that by calling the @p{reinit}
+                                     * that by calling the @p reinit
                                      * functions of the blocks
                                      * themselves. Do not forget to
-                                     * call @p{collect_sizes} after
+                                     * call @p collect_sizes after
                                      * that on this object.
                                      *
                                      * The reason that you have to
@@ -143,7 +143,7 @@ class BlockSparsityPatternBase : public Subscriptor
                                      * of elements per row may be
                                      * varying, etc. It is simpler
                                      * not to reproduce the interface
-                                     * of the @p{SparsityPattern}
+                                     * of the @p SparsityPattern
                                      * class here but rather let the
                                      * user call whatever function
                                      * she desires.
@@ -215,7 +215,7 @@ class BlockSparsityPatternBase : public Subscriptor
                                      * This function compresses the
                                      * sparsity structures that this
                                      * object represents. It simply
-                                     * calls @p{compress} for all
+                                     * calls @p compress for all
                                      * sub-objects.
                                      */
     void compress ();
@@ -397,8 +397,8 @@ class BlockSparsityPatternBase : public Subscriptor
                                     /**
                                      * Make the block sparse matrix a
                                      * friend, so that it can use our
-                                     * @p{row_indices} and
-                                     * @p{column_indices} objects.
+                                     * @p row_indices and
+                                     * @p column_indices objects.
                                      */
     template <typename number>
     friend class BlockSparseMatrix;
@@ -426,7 +426,7 @@ class BlockSparsityPattern : public BlockSparsityPatternBase<SparsityPattern>
                                      * member variables in other
                                      * classes. You can make the
                                      * structure usable by calling
-                                     * the @p{reinit} function.
+                                     * the @p reinit function.
                                      */
     BlockSparsityPattern ();
 
@@ -435,7 +435,7 @@ class BlockSparsityPattern : public BlockSparsityPatternBase<SparsityPattern>
                                      * given number of block rows and
                                      * columns. The blocks themselves
                                      * are still empty, and you have
-                                     * to call @p{collect_sizes} after
+                                     * to call @p collect_sizes after
                                      * you assign them sizes.
                                      */
     BlockSparsityPattern (const unsigned int n_rows,
@@ -459,7 +459,7 @@ class BlockSparsityPattern : public BlockSparsityPatternBase<SparsityPattern>
                                     /**
                                      * Copy data from an object of
                                      * type
-                                     * @ref{CompressedBlockSparsityPattern},
+                                     * CompressedBlockSparsityPattern,
                                      * i.e. resize this object to the
                                      * size of the given argument,
                                      * and copy over the contents of
@@ -475,8 +475,8 @@ class BlockSparsityPattern : public BlockSparsityPatternBase<SparsityPattern>
 /**
  * This class extends the base class to implement an array of
  * compressed sparsity patterns that can be used to initialize objects
- * of type @ref{BlockSparsityPattern}. It does not add additional
- * member functions, but rather acts as a @p{typedef} to introduce the
+ * of type BlockSparsityPattern. It does not add additional
+ * member functions, but rather acts as a @p typedef to introduce the
  * name of this class, without requiring the user to specify the
  * templated name of the base class. For information on the interface
  * of this class refer to the base class.
@@ -495,7 +495,7 @@ class CompressedBlockSparsityPattern : public BlockSparsityPatternBase<Compresse
                                      * member variables in other
                                      * classes. You can make the
                                      * structure usable by calling
-                                     * the @p{reinit} function.
+                                     * the @p reinit function.
                                      */
     CompressedBlockSparsityPattern ();
 
@@ -504,7 +504,7 @@ class CompressedBlockSparsityPattern : public BlockSparsityPatternBase<Compresse
                                      * given number of block rows and
                                      * columns. The blocks themselves
                                      * are still empty, and you have
-                                     * to call @p{collect_sizes} after
+                                     * to call @p collect_sizes after
                                      * you assign them sizes.
                                      */
     CompressedBlockSparsityPattern (const unsigned int n_rows,
index 60253849ee3552a4675a6d9e929b9065275a0a7e..ed4aa2667de602937db6105b4770e85d4b2d98c1 100644 (file)
@@ -599,7 +599,7 @@ namespace internal
  * A vector composed of several blocks each representing a vector of
  * its own.
  *
- * The BlockVector is a collection of normal LAC-@ref{Vector}s. Each of
+ * The BlockVector is a collection of normal LAC-Vectors. Each of
  * the vectors inside can have a different size. The special case of a
  * block vector with constant block size is supported by constructor
  * and reinit() functions.
@@ -969,7 +969,7 @@ class BlockVector
                                      */
     bool all_zero () const;
                                      /**
-                                      * Return @p{true} if the vector has no
+                                      * Return @p true if the vector has no
                                       * negative entries, i.e. all entries are
                                       * zero or positive. This function is
                                       * used, for example, to check whether
index 83ee124b1968fc7e08fbed247863f5fba3f005e0..87bad9a88cde7c4bf43b6c83c08b42433dbf7a4a 100644 (file)
@@ -30,8 +30,8 @@ template <typename number> class SparseMatrix;
 
 /**
  * This class acts as an intermediate form of the
- * @ref{SparsityPattern} class. From the interface it mostly
- * represents a @ref{SparsityPattern} object that is kept compressed
+ * SparsityPattern class. From the interface it mostly
+ * represents a SparsityPattern object that is kept compressed
  * at all times. However, since the final sparsity pattern is not
  * known while constructing it, keeping the pattern compressed at all
  * times can only be achieved at the expense of either increased
@@ -40,7 +40,7 @@ template <typename number> class SparseMatrix;
  * it memory conservative, but the chosen data format is too unsuited
  * to be used for actual matrices. It is therefore necessary to first
  * copy the data of this object over to an object of type
- * @ref{SparsityPattern} before using it in actual matrices.
+ * SparsityPattern before using it in actual matrices.
  *
  * Another viewpoint is that this class does not need up front
  * allocation of a certain amount of memory, but grows as necessary.
@@ -52,16 +52,16 @@ template <typename number> class SparseMatrix;
  * first have to provide an empty sparsity pattern object with a fixed
  * maximal number of entries per row. To find out about this maximal
  * row length, one usually calls the function
- * @ref{DoFHandler}@p{::max_couplings_per_dof} which returns an
+ * DoFHandler@p ::max_couplings_per_dof which returns an
  * estimate for that quantity. While this estimate is usually quite
  * good in 2d and exact in 1d, it is often significantly too large in
  * 3d and especially for higher order elements. Furthermore, normally
  * only a small fraction of the rows of a matrix will end up having
  * the maximal number of nonzero entries per row (usually those nodes
  * adjacent to hanging nodes), most have much less. In effect, the
- * empty @ref{SparsityPattern} object has allocated much too much
+ * empty SparsityPattern object has allocated much too much
  * memory. Although this unnecessarily allocated memory is later freed
- * when @ref{SparsityPattern}@p{::compress} is called, this
+ * when SparsityPattern@p ::compress is called, this
  * overallocation has, with higher order elements and in 3d, sometimes
  * been so large that the program aborted due to lack of memory.
  *
@@ -70,21 +70,21 @@ template <typename number> class SparseMatrix;
  * but store a set of column indices indicating possible nonzero
  * entries in the sparsity pattern for each row. This is very much
  * like the final "compressed" format used in the
- * @ref{SparsityPattern} object after compression, but uses a less
+ * SparsityPattern object after compression, but uses a less
  * compact memory storage format, since the exact number of entries
  * per row is only known a posteriori and since it may change (for the
- * @ref{SparsityPattern} class, no more changes are allowed after
+ * SparsityPattern class, no more changes are allowed after
  * compressing it). We can therefore not store all the column indices
  * in a big array, but have to use a vector of sets. This can later be
- * used to actually initialize a @ref{SparsityPattern} object with the
+ * used to actually initialize a SparsityPattern object with the
  * then final set of necessary indices.
  *
  *
  * @sect3{Interface}
  *
  * Since this class is intended as an intermediate replacement of the
- * @ref{SparsityPattern} class, it has mostly the same interface, with
- * small changes where necessary. In particular, the @ref{add}
+ * SparsityPattern class, it has mostly the same interface, with
+ * small changes where necessary. In particular, the add()
  * function, and the functions inquiring properties of the sparsity
  * pattern are the same.
  *
@@ -92,7 +92,7 @@ template <typename number> class SparseMatrix;
  * @sect3{Usage}
  *
  * Use this class as follows:
- * @begin{verbatim}
+ * @verbatim
  * CompressedSparsityPattern compressed_pattern (dof_handler.n_dofs());
  * DoFTools::make_sparsity_pattern (dof_handler,
  *                                  compressed_pattern);
@@ -100,7 +100,7 @@ template <typename number> class SparseMatrix;
  *
  * SparsityPattern sp;
  * sp.copy_from (compressed_pattern);
- * @end{verbatim}
+ * @endverbatim
  *
  *
  * @author Wolfgang Bangerth, 2001
@@ -116,7 +116,7 @@ class CompressedSparsityPattern : public Subscriptor
                                      * member variables in other
                                      * classes. You can make the
                                      * structure usable by calling
-                                     * the @p{reinit} function.
+                                     * the @p reinit function.
                                      */
     CompressedSparsityPattern ();
     
@@ -132,7 +132,7 @@ class CompressedSparsityPattern : public Subscriptor
                                      * on classes like this, e.g. to write
                                      * such statements like
                                      * @p{v.push_back (CompressedSparsityPattern());},
-                                     * with @p{v} a vector of @p{CompressedSparsityPattern}
+                                     * with @p v a vector of @p CompressedSparsityPattern
                                      * objects.
                                      *
                                      * Usually, it is sufficient to
@@ -151,15 +151,15 @@ class CompressedSparsityPattern : public Subscriptor
 
                                     /**
                                      * Initialize a rectangular
-                                     * matrix with @p{m} rows and
-                                     * @p{n} columns.
+                                     * matrix with @p m rows and
+                                     * @p n columns.
                                      */
     CompressedSparsityPattern (const unsigned int m,
                               const unsigned int n);
     
                                     /**
                                      * Initialize a square matrix of
-                                     * dimension @p{n}.
+                                     * dimension @p n.
                                      */
     CompressedSparsityPattern (const unsigned int n);
 
@@ -176,9 +176,9 @@ class CompressedSparsityPattern : public Subscriptor
                                     /**
                                      * Reallocate memory and set up
                                      * data structures for a new
-                                     * matrix with @p{m} rows and
-                                     * @p{n} columns, with at most
-                                     * @p{max_per_row} nonzero
+                                     * matrix with @p m rows and
+                                     * @p n columns, with at most
+                                     * @p max_per_row nonzero
                                      * entries per row.
                                      */
     void reinit (const unsigned int m,
@@ -191,7 +191,7 @@ class CompressedSparsityPattern : public Subscriptor
                                      * but is declared to make the
                                      * interface of this class as
                                      * much alike as that of the
-                                     * @ref{SparsityPattern} class.
+                                     * SparsityPattern class.
                                      */
     void compress ();
     
@@ -242,7 +242,7 @@ class CompressedSparsityPattern : public Subscriptor
     
                                     /**
                                      * Print the sparsity of the matrix
-                                     * in a format that @p{gnuplot} understands
+                                     * in a format that @p gnuplot understands
                                      * and which can be used to plot the
                                      * sparsity pattern in a graphical
                                      * way. The format consists of pairs
@@ -262,7 +262,7 @@ class CompressedSparsityPattern : public Subscriptor
                                      * Print the sparsity pattern in
                                      * gnuplot by setting the data style
                                      * to dots or points and use the
-                                     * @p{plot} command.
+                                     * @p plot command.
                                      */
     void print_gnuplot (std::ostream &out) const;
 
@@ -288,7 +288,7 @@ class CompressedSparsityPattern : public Subscriptor
                                     /**
                                      * Access to column number field.
                                      * Return the column number of
-                                     * the @p{index}th entry in @p{row}.
+                                     * the @p indexth entry in @p row.
                                      */
     unsigned int column_number (const unsigned int row,
                                const unsigned int index) const;
index 692aaca05be6200cc0a167f488ce10e6c17ed2ac..ba7c29b266efd351aca2fd7beaf1951222fa6466 100644 (file)
@@ -86,13 +86,13 @@ class EigenPower : private Solver<VECTOR>
     virtual ~EigenPower ();
 
                                     /**
-                                     * Power method. @p{x} is the
+                                     * Power method. @p x is the
                                      * (not necessarily normalized,
                                      * but nonzero) start vector for
                                      * the power method. After the
-                                     * iteration, @p{value} is the
+                                     * iteration, @p value is the
                                      * approximated eigenvalue and
-                                     * @p{x} is the corresponding
+                                     * @p x is the corresponding
                                      * eigenvector, normalized with
                                      * respect to the l2-norm.
                                      */
@@ -119,17 +119,17 @@ class EigenPower : private Solver<VECTOR>
  * norm of the residual $A x - l x$ is computed. Since this might not
  * converge to zero for non-symmetric matrices with non-trivial Jordan
  * blocks, it can be replaced by checking the difference of successive
- * eigenvalues. Use @p{AdditionalData::use_residual} for switching
+ * eigenvalues. Use @p AdditionalData::use_residual for switching
  * this option.
  *
  * Usually, the initial guess entering this method is updated after
  * each step, replacing it with the new approximation of the
- * eigenvalue. Using a parameter @p{AdditionalData::relaxation}
+ * eigenvalue. Using a parameter @p AdditionalData::relaxation
  * between 0 and 1, this update can be damped. With relaxation
  * parameter 0, no update is performed. This damping allows for slower
  * adaption of the shift value to make sure that the method converges
  * to the eigenvalue closest to the initial guess. This can be aided
- * by the parameter @p{AdditionalData::start_adaption}, which
+ * by the parameter @p AdditionalData::start_adaption, which
  * indicates the first iteration step in which the shift value should
  * be adapted.
  *
@@ -188,15 +188,15 @@ class EigenInverse : private Solver<VECTOR>
     virtual ~EigenInverse ();
 
                                     /**
-                                     * Inverse method. @p{value} is
+                                     * Inverse method. @p value is
                                      * the start guess for the
-                                     * eigenvalue and @p{x} is the
+                                     * eigenvalue and @p x is the
                                      * (not necessarily normalized,
                                      * but nonzero) start vector for
                                      * the power method. After the
-                                     * iteration, @p{value} is the
+                                     * iteration, @p value is the
                                      * approximated eigenvalue and
-                                     * @p{x} is the corresponding
+                                     * @p x is the corresponding
                                      * eigenvector, normalized with
                                      * respect to the l2-norm.
                                      */
index 102f9c60da0be7c04c1d910be42fb12a6619cc37..0b9c60f0c607bbdea105563eb6d958fd6bb1bdfd 100644 (file)
@@ -89,23 +89,23 @@ template <typename number> class Vector;
  * then clears again. This class is a wrapper to this procedure, it
  * takes a pointer to a matrix with which to perform matrix-vector
  * products, and does the cleaning of constrained elements itself.
- * This class therefore implements an overloaded @p{vmult} function
- * that does the matrix-vector product, as well as @p{Tvmult} for
- * transpose matrix-vector multiplication and @p{residual} for
+ * This class therefore implements an overloaded @p vmult function
+ * that does the matrix-vector product, as well as @p Tvmult for
+ * transpose matrix-vector multiplication and @p residual for
  * residual computation, and can thus be used as a matrix replacement
  * in lineaer solvers.
  *
  * It also has the ability to generate the modification of the right
- * hand side, through the @ref{apply_constraints} function.
+ * hand side, through the apply_constraints() function.
  *
  *
  * @sect3{Connection to other classes}
  *
- * The function @p{MatrixTools::apply_boundary_values} does exactly
+ * The function @p MatrixTools::apply_boundary_values does exactly
  * the same that this class does, except for the fact that that
  * function actually modifies the matrix. Due to this, it is only
  * possible to solve with a matrix onto which
- * @p{MatrixTools::apply_boundary_values} was applied for one right
+ * @p MatrixTools::apply_boundary_values was applied for one right
  * hand side and one set of boundary values since the modification of
  * the right hand side depends on the original matrix.
  *
@@ -125,23 +125,23 @@ template <typename number> class Vector;
  * Usage is simple: create an object of this type, point it to a
  * matrix that shall be used for $A$ above (either through the
  * constructor, the copy constructor, or the
- * @ref{set_referenced_matrix} function), specify the list of boundary
- * values or other constraints (through the @ref{add_constraints}
+ * set_referenced_matrix() function), specify the list of boundary
+ * values or other constraints (through the add_constraints()
  * function), and then for each required solution modify the right
- * hand side vector (through @ref{apply_constraints}) and use this
+ * hand side vector (through apply_constraints()) and use this
  * object as matrix object in a linear solver. As linear solvers
- * should only use @ref{vmult} and @ref{residual} functions of a
+ * should only use vmult() and residual() functions of a
  * matrix class, this class should be as a good a matrix as any other
  * for that purpose.
  *
- * Furthermore, also the @ref{precondition_Jacobi} function is
+ * Furthermore, also the precondition_Jacobi() function is
  * provided (since the computation of diagonal elements of the
  * filtered matrix $A_X$ is simple), so you can use this as a
  * preconditioner. Some other function useful for matrices are also
  * available.
  *
  * A typical code snippet showing the above steps is as follows:
- * @begin{verbatim}
+ * @verbatim
  *   ... // set up sparse matrix A and right hand side b somehow
  *
  *                     // initialize filtered matrix with
@@ -163,14 +163,14 @@ template <typename number> class Vector;
  *
  *                     // solve for solution vector x
  *   solver.solve (filtered_A, x, b, prec);
- * @end{verbatim}
+ * @endverbatim
  *
  *
  * @sect3{Template arguments}
  *
  * This class takes as template arguments a matrix and a vector
- * class. The former must provide @p{vmult}, @p{Tvmult}, and
- * @p{residual} member function that operate on the vector type (the
+ * class. The former must provide @p vmult, @p Tvmult, and
+ * @p residual member function that operate on the vector type (the
  * second template argument). The latter template parameter must
  * provide access to indivual elements through @p{operator()},
  * assignment through @p{operator=}.
@@ -180,8 +180,8 @@ template <typename number> class Vector;
  *
  * The functions that operate as a matrix and do not change the
  * internal state of this object are synchronised and thus
- * threadsafe. You need not serialize calls to @p{vmult} or
- * @p{residual} therefore. Because these functions require the use of
+ * threadsafe. You need not serialize calls to @p vmult or
+ * @p residual therefore. Because these functions require the use of
  * a temporary, they block mutual execution, however. It is necessary
  * to allocate this temporary vector in class space since otherwise we
  * would have to allocate such a vector each time one of the member
@@ -215,7 +215,7 @@ class FilteredMatrix : public Subscriptor
                                      * Default constructor. You will
                                      * have to set the matrix to be
                                      * used later using the
-                                     * @p{set_referenced_matrix}
+                                     * @p set_referenced_matrix
                                      * function.
                                      */
     FilteredMatrix ();
@@ -245,7 +245,7 @@ class FilteredMatrix : public Subscriptor
                                      * Set the matrix to be used
                                      * further on. You will probably
                                      * also want to call the
-                                     * @ref{clear_constraints}
+                                     * clear_constraints()
                                      * function if constraits were
                                      * previously added.
                                      */
@@ -269,9 +269,9 @@ class FilteredMatrix : public Subscriptor
                                      * enforced on the respective
                                      * solution vector's entry. Thus,
                                      * the data type might be, for
-                                     * example, a @p{std::list} or
-                                     * @p{std::vector} of
-                                     * @ref{IndexValuePair} objects,
+                                     * example, a @p std::list or
+                                     * @p std::vector of
+                                     * IndexValuePair objects,
                                      * but also a
                                      * @p{std::map<unsigned,value_type>}.
                                      *
@@ -311,7 +311,7 @@ class FilteredMatrix : public Subscriptor
                                      * is symmetric (i.e. the matrix
                                      * itself, not only its sparsity
                                      * pattern), set the second
-                                     * parameter to @p{true} to use a
+                                     * parameter to @p true to use a
                                      * faster algorithm.
                                      */
     void apply_constraints (VECTOR     &v,
@@ -348,7 +348,7 @@ class FilteredMatrix : public Subscriptor
                                      * let $dst = M^T*src$ with $M$
                                      * being this matrix. This
                                      * function does the same as
-                                     * @p{vmult} but takes the
+                                     * @p vmult but takes the
                                      * transposed matrix. (This
                                      * matrix is the filtered one to
                                      * which we store a reference.)
@@ -402,18 +402,18 @@ class FilteredMatrix : public Subscriptor
                                      * Compute the residual of an
                                      * equation @p{Mx=b}, where the
                                      * residual is defined to be
-                                     * @p{r=b-Mx} with @p{x}
+                                     * @p{r=b-Mx} with @p x
                                      * typically being an approximate
                                      * of the true solution of the
                                      * equation. Write the residual
-                                     * into @p{dst}. The l2 norm of
+                                     * into @p dst. The l2 norm of
                                      * the residual vector is
                                      * returned.
                                      *
                                      * Note that it is assumed that
-                                     * @p{b} is a vector that has been
+                                     * @p b is a vector that has been
                                      * treated by the
-                                     * @ref{modify_rhs} function,
+                                     * modify_rhs() function,
                                      * since we can then assume that
                                      * the components of the residual
                                      * which correspond to
@@ -429,11 +429,11 @@ class FilteredMatrix : public Subscriptor
                                      * Apply the Jacobi
                                      * preconditioner, which
                                      * multiplies every element of
-                                     * the @p{src} vector by the
+                                     * the @p src vector by the
                                      * inverse of the respective
                                      * diagonal element and
                                      * multiplies the result with the
-                                     * damping factor @p{omega}.
+                                     * damping factor @p omega.
                                      */
     void precondition_Jacobi (VECTOR           &dst,
                              const VECTOR     &src,
@@ -470,7 +470,7 @@ class FilteredMatrix : public Subscriptor
     {
                                         /**
                                          * Function comparing the
-                                         * pairs @p{i1} and @p{i2}
+                                         * pairs @p i1 and @p i2
                                          * for their keys.
                                          */
        bool operator () (const IndexValuePair &i1,
@@ -483,7 +483,7 @@ class FilteredMatrix : public Subscriptor
                                      * matrix. In order to guarantee
                                      * that it is not deleted while
                                      * still in use, we subscribe to
-                                     * it using the @p{SmartPointer}
+                                     * it using the @p SmartPointer
                                      * class.
                                      */
     SmartPointer<const MATRIX> matrix;
index 93de176a44f66d41248e9fd32d749460c377c7c2..7a9bdc959f7f038e7c596396d187e2a157e8fb23 100644 (file)
@@ -697,7 +697,7 @@ class FullMatrix : public Table<2,number>
                                      * since the amount of code
                                      * needed grows quickly.  For
                                      * larger matrices, the method
-                                     * @ref{gauss_jordan} is invoked
+                                     * gauss_jordan() is invoked
                                      * implicitly.
                                      */
     template <typename number2>
index a252820127eb751d2e26a93a833c8826690d9f02..ecf1d7ac0fad32904e2269eeaa728fcd89b56e0b 100644 (file)
@@ -56,14 +56,14 @@ class ProductMatrix : public PointerMatrixBase<VECTOR>
     
                                     /**
                                      * Matrix-vector product, adding to
-                                     * @p{dst}.
+                                     * @p dst.
                                      */
     virtual void vmult_add (VECTOR& dst,
                            const VECTOR& src) const;
     
                                     /**
                                      * Tranposed matrix-vector product,
-                                     * adding to @p{dst}.
+                                     * adding to @p dst.
                                      */
     virtual void Tvmult_add (VECTOR& dst,
                             const VECTOR& src) const;
@@ -87,9 +87,9 @@ class ProductMatrix : public PointerMatrixBase<VECTOR>
 
 
 /**
- * Mean value filter.  The @p{vmult} functions of this matrix filter
+ * Mean value filter.  The @p vmult functions of this matrix filter
  * out mean values of the vector.  If the vector is of type
- * @p{BlockVector}, then an additional parameter selects a single
+ * @p BlockVector, then an additional parameter selects a single
  * component for this operation.
  *
  * @author Guido Kanschat, 2002, 2003
@@ -104,13 +104,13 @@ class MeanValueFilter : public Subscriptor
     MeanValueFilter(unsigned int component = deal_II_numbers::invalid_unsigned_int);
 
                                     /**
-                                     * Subtract mean value from @p{v}.
+                                     * Subtract mean value from @p v.
                                      */
     template <typename number>
     void filter (Vector<number>& v) const;
     
                                     /**
-                                     * Subtract mean value from @p{v}.
+                                     * Subtract mean value from @p v.
                                      */
     template <typename number>
     void filter (BlockVector<number>& v) const;
index a98cda476ac7233ba98a583cc87672ddc0f4c3d4..d42ef8345a9b9a10aa0dbdbae53af2ba6d575b5c 100644 (file)
@@ -33,7 +33,7 @@
  * of the base class.
  *
  * A typical usage of this class would be as follows:
- * @begin{verbatim}
+ * @verbatim
  *    FullMatrix<double> M;
  *    ...                // fill matrix M with some values
  *
  *    std::ofstream out ("M.gnuplot");
  *    matrix_out.build_patches (M, "M");
  *    matrix_out.write_gnuplot (out);
- * @end{verbatim}
+ * @endverbatim
  * Of course, you can as well choose a different graphical output
  * format. Also, this class supports any matrix, not only of type
- * @ref{FullMatrix}, as long as it satisfies a number of requirements,
+ * FullMatrix, as long as it satisfies a number of requirements,
  * stated with the member functions of this class.
  *
- * The generation of patches through the @p{build_patches} function
+ * The generation of patches through the @p build_patches function
  * can be modified by giving it an object holding certain flags. See
- * the documentation of the members of the @ref{Options} class for a
+ * the documentation of the members of the Options class for a
  * description of these flags.
  *
  *
  * @sect3{Internals}
  *
  * To avoid a compiler error in Sun's Forte compiler, we derive
- * privately from @ref{DataOutBase}. Since the base class
- * @ref{DataOutInterface} does so as well, this does no harm, but
+ * privately from DataOutBase. Since the base class
+ * DataOutInterface does so as well, this does no harm, but
  * calms the compiler which is suspecting an access control conflict
  * otherwise. Testcase here:
- * @begin{verbatim}
+ * @verbatim
  *    template <typename T> class V {};
  *    
  *    struct B1 { 
@@ -79,7 +79,7 @@
  *    }; 
  *    
  *    D d;
- * @end{verbatim} 
+ * @endverbatim 
  *
  *
  * @author Wolfgang Bangerth, 2001
@@ -91,18 +91,18 @@ class MatrixOut : public DataOutInterface<2,2>
                                      * Class holding various
                                      * variables which are used to
                                      * modify the output of the
-                                     * @ref{MatrixOut} class.
+                                     * MatrixOut class.
                                      */
     struct Options 
     {
                                         /**
-                                         * If @p{true}, only show the
+                                         * If @p true, only show the
                                          * absolute values of the
                                          * matrix entries, rather
                                          * than their true values
                                          * including the
                                          * sign. Default value is
-                                         * @p{false}.
+                                         * @p false.
                                          */
        bool         show_absolute_values;
 
@@ -171,7 +171,7 @@ class MatrixOut : public DataOutInterface<2,2>
                                      * requires that we can extract
                                      * elements of the matrix, which
                                      * is done using the
-                                     * @p{get_element} function
+                                     * @p get_element function
                                      * declared below. By adding
                                      * specializations, you can
                                      * extend this class to other
@@ -195,21 +195,21 @@ class MatrixOut : public DataOutInterface<2,2>
     
                                     /**
                                      * Abbreviate the somewhat
-                                     * lengthy name for the @p{Patch}
+                                     * lengthy name for the @p Patch
                                      * class.
                                      *
                                      * Note that we have to indicate
                                      * the global scope using the
-                                     * @p{::} in front of
-                                     * @p{DataOutBase}, since
+                                     * @p :: in front of
+                                     * @p DataOutBase, since
                                      * otherwise the C++ rules
                                      * specify that this here
-                                     * indicates the @p{DataOutBase}
+                                     * indicates the @p DataOutBase
                                      * base class of this
                                      * class. Since that is a private
                                      * base class, we cannot access
                                      * its members, and so access to
-                                     * the local @p{Patch} type would
+                                     * the local @p Patch type would
                                      * be forbidden.
                                      */
     typedef ::DataOutBase::Patch<2,2> Patch;
@@ -217,7 +217,7 @@ class MatrixOut : public DataOutInterface<2,2>
                                     /**
                                      * This is a list of patches that
                                      * is created each time
-                                     * @p{build_patches} is
+                                     * @p build_patches is
                                      * called. These patches are used
                                      * in the output routines of the
                                      * base classes.
index 5a2e4a4d21a49881a23e4329a6bab844bf664111..4c5f8ccda9c7bf3d7858ab45e10c4501a7caa308 100644 (file)
@@ -44,7 +44,7 @@ namespace PETScWrappers
     public:
                                        /**
                                         * Create a full matrix of dimensions
-                                        * @p{m} times @p{n}.
+                                        * @p m times @p n.
                                         */
       FullMatrix (const unsigned int m,
                   const unsigned int n);
index 004805cc1d0ece93fac5ac79b9e86f3a2ee1eb57..4c86b80da2e93d0bc3d1d89292d64d2cb5939fd4 100644 (file)
@@ -263,21 +263,21 @@ namespace PETScWrappers
  * matrix.
  *
  * The interface of this class is modeled after the existing
- * @ref{SparseMatrix} class in deal.II. It has almost the same member
+ * SparseMatrix class in deal.II. It has almost the same member
  * functions, and is often exchangable. However, since PETSc only supports a
  * single scalar type (either double, float, or a complex data type), it is
  * not templated, and only works with whatever your PETSc installation has
- * defined the data type @p{PetscScalar} to.
+ * defined the data type @p PetscScalar to.
  *
  * Note that PETSc only guarantees that operations do what you expect if the
- * functions @p{MatAssemblyBegin} and @p{MatAssemblyEnd} have been called
+ * functions @p MatAssemblyBegin and @p MatAssemblyEnd have been called
  * after matrix assembly. Therefore, you need to call
- * @ref{SparseMatrix::compress} before you actually use the matrix. This also
- * calls @p{MatCompress} that compresses the storage format for sparse
+ * SparseMatrix::compress() before you actually use the matrix. This also
+ * calls @p MatCompress that compresses the storage format for sparse
  * matrices by discarding unused elements. PETSc allows to continue with
  * assembling the matrix after calls to these functions, but since there are
  * no more free entries available after that any more, it is better to only
- * call @ref{SparseMatrix::compress} once at the end of the assembly stage and
+ * call SparseMatrix::compress() once at the end of the assembly stage and
  * before the matrix is actively used.
  * 
  * @author Wolfgang Bangerth, 2004
@@ -342,7 +342,7 @@ namespace PETScWrappers
                                        /**
                                         * PETSc matrices store their own
                                         * sparsity patterns. So, in analogy to
-                                        * our own @ref{SparsityPattern} class,
+                                        * our own SparsityPattern class,
                                         * this function compresses the
                                         * sparsity pattern and allows the
                                         * resulting matrix to be used in all
@@ -361,7 +361,7 @@ namespace PETScWrappers
                                         * always take care where to call this
                                         * function. In contrast to the
                                         * respective function in the
-                                        * @p{MatrixBase} class, we don't
+                                        * @p MatrixBase class, we don't
                                         * throw an exception if the respective
                                         * entry doesn't exist in the sparsity
                                         * pattern of this class, since PETSc
@@ -549,7 +549,7 @@ namespace PETScWrappers
                                         *
                                         * The implementation of this function
                                         * is not as efficient as the one in
-                                        * the @p{MatrixBase} class used in
+                                        * the @p MatrixBase class used in
                                         * deal.II (i.e. the original one, not
                                         * the PETSc wrapper class) since PETSc
                                         * doesn't support this operation and
@@ -563,7 +563,7 @@ namespace PETScWrappers
                                         *
                                         * The implementation of this function
                                         * is not as efficient as the one in
-                                        * the @p{MatrixBase} class used in
+                                        * the @p MatrixBase class used in
                                         * deal.II (i.e. the original one, not
                                         * the PETSc wrapper class) since PETSc
                                         * doesn't support this operation and
index 1797b6d03d33985bf3f1eaf288cc1744e0c992d9..3f719d502080a823ee5f8d19e7ef3cd80cf498fc 100644 (file)
@@ -71,7 +71,7 @@ namespace PETScWrappers
                                           * involves copying data, and is thus
                                           * expensive.
                                           *
-                                          * The @p{is_symmetric} flag determines
+                                          * The @p is_symmetric flag determines
                                           * whether we should tell PETSc that
                                           * the matrix is going to be symmetric
                                           * (as indicated by the call
@@ -80,7 +80,7 @@ namespace PETScWrappers
                                           * that one cannot form an ILU
                                           * decomposition of a matrix for which
                                           * this flag has been set. The default
-                                          * value of this flag is @p{false}.
+                                          * value of this flag is @p false.
                                           */
         SparseMatrix (const MPI_Comm     &communicator,
                       const unsigned int  m,
@@ -104,7 +104,7 @@ namespace PETScWrappers
                                           * row, but this involves copying data,
                                           * and is thus expensive.
                                           *
-                                          * The @p{is_symmetric} flag determines
+                                          * The @p is_symmetric flag determines
                                           * whether we should tell PETSc that
                                           * the matrix is going to be symmetric
                                           * (as indicated by the call
@@ -113,7 +113,7 @@ namespace PETScWrappers
                                           * that one cannot form an ILU
                                           * decomposition of a matrix for which
                                           * this flag has been set. The default
-                                          * value of this flag is @p{false}.
+                                          * value of this flag is @p false.
                                           */
         SparseMatrix (const MPI_Comm                  &communicator,
                       const unsigned int               m,
index e00564cf672af198decea52b51013611b64477e4..5f70be46a0ea9402f867cad7c2e8d51bdf4e4b31 100644 (file)
@@ -262,7 +262,7 @@ namespace PETScWrappers
 
                                          /**
                                           * Set all components of the vector to
-                                          * the given number @p{s}. Simply pass
+                                          * the given number @p s. Simply pass
                                           * this down to the base class, but we
                                           * still need to declare this function
                                           * to make the example given in the
@@ -326,7 +326,7 @@ namespace PETScWrappers
                                           * over the partitioning into local
                                           * sizes as well as the MPI
                                           * communicator. The same applies as
-                                          * for the other @p{reinit} function.
+                                          * for the other @p reinit function.
                                           *
                                           * The elements of @p v are not
                                           * copied, i.e. this function is the
@@ -340,7 +340,7 @@ namespace PETScWrappers
       protected:
                                          /**
                                           * Create a vector of length
-                                          * @p{n}. For this class, we create a
+                                          * @p n. For this class, we create a
                                           * parallel vector. @p n denotes
                                           * the total size of the vector to be
                                           * created. @p local_size denotes
index db400915b7072dcc46bd5593d597f7f5f1eee849..11c2414382efc58b01bc62bbae926006ae2ea58d 100644 (file)
@@ -184,7 +184,7 @@ namespace PETScWrappers
                                         * to have an MPI communicator context
                                         * over which computations are
                                         * parallelized. By default,
-                                        * @p{PETSC_COMM_SELF} is used here,
+                                        * @p PETSC_COMM_SELF is used here,
                                         * but you can change this. Note that
                                         * for single processor (non-MPI)
                                         * versions, this parameter does not
@@ -253,7 +253,7 @@ namespace PETScWrappers
                                         * to have an MPI communicator context
                                         * over which computations are
                                         * parallelized. By default,
-                                        * @p{PETSC_COMM_SELF} is used here,
+                                        * @p PETSC_COMM_SELF is used here,
                                         * but you can change this. Note that
                                         * for single processor (non-MPI)
                                         * versions, this parameter does not
@@ -318,7 +318,7 @@ namespace PETScWrappers
                                         * to have an MPI communicator context
                                         * over which computations are
                                         * parallelized. By default,
-                                        * @p{PETSC_COMM_SELF} is used here,
+                                        * @p PETSC_COMM_SELF is used here,
                                         * but you can change this. Note that
                                         * for single processor (non-MPI)
                                         * versions, this parameter does not
@@ -383,7 +383,7 @@ namespace PETScWrappers
                                         * to have an MPI communicator context
                                         * over which computations are
                                         * parallelized. By default,
-                                        * @p{PETSC_COMM_SELF} is used here,
+                                        * @p PETSC_COMM_SELF is used here,
                                         * but you can change this. Note that
                                         * for single processor (non-MPI)
                                         * versions, this parameter does not
@@ -462,7 +462,7 @@ namespace PETScWrappers
                                         * to have an MPI communicator context
                                         * over which computations are
                                         * parallelized. By default,
-                                        * @p{PETSC_COMM_SELF} is used here,
+                                        * @p PETSC_COMM_SELF is used here,
                                         * but you can change this. Note that
                                         * for single processor (non-MPI)
                                         * versions, this parameter does not
@@ -531,7 +531,7 @@ namespace PETScWrappers
                                         * to have an MPI communicator context
                                         * over which computations are
                                         * parallelized. By default,
-                                        * @p{PETSC_COMM_SELF} is used here,
+                                        * @p PETSC_COMM_SELF is used here,
                                         * but you can change this. Note that
                                         * for single processor (non-MPI)
                                         * versions, this parameter does not
@@ -596,7 +596,7 @@ namespace PETScWrappers
                                         * to have an MPI communicator context
                                         * over which computations are
                                         * parallelized. By default,
-                                        * @p{PETSC_COMM_SELF} is used here,
+                                        * @p PETSC_COMM_SELF is used here,
                                         * but you can change this. Note that
                                         * for single processor (non-MPI)
                                         * versions, this parameter does not
@@ -661,7 +661,7 @@ namespace PETScWrappers
                                         * to have an MPI communicator context
                                         * over which computations are
                                         * parallelized. By default,
-                                        * @p{PETSC_COMM_SELF} is used here,
+                                        * @p PETSC_COMM_SELF is used here,
                                         * but you can change this. Note that
                                         * for single processor (non-MPI)
                                         * versions, this parameter does not
@@ -731,7 +731,7 @@ namespace PETScWrappers
                                         * to have an MPI communicator context
                                         * over which computations are
                                         * parallelized. By default,
-                                        * @p{PETSC_COMM_SELF} is used here,
+                                        * @p PETSC_COMM_SELF is used here,
                                         * but you can change this. Note that
                                         * for single processor (non-MPI)
                                         * versions, this parameter does not
@@ -796,7 +796,7 @@ namespace PETScWrappers
                                         * to have an MPI communicator context
                                         * over which computations are
                                         * parallelized. By default,
-                                        * @p{PETSC_COMM_SELF} is used here,
+                                        * @p PETSC_COMM_SELF is used here,
                                         * but you can change this. Note that
                                         * for single processor (non-MPI)
                                         * versions, this parameter does not
@@ -861,7 +861,7 @@ namespace PETScWrappers
                                         * to have an MPI communicator context
                                         * over which computations are
                                         * parallelized. By default,
-                                        * @p{PETSC_COMM_SELF} is used here,
+                                        * @p PETSC_COMM_SELF is used here,
                                         * but you can change this. Note that
                                         * for single processor (non-MPI)
                                         * versions, this parameter does not
index c49af00efeb5123b297c442f1aaec39fcbd22693..80ab0021a7f180fdcf81a81aa68af5acf3629173 100644 (file)
@@ -62,7 +62,7 @@ namespace PETScWrappers
                                         * involves copying data, and is thus
                                         * expensive.
                                         *
-                                        * The @p{is_symmetric} flag determines
+                                        * The @p is_symmetric flag determines
                                         * whether we should tell PETSc that
                                         * the matrix is going to be symmetric
                                         * (as indicated by the call
@@ -71,7 +71,7 @@ namespace PETScWrappers
                                         * that one cannot form an ILU
                                         * decomposition of a matrix for which
                                         * this flag has been set. The default
-                                        * value of this flag is @p{false}.
+                                        * value of this flag is @p false.
                                         */
       SparseMatrix (const unsigned int m,
                     const unsigned int n,
@@ -93,7 +93,7 @@ namespace PETScWrappers
                                         * row, but this involves copying data,
                                         * and is thus expensive.
                                         *
-                                        * The @p{is_symmetric} flag determines
+                                        * The @p is_symmetric flag determines
                                         * whether we should tell PETSc that
                                         * the matrix is going to be symmetric
                                         * (as indicated by the call
@@ -102,7 +102,7 @@ namespace PETScWrappers
                                         * that one cannot form an ILU
                                         * decomposition of a matrix for which
                                         * this flag has been set. The default
-                                        * value of this flag is @p{false}.
+                                        * value of this flag is @p false.
                                         */
       SparseMatrix (const unsigned int               m,
                     const unsigned int               n,
index e457f844f189cb08eaac4c81e0d45f76f495ae27..c72d3800ee3a712c20fd5a57859afbeb70dd42fa 100644 (file)
@@ -53,7 +53,7 @@ namespace PETScWrappers
       
                                        /**
                                         * Constructor. Set dimension to
-                                        * @p{n} and initialize all
+                                        * @p n and initialize all
                                         * elements with zero.
                                         *
                                         * The constructor is made explicit to
@@ -111,7 +111,7 @@ namespace PETScWrappers
 
                                        /**
                                         * Set all components of the vector to
-                                        * the given number @p{s}. Simply pass
+                                        * the given number @p s. Simply pass
                                         * this down to the base class, but we
                                         * still need to declare this function
                                         * to make the example given in the
@@ -164,7 +164,7 @@ namespace PETScWrappers
 
     protected:
                                        /**
-                                        * Create a vector of length @p{n}. For
+                                        * Create a vector of length @p n. For
                                         * this class, we create a sequential
                                         * vector. @p n denotes the total
                                         * size of the vector to be
index 5279e84b2da8b2b799141fa9dd6cd8bb38e6c541..9bc1a9b0e38fb653ff5eaa7418b368968a41c9d3 100644 (file)
@@ -186,16 +186,16 @@ namespace PETScWrappers
  * base class. Derived classes will then only have to provide the
  * functionality to create one or the other kind of vector.
  *
- * The interface of this class is modeled after the existing @ref{Vector}
+ * The interface of this class is modeled after the existing Vector
  * class in deal.II. It has almost the same member functions, and is often
  * exchangable. However, since PETSc only supports a single scalar type
  * (either double, float, or a complex data type), it is not templated, and
  * only works with whatever your PETSc installation has defined the data type
- * @p{PetscScalar} to.
+ * @p PetscScalar to.
  *
  * Note that PETSc only guarantees that operations do what you expect if the
- * functions @p{VecAssemblyBegin} and @p{VecAssemblyEnd} have been called
- * after vector assembly. Therefore, you need to call @ref{Vector::compress}
+ * functions @p VecAssemblyBegin and @p VecAssemblyEnd have been called
+ * after vector assembly. Therefore, you need to call Vector::compress()
  * before you actually use the vector.
  *
  * @author Wolfgang Bangerth, 2004
@@ -255,7 +255,7 @@ namespace PETScWrappers
       
                                        /**
                                         * Set all components of the vector to
-                                        * the given number @p{s}.
+                                        * the given number @p s.
                                         */
       VectorBase & operator = (const PetscScalar s);    
       
@@ -388,7 +388,7 @@ namespace PETScWrappers
       bool all_zero () const;
 
                                        /**
-                                        * Return @p{true} if the vector has no
+                                        * Return @p true if the vector has no
                                         * negative entries, i.e. all entries
                                         * are zero or positive. This function
                                         * is used, for example, to check
@@ -422,8 +422,8 @@ namespace PETScWrappers
       VectorBase & operator -= (const VectorBase &V);
 
                                        /**
-                                        * Addition of @p{s} to all
-                                        * components. Note that @p{s} is a
+                                        * Addition of @p s to all
+                                        * components. Note that @p s is a
                                         * scalar and not a vector.
                                         */
       void add (const PetscScalar s);
@@ -527,15 +527,15 @@ namespace PETScWrappers
 
                                        /**
                                         * Print to a
-                                        * stream. @p{precision} denotes
+                                        * stream. @p precision denotes
                                         * the desired precision with
                                         * which values shall be printed,
-                                        * @p{scientific} whether
+                                        * @p scientific whether
                                         * scientific notation shall be
-                                        * used. If @p{across} is
-                                        * @p{true} then the vector is
+                                        * used. If @p across is
+                                        * @p true then the vector is
                                         * printed in a line, while if
-                                        * @p{false} then the elements
+                                        * @p false then the elements
                                         * are printed on a separate line
                                         * each.
                                         */
@@ -547,7 +547,7 @@ namespace PETScWrappers
                                        /**
                                         * Swap the contents of this
                                         * vector and the other vector
-                                        * @p{v}. One could do this
+                                        * @p v. One could do this
                                         * operation with a temporary
                                         * variable and copying over the
                                         * data elements, but this
@@ -560,7 +560,7 @@ namespace PETScWrappers
                                         * data around.
                                         *
                                         * This function is analog to the
-                                        * the @p{swap} function of all C++
+                                        * the @p swap function of all C++
                                         * standard containers. Also,
                                         * there is a global function
                                         * @p{swap(u,v)} that simply calls
@@ -637,7 +637,7 @@ namespace PETScWrappers
                                        /**
                                         * Store whether the last action was a
                                         * write or add operation. This
-                                        * variable is @p{mutable} so that the
+                                        * variable is @p mutable so that the
                                         * accessor classes can write to it,
                                         * even though the vector object they
                                         * refer to is constant.
@@ -655,7 +655,7 @@ namespace PETScWrappers
 // ------------------- inline and template functions --------------  
 
 /**
- * Global function @p{swap} which overloads the default implementation
+ * Global function @p swap which overloads the default implementation
  * of the C++ standard library which uses a temporary object. The
  * function simply exchanges the data of the two vectors.
  *
index 04a46ef6a03a2d566f65481bf5ba13f5288e417a..573c80ec7e4eb0377b1cad73a1e6c96b91e77b91 100644 (file)
@@ -35,7 +35,7 @@ class PointerMatrixBase : public Subscriptor
                                      * This was defined to make this
                                      * matrix a possible template
                                      * argument to
-                                     * @ref{BlockMatrixArray}.
+                                     * BlockMatrixArray.
                                      */
     typedef typename VECTOR::value_type value_type;
     
@@ -61,14 +61,14 @@ class PointerMatrixBase : public Subscriptor
 
                                   /**
                                    * Matrix-vector product, adding to
-                                   * @p{dst}.
+                                   * @p dst.
                                    */
   virtual void vmult_add (VECTOR& dst,
                          const VECTOR& src) const = 0;
 
                                   /**
                                    * Tranposed matrix-vector product,
-                                   * adding to @p{dst}.
+                                   * adding to @p dst.
                                    */
   virtual void Tvmult_add (VECTOR& dst,
                           const VECTOR& src) const = 0;
@@ -93,9 +93,9 @@ public:
                                    * argument is stored in this
                                    * class. As usual, the lifetime of
                                    * @p{*M} must be longer than the
-                                   * one of the @p{PointerMatrix}.
+                                   * one of the @p PointerMatrix.
                                    *
-                                   * If @p{M} is zero, no matrix is stored.
+                                   * If @p M is zero, no matrix is stored.
                                    */
   PointerMatrix (const MATRIX* M=0);
 
@@ -127,14 +127,14 @@ public:
 
                                   /**
                                    * Matrix-vector product, adding to
-                                   * @p{dst}.
+                                   * @p dst.
                                    */
   virtual void vmult_add (VECTOR& dst,
                          const VECTOR& src) const;
   
                                   /**
                                    * Tranposed matrix-vector product,
-                                   * adding to @p{dst}.
+                                   * adding to @p dst.
                                    */
   virtual void Tvmult_add (VECTOR& dst,
                           const VECTOR& src) const;
index 8213c5998073acb6a1bfb7aeb947e3714fb2f126..1775647d9845aaee483070c99a9fd2e5743345ba 100644 (file)
@@ -33,10 +33,10 @@ class PreconditionBlockJacobi;
 
 
 /**
- * Base class for @p{PreconditionBlockJacobi},
- * @p{PreconditionBlockSOR}, ...  This class assumes the
+ * Base class for @p PreconditionBlockJacobi,
+ * @p PreconditionBlockSOR, ...  This class assumes the
  * @p{SparseMatrix<number>} consisting of invertible blocks of
- * @p{blocksize} on the diagonal and provides the inversion of the
+ * @p blocksize on the diagonal and provides the inversion of the
  * diagonal blocks of the matrix. NOT only block diagonal matrices are
  * allowed but all matrices of arbitrary structure with the minimal
  * property of having invertible blocks on the diagonal!
@@ -47,13 +47,13 @@ class PreconditionBlockJacobi;
  * empty above the diagonal blocks.
  *
  * For all matrices that are empty above and below the diagonal blocks
- * (i.e. for all block diagonal matrices) the @p{BlockJacobi}
+ * (i.e. for all block diagonal matrices) the @p BlockJacobi
  * preconditioner is a direct solver. For all matrices that are empty
  * only above the diagonal blocks (e.g. the matrices one gets by the
- * DG method with downstream numbering) @p{BlockSOR} is a direct
+ * DG method with downstream numbering) @p BlockSOR is a direct
  * solver.
  * 
- * This first implementation of the @p{PreconditionBlock} assumes the
+ * This first implementation of the @p PreconditionBlock assumes the
  * matrix has blocks each of the same block size. Varying block sizes
  * within the matrix must still be implemented if needed.
  *
@@ -210,7 +210,7 @@ class PreconditionBlock : public virtual Subscriptor
                                     /**
                                      * Stores the inverse of the
                                      * diagonal blocks in
-                                     * @p{inverse}. This costs some
+                                     * @p inverse. This costs some
                                      * additional memory - for DG
                                      * methods about 1/3 (for double
                                      * inverses) or 1/6 (for float
@@ -227,7 +227,7 @@ class PreconditionBlock : public virtual Subscriptor
                                      *
                                      * After this function is called,
                                      * the lock on the matrix given
-                                     * through the @p{use_matrix}
+                                     * through the @p use_matrix
                                      * function is released, i.e. you
                                      * may overwrite of delete it.
                                      * You may want to do this in
@@ -318,11 +318,11 @@ class PreconditionBlock : public virtual Subscriptor
                                      * sure that the matrix exists as
                                      * long as this class needs it,
                                      * i.e. until calling
-                                     * @p{invert_diagblocks}, or (if
+                                     * @p invert_diagblocks, or (if
                                      * the inverse matrices should
                                      * not be stored) until the last
                                      * call of the preconditoining
-                                     * @p{vmult} function of the
+                                     * @p vmult function of the
                                      * derived classes.
                                      */
     SmartPointer<const MATRIX> A;
@@ -359,8 +359,8 @@ class PreconditionBlock : public virtual Subscriptor
 
                                     /**
                                      * Storage of the original diagonal blocks.
-                                     * These are only filled if @p{store_diagonals}
-                                     * is @p{true}.
+                                     * These are only filled if @p store_diagonals
+                                     * is @p true.
                                      *
                                      * Used by the blocked SSOR method.
                                      */
@@ -377,7 +377,7 @@ class PreconditionBlock : public virtual Subscriptor
 
 /**
  * Block Jacobi preconditioning.
- * See @ref{PreconditionBlock} for requirements on the matrix.
+ * See PreconditionBlock for requirements on the matrix.
  * @author Ralf Hartmann, Guido Kanschat, 1999, 2000, 2003
  */
 template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
@@ -584,13 +584,13 @@ class PreconditionBlockJacobi : public virtual Subscriptor,
     void vmult (Vector<number2>&, const Vector<number2>&) const;
 
                                     /**
-                                     * Same as @p{vmult}, since Jacobi is symmetric.
+                                     * Same as @p vmult, since Jacobi is symmetric.
                                      */
     template <typename number2>
     void Tvmult (Vector<number2>&, const Vector<number2>&) const;
                                     /**
                                      * Execute block Jacobi
-                                     * preconditioning, adding to @p{dst}.
+                                     * preconditioning, adding to @p dst.
                                      *
                                      * This function will
                                      * automatically use the inverse
@@ -604,7 +604,7 @@ class PreconditionBlockJacobi : public virtual Subscriptor,
     void vmult_add (Vector<number2>&, const Vector<number2>&) const;
 
                                     /**
-                                     * Same as @p{vmult_add}, since Jacobi is symmetric.
+                                     * Same as @p vmult_add, since Jacobi is symmetric.
                                      */
     template <typename number2>
     void Tvmult_add (Vector<number2>&, const Vector<number2>&) const;
@@ -622,12 +622,12 @@ class PreconditionBlockJacobi : public virtual Subscriptor,
     
                                     /**
                                      * STL-like iterator with the
-                                     * first entry of row @p{r}.
+                                     * first entry of row @p r.
                                      */
     const_iterator begin (const unsigned int r) const;
 
                                     /**
-                                     * Final iterator of row @p{r}.
+                                     * Final iterator of row @p r.
                                      */
     const_iterator end (const unsigned int r) const;
     
@@ -637,7 +637,7 @@ class PreconditionBlockJacobi : public virtual Subscriptor,
                                    * Actual implementation of the
                                    * preconditioner.
                                    *
-                                   * Depending on @p{adding}, the
+                                   * Depending on @p adding, the
                                    * result of preconditioning is
                                    * added to the destination vector.
                                    */
@@ -655,12 +655,12 @@ class PreconditionBlockJacobi : public virtual Subscriptor,
 /**
  * Block SOR preconditioning.
  *
- * The functions @p{vmult} and @p{Tvmult} execute a (transposed)
- * block-SOR step, based on the blocks in @ref{PreconditionBlock}. The
+ * The functions @p vmult and @p Tvmult execute a (transposed)
+ * block-SOR step, based on the blocks in PreconditionBlock. The
  * elements outside the diagonal blocks may be distributed
  * arbitrarily.
  *
- * See @ref{PreconditionBlock} for requirements on the matrix.
+ * See PreconditionBlock for requirements on the matrix.
  * @author Ralf Hartmann, Guido Kanschat, 1999, 2000, 2001, 2002, 2003
  */
 template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
@@ -729,10 +729,10 @@ class PreconditionBlockSOR : public virtual Subscriptor,
                                      * preconditioning.
                                      *
                                      * Warning: this function
-                                     * performs normal @p{vmult}
+                                     * performs normal @p vmult
                                      * without adding. The reason for
                                      * its existence is that
-                                     * @ref{BlockMatrixArray}
+                                     * BlockMatrixArray
                                      * requires the adding version by
                                      * default. On the other hand,
                                      * adding requires an additional
@@ -745,11 +745,11 @@ class PreconditionBlockSOR : public virtual Subscriptor,
     void vmult_add (Vector<number2>&, const Vector<number2>&) const;
 
                                     /**
-                                     * Backward application of @ref{vmult}.
+                                     * Backward application of vmult().
                                      *
                                      * In the current implementation,
                                      * this is not the transpose of
-                                     * @ref{vmult}. It is a
+                                     * vmult(). It is a
                                      * transposed Gauss-Seidel
                                      * algorithm applied to the whole
                                      * matrix, but the diagonal
@@ -766,10 +766,10 @@ class PreconditionBlockSOR : public virtual Subscriptor,
                                      * preconditioning.
                                      *
                                      * Warning: this function
-                                     * performs normal @p{vmult}
+                                     * performs normal @p vmult
                                      * without adding. The reason for
                                      * its existence is that
-                                     * @ref{BlockMatrixArray}
+                                     * BlockMatrixArray
                                      * requires the adding version by
                                      * default. On the other hand,
                                      * adding requires an additional
@@ -786,7 +786,7 @@ class PreconditionBlockSOR : public virtual Subscriptor,
                                      * Actual implementation of the
                                      * preconditioning algorithm.
                                      *
-                                     * The parameter @p{adding} does
+                                     * The parameter @p adding does
                                      * not have any function, yet.
                                      */
     template <typename number2>
@@ -798,7 +798,7 @@ class PreconditionBlockSOR : public virtual Subscriptor,
                                      * Actual implementation of the
                                      * preconditioning algorithm.
                                      *
-                                     * The parameter @p{adding} does
+                                     * The parameter @p adding does
                                      * not have any function, yet.
                                      */
     template <typename number2>
@@ -812,11 +812,11 @@ class PreconditionBlockSOR : public virtual Subscriptor,
 /**
  * Block SSOR preconditioning.
  *
- * The functions @p{vmult} and @p{Tvmult} execute a block-SSOR step,
- * based on the implementation in @ref{PreconditionBlockSOR}.  This
+ * The functions @p vmult and @p Tvmult execute a block-SSOR step,
+ * based on the implementation in PreconditionBlockSOR.  This
  * class requires storage of the diagonal blocks and their inverses.
  *
- * See @ref{PreconditionBlock} for requirements on the matrix.
+ * See PreconditionBlock for requirements on the matrix.
  * @author Ralf Hartmann, Guido Kanschat, 1999, 2000
  */
 template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
@@ -881,7 +881,7 @@ class PreconditionBlockSSOR : public virtual Subscriptor,
     void vmult (Vector<number2>&, const Vector<number2>&) const;
 
                                     /**
-                                     * Same as @ref{vmult}
+                                     * Same as vmult()
                                      */
     template <typename number2>
     void Tvmult (Vector<number2>&, const Vector<number2>&) const;
index 8fb5b0ab49b38ea24e06e1a4df65ab44e01629cf..4f34759200f7e710ff48af7784ad30172ba87fb0 100644 (file)
@@ -182,7 +182,7 @@ void PreconditionBlock<MATRIX,inverse_type>::invert_diagblocks()
                                       // row, column are the global numbering
                                       // of the unkowns.
 
-                                      // set the @p{var_inverse} array to the right
+                                      // set the @p var_inverse array to the right
                                       // size. we could do it like this:
                                       // var_inverse = vector<>(nblocks,FullMatrix<>())
                                       // but this would involve copying many
index ad675d6fd5196e3f7c1f1ba9240cb1a408ec0038..cbdcffa61f3a614d8b9ef40dab84647aefe8fcbc 100644 (file)
@@ -29,27 +29,27 @@ template <class number> class SparseMatrix;
 /**
  * Selects the preconditioner. The constructor of this class takes 
  * the name of the preconditioning and the damping parameter 
- * @p{omega} of the preconditioning and the @p{use_matrix} function takes
+ * @p omega of the preconditioning and the @p use_matrix function takes
  * the matrix that is used
  * by the matrix-builtin precondition functions. Each time, the @p{operator()} function
  * is called, this preselected preconditioner, this matrix and
- * this @p{omega} is used
+ * this @p omega is used
  * for the preconditioning. This class is designed for being used as
- * argument of the @p{solve} function of a @p{Solver} and it covers the
+ * argument of the @p solve function of a @p Solver and it covers the
  * selection of all matrix-builtin precondition functions. The selection
  * of other preconditioners, like BlockSOR or ILU should be handled in
  * derived classes by the user.
  *
  * @sect3{Usage}
  * The simplest use of this class is the following:
- * @begin{verbatim}
- *                                  // generate a @p{SolverControl} and
- *                                  // a @p{VectorMemory}
+ * @verbatim
+ *                                  // generate a @p SolverControl and
+ *                                  // a @p VectorMemory
  * SolverControl control;
  * VectorMemory<Vector<double> > memory;
  *                                  // generate a solver
  * SolverCG<SparseMatrix<double>, Vector<double> > solver(control, memory);
- *                                  // generate a @p{PreconditionSelector}
+ *                                  // generate a @p PreconditionSelector
  * PreconditionSelector<SparseMatrix<double>, Vector<double> >
  *   preconditioning("jacobi", 1.);
  *                                  // give a matrix whose diagonal entries
@@ -57,29 +57,29 @@ template <class number> class SparseMatrix;
  *                                  // Generally the matrix of the linear
  *                                  // equation system Ax=b.
  * preconditioning.use_matrix(A);
- *                                  // call the @p{solve} function with this
+ *                                  // call the @p solve function with this
  *                                  // preconditioning as last argument
  * solver.solve(A,x,b,preconditioning);
- * @end{verbatim}
- * The same example where also the @p{SolverSelector} class is used reads
- * @begin{verbatim}
- *                                  // generate a @p{SolverControl} and
- *                                  // a @p{VectorMemory}
+ * @endverbatim
+ * The same example where also the @p SolverSelector class is used reads
+ * @verbatim
+ *                                  // generate a @p SolverControl and
+ *                                  // a @p VectorMemory
  * SolverControl control;
  * VectorMemory<Vector<double> > memory;
- *                                  // generate a @p{SolverSelector} that
- *                                  // calls the @p{SolverCG}
+ *                                  // generate a @p SolverSelector that
+ *                                  // calls the @p SolverCG
  * SolverSelector<SparseMatrix<double>, Vector<double> > 
  *   solver_selector("cg", control, memory);
- *                                  // generate a @p{PreconditionSelector}
+ *                                  // generate a @p PreconditionSelector
  * PreconditionSelector<SparseMatrix<double>, Vector<double> >
  *   preconditioning("jacobi", 1.);
  *
  * preconditioning.use_matrix(A);
  *
  * solver_selector.solve(A,x,b,preconditioning);
- * @end{verbatim}
- * Now the use of the @p{SolverSelector} in combination with the @p{PreconditionSelector}
+ * @endverbatim
+ * Now the use of the @p SolverSelector in combination with the @p PreconditionSelector
  * allows the user to select both, the solver and the preconditioner, at the
  * beginning of his program and each time the
  * solver is started (that is several times e.g. in a nonlinear iteration) this
@@ -94,7 +94,7 @@ class PreconditionSelector : public Subscriptor
   public:
     
                                     /**
-                                     * Constructor. @p{omega} denotes
+                                     * Constructor. @p omega denotes
                                      * the damping parameter of
                                      * the preconditioning.
                                      */
@@ -109,7 +109,7 @@ class PreconditionSelector : public Subscriptor
                                     /**
                                      * Takes the matrix that is needed
                                      * for preconditionings that involves a
-                                     * matrix. e.g. for @p{precondition_jacobi},
+                                     * matrix. e.g. for @p precondition_jacobi,
                                      * @p{~_sor}, @p{~_ssor}.
                                      */
     void use_matrix(const Matrix &M);
@@ -145,7 +145,7 @@ class PreconditionSelector : public Subscriptor
                                     /**
                                      * Matrix that is used for the
                                      * matrix-builtin preconditioning function.
-                                     * cf. also @p{PreconditionUseMatrix}.
+                                     * cf. also @p PreconditionUseMatrix.
                                      */
     SmartPointer<const Matrix> A;
     
index 06c066690a6d04ce92f9c332bd8fd43337116c5e..96ddf15750bed55d467dbd5e434dc9aa34fe4bca 100644 (file)
 /**
  * Schur complement of a block matrix.
  *
- * Given a non-singular matrix @p{A} (often positive definite) and a
- * positive semi-definite matrix @p{C} as well as matrices @p{B} and
- * @p{Dt} of full rank, this class implements a new matrix, the Schur
+ * Given a non-singular matrix @p A (often positive definite) and a
+ * positive semi-definite matrix @p C as well as matrices @p B and
+ * @p Dt of full rank, this class implements a new matrix, the Schur
  * complement a the system of equations of the structure
  *
- * @begin{verbatim}
+ * @verbatim
  * /        \  /   \     /   \
  * |  A  Dt |  | u |  -  | f |
  * | -B  C  |  | p |  -  | g |
  * \        /  \   /     \   /
- * @end{verbatim}
+ * @endverbatim
  *
- * Multiplication with the Schur matrix @p{S} is the operation
- * @begin{verbatim}
+ * Multiplication with the Schur matrix @p S is the operation
+ * @verbatim
  * S p = C p + B A-inverse Dt-transpose p,
- * @end{verbatim}
- * which is an operation within the space for @p{p}.
+ * @endverbatim
+ * which is an operation within the space for @p p.
  *
  * The data handed to the Schur matrix are as follows:
  *
- * @p{A}: the inverse of @p{A} is stored, instead of @p{A}. This
+ * @p A: the inverse of @p A is stored, instead of @p A. This
  * allows the application to use the most efficient form of inversion,
  * iterative or direct.
  *
- * @p{B}, @p{C}: these matrices are stored "as is".
+ * @p B, @p C: these matrices are stored "as is".
  *
- * @p{Dt}: the computation of the Schur complement involves the
- * function @p{Tvmult} of the matrix @p{Dt}, not @p{vmult}! This way,
- * it is sufficient to build only one matrix @p{B} for the symmetric
+ * @p Dt: the computation of the Schur complement involves the
+ * function @p Tvmult of the matrix @p Dt, not @p vmult! This way,
+ * it is sufficient to build only one matrix @p B for the symmetric
  * Schur complement and use it twice.
  *
  * All matrices involved are of arbitrary type and vectors are
- * @ref{BlockVector}s. This way, @p{SchurMatrix} can be coupled with
- * any matrix classes providing @p{vmult} and @p{Tvmult} and can be
- * even nested. Since @ref{SmartPointer}s of matrices are stored, the
- * matrix blocks should be derived from @ref{Subscriptor}.
+ * BlockVectors. This way, @p SchurMatrix can be coupled with
+ * any matrix classes providing @p vmult and @p Tvmult and can be
+ * even nested. Since SmartPointers of matrices are stored, the
+ * matrix blocks should be derived from Subscriptor.
  *
  * Since the Schur complement of a matrix corresponds to a Gaussian
  * block elimination, the right hand side of the condensed system must
  * be preprocessed. Furthermore, the eliminated variable must be
  * reconstructed after solving.
  *
- * @begin{verbatim}
+ * @verbatim
  *   g = g + B A-inverse f
  *   u = A-inverse (f - D-transpose p)
- * @end{verbatim}
+ * @endverbatim
  *
  * Applying these transformations, the solution of the system above by a
- * @p{SchurMatrix} @p{schur} is coded as follows:
+ * @p SchurMatrix @p schur is coded as follows:
  *
- * @begin{verbatim}
+ * @verbatim
  *   schur.prepare_rhs (g, f);
  *   solver.solve (schur, p, g, precondition);
  *   schur.postprocess (u, p);
- * @end{verbatim}
+ * @endverbatim
  *
  * @author Guido Kanschat, 2000, 2001, 2002
  */
@@ -102,7 +102,7 @@ class SchurMatrix :
                                    * for obtaining block vectors.
                                    *
                                    * Optionally, the length of the
-                                   * @p{u}-vector can be provided.
+                                   * @p u-vector can be provided.
                                    *
                                    * For the meaning of the matrices
                                    * see the class documentation.
@@ -126,7 +126,7 @@ class SchurMatrix :
                                    * first argument, which is also
                                    * part of the input data. If it is
                                    * necessary to conserve the data,
-                                   * @p{dst} must be copied before
+                                   * @p dst must be copied before
                                    * calling this function. This is
                                    * reasonable, since in many cases,
                                    * only the pre-processed right
@@ -202,7 +202,7 @@ class SchurMatrix :
   VectorMemory<BlockVector<double> >& mem;
 
                                   /**
-                                   * Optional signature of the @p{u}-vector.
+                                   * Optional signature of the @p u-vector.
                                    */
   std::vector<unsigned int> signature;
   
index b2aeeceafa91b574d1d271b2dd8848ab6130d9a8..bdc8929e63badf86632dda75cd5e06ca26fe420b 100644 (file)
@@ -44,7 +44,7 @@ class SolverControl;
  * that the matrix and vector classes within this library of course
  * conform to this interface.
  *
- * @begin{verbatim}
+ * @verbatim
  * class Matrix
  * {
  *   public:
@@ -96,29 +96,29 @@ class SolverControl;
  *                        // return the l2 norm of the vector
  *     double l2_norm () const;
  * };
- * @end{verbatim}
+ * @endverbatim
  *
  * In addition, for some solvers there has to be a global function
  * @p{swap(VECTOR &a, VECTOR &b)} that exchanges the values of the two vectors.
  *
  * The preconditioners used must have the same interface as matrices,
- * i.e. in particular they have to provide a member function @p{vmult}
+ * i.e. in particular they have to provide a member function @p vmult
  * which denotes the application of the preconditioner.
  *
  *
  * @sect3{AdditionalData}
  *
- * Several solvers need additional data, like the damping parameter @p{omega}
- * of the @p{SolverRichardson} class or the maximum number of temporary
- * vectors of the @p{SolverGMRES}.  To have a standardized constructor for
+ * Several solvers need additional data, like the damping parameter @p omega
+ * of the @p SolverRichardson class or the maximum number of temporary
+ * vectors of the @p SolverGMRES.  To have a standardized constructor for
  * each solver class the @p{struct AdditionalData} has been introduced to each
- * solver class. Some solvers need no additional data, like @p{SolverCG} or
- * @p{SolverBicgstab}. For these solvers the struct @p{AdditionalData} is
+ * solver class. Some solvers need no additional data, like @p SolverCG or
+ * @p SolverBicgstab. For these solvers the struct @p AdditionalData is
  * empty and calling the constructor may be done without giving the additional
- * structure as an argument as a default @p{AdditionalData} is set by default.
+ * structure as an argument as a default @p AdditionalData is set by default.
  *
  * Now the generating of a solver looks like
- * @begin{verbatim}
+ * @verbatim
  *                               // GMRES with 50 tmp vectors
  * SolverGMRES solver_gmres (solver_control, vector_memory,
  *                           SolverGMRES::AdditionalData(50));
@@ -129,13 +129,13 @@ class SolverControl;
  *
  *                               // CG with default AdditionalData
  * SolverCG solver_cg (solver_control, vector_memory);
- * @end{verbatim}
+ * @endverbatim
  *
  * Using a unified constructor parameter list for all solvers was introduced
- * when the @p{SolverSelector} class was written; the unified interface
+ * when the @p SolverSelector class was written; the unified interface
  * enabled us to use this class unchanged even if the number of types of
  * parameters to a certain solver changes and it is still possible in a simple
- * way to give these additional data to the @p{SolverSelector} object for each
+ * way to give these additional data to the @p SolverSelector object for each
  * solver which it may use.
  *
  * @author Wolfgang Bangerth, Guido Kanschat, Ralf Hartmann, 1997-2001
index 6305dcb959db985e299573dc7e7b9794b7368d87..7058d9adfdcce759b71ca53fa2190dff1a04d91b 100644 (file)
  * Bicgstab algorithm by van der Vorst.
  *
  * For the requirements on matrices and vectors in order to work with
- * this class, see the documentation of the @ref{Solver} base class.
+ * this class, see the documentation of the Solver base class.
  *
  * Like all other solver classes, this class has a local structure called
- * @p{AdditionalData} which is used to pass additional parameters to the
+ * @p AdditionalData which is used to pass additional parameters to the
  * solver, like damping parameters or the number of temporary vectors. We
  * use this additional structure instead of passing these values directly
- * to the constructor because this makes the use of the @p{SolverSelector} and
+ * to the constructor because this makes the use of the @p SolverSelector and
  * other classes much easier and guarantees that these will continue to
  * work even if number or type of the additional parameters for a certain
  * solver changes.
  *
  * The Bicgstab-method has two additional parameters: the first is a
  * boolean, deciding whether to compute the actual residual in each
- * step (@p{true}) or to use the length of the computed orthogonal
- * residual (@p{false}). Remark, that computing the residual causes a
+ * step (@p true) or to use the length of the computed orthogonal
+ * residual (@p false). Remark, that computing the residual causes a
  * third matrix-vector-multiplication, though no additional
  * preconditioning, in each step. The reason for doing this is, that
  * the size of the orthogonalized residual computed during the
  * iteration may be larger by orders of magnitude than the true
  * residual. This is due to numerical instabilities related to badly
  * conditioned matrices. Since this instability results in a bad
- * stopping criterion, the default for this parameter is @p{true}.
+ * stopping criterion, the default for this parameter is @p true.
  *
  * The second parameter is the size of a breakdown criterion. It is
  * difficult to find a general good criterion, so if things do not
@@ -63,7 +63,7 @@ class SolverBicgstab : public Solver<VECTOR>
                                     /**
                                      * There are two possibilities to compute
                                      * the residual: one is an estimate using
-                                     * the computed value @p{tau}. The other
+                                     * the computed value @p tau. The other
                                      * is exact computation using another matrix
                                      * vector multiplication.
                                      *
index d691f9a4f88a39a59792bc07feba6ee90778b03d..80e1e49341cfac3533eb4b37bb41bb93b5149693 100644 (file)
  * Preconditioned cg method.
  *
  * For the requirements on matrices and vectors in order to work with
- * this class, see the documentation of the @ref{Solver} base class.
+ * this class, see the documentation of the Solver base class.
  *
  * Like all other solver classes, this class has a local structure
- * called @p{AdditionalData} which is used to pass additional
+ * called @p AdditionalData which is used to pass additional
  * parameters to the solver, like damping parameters or the number of
  * temporary vectors. For this class, there is a switch allowing for
  * additional output for the computation of eigenvalues of the matrix.
  *
  * The cg-method performs an orthogonal projection of the original
  * preconditioned linear system to another system of smaller
- * dimension. Furthermore, the projected matrix @p{T} is
+ * dimension. Furthermore, the projected matrix @p T is
  * tri-diagonal. Since the projection is orthogonal, the eigenvalues
- * of @p{T} approximate those of the original preconditioned matrix
- * @p{PA}. In fact, after @p{n} steps, where @p{n} is the dimension of
+ * of @p T approximate those of the original preconditioned matrix
+ * @p PA. In fact, after @p n steps, where @p n is the dimension of
  * the original system, the eigenvalues of both matrices are
  * equal. But, even for small numbers of iteration steps, the
- * condition number of @p{T} is a good estimate for the one of @p{PA}.
+ * condition number of @p T is a good estimate for the one of @p PA.
  *
- * With the coefficients @p{alpha} and @p{beta} written to the log
+ * With the coefficients @p alpha and @p beta written to the log
  * file if @p{AdditionalData::log_coefficients = true}, the matrix
- * @p{T_m} after @p{m} steps is the tri-diagonal matrix with diagonal
+ * @p T_m after @p m steps is the tri-diagonal matrix with diagonal
  * elements @p{1/alpha_0}, @p{1/alpha_1 + beta_0/alpha_0}, ...,
  * @p{1/alpha_{m-1}+beta_{m-2}/alpha_{m-2}} and off-diagonal elements
  * @p{sqrt(beta_0)/alpha_0}, ..., @p{sqrt(beta_{m-2})/alpha_{m-2}}.
@@ -139,7 +139,7 @@ class SolverCG : public Solver<VECTOR>
 
                                     /**
                                      * Temporary vectors, allocated through
-                                     * the @p{VectorMemory} object at the start
+                                     * the @p VectorMemory object at the start
                                      * of the actual solution process and
                                      * deallocated at the end.
                                      */
@@ -152,11 +152,11 @@ class SolverCG : public Solver<VECTOR>
                                      * Within the iteration loop, the
                                      * square of the residual vector is
                                      * stored in this variable. The
-                                     * function @p{criterion} uses this
+                                     * function @p criterion uses this
                                      * variable to compute the convergence
                                      * value, which in this class is the
                                      * norm of the residual vector and thus
-                                     * the square root of the @p{res2} value.
+                                     * the square root of the @p res2 value.
                                      */
     double res2;
 
index 7848cf3505765768b501f3c71da68e24ccae1ffa..9ec9e6224d9c4f1cae2d1642134a0ef648fb95df 100644 (file)
@@ -31,8 +31,8 @@ class ParameterHandler;
  * called in each iteration with the current iteration step and the
  * value indicating convergence (usually the residual).
  *
- * After the iteration has terminated, the functions @p{last_value} and
- * @p{last_step} can be used to obtain information about the final state
+ * After the iteration has terminated, the functions @p last_value and
+ * @p last_step can be used to obtain information about the final state
  * of the iteration.
  *
  * @p{check()} can be replaced in derived classes to allow for more
@@ -40,26 +40,26 @@ class ParameterHandler;
  *
  *
  * @sect2{State}
- * The return states of the check function are of type @p{State},
+ * The return states of the check function are of type @p State,
  * which is an enum local to this class. It indicates the state the
  * solver is in.
  *
  * The possible values of State are
- * @begin{itemize}
- * @item @p{iterate = 0}: continue the iteration.
- * @item @p{success}: the goal is reached, the iterative method can terminate
+ * <ul>
+ * <li> @p{iterate = 0}: continue the iteration.
+ * <li> @p success: the goal is reached, the iterative method can terminate
  *       successfully.
- * @item @p{failure}: the iterative method should stop because convergence 
+ * <li> @p failure: the iterative method should stop because convergence 
  *       could not be achieved or at least was not achieved within the given
  *       maximal number of iterations.
- * @end{itemize}
+ * </ul>
  */
 class SolverControl : public Subscriptor
 {
   public:
 
                                     /**
-                                     * @p{Enum} denoting the different
+                                     * @p Enum denoting the different
                                      * states a solver can be in. See
                                      * the general documentation of
                                      * this class for more
@@ -117,22 +117,22 @@ class SolverControl : public Subscriptor
     
                                     /**
                                      * Constructor. The parameters
-                                     * @p{n} and @p{tol} are the
+                                     * @p n and @p tol are the
                                      * maximum number of iteration
                                      * steps before failure and the
                                      * tolerance to determine success
                                      * of the iteration.
                                      *
-                                     * @p{log_history} specifies
+                                     * @p log_history specifies
                                      * whether the history (i.e. the
                                      * value to be checked and the
                                      * number of the iteration step)
                                      * shall be printed to
-                                     * @p{deallog} stream.  Default
+                                     * @p deallog stream.  Default
                                      * is: do not print. Similarly,
-                                     * @p{log_result} specifies the
+                                     * @p log_result specifies the
                                      * whether the final result is
-                                     * logged to @p{deallog}. Default
+                                     * logged to @p deallog. Default
                                      * is yes.
                                      */
     SolverControl (const unsigned int n           = 100,
@@ -164,11 +164,11 @@ class SolverControl : public Subscriptor
                                      * to determine, whether the
                                      * allowed number of steps has
                                      * been exceeded and returns
-                                     * @p{failure} in this case. If
-                                     * @p{check_value} is below the
+                                     * @p failure in this case. If
+                                     * @p check_value is below the
                                      * prescribed tolerance, it
-                                     * returns @p{success}. In all
-                                     * other cases @p{iterate} is
+                                     * returns @p success. In all
+                                     * other cases @p iterate is
                                      * returned to suggest
                                      * continuation of the iterative
                                      * procedure.
@@ -176,21 +176,21 @@ class SolverControl : public Subscriptor
                                      * The iteration is also aborted
                                      * if the residual becomes a
                                      * denormalized value
-                                     * (@p{NaN}). Note, however, that
+                                     * (@p NaN). Note, however, that
                                      * this check is only performed
-                                     * if the @p{isnan} function is
+                                     * if the @p isnan function is
                                      * provided by the operating
                                      * system, which is not always
-                                     * true. The @p{configure}
+                                     * true. The @p configure
                                      * scripts checks for this and
-                                     * sets the flag @p{HAVE_ISNAN}
+                                     * sets the flag @p HAVE_ISNAN
                                      * in the file
                                      * @p{Make.global_options} if
                                      * this function was found.
                                      *
                                      * @p{check()} additionally
-                                     * preserves @p{step} and
-                                     * @p{check_value}. These
+                                     * preserves @p step and
+                                     * @p check_value. These
                                      * values are accessible by
                                      * @p{last_value()} and
                                      * @p{last_step()}.
@@ -198,7 +198,7 @@ class SolverControl : public Subscriptor
                                      * Derived classes may overload
                                      * this function, e.g. to log the
                                      * convergence indicators
-                                     * (@p{check_value}) or to do
+                                     * (@p check_value) or to do
                                      * other computations.
                                      */
     virtual State check (const unsigned int step,
@@ -211,7 +211,7 @@ class SolverControl : public Subscriptor
     
                                     /**
                                      * Return the convergence value of last
-                                     * iteration step for which @p{check} was
+                                     * iteration step for which @p check was
                                      * called by the solver.
                                      */
     double last_value() const;
@@ -234,7 +234,7 @@ class SolverControl : public Subscriptor
                                     /**
                                      * Enables the failure
                                      * check. Solving is stopped with
-                                     * @p{ReturnState} @p{failure} if
+                                     * @p ReturnState @p failure if
                                      * @p{residual>failure_residual} with
                                      * @p{failure_residual:=rel_failure_residual*first_residual}.
                                      */
@@ -243,8 +243,8 @@ class SolverControl : public Subscriptor
                                     /**
                                      * Disables failure check and
                                      * resets
-                                     * @p{relative_failure_residual}
-                                     * and @p{failure_residual} to
+                                     * @p relative_failure_residual
+                                     * and @p failure_residual to
                                      * zero.
                                      */
     void clear_failure_criterion ();
@@ -261,13 +261,13 @@ class SolverControl : public Subscriptor
 
                                     /**
                                      * Log each iteration step. Use
-                                     * @p{log_frequency} for skipping
+                                     * @p log_frequency for skipping
                                      * steps.
                                      */
     void log_history (const bool);
 
                                     /**
-                                     * Returns the @p{log_history} flag.
+                                     * Returns the @p log_history flag.
                                      */
     bool log_history () const;
     
@@ -282,7 +282,7 @@ class SolverControl : public Subscriptor
     void log_result (const bool);
     
                                     /**
-                                     * Returns the @p{log_result} flag.
+                                     * Returns the @p log_result flag.
                                      */
     bool log_result () const;
     
@@ -313,24 +313,24 @@ class SolverControl : public Subscriptor
     unsigned int lstep;
 
                                     /**
-                                     * Is set to @p{true} by
-                                     * @p{set_failure_criterion} and
+                                     * Is set to @p true by
+                                     * @p set_failure_criterion and
                                      * enables failure checking.
                                      */
     bool         check_failure;
 
                                     /*
                                      * Stores the
-                                     * @p{rel_failure_residual} set by
-                                     * @p{set_failure_criterion}
+                                     * @p rel_failure_residual set by
+                                     * @p set_failure_criterion
                                      */
     double       relative_failure_residual;
     
                                     /**
-                                     * @p{failure_residual} equals the
+                                     * @p failure_residual equals the
                                      * first residual multiplied by
-                                     * @p{relative_crit} set by
-                                     * @p{set_failure_criterion} (see there).
+                                     * @p relative_crit set by
+                                     * @p set_failure_criterion (see there).
                                      *
                                      * Until the first residual is
                                      * known it is 0.
@@ -339,7 +339,7 @@ class SolverControl : public Subscriptor
     
                                     /**
                                      * Log convergence history to
-                                     * @p{deallog}.
+                                     * @p deallog.
                                      */
     bool         m_log_history;
                                     /**
@@ -349,18 +349,18 @@ class SolverControl : public Subscriptor
     
                                     /**
                                      * Log iteration result to
-                                     * @p{deallog}.  If true, after
+                                     * @p deallog.  If true, after
                                      * finishing the iteration, a
                                      * statement about failure or
-                                     * success together with @p{lstep}
-                                     * and @p{lvalue} are logged.
+                                     * success together with @p lstep
+                                     * and @p lvalue are logged.
                                      */
     bool         m_log_result;
 };
 
 //! Control of the stopping criterion depending on the initial residual.
 /**
- * Specialization of @p{SolverControl} which returns @p{success} if either
+ * Specialization of @p SolverControl which returns @p success if either
  * the specified tolerance is achieved or if the initial residual (or
  * whatever criterion was chosen by the solver class) is reduced by a
  * given factor. This is useful in cases where you don't want to solve
index a873f58359bfadc789ede090bf761814ca96ab13..55d8175a2ef55a15bf5e9b6cbd712d3fd59f7b6c 100644 (file)
@@ -55,8 +55,8 @@ namespace internal
       public:
                                         /**
                                          * Constructor. Prepares an
-                                         * array of @p{VECTOR} of
-                                         * length @p{max_size}.
+                                         * array of @p VECTOR of
+                                         * length @p max_size.
                                          */
        TmpVectors(const unsigned int    max_size,
                   VectorMemory<VECTOR> &vmem);
@@ -68,7 +68,7 @@ namespace internal
 
                                         /**
                                          * Get vector number
-                                         * @p{i}. If this vector was
+                                         * @p i. If this vector was
                                          * unused before, an error
                                          * occurs.
                                          */
@@ -76,11 +76,11 @@ namespace internal
        
                                         /**
                                          * Get vector number
-                                         * @p{i}. Allocate it if
+                                         * @p i. Allocate it if
                                          * necessary.
                                          *
                                          * If a vector must be
-                                         * allocated, @p{temp} is
+                                         * allocated, @p temp is
                                          * used to reinit it to the
                                          * proper dimensions.
                                          */
@@ -122,7 +122,7 @@ namespace internal
  * the number of iterations needed to solve the problem to the given
  * criterion, an intermediate solution is computed and a restart is
  * performed. If you don't want to use the restarted method, you can
- * limit the number of iterations (stated in the @p{SolverControl}
+ * limit the number of iterations (stated in the @p SolverControl
  * object given to the constructor) to be below the number of
  * temporary vectors minus three. Note the subtraction, which is due
  * to the fact that three vectors are used for other purposes, so the
@@ -145,23 +145,23 @@ namespace internal
  * possibilities is to use a good preconditioner.
  *
  * Like all other solver classes, this class has a local structure
- * called @p{AdditionalData} which is used to pass additional
+ * called @p AdditionalData which is used to pass additional
  * parameters to the solver, like the number of temporary vectors for
  * example. We use this additional structure instead of passing these
  * values directly to the constructor because this makes the use of
- * the @p{SolverSelector} and other classes much easier and guarantees
+ * the @p SolverSelector and other classes much easier and guarantees
  * that these will continue to work even if number or type of the
  * additional parameters for a certain solver changes.
  *
- * For the GMRes method, the @p{AdditionalData} structure contains the number
+ * For the GMRes method, the @p AdditionalData structure contains the number
  * of temporary vectors as commented upon above. By default, the number of
- * these vectors is set to 30. The @p{AdditionalData} also containes a flag
+ * these vectors is set to 30. The @p AdditionalData also containes a flag
  * indicating the use of right or left preconditioning. The default is left
  * preconditioning. Finally it includes a flag indicating whether or not the
  * default residual is used as stopping criterion. By default, the left
  * preconditioned GMRes uses the preconditioned residual and the right
  * preconditioned GMRes uses the normal, i.e. unpreconditioned, residual as
- * stopping criterion. If the @p{use_default_residual} flag is @p{false}, the
+ * stopping criterion. If the @p use_default_residual flag is @p false, the
  * left preconditioned GMRes uses as stopping criterion the unpreconditioned
  * residual and the right preconditioned GMRes the preconditioned
  * residual. But be aware that the non-default residuals are not automatically
@@ -171,7 +171,7 @@ namespace internal
  * @p{use_default_residual=false} only for debugging/testing purposes.
  *
  * For the requirements on matrices and vectors in order to work with
- * this class, see the documentation of the @ref{Solver} base class.
+ * this class, see the documentation of the Solver base class.
  *
  * @author Wolfgang Bangerth, Guido Kanschat, Ralf Hartmann.
  */
@@ -271,7 +271,7 @@ class SolverGMRES : public Solver<VECTOR>
                                      */
     FullMatrix<double> H;
                                     /**
-                                     * Auxiliary matrix for inverting @p{H}
+                                     * Auxiliary matrix for inverting @p H
                                      */
     FullMatrix<double> H1;
     
@@ -362,7 +362,7 @@ class SolverFGMRES : public Solver<VECTOR>
                                      */
     FullMatrix<double> H;
                                     /**
-                                     * Auxiliary matrix for inverting @p{H}
+                                     * Auxiliary matrix for inverting @p H
                                      */
     FullMatrix<double> H1;
 };
@@ -633,7 +633,7 @@ SolverGMRES<VECTOR>::solve (const MATRIX         &A,
                                       // are temporary vectors. the
                                       // number of steps actually
                                       // been done is propagated
-                                      // outside through the @p{dim}
+                                      // outside through the @p dim
                                       // variable
       for (unsigned int inner_iteration=0;
           ((inner_iteration < n_tmp_vectors-2)
index 5cee9b351adcc5ce2e93df40c9c0d4df9d32e66a..2c4aa53c04de78a58471f4560ca1f173b6ad6e7d 100644 (file)
  * Preconditioned MinRes method.
  *
  * For the requirements on matrices and vectors in order to work with
- * this class, see the documentation of the @ref{Solver} base class.
+ * this class, see the documentation of the Solver base class.
  *
  * Like all other solver classes, this class has a local structure called
- * @p{AdditionalData} which is used to pass additional parameters to the
+ * @p AdditionalData which is used to pass additional parameters to the
  * solver, like damping parameters or the number of temporary vectors. We
  * use this additional structure instead of passing these values directly
- * to the constructor because this makes the use of the @p{SolverSelector} and
+ * to the constructor because this makes the use of the @p SolverSelector and
  * other classes much easier and guarantees that these will continue to
  * work even if number or type of the additional parameters for a certain
  * solver changes.
@@ -119,7 +119,7 @@ class SolverMinRes : public Solver<VECTOR>
 
                                     /**
                                      * Temporary vectors, allocated through
-                                     * the @p{VectorMemory} object at the start
+                                     * the @p VectorMemory object at the start
                                      * of the actual solution process and
                                      * deallocated at the end.
                                      */
@@ -131,11 +131,11 @@ class SolverMinRes : public Solver<VECTOR>
                                      * Within the iteration loop, the
                                      * square of the residual vector is
                                      * stored in this variable. The
-                                     * function @p{criterion} uses this
+                                     * function @p criterion uses this
                                      * variable to compute the convergence
                                      * value, which in this class is the
                                      * norm of the residual vector and thus
-                                     * the square root of the @p{res2} value.
+                                     * the square root of the @p res2 value.
                                      */
     double res2;
 };
index 0ade9497c837a96c81294573fa071b533f4302b9..4a1b6a7890710b907986b0c21cefbc395977c167 100644 (file)
  * inverse.
  *
  * For the requirements on matrices and vectors in order to work with
- * this class, see the documentation of the @ref{Solver} base class.
+ * this class, see the documentation of the Solver base class.
  *
  * Like all other solver classes, this class has a local structure called
- * @p{AdditionalData} which is used to pass additional parameters to the
+ * @p AdditionalData which is used to pass additional parameters to the
  * solver, like damping parameters or the number of temporary vectors. We
  * use this additional structure instead of passing these values directly
- * to the constructor because this makes the use of the @p{SolverSelector} and
+ * to the constructor because this makes the use of the @p SolverSelector and
  * other classes much easier and guarantees that these will continue to
  * work even if number or type of the additional parameters for a certain
  * solver changes.
@@ -69,7 +69,7 @@ class SolverQMRS : public Solver<VECTOR>
                                      *
                                      * There are two possibilities to compute
                                      * the residual: one is an estimate using
-                                     * the computed value @p{tau}. The other
+                                     * the computed value @p tau. The other
                                      * is exact computation using another matrix
                                      * vector multiplication.
                                      *
@@ -148,7 +148,7 @@ class SolverQMRS : public Solver<VECTOR>
     
                                     /**
                                      * Temporary vectors, allocated through
-                                     * the @p{VectorMemory} object at the start
+                                     * the @p VectorMemory object at the start
                                      * of the actual solution process and
                                      * deallocated at the end.
                                      */
@@ -170,11 +170,11 @@ class SolverQMRS : public Solver<VECTOR>
                                      * Within the iteration loop, the
                                      * square of the residual vector is
                                      * stored in this variable. The
-                                     * function @p{criterion} uses this
+                                     * function @p criterion uses this
                                      * variable to compute the convergence
                                      * value, which in this class is the
                                      * norm of the residual vector and thus
-                                     * the square root of the @p{res2} value.
+                                     * the square root of the @p res2 value.
                                      */
     double res2;
                                     /**
index a136c3c16c082ad4d1b49d5f112712d04f2c4d38..ef0f9bf7ebe7eb75bf405e26818c4f8fb78959fd 100644 (file)
  * is the norm of the residual.
  *
  * For the requirements on matrices and vectors in order to work with
- * this class, see the documentation of the @ref{Solver} base class.
+ * this class, see the documentation of the Solver base class.
  *
  * Like all other solver classes, this class has a local structure called
- * @p{AdditionalData} which is used to pass additional parameters to the
+ * @p AdditionalData which is used to pass additional parameters to the
  * solver, like damping parameters or the number of temporary vectors. We
  * use this additional structure instead of passing these values directly
- * to the constructor because this makes the use of the @p{SolverSelector} and
+ * to the constructor because this makes the use of the @p SolverSelector and
  * other classes much easier and guarantees that these will continue to
  * work even if number or type of the additional parameters for a certain
  * solver changes.
  *
  * For the Richardson method, the additional data is the damping parameter,
- * which is the only content of the @p{AdditionalData} structure. By default,
+ * which is the only content of the @p AdditionalData structure. By default,
  * the constructor of the structure sets it to one.
  *
  * @author Ralf Hartmann
@@ -139,7 +139,7 @@ class SolverRichardson : public Solver<VECTOR>
     
                                     /**
                                      * Temporary vectors, allocated through
-                                     * the @p{VectorMemory} object at the start
+                                     * the @p VectorMemory object at the start
                                      * of the actual solution process and
                                      * deallocated at the end.
                                      */
@@ -155,11 +155,11 @@ class SolverRichardson : public Solver<VECTOR>
                                      * Within the iteration loop, the
                                      * norm of the residual is
                                      * stored in this variable. The
-                                     * function @p{criterion} uses this
+                                     * function @p criterion uses this
                                      * variable to compute the convergence
                                      * value, which in this class is the
                                      * norm of the residual vector and thus
-                                     * the square root of the @p{res2} value.
+                                     * the square root of the @p res2 value.
                                      */
     typename VECTOR::value_type res;
 };
index 52775c6f19fe0850bcc79760bac6fbf6c0de3221..ef93a69790c4b08d8fae0090b153504a011d9cfc 100644 (file)
 
 //! Selects a solver by changing a parameter.
 /**
- * By calling the @p{solve} function of this @p{SolverSelector}, it selects
- * the @p{solve} function of that @p{Solver} that was specified in the constructor
+ * By calling the @p solve function of this @p SolverSelector, it selects
+ * the @p solve function of that @p Solver that was specified in the constructor
  * of this class.
  *
  * @sect3{Usage}
  * The simplest use of this class is the following:
- * @begin{verbatim}
- *                                  // generate a @p{SolverControl} and
- *                                  // a @p{VectorMemory}
+ * @verbatim
+ *                                  // generate a @p SolverControl and
+ *                                  // a @p VectorMemory
  * SolverControl control;
  * VectorMemory<Vector<double> > memory;
  *                                  // Line 3:
  *                                  //
- *                                  // generate a @p{SolverSelector} that
- *                                  // calls the @p{SolverCG}
+ *                                  // generate a @p SolverSelector that
+ *                                  // calls the @p SolverCG
  * SolverSelector<SparseMatrix<double>, Vector<double> > 
  *   solver_selector("cg", control, memory);
- *                                  // generate e.g. a @p{PreconditionRelaxation}
+ *                                  // generate e.g. a @p PreconditionRelaxation
  * PreconditionRelaxation<SparseMatrix<double>, Vector<double> >
  *   preconditioning(A, &SparseMatrix<double>
  *                   ::template precondition_SSOR<double>,0.8);
- *                                  // call the @p{solve} function with this
+ *                                  // call the @p solve function with this
  *                                  // preconditioning as last argument
  * solver_selector.solve(A,x,b,preconditioning);
- * @end{verbatim}
- * But the full usefulness of the @p{SolverSelector} class is not
+ * @endverbatim
+ * But the full usefulness of the @p SolverSelector class is not
  * clear until the presentation of the following example that assumes
- * the user using the @p{ParameterHandler} class and having declared a
+ * the user using the @p ParameterHandler class and having declared a
  * "solver" entry, e.g. with
- * @begin{verbatim}
+ * @verbatim
  * Parameter_Handler prm;
  * prm.declare_entry ("solver", "none",
  *                    Patterns::Sequence(SolverSelector::get_solver_names()));
  * ...
- * @end{verbatim}
+ * @endverbatim
  * Assuming that in the users parameter file there exists the line
- * @begin{verbatim}
+ * @verbatim
  * set solver = cg
- * @end{verbatim}
+ * @endverbatim
  * then `Line 3' of the above example reads
- * @begin{verbatim}
+ * @verbatim
  * SolverSelector<SparseMatrix<double>, Vector<double> > 
  *   solver_selector(prm.get("solver"), control, memory);
- * @end{verbatim}
+ * @endverbatim
  *
  *
  * If at some time there exists a new solver "xyz" then the user does not need
- * to change his program. Only in the implementation of the @p{SolverSelector}
+ * to change his program. Only in the implementation of the @p SolverSelector
  * the calling of this solver has to be added and each user with program lines
  * quoted above only needs to 'set solver = xyz' in his parameter file to get
  * access to that new solver.  :-)
  *
- * (By the way, thanks to Wolfgang for implementing the @p{ParameterHandler}.)
+ * (By the way, thanks to Wolfgang for implementing the @p ParameterHandler.)
  * 
  * @author Ralf Hartmann, 1999
  */
@@ -95,9 +95,9 @@ class SolverSelector : public Subscriptor
   public:
 
                                     /**
-                                     * Constructor. Takes the @p{SolverName},
-                                     * the @p{SolverControl} and the 
-                                     * @p{VectorMemory} as argument.
+                                     * Constructor. Takes the @p SolverName,
+                                     * the @p SolverControl and the 
+                                     * @p VectorMemory as argument.
                                      */
     SolverSelector (const std::string    &solvername,
                    SolverControl        &control,
@@ -109,9 +109,9 @@ class SolverSelector : public Subscriptor
     ~SolverSelector();
 
                                     /**
-                                     * Solver procedure. Calls the @p{solve}
+                                     * Solver procedure. Calls the @p solve
                                      * function
-                                     * of the @p{solver} whose @p{SolverName}
+                                     * of the @p solver whose @p SolverName
                                      * was specified in the constructor.
                                      * 
                                      */
@@ -123,35 +123,35 @@ class SolverSelector : public Subscriptor
     
                                     /**
                                      * Set the additional data. For more
-                                     * info see the @p{Solver} class.
+                                     * info see the @p Solver class.
                                      */
     void set_data(const typename SolverRichardson<VECTOR>
                  ::AdditionalData &data);
 
                                     /**
                                      * Set the additional data. For more
-                                     * info see the @p{Solver} class.
+                                     * info see the @p Solver class.
                                      */
     void set_data(const typename SolverCG<VECTOR>
                  ::AdditionalData &data);
 
                                     /**
                                      * Set the additional data. For more
-                                     * info see the @p{Solver} class.
+                                     * info see the @p Solver class.
                                      */
     void set_data(const typename SolverBicgstab<VECTOR>
                  ::AdditionalData &data); 
 
                                     /**
                                      * Set the additional data. For more
-                                     * info see the @p{Solver} class.
+                                     * info see the @p Solver class.
                                      */
     void set_data(const typename SolverGMRES<VECTOR>
                  ::AdditionalData &data);
 
                                     /**
                                      * Set the additional data. For more
-                                     * info see the @p{Solver} class.
+                                     * info see the @p Solver class.
                                      */
     void set_data(const typename SolverFGMRES<VECTOR>
                  ::AdditionalData &data);
@@ -176,16 +176,16 @@ class SolverSelector : public Subscriptor
     std::string solver_name;
     
                                     /**
-                                     * Stores the @p{SolverControl} that
+                                     * Stores the @p SolverControl that
                                      * is needed in the constructor of
-                                     * each @p{Solver} class.
+                                     * each @p Solver class.
                                      */
     SmartPointer<SolverControl> control;
 
                                     /**
-                                     * Stores the @p{VectorMemory} that
+                                     * Stores the @p VectorMemory that
                                      * is needed in the constructor of
-                                     * each @p{Solver} class.
+                                     * each @p Solver class.
                                      */
     SmartPointer<VectorMemory<VECTOR> > vector_memory;
 
index 6cc8d97e900f6de513fa5724f4e8a36f59327e4d..10a06d587570ca816ac539e42090803782eb7f16 100644 (file)
  * to the sparse direct solver routines are not multithreading-safe,
  * i.e. at each time there may only be one call to these functions
  * active. You have to synchronise your calls to the functions
- * provided by this class using mutexes (see the @ref{Threads}
+ * provided by this class using mutexes (see the Threads
  * namespace for such classes) to avoid multiple active calls at the
  * same time if you use multithreading. Since you may use this class
  * in different parts of your program, and may not want to use a
@@ -631,7 +631,7 @@ class SparseDirectMA27 : public Subscriptor
  * to the sparse direct solver routines is not multithreading-capable,
  * i.e. at each time there may only be one call to these functions
  * active. You have to synchronise your calls to the functions
- * provided by this class using mutexes (see the @ref{Threads}
+ * provided by this class using mutexes (see the Threads
  * namespace for such classes) to avoid multiple active calls at the
  * same time if you use multithreading. Since you may use this class
  * in different parts of your program, and may not want to use a
index da5842073a22acdfb0608c18b533b480eab3c3fe..b120ee20f49ae2cd7f56e6ff482bda549be7cdf0 100644 (file)
@@ -29,9 +29,9 @@
  * in the decomposition that do not fit into the sparsity structure of this
  * object are discarded.
  *
- * The algorithm used by this class is as follows (indices run from @p{0}
- * to @p{N-1}):
- * @begin{verbatim}
+ * The algorithm used by this class is as follows (indices run from @p 0
+ * to @p N-1):
+ * @verbatim
  * copy original matrix into a[i,j]
  * 
  * for i=1..N-1
  *     for j=k+1..N-1
  *      if (a[i,j] exists & a[k,j] exists)
  *        a[i,j] -= a[i,k] * a[k,j]
- * @end{verbatim}
+ * @endverbatim
  *
  * 
  * @sect2{Usage and state management}
  *
- * Refer to @ref{SparseLUDecomposition} documentation for suggested
+ * Refer to SparseLUDecomposition documentation for suggested
  * usage and state management.
  *
  * 
@@ -73,10 +73,10 @@ class SparseILU : public SparseLUDecomposition<number>
                                      /**
                                       * Constructor. Does nothing.
                                      *
-                                     * Call the @p{initialize}
+                                     * Call the @p initialize
                                      * function before using this
                                      * object as preconditioner
-                                     * (@p{vmult}).
+                                     * (@p vmult).
                                       */
     SparseILU ();
 
@@ -89,7 +89,7 @@ class SparseILU : public SparseLUDecomposition<number>
     SparseILU (const SparsityPattern &sparsity);
 
                                     /**
-                                     * Make the @p{AdditionalData}
+                                     * Make the @p AdditionalData
                                      * type in the base class
                                      * accessible to this class as
                                      * well.
@@ -113,15 +113,15 @@ class SparseILU : public SparseLUDecomposition<number>
                                      * class documentation of
                                      * SparseLUDecomposition and the
                                      * documentation of the
-                                     * @p{SparseLUDecomposition::AdditionalData}
+                                     * @p SparseLUDecomposition::AdditionalData
                                      * class.
                                      *
                                      * According to the
-                                     * @p{parameters}, this function
+                                     * @p parameters, this function
                                      * creates a new SparsityPattern
                                      * or keeps the previous sparsity
                                      * or takes the sparsity given by
-                                     * the user to @p{data}. Then,
+                                     * the user to @p data. Then,
                                      * this function performs the LU
                                      * decomposition.
                                      *
@@ -158,7 +158,7 @@ class SparseILU : public SparseLUDecomposition<number>
                                      * i.e. do one forward-backward step
                                      * $dst=(LU)^{-1}src$.
                                      *
-                                     * The @p{initialize} function
+                                     * The @p initialize function
                                      * needs to be called beforehand.
                                      */
     template <typename somenumber>
index b2c029dc801c98550cf0133c46ab9940ef5ed922..b12bb0864b60c90c67ca2ffb0ded7737581a2cb6 100644 (file)
@@ -33,17 +33,17 @@ template<typename number> class FullMatrix;
  *
  * Instead of using a pre-assembled sparsity pattern, this matrix
  * builds the pattern on the fly. Filling the matrix may consume more
- * time as with @p{SparseMatrix}, since large memory movements may be
+ * time as with @p SparseMatrix, since large memory movements may be
  * involved. To help optimizing things, an expected row-length may be
  * provided to the constructor, as well as an increment size
  * for rows.
  *
  * The storage structure: like with the usual sparse matrix, it is
  * attempted to store only non-zero elements. these are stored in a
- * single data array @p{data}. They are ordered by row and inside each
+ * single data array @p data. They are ordered by row and inside each
  * row by column number. Each row is described by its starting point
  * in the data array and its length. These are stored in the
- * @p{row_info} array, together with additional useful information.
+ * @p row_info array, together with additional useful information.
  *
  * Due to the structure, gaps may occur between rows. Whenever a new
  * entry must be created, an attempt is made to use the gap in its
@@ -52,35 +52,35 @@ template<typename number> class FullMatrix;
  * operation and should be avoided as much as possible.
  *
  * This is, where the optimization parameters, provided to the
- * constructor or to the function @p{reinit} come
- * in. @p{default_row_length} is the amount of entries that will be
+ * constructor or to the function @p reinit come
+ * in. @p default_row_length is the amount of entries that will be
  * allocated for each row on initialization (the actual length of the
- * rows is still zero). This means, that @p{default_row_length}
+ * rows is still zero). This means, that @p default_row_length
  * entries can be added to this row without shifting other rows. If
  * less entries are added, the additional memory will be wasted.
  *
  * If the space for a row is not sufficient, then it is enlarged by
- * @p{default_increment} entries. This way, the subsequent rows are
+ * @p default_increment entries. This way, the subsequent rows are
  * not shifted by single entries very often.
  *
- * Finally, the @p{default_reserve} allocates extra space at the end
+ * Finally, the @p default_reserve allocates extra space at the end
  * of the data array. This space is used whenever a row must be
- * enlarged. Since @p{std::vector} doubles the capacity everytime it
+ * enlarged. Since @p std::vector doubles the capacity everytime it
  * must increase it, this value should allow for all the growth needed.
  *
- * Suggested settings: @p{default_row_length} should be the length of
+ * Suggested settings: @p default_row_length should be the length of
  * a typical row, for instance the size of the stencil in regular
- * parts of the grid. Then, @p{default_increment} may be the expected
+ * parts of the grid. Then, @p default_increment may be the expected
  * amount of entries added to the row by having one hanging node. This
  * way, a good compromise between memory consumption and speed should
- * be achieved. @p{default_reserve} should then be an estimate for the
- * number of hanging nodes times @p{default_increment}.
+ * be achieved. @p default_reserve should then be an estimate for the
+ * number of hanging nodes times @p default_increment.
  *
- * Letting @p{default_increment} zero causes an exception whenever a
+ * Letting @p default_increment zero causes an exception whenever a
  * row overflows.
  *
  * If the rows are expected to be filled more or less from first to
- * last, using a @p{default_row_length} of zero may not be such a bad
+ * last, using a @p default_row_length of zero may not be such a bad
  * idea.
  *
  * The name of this matrix is in reverence to a publication of the
@@ -103,8 +103,8 @@ class SparseMatrixEZ : public Subscriptor
     {
                                         /**
                                          * Standard constructor. Sets
-                                         * @p{column} to
-                                         * @p{invalid}.
+                                         * @p column to
+                                         * @p invalid.
                                          */
        Entry();
 
@@ -350,7 +350,7 @@ class SparseMatrixEZ : public Subscriptor
                                      *
                                      * If you really want to copy a whole
                                      * matrix, you can do so by using the
-                                     * @p{copy_from} function.
+                                     * @p copy_from function.
                                      */
     SparseMatrixEZ (const SparseMatrixEZ &);
 
@@ -359,8 +359,8 @@ class SparseMatrixEZ : public Subscriptor
                                      * matrix of the given size,
                                      * ready to be filled. The
                                      * optional parameters
-                                     * @p{default_row_length} and
-                                     * @p{default_increment} allow
+                                     * @p default_row_length and
+                                     * @p default_increment allow
                                      * for preallocating
                                      * memory. Providing these
                                      * properly is essential for an
@@ -391,9 +391,9 @@ class SparseMatrixEZ : public Subscriptor
                                      * The matrix will have no
                                      * entries at this point. The
                                      * optional parameters
-                                     * @p{default_row_length},
-                                     * @p{default_increment} and
-                                     * @p{reserve} allow
+                                     * @p default_row_length,
+                                     * @p default_increment and
+                                     * @p reserve allow
                                      * for preallocating
                                      * memory. Providing these
                                      * properly is essential for an
@@ -441,15 +441,15 @@ class SparseMatrixEZ : public Subscriptor
 
                                     /**
                                      * Set the element @p{(i,j)} to
-                                     * @p{value}. Allocates the entry,
+                                     * @p value. Allocates the entry,
                                      * if it does not exist and
-                                     * @p{value} is non-zero.
+                                     * @p value is non-zero.
                                      */
     void set (const unsigned int i, const unsigned int j,
              const number value);
     
                                     /**
-                                     * Add @p{value} to the element
+                                     * Add @p value to the element
                                      * @p{(i,j)}. Allocates the entry
                                      * if it does not exist. Filters
                                      * out zeroes automatically.
@@ -480,7 +480,7 @@ class SparseMatrixEZ : public Subscriptor
                                      * symmetrization. Symmetrization
                                      * of the sparsity pattern can be
                                      * obtain by the
-                                     * @ref{SparsityPattern}@p{::symmetrize}
+                                     * SparsityPattern@p ::symmetrize
                                      * function.
                                      */
 //    void symmetrize ();
@@ -509,7 +509,7 @@ class SparseMatrixEZ : public Subscriptor
                                      * data type of this matrix.
                                      *
                                      * The function returns a reference to
-                                     * @p{this}.
+                                     * @p this.
                                      */
     template <class MATRIX>
     SparseMatrixEZ<number> &
@@ -518,7 +518,7 @@ class SparseMatrixEZ : public Subscriptor
                                     /**
                                      * This function is complete
                                      * analogous to the
-                                     * @ref{SparsityPattern}@p{::copy_from}
+                                     * SparsityPattern@p ::copy_from
                                      * function in that it allows to
                                      * initialize a whole matrix in
                                      * one step. See there for more
@@ -533,10 +533,10 @@ class SparseMatrixEZ : public Subscriptor
                                      * objects which the inner
                                      * iterator points to need to be
                                      * of type @p{std::pair<unsigned int, value},
-                                     * where @p{value}
+                                     * where @p value
                                      * needs to be convertible to the
                                      * element type of this class, as
-                                     * specified by the @p{number}
+                                     * specified by the @p number
                                      * template argument.
                                      *
                                      * Previous content of the matrix
@@ -565,15 +565,15 @@ class SparseMatrixEZ : public Subscriptor
 //    void copy_from (const FullMatrix<somenumber> &matrix);
     
                                     /**
-                                     * Add @p{matrix} scaled by
-                                     * @p{factor} to this matrix.
+                                     * Add @p matrix scaled by
+                                     * @p factor to this matrix.
                                      *
                                      * The source matrix may be a
                                      * matrix of arbitrary type, as
                                      * long as its data type is
                                      * convertible to the data type
                                      * of this matrix and it has the
-                                     * standard @p{const_iterator}.
+                                     * standard @p const_iterator.
                                      */
     template <class MATRIX>
     void add_scaled (const number factor,
@@ -594,7 +594,7 @@ class SparseMatrixEZ : public Subscriptor
                                      * that returns zero instead (for
                                      * entries that are not in the
                                      * sparsity pattern of the
-                                     * matrix), use the @p{el}
+                                     * matrix), use the @p el
                                      * function.
                                      */
     number operator () (const unsigned int i,
@@ -610,7 +610,7 @@ class SparseMatrixEZ : public Subscriptor
 
                                     /**
                                      * Return the main diagonal element in
-                                     * the @p{i}th row. This function throws an
+                                     * the @p ith row. This function throws an
                                      * error if the matrix is not square.
                                      *
                                      * This function is considerably
@@ -645,7 +645,7 @@ class SparseMatrixEZ : public Subscriptor
                                      * let $dst = M^T*src$ with $M$
                                      * being this matrix. This
                                      * function does the same as
-                                     * @p{vmult} but takes the
+                                     * @p vmult but takes the
                                      * transposed matrix.
                                      */
     template <typename somenumber>
@@ -667,7 +667,7 @@ class SparseMatrixEZ : public Subscriptor
                                      * multiplication. Add $M^T*src$
                                      * to $dst$ with $M$ being this
                                      * matrix. This function does the
-                                     * same as @p{vmult_add} but takes
+                                     * same as @p vmult_add but takes
                                      * the transposed matrix.
                                      */
     template <typename somenumber>
@@ -739,11 +739,11 @@ class SparseMatrixEZ : public Subscriptor
                                      * Apply the Jacobi
                                      * preconditioner, which
                                      * multiplies every element of
-                                     * the @p{src} vector by the
+                                     * the @p src vector by the
                                      * inverse of the respective
                                      * diagonal element and
                                      * multiplies the result with the
-                                     * damping factor @p{omega}.
+                                     * damping factor @p omega.
                                      */
     template <typename somenumber>
     void precondition_Jacobi (Vector<somenumber>       &dst,
@@ -752,7 +752,7 @@ class SparseMatrixEZ : public Subscriptor
 
                                     /**
                                      * Apply SSOR preconditioning to
-                                     * @p{src}.
+                                     * @p src.
                                      */
     template <typename somenumber>
     void precondition_SSOR (Vector<somenumber>       &dst,
@@ -760,7 +760,7 @@ class SparseMatrixEZ : public Subscriptor
                            const number              om = 1.) const;
 
                                     /**
-                                     * Apply SOR preconditioning matrix to @p{src}.
+                                     * Apply SOR preconditioning matrix to @p src.
                                      * The result of this method is
                                      * $dst = (om D - L)^{-1} src$.
                                      */
@@ -770,7 +770,7 @@ class SparseMatrixEZ : public Subscriptor
                           const number              om = 1.) const;
     
                                     /**
-                                     * Apply transpose SOR preconditioning matrix to @p{src}.
+                                     * Apply transpose SOR preconditioning matrix to @p src.
                                      * The result of this method is
                                      * $dst = (om D - U)^{-1} src$.
                                      */
@@ -780,16 +780,16 @@ class SparseMatrixEZ : public Subscriptor
                            const number              om = 1.) const;
 
                                     /**
-                                     * Add the matrix @p{A}
-                                     * conjugated by @p{B}, that is,
+                                     * Add the matrix @p A
+                                     * conjugated by @p B, that is,
                                      * $B A B^T$ to this object. If
-                                     * the parameter @p{transpose} is
+                                     * the parameter @p transpose is
                                      * true, compute $B^T A B$.
                                      *
                                      * This function requires that
-                                     * @p{B} has a @p{const_iterator}
+                                     * @p B has a @p const_iterator
                                      * traversing all matrix entries
-                                     * and that @p{A} has a function
+                                     * and that @p A has a function
                                      * @p{el(i,j)} for access to a
                                      * specific entry.
                                      */
@@ -811,16 +811,16 @@ class SparseMatrixEZ : public Subscriptor
     
                                     /**
                                      * STL-like iterator with the
-                                     * first entry of row @p{r}. If
+                                     * first entry of row @p r. If
                                      * this row is empty, the result
                                      * is @p{end(r)}, which does NOT
-                                     * point into row @p{r}..
+                                     * point into row @p r..
                                      */
     const_iterator begin (const unsigned int r) const;
 
                                     /**
                                      * Final iterator of row
-                                     * @p{r}. The result may be
+                                     * @p r. The result may be
                                      * different from @p{end()}!
                                      */
     const_iterator end (const unsigned int r) const;
@@ -862,12 +862,12 @@ class SparseMatrixEZ : public Subscriptor
                                      *
                                      * The parameters allow for a
                                      * flexible setting of the output
-                                     * format: @p{precision} and
-                                     * @p{scientific} are used to
+                                     * format: @p precision and
+                                     * @p scientific are used to
                                      * determine the number format,
-                                     * where @p{scientific} = @p{false}
+                                     * where @p scientific = @p false
                                      * means fixed point notation.  A
-                                     * zero entry for @p{width} makes
+                                     * zero entry for @p width makes
                                      * the function compute a width,
                                      * but it may be changed to a
                                      * positive value, if output is
@@ -906,7 +906,7 @@ class SparseMatrixEZ : public Subscriptor
                                     /**
                                      * Read data that has previously
                                      * been written by
-                                     * @p{block_write}.
+                                     * @p block_write.
                                      *
                                      * The object is resized on this
                                      * operation, and all previous
@@ -931,8 +931,8 @@ class SparseMatrixEZ : public Subscriptor
     unsigned int memory_consumption () const;
 
                                     /**
-                                     * Print statistics. If @p{full}
-                                     * is @p{true}, prints a
+                                     * Print statistics. If @p full
+                                     * is @p true, prints a
                                      * histogram of all existing row
                                      * lengths and allocated row
                                      * lengths. Otherwise, just the
@@ -1011,11 +1011,11 @@ class SparseMatrixEZ : public Subscriptor
                     const unsigned int col);
     
                                     /**
-                                     * Version of @p{vmult} which only
+                                     * Version of @p vmult which only
                                      * performs its actions on the
                                      * region defined by
                                      * @p{[begin_row,end_row)}. This
-                                     * function is called by @p{vmult}
+                                     * function is called by @p vmult
                                      * in the case of enabled
                                      * multithreading.
                                      */
@@ -1027,12 +1027,12 @@ class SparseMatrixEZ : public Subscriptor
 
                                     /**
                                      * Version of
-                                     * @p{matrix_norm_square} which
+                                     * @p matrix_norm_square which
                                      * only performs its actions on
                                      * the region defined by
                                      * @p{[begin_row,end_row)}. This
                                      * function is called by
-                                     * @p{matrix_norm_square} in the
+                                     * @p matrix_norm_square in the
                                      * case of enabled
                                      * multithreading.
                                      */
@@ -1044,12 +1044,12 @@ class SparseMatrixEZ : public Subscriptor
 
                                     /**
                                      * Version of
-                                     * @p{matrix_scalar_product} which
+                                     * @p matrix_scalar_product which
                                      * only performs its actions on
                                      * the region defined by
                                      * @p{[begin_row,end_row)}. This
                                      * function is called by
-                                     * @p{matrix_scalar_product} in the
+                                     * @p matrix_scalar_product in the
                                      * case of enabled
                                      * multithreading.
                                      */
index 20f51f8e291bb92ed242931442ea742f8110f374..ff808520a916ecaa7b2ea78496a1fff768a5b2b2 100644 (file)
@@ -22,7 +22,7 @@
 /**
  * Modified incomplete Cholesky (MIC(0)) preconditioner.  This class
  * conforms to the state and usage specification in
- * @ref{SparseLUDecomposition}.
+ * SparseLUDecomposition.
  *
  * 
  * @sect2{The decomposition}
@@ -42,7 +42,7 @@ class SparseMIC : public SparseLUDecomposition<number>
   public:
                                      /**
                                       * Constructor. Does nothing, so
-                                      * you have to call @p{reinit}
+                                      * you have to call @p reinit
                                       * sometimes afterwards.
                                       */
     SparseMIC ();
@@ -69,7 +69,7 @@ class SparseMIC : public SparseLUDecomposition<number>
     virtual void clear();
 
                                     /**
-                                     * Make the @p{AdditionalData}
+                                     * Make the @p AdditionalData
                                      * type in the base class
                                      * accessible to this class as
                                      * well.
@@ -95,7 +95,7 @@ class SparseMIC : public SparseLUDecomposition<number>
     void reinit (const SparsityPattern &sparsity);
 
                                     /**
-                                     * Same as @p{decompose}.
+                                     * Same as @p decompose.
                                      */
     template <typename somenumber>
     void initialize (const SparseMatrix<somenumber> &matrix,
@@ -116,7 +116,7 @@ class SparseMIC : public SparseLUDecomposition<number>
                                      * i.e. do one forward-backward step
                                      * $dst=(LU)^{-1}src$.
                                      *
-                                     * Call @p{initialize} before
+                                     * Call @p initialize before
                                      * calling this function.
                                      */
     template <typename somenumber>
index 9bfd1d648f7e1473e3fee0eb2f8ff6da062be1f6..1b4549995947c279f04173cfe56b396c1f72eaa7 100644 (file)
@@ -57,7 +57,7 @@ template <typename number> class SparseBlockVanka;
  * For each selected degree of freedom, a local system of equations is built
  * by the degree of freedom itself and all other values coupling immediately,
  * i.e. the set of degrees of freedom considered for the local system of
- * equations for degree of freedom @p{i} is @p{i} itself and all @p{j} such that
+ * equations for degree of freedom @p i is @p i itself and all @p j such that
  * the element @p{(i,j)} is a nonzero entry in the sparse matrix under 
  * consideration. The elements @p{(j,i)} are not considered. We now pick all
  * matrix entries from rows and columns out of the set of degrees of freedom
@@ -88,7 +88,7 @@ template <typename number> class SparseBlockVanka;
  * This little example is taken from a program doing parameter optimization.
  * The Lagrange multiplier is the third component of the finite element
  * used. The system is solved by the GMRES method.
- * @begin{verbatim}
+ * @verbatim
  *                        // tag the Lagrange multiplier variable
  *    vector<bool> signature(3);
  *    signature[0] = signature[1] = false;
@@ -108,7 +108,7 @@ template <typename number> class SparseBlockVanka;
  *                       // solve
  *    gmres.solve (global_matrix, solution, right_hand_side,
  *                vanka);
- * @end{verbatim}
+ * @endverbatim
  *
  *
  * @sect4{Implementor's remark}
@@ -139,7 +139,7 @@ class SparseVanka
                                     /**
                                      * Constructor. Gets the matrix
                                      * for preconditioning and a bit
-                                     * vector with entries @p{true} for
+                                     * vector with entries @p true for
                                      * all rows to be updated. A
                                      * reference to this vector will
                                      * be stored, so it must persist
@@ -147,7 +147,7 @@ class SparseVanka
                                      * object. The same is true for
                                      * the matrix.
                                      *
-                                     * The matrix @p{M} which is passed
+                                     * The matrix @p M which is passed
                                      * here may or may not be the
                                      * same matrix for which this
                                      * object shall act as
@@ -160,27 +160,27 @@ class SparseVanka
                                      * where the matrix changes in
                                      * each step slightly.
                                      *
-                                     * If @p{conserve_mem} is @p{false},
+                                     * If @p conserve_mem is @p false,
                                      * then the inverses of the local
                                      * systems are computed now, if
-                                     * the flag is @p{true}, then they
+                                     * the flag is @p true, then they
                                      * are computed every time the
                                      * preconditioner is
                                      * applied. This saves some
                                      * memory, but makes
                                      * preconditioning very
                                      * slow. Note also, that if the
-                                     * flag is @p{false}, the the
-                                     * contents of the matrix @p{M} at
+                                     * flag is @p false, the the
+                                     * contents of the matrix @p M at
                                      * the time of calling this
                                      * constructor are used, while if
-                                     * the flag is @p{true}, then the
-                                     * values in @p{M} at the time of
+                                     * the flag is @p true, then the
+                                     * values in @p M at the time of
                                      * preconditioning are used. This
                                      * may lead to different results,
-                                     * obviously, of @p{M} changes.
+                                     * obviously, of @p M changes.
                                      *
-                                     * The parameter @p{n_threads}
+                                     * The parameter @p n_threads
                                      * determines how many threads
                                      * shall be used in parallel when
                                      * building the inverses of the
@@ -205,8 +205,8 @@ class SparseVanka
                                     /**
                                      * Do the preconditioning.
                                      * This function takes the residual
-                                     * in @p{src} and returns the resulting
-                                     * update vector in @p{dst}.
+                                     * in @p src and returns the resulting
+                                     * update vector in @p dst.
                                      */
     template<typename number2>
     void vmult (Vector<number2>       &dst,
@@ -228,12 +228,12 @@ class SparseVanka
                                     /**
                                      * Apply the inverses
                                      * corresponding to those degrees
-                                     * of freedom that have a @p{true}
-                                     * value in @p{dof_mask}, to the
-                                     * @p{src} vector and move the
-                                     * result into @p{dst}. Actually,
+                                     * of freedom that have a @p true
+                                     * value in @p dof_mask, to the
+                                     * @p src vector and move the
+                                     * result into @p dst. Actually,
                                      * only values for allowed
-                                     * indices are written to @p{dst},
+                                     * indices are written to @p dst,
                                      * so the application of this
                                      * function only does what is
                                      * announced in the general
@@ -248,13 +248,13 @@ class SparseVanka
                                      * parallelize the
                                      * application. Then, it is
                                      * important to only write to
-                                     * some slices of @p{dst}, in order
+                                     * some slices of @p dst, in order
                                      * to eliminate the dependencies
                                      * of threads of each other.
                                      *
                                      * If a null pointer is passed
                                      * instead of a pointer to the
-                                     * @p{dof_mask} (as is the default
+                                     * @p dof_mask (as is the default
                                      * value), then it is assumed
                                      * that we shall work on all
                                      * degrees of freedom. This is
@@ -262,7 +262,7 @@ class SparseVanka
                                      * function with a
                                      * @p{vector<bool>(n_dofs,true)}.
                                      *
-                                     * The @p{vmult} of this class
+                                     * The @p vmult of this class
                                      * of course calls this function
                                      * with a null pointer
                                      */
@@ -307,7 +307,7 @@ class SparseVanka
                                      * Array of inverse matrices,
                                      * one for each degree of freedom.
                                      * Only those elements will be used
-                                     * that are tagged in @p{selected}.
+                                     * that are tagged in @p selected.
                                      */
     mutable std::vector<SmartPointer<FullMatrix<float> > > inverses;
 
@@ -334,7 +334,7 @@ class SparseVanka
                                     /**
                                      * Compute the inverse of the
                                      * block located at position
-                                     * @p{row}. Since the vector is
+                                     * @p row. Since the vector is
                                      * used quite often, it is
                                      * generated only once in the
                                      * caller of this function and
@@ -354,18 +354,18 @@ class SparseVanka
                                       * is actually necessary, since
                                       * derived classes can only
                                       * access non-public members
-                                      * through their @p{this}
+                                      * through their @p this
                                       * pointer, but not access these
                                       * members as member functions of
                                       * other objects of the type of
                                       * this base class (i.e. like
-                                      * @p{x.f()}, where @p{x} is an
+                                      * @p{x.f()}, where @p x is an
                                       * object of the base class, and
-                                      * @p{f} one of it's non-public
+                                      * @p f one of it's non-public
                                       * member functions).
                                       *
                                       * Now, in the case of the
-                                      * @p{SparseBlockVanka} class, we
+                                      * @p SparseBlockVanka class, we
                                       * would like to take the address
                                       * of a function of the base
                                       * class in order to call it
@@ -389,7 +389,7 @@ class SparseVanka
  *
  * This class is probably useless if you don't have a multiprocessor
  * system, since then the amount of work per preconditioning step is
- * the same as for the @p{SparseVanka} class, but preconditioning
+ * the same as for the @p SparseVanka class, but preconditioning
  * properties are worse. On the other hand, if you have a
  * multiprocessor system, the worse preconditioning quality (leading
  * to more iterations of the linear solver) usually is well balanced
@@ -402,7 +402,7 @@ class SparseVanka
  *
  * To facilitate writing portable code, if the number of blocks into
  * which the matrix is to be subdivided, is set to one, then this
- * class acts just like the @p{SparseVanka} class. You may therefore
+ * class acts just like the @p SparseVanka class. You may therefore
  * want to set the number of blocks equal to the number of processors
  * you have.
  *
@@ -421,7 +421,7 @@ class SparseVanka
  * to be solved is equal between blocks. The reason for this strategy
  * to subdivision is load-balancing for multithreading. There are
  * several possibilities to actually split the matrix into blocks,
- * which are selected by the flag @p{blocking_strategy} that is passed
+ * which are selected by the flag @p blocking_strategy that is passed
  * to the constructor. By a block, we will in the sequel denote a list
  * of indices of degrees of freedom; the algorithm will work on each
  * block separately, i.e. the solutions of the local systems
@@ -431,11 +431,11 @@ class SparseVanka
  * a consecutive list of indices, as in the first alternative below,
  * or a nonconsecutive list of indices. Of course, we assume that the
  * intersection of each two blocks is empty and that the union of all
- * blocks equals the interval @p{[0,N)}, where @p{N} is the number of
+ * blocks equals the interval @p{[0,N)}, where @p N is the number of
  * degrees of freedom of the system of equations.
  *
- * @begin{itemize}
- * @item @p{index_intervals}:
+ * <ul>
+ * <li> @p index_intervals:
  *    Here, we chose the blocks to be intervals @p{[a_i,a_{i+1})},
  *    i.e. consecutive degrees of freedom are usually also within the
  *    same block. This is a reasonable strategy, if the degrees of
@@ -445,7 +445,7 @@ class SparseVanka
  *    the matrix is usually restricted to the vicinity of the diagonal
  *    as well, and we can simply cut the matrix into blocks.
  *
- *    The bounds of the intervals, i.e. the @p{a_i} above, are chosen
+ *    The bounds of the intervals, i.e. the @p a_i above, are chosen
  *    such that the number of degrees of freedom on which we shall
  *    work (i.e. usually the degrees of freedom corresponding to
  *    Lagrange multipliers) is about the same in each block; this does
@@ -463,7 +463,7 @@ class SparseVanka
  *    preconditioner useless if the degrees of freedom are numbered by
  *    component, i.e. all Lagrange multipliers en bloc.
  *
- * @item @p{adaptive}: This strategy is a bit more clever in cases where
+ * <li> @p adaptive: This strategy is a bit more clever in cases where
  *    the Langrange DoFs are clustered, as in the example above. It
  *    works as follows: it first groups the Lagrange DoFs into blocks,
  *    using the same strategy as above. However, instead of grouping
@@ -485,7 +485,7 @@ class SparseVanka
  *    does not differ much. However, unlike the first strategy, the
  *    performance of the second strategy does not deteriorate if the
  *    DoFs are renumbered by component.
- * @end{itemize}
+ * </ul>
  *
  *
  * @sect3{Typical results}
@@ -494,18 +494,18 @@ class SparseVanka
  * optimization, which leads to a series of saddle point problems,
  * each of which is solved using GMRES with Vanka as
  * preconditioner. The equation had approx. 850 degrees of
- * freedom. With the non-blocked version @p{SparseVanka} (or
- * @p{SparseBlockVanka} with @p{n_blocks==1}), the following numbers of
+ * freedom. With the non-blocked version @p SparseVanka (or
+ * @p SparseBlockVanka with @p{n_blocks==1}), the following numbers of
  * iterations is needed to solver the linear system in each nonlinear
  * step:
- * @begin{verbatim}
+ * @verbatim
  *   101 68 64 53 35 21
- * @end{verbatim}
+ * @endverbatim
  *
  * With four blocks, we need the following numbers of iterations
- * @begin{verbatim}
+ * @verbatim
  *   124 88 83 66 44 28
- * @end{verbatim}
+ * @endverbatim
  * As can be seen, more iterations are needed. However, in terms of
  * computing time, the first version needs 72 seconds wall time (and
  * 79 seconds CPU time, which is more than wall time since some other
@@ -542,7 +542,7 @@ class SparseBlockVanka : public SparseVanka<number>
                                     /**
                                      * Constructor. Pass all
                                      * arguments except for
-                                     * @p{n_blocks} to the base class.
+                                     * @p n_blocks to the base class.
                                      */
     SparseBlockVanka (const SparseMatrix<number> &M,
                      const std::vector<bool>    &selected,
@@ -576,10 +576,10 @@ class SparseBlockVanka : public SparseVanka<number>
                                      * for each block which degrees
                                      * of freedom belong to it. Thus,
                                      * if @p{dof_masks[i][j]==true},
-                                     * then DoF @p{j} belongs to block
-                                     * @p{i}. Of course, no other
+                                     * then DoF @p j belongs to block
+                                     * @p i. Of course, no other
                                      * @p{dof_masks[l][j]} may be
-                                     * @p{true} for @p{l!=i}. This
+                                     * @p true for @p{l!=i}. This
                                      * computation is done in the
                                      * constructor, to avoid
                                      * recomputing each time the
@@ -589,7 +589,7 @@ class SparseBlockVanka : public SparseVanka<number>
 
                                     /**
                                      * Compute the contents of the
-                                     * field @p{dof_masks}. This
+                                     * field @p dof_masks. This
                                      * function is called from the
                                      * constructor.
                                      */
index 4f3831955e22feb1e4dcd60e7807d88b4b6b86d6..e1c45e7b16949321aa69292cbe320bcea480d128 100644 (file)
@@ -159,7 +159,7 @@ SparseVanka<number>::compute_inverse (const unsigned int         row,
                                         row_length); 
 
                                   // collect the dofs that couple
-                                  // with @p{row}
+                                  // with @p row
   local_indices.resize (row_length);
   for (unsigned int i=0; i<row_length; ++i)
     local_indices[i] = structure.column_number(row, i);
@@ -274,7 +274,7 @@ SparseVanka<number>::apply_preconditioner (Vector<number2>         &dst,
                                         // patterns, the first element
                                         // of each entry simply denotes
                                         // all degrees of freedom that
-                                        // couple with @p{row}.
+                                        // couple with @p row.
        local_index.clear ();
        for (unsigned int i=0; i<row_length; ++i)
          local_index.insert(std::pair<unsigned int, unsigned int>
@@ -288,7 +288,7 @@ SparseVanka<number>::apply_preconditioner (Vector<number2>         &dst,
                                             // couple with the present DoF
            const unsigned int irow = is->first;
                                             // index of DoF irow in the matrix
-                                            // row corresponding to DoF @p{row}.
+                                            // row corresponding to DoF @p row.
                                             // runs between 0 and row_length
            const unsigned int i = is->second;
                                             // number of DoFs coupling to
@@ -306,10 +306,10 @@ SparseVanka<number>::apply_preconditioner (Vector<number2>         &dst,
                                                 // this dof
                const unsigned int col = structure.column_number(irow, j);
                                                 // find out whether this DoF
-                                                // (that couples with @p{irow},
+                                                // (that couples with @p irow,
                                                 // which itself couples with
-                                                // @p{row}) also couples with
-                                                // @p{row}.
+                                                // @p row) also couples with
+                                                // @p row.
                const std::map<unsigned int, unsigned int>::const_iterator js
                  = local_index.find(col);
                                                 // if not, then still use
@@ -510,11 +510,11 @@ SparseBlockVanka<number>::compute_dof_masks (const SparseMatrix<number> &M,
                ++access_count[block_number][structure.column_number(row, i)];
            };
 
-                                        // now we know that block @p{i}
-                                        // wants to write to DoF @p{j}
+                                        // now we know that block @p i
+                                        // wants to write to DoF @p j
                                         // as often as
                                         // @p{access_count[i][j]}
-                                        // times. Let @p{j} be allotted
+                                        // times. Let @p j be allotted
                                         // to the block which
                                         // accesses it most often.
                                         //
index d1778c0ac9d2bdb49db709240646829b223323be..56108e047687792c18af8b3d56b0c2571d15d1f3 100644 (file)
@@ -261,7 +261,7 @@ namespace internals
  * The following picture will illustrate the relation between the
  * SparsityPattern an the SparseMatrix.
  *
- * @begin{verbatim}
+ * @verbatim
  *  SparsityPattern:                               \
  *                                                 |
  *              _________________________          |
@@ -291,9 +291,9 @@ namespace internals
  *   /_________colnums[0]                          |
  *                                                 |                    
  *                                                /                    
- * @end{verbatim}
+ * @endverbatim
  *
- * @begin{verbatim}
+ * @verbatim
  * For row = 0
  *   
  * there are: (0| 3) = colnums[0]
@@ -307,9 +307,9 @@ namespace internals
  *            (1| 4) = colnums[5]
  * ....
  *
- * @end{verbatim}
+ * @endverbatim
  *
- * @begin{verbatim}
+ * @verbatim
  * SparseMatrix:                                  \
  *                                                 |
  *              _____________________________      |
@@ -318,7 +318,7 @@ namespace internals
  *                                                 |
  *                                                 |
  *                                                /
- * @end{verbatim}
+ * @endverbatim
  *
  * If you want to get the <tt>3</tt> you need to get its position in
  * the table above and its value by returning the value of the element
@@ -696,15 +696,15 @@ class SparsityPattern : public Subscriptor
                                      * represented by a sequence of
                                      * pairs of column indices and
                                      * values. In the present
-                                     * context, the @ref{begin} and
-                                     * @ref{end} parameters designate
+                                     * context, the begin() and
+                                     * end() parameters designate
                                      * iterators (of forward iterator
                                      * type) into a container, one
                                      * representing one row. The
-                                     * distance between @ref{begin}
-                                     * and @ref{end} should therefore
+                                     * distance between begin()
+                                     * and end() should therefore
                                      * be equal to
-                                     * @ref{n_rows}. These iterators
+                                     * n_rows(). These iterators
                                      * may be iterators of
                                      * <tt>std::vector</tt>,
                                      * <tt>std::list</tt>, pointers into a
@@ -1087,13 +1087,13 @@ class SparsityPattern : public Subscriptor
                                       *
                                       * After calling this function, the
                                       * output array will have values between
-                                      * zero and @p{n_partitions-1} for each
+                                      * zero and @p n_partitions-1 for each
                                       * node (i.e. row or column of the
                                       * matrix).
                                       *
                                       * This function will generate an error
                                       * if METIS is not installed unless
-                                      * @p{n_partitions} is one. I.e., you can
+                                      * @p n_partitions is one. I.e., you can
                                       * write a program so that it runs in the
                                       * single-processor single-partition case
                                       * without METIS installed, and only
@@ -1114,7 +1114,7 @@ class SparsityPattern : public Subscriptor
                                       * methods you will want to partition the
                                       * mesh, not the matrix. This can be done
                                       * by calling
-                                      * @p{GridTools::partition_triangulation}.
+                                      * @p GridTools::partition_triangulation.
                                       */
     void partition (const unsigned int         n_partitions,
                     std::vector<unsigned int> &partition_indices) const;
@@ -1217,8 +1217,8 @@ class SparsityPattern : public Subscriptor
                                      * read-only.
                                      *
                                      * Use of this function is highly
-                                     * deprecated. Use @p{row_length} and
-                                     * @p{column_number} instead. Also, using
+                                     * deprecated. Use @p row_length and
+                                     * @p column_number instead. Also, using
                                      * iterators may get you most of the
                                      * information you may want.
                                      *
@@ -1241,8 +1241,8 @@ class SparsityPattern : public Subscriptor
     const unsigned int * get_rowstart_indices () const;
 
                                     /**
-                                     * @deprecated. Use @p{row_length} and
-                                     * @p{column_number} instead. Also, using
+                                     * @deprecated. Use @p row_length and
+                                     * @p column_number instead. Also, using
                                      * iterators may get you most of the
                                      * information you may want.
                                      *
@@ -1448,7 +1448,7 @@ class SparsityPattern : public Subscriptor
                                      *
                                      * At the beginning, all elements
                                      * of this array are set to
-                                     * @p{-1} indicating invalid
+                                     * @p -1 indicating invalid
                                      * (unused) column numbers
                                      * (diagonal elements are preset
                                      * if optimized storage is
@@ -1461,7 +1461,7 @@ class SparsityPattern : public Subscriptor
                                      * element. When compress is
                                      * called, unused elements
                                      * (indicated by column numbers
-                                     * @p{-1}) are eliminated by
+                                     * @p -1) are eliminated by
                                      * copying the column number of
                                      * subsequent rows and the column
                                      * numbers within each row (with
index 981e475f89e57ae788ecd40d67a83dd028944ced..8407729c6c4895087f8aa812220451e28c1ab2ba 100644 (file)
  */
 
 /**
- * This class is a wrapper to the @p{Vector} class which allows to swap
+ * This class is a wrapper to the @p Vector class which allows to swap
  * out the data to a file and reload it later on. It handles the
  * management of the name of the file where the data is to be stored
  * temporarily and removes the file is necessary at the end of the
  * lifetime of the vector.
  *
  * There are functions to swap the data to a file, and to reload
- * it. There is also a function @p{alert} that can be used to signal to
+ * it. There is also a function @p alert that can be used to signal to
  * an object of this class that the data will be needed shortly, so
  * the object can initiate that the data be loaded already. While in
- * non-multithreading mode, this function has no effect since @p{reload}
+ * non-multithreading mode, this function has no effect since @p reload
  * has to be called afterwards anyway. On the other hand, in
  * multithreading mode, the data is preloaded in the background using
  * a thread on its own, and may already be available at the time when
- * @p{reload} is called. If it is not available, @p{reload} waits until
+ * @p reload is called. If it is not available, @p reload waits until
  * the detached thread has loaded the data.
  *
  *
@@ -69,15 +69,15 @@ class SwappableVector : public Vector<number>
 
                                     /**
                                      * Copy constructor. Copies the
-                                     * data if @p{v} contains some, but
-                                     * does not do so if @p{v} is empty
+                                     * data if @p v contains some, but
+                                     * does not do so if @p v is empty
                                      * or has its data swapped
                                      * out. In the latter case, warn
                                      * about that. In particular do
                                      * not take over ownership of any
-                                     * files that @p{v} might own (as,
+                                     * files that @p v might own (as,
                                      * for example, @p{C++}'s
-                                     * @p{auto_ptr} objects would do).
+                                     * @p auto_ptr objects would do).
                                      */
     SwappableVector (const SwappableVector &v);
 
@@ -107,7 +107,7 @@ class SwappableVector : public Vector<number>
                                      * ownership of this file is
                                      * assumed by this object. The
                                      * file is deleted either upon
-                                     * calling @p{kill_file}, or on
+                                     * calling @p kill_file, or on
                                      * destruction of this object.
                                      *
                                      * The content of the vector is
@@ -116,7 +116,7 @@ class SwappableVector : public Vector<number>
                                      *
                                      * If this object owns another
                                      * file, for example when
-                                     * @p{swap_out} but no @p{kill_file}
+                                     * @p swap_out but no @p kill_file
                                      * has previously been called,
                                      * then that is deleted first.
                                      */
@@ -126,9 +126,9 @@ class SwappableVector : public Vector<number>
                                      * Reload the data of this vector
                                      * from the file to which it has
                                      * been stored previously using
-                                     * @p{swap_out}. Since the file is
+                                     * @p swap_out. Since the file is
                                      * not deleted after reloading,
-                                     * you can call @p{reload} multiple
+                                     * you can call @p reload multiple
                                      * times, in between you may do
                                      * everything with the vector,
                                      * including changing its size.
@@ -136,7 +136,7 @@ class SwappableVector : public Vector<number>
                                      * This function resets the size
                                      * of the vector to the number of
                                      * elements there were upon
-                                     * calling @p{swap_out} before.
+                                     * calling @p swap_out before.
                                      */
     void reload ();
 
@@ -153,7 +153,7 @@ class SwappableVector : public Vector<number>
                                      * that reads the data in
                                      * parallel to the usual
                                      * execution of the program, such
-                                     * that when @p{reload} is called,
+                                     * that when @p reload is called,
                                      * the data may eventually be
                                      * available already. It might
                                      * therefore be wirthwhile to
@@ -166,7 +166,7 @@ class SwappableVector : public Vector<number>
                                      * a local tmp directory.
                                      *
                                      * Calling this function multiple
-                                     * times before calling @p{reload}
+                                     * times before calling @p reload
                                      * is allowed and has no effect
                                      * for subsequent calls. Calling
                                      * this function while the data
@@ -201,12 +201,12 @@ class SwappableVector : public Vector<number>
                                      * time. After this, the object
                                      * does not own any file any
                                      * more, so of course you can't
-                                     * call @p{reload} no more.
+                                     * call @p reload no more.
                                      *
                                      * If this object does not own a
                                      * file, for example since
-                                     * @p{swap_out} was not called, or
-                                     * because @p{kill_file} has been
+                                     * @p swap_out was not called, or
+                                     * because @p kill_file has been
                                      * called previously, then this
                                      * function does nothing.
                                      */
@@ -216,9 +216,9 @@ class SwappableVector : public Vector<number>
                                      * Return the name of the file to
                                      * which the data was stored the
                                      * last time you called
-                                     * @p{swap_out}. If @p{swap_out} was
+                                     * @p swap_out. If @p swap_out was
                                      * not called, or if in between
-                                     * @p{kill_file} was called, then
+                                     * @p kill_file was called, then
                                      * the filename is an empty
                                      * string.
                                      */
@@ -257,8 +257,8 @@ class SwappableVector : public Vector<number>
                                      * was swapped out. If no data is
                                      * presently swapped out
                                      * (i.e. before calling
-                                     * @p{swap_out} and after
-                                     * @p{kill_file}), the string is
+                                     * @p swap_out and after
+                                     * @p kill_file), the string is
                                      * empty, indicating no ownership
                                      * of files.
                                      */
@@ -266,9 +266,9 @@ class SwappableVector : public Vector<number>
 
                                     /**
                                      * If in multithread mode, then
-                                     * the @p{alert} function has
+                                     * the @p alert function has
                                      * functionality, but needs to
-                                     * coordinate with the @p{reload}
+                                     * coordinate with the @p reload
                                      * function. This is done through
                                      * the following lock.
                                      *
@@ -280,23 +280,23 @@ class SwappableVector : public Vector<number>
     Threads::ThreadMutex lock;
 
                                     /**
-                                     * Flag by which the @p{alert}
+                                     * Flag by which the @p alert
                                      * function signifies that the
                                      * data has been preloaded
                                      * already. This flag is always
-                                     * @p{false} in non-MT mode.
+                                     * @p false in non-MT mode.
                                      */
     bool data_is_preloaded;
 
                                     /**
                                      * Internal function that
                                      * actually reloads the
-                                     * vector. Called from @p{reload}
-                                     * and @p{alert}.
+                                     * vector. Called from @p reload
+                                     * and @p alert.
                                      *
                                      * The parameter specifies
                                      * whether the function shall set
-                                     * @p{data_is_preloaded} or
+                                     * @p data_is_preloaded or
                                      * not. The calling functions
                                      * can't sometimes do this
                                      * themselves, since they call
index 828483c04e3053e40426e7396ce4dcc85143c7c6..6fd97f2e5043ab59ad92d017416b1681e37f2a6f 100644 (file)
@@ -97,8 +97,8 @@ void SwappableVector<number>::swap_out (const std::string &name)
   Threads::ThreadMutex::ScopedLock lock(this->lock);
 
                                    //  check that we have not called
-                                  //  @p{alert} without the respective
-                                  //  @p{reload} function
+                                  //  @p alert without the respective
+                                  //  @p reload function
   Assert (data_is_preloaded == false, ExcInternalError());
   
   std::ofstream tmp_out(filename.c_str());
@@ -114,7 +114,7 @@ template <typename number>
 void SwappableVector<number>::reload () 
 {
                                   // if in MT mode: synchronise with
-                                  // possibly existing @p{alert}
+                                  // possibly existing @p alert
                                   // calls. if not in MT mode, this
                                   // is a no-op
   lock.acquire ();
index 0c6ca30127e871b528037d7b65e57383461835d1..21e3ef9465a1aaf987fffdf5fb2cc039c59c61bf 100644 (file)
@@ -45,7 +45,7 @@ namespace PETScWrappers
  * second type support the abgebraic operation for vectors. The third
  * und last type helps us to manipulate the components of the vector.
  * As opposed to the array of the C++ standard library called
- * @p{vector} (with a lowercase "v"), this class implements an element
+ * @p vector (with a lowercase "v"), this class implements an element
  * of a vector space suitable for numerical computations.
  *
  *
@@ -112,7 +112,7 @@ class Vector
 //                                   * Copy constructor taking a vector of
 //                                   * another data type. This will fail if
 //                                   * there is no conversion path from
-//                                   * @p{OtherNumber} to @p{Number}. Note that
+//                                   * @p OtherNumber to @p Number. Note that
 //                                   * you may lose accuracy when copying
 //                                   * to a vector with data elements with
 //                                   * less accuracy.
@@ -152,7 +152,7 @@ class Vector
     
                                     /**
                                      * Constructor. Set dimension to
-                                     * @p{n} and initialize all
+                                     * @p n and initialize all
                                      * elements with zero.
                                      *
                                      * The constructor is made
@@ -174,7 +174,7 @@ class Vector
                                      * given range of values pointed
                                      * to by the iterators. This
                                      * function is there in analogy
-                                     * to the @p{std::vector} class.
+                                     * to the @p std::vector class.
                                      */
     template <typename InputIterator>
     Vector (const InputIterator first,
@@ -191,7 +191,7 @@ class Vector
                                      /**
                                       * This function does nothing but is
                                       * there for compatibility with the
-                                      * @p{PETScWrappers::Vector} class.
+                                      * @p PETScWrappers::Vector class.
                                       * 
                                       * For the PETSc vector wrapper class,
                                       * thios function compresses the
@@ -221,7 +221,7 @@ class Vector
 
                                     /**
                                      * Change the dimension of the vector to
-                                     * @p{N}. The reserved memory for this
+                                     * @p N. The reserved memory for this
                                      * vector remains unchanged if possible,
                                      * to make things faster; this may waste
                                      * some memory, so keep this in mind.
@@ -244,10 +244,10 @@ class Vector
     
                                     /**
                                      * Change the dimension to that of the
-                                     * vector @p{V}. The same applies as for
-                                     * the other @p{reinit} function.
+                                     * vector @p V. The same applies as for
+                                     * the other @p reinit function.
                                      *
-                                     * The elements of @p{V} are not copied,
+                                     * The elements of @p V are not copied,
                                      * i.e.  this function is the same as
                                      * calling @p{reinit (V.size(), fast)}.
                                      */
@@ -258,7 +258,7 @@ class Vector
                                     /**
                                      * Swap the contents of this
                                      * vector and the other vector
-                                     * @p{v}. One could do this
+                                     * @p v. One could do this
                                      * operation with a temporary
                                      * variable and copying over the
                                      * data elements, but this
@@ -271,7 +271,7 @@ class Vector
                                      * data around.
                                      *
                                      * This function is analog to the
-                                     * the @p{swap} function of all C++
+                                     * the @p swap function of all C++
                                      * standard containers. Also,
                                      * there is a global function
                                      * @p{swap(u,v)} that simply calls
@@ -282,7 +282,7 @@ class Vector
     
                                     /**
                                      * Set all components of the vector to
-                                     * the given number @p{s}.
+                                     * the given number @p s.
                                      */
     Vector<Number> & operator= (const Number s);
     
@@ -356,7 +356,7 @@ class Vector
                                      * Return the scalar product of
                                      * two vectors.  The return type
                                      * is the underlying type of
-                                     * @p{this} vector, so the return
+                                     * @p this vector, so the return
                                      * type and the accuracy with
                                      * which it the result is
                                      * computed depend on the order
@@ -420,7 +420,7 @@ class Vector
     bool all_zero () const;
 
                                      /**
-                                      * Return @p{true} if the vector has no
+                                      * Return @p true if the vector has no
                                       * negative entries, i.e. all entries are
                                       * zero or positive. This function is
                                       * used, for example, to check whether
@@ -430,7 +430,7 @@ class Vector
     bool is_non_negative () const;
     
                                     /**
-                                     * Make the @p{Vector} class a bit like the
+                                     * Make the @p Vector class a bit like the
                                      * @p{vector<>} class of the C++ standard
                                      * library by returning iterators to
                                      * the start and end of the elements of this
@@ -463,13 +463,13 @@ class Vector
                                      */
                                     //@{
                                     /**
-                                     * Access the value of the @p{i}th
+                                     * Access the value of the @p ith
                                      * component.
                                      */
     Number operator() (const unsigned int i) const;
     
                                     /**
-                                     * Access the @p{i}th component
+                                     * Access the @p ith component
                                      * as a writeable reference.
                                      */
     Number& operator() (const unsigned int i);
@@ -494,8 +494,8 @@ class Vector
     Vector<Number> & operator -= (const Vector<Number> &V);
 
                                     /**
-                                     * Addition of @p{s} to all
-                                     * components. Note that @p{s} is a
+                                     * Addition of @p s to all
+                                     * components. Note that @p s is a
                                      * scalar and not a vector.
                                      */
     void add (const Number s);
@@ -639,15 +639,15 @@ class Vector
 
                                     /**
                                      * Print to a
-                                     * stream. @p{precision} denotes
+                                     * stream. @p precision denotes
                                      * the desired precision with
                                      * which values shall be printed,
-                                     * @p{scientific} whether
+                                     * @p scientific whether
                                      * scientific notation shall be
-                                     * used. If @p{across} is
-                                     * @p{true} then the vector is
+                                     * used. If @p across is
+                                     * @p true then the vector is
                                      * printed in a line, while if
-                                     * @p{false} then the elements
+                                     * @p false then the elements
                                      * are printed on a separate line
                                      * each.
                                      */
@@ -715,11 +715,11 @@ class Vector
                                      * Amount of memory actually
                                      * reserved for this vector. This
                                      * number may be greater than
-                                     * @p{dim} if a @p{reinit} was
+                                     * @p dim if a @p reinit was
                                      * called with less memory
                                      * requirements than the vector
                                      * needed last time. At present
-                                     * @p{reinit} does not free
+                                     * @p reinit does not free
                                      * memory when the number of
                                      * needed elements is reduced.
                                      */
@@ -959,7 +959,7 @@ Vector<Number>::compress () const
 
 
 /**
- * Global function @p{swap} which overloads the default implementation
+ * Global function @p swap which overloads the default implementation
  * of the C++ standard library which uses a temporary object. The
  * function simply exchanges the data of the two vectors.
  *
index 61604402a831dbc43bb12ae73746b2851c0e71b8..cc2b99d71c819de3c5306bb6abaf80ca2dfd8a0b 100644 (file)
@@ -109,7 +109,7 @@ class PrimitiveVectorMemory : public VectorMemory<VECTOR>
 
 //! Keeps all vectors and avoids reallocation.
 /**
- * Memory keeping allocated vectors.  This @p{VectorMemory} is able to
+ * Memory keeping allocated vectors.  This @p VectorMemory is able to
  * grow infinitely (according to computer memory).  A vector once
  * allocated will stay in the memory pool, though, and it will be
  * reused in later allocation.

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

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.