]> https://gitweb.dealii.org/ - dealii.git/commitdiff
More doxygen conversions.
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Mon, 19 Apr 2004 16:29:27 +0000 (16:29 +0000)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Mon, 19 Apr 2004 16:29:27 +0000 (16:29 +0000)
git-svn-id: https://svn.dealii.org/trunk@9050 0785d39b-7218-0410-832d-ea1e28bc413d

86 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_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/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_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_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_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_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_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_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_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/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_array.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/compressed_sparsity_pattern.h
deal.II/lac/include/lac/filtered_matrix.h
deal.II/lac/include/lac/matrix_out.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_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_selector.h
deal.II/lac/include/lac/solver.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/sparse_matrix_ez.h
deal.II/lac/include/lac/sparse_vanka.h
deal.II/lac/include/lac/sparse_vanka.templates.h
deal.II/lac/include/lac/swappable_vector.h
deal.II/lac/include/lac/vector.h

index f6daa50b4e832844c0c5d4986cefa23ef58a8bdf..d4b02fd9cbb777f29334ca83b3d518ccb174777a 100644 (file)
@@ -150,11 +150,11 @@ class DoFAccessor
 /**
  * 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>}
- * 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,
+ * from. By default, <tt>DoFObjectAccessor<celldim,dim></tt> derives from
+ * the @p typedef in the general <tt>DoFObjectAccessor_Inheritance<celldim,dim></tt>
+ * class, which is <tt>TriaObjectAccessor<celldim,dim></tt>,
+ * but if <tt>celldim==dim</tt>, then the specialization <tt>DoFObjectAccessor_Inheritance<dim,dim></tt>
+ * is used which declares its local type to be <tt>CellAccessor<dim></tt>. Therefore,
  * the inheritance is automatically chosen to be from CellAccessor if the
  * object under consideration has full dimension, i.e. constitutes a cell.
  *
@@ -176,11 +176,11 @@ class DoFObjectAccessor_Inheritance
 /**
  * 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>}
- * 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,
+ * from. By default, <tt>DoFObjectAccessor<celldim,dim></tt> derives from
+ * the @p typedef in the general <tt>DoFObjectAccessor_Inheritance<celldim,dim></tt>
+ * class, which is <tt>TriaObjectAccessor<celldim,dim></tt>,
+ * but if <tt>celldim==dim</tt>, then the specialization <tt>DoFObjectAccessor_Inheritance<dim,dim></tt>
+ * is used which declares its local type to be <tt>CellAccessor<dim></tt>. Therefore,
  * the inheritance is automatically chosen to be from CellAccessor if the
  * object under consideration has full dimension, i.e. constitutes a cell.
  *
@@ -327,9 +327,9 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
                                      * active cells.
                                      *
                                      * The input vector may be either a
-                                     * @p{Vector<float>},
-                                     * Vector@p{<double>}, or a
-                                     * BlockVector@p{<double>}, or a
+                                     * <tt>Vector<float></tt>,
+                                     * Vector<tt><double></tt>, or a
+                                     * BlockVector<tt><double></tt>, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -365,9 +365,9 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
                                      * to this function.
                                      *
                                      * The output vector may be either a
-                                     * Vector@p{<float>},
-                                     * Vector@p{<double>}, or a
-                                     * BlockVector@p{<double>}, or a
+                                     * Vector<tt><float></tt>,
+                                     * Vector<tt><double></tt>, or a
+                                     * BlockVector<tt><double></tt>, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -426,7 +426,7 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
                                     /**
                                      * This function does much the same as
                                      * the
-                                     * @p{distribute_local_to_global(Vector,Vector)}
+                                     * <tt>distribute_local_to_global(Vector,Vector)</tt>
                                      * function, but operates on matrices
                                      * instead of vectors. The sparse matrix
                                      * is supposed to have non-zero entry
@@ -490,9 +490,9 @@ class DoFObjectAccessor<0, dim> : public DoFAccessor<dim>,
  * 
  * @sect3{Notes about the class hierarchy structure}
  *
- * 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
+ * Inheritance from <tt>DoFObjectAccessor_Inheritance<1,dim>::BaseClass</tt> yields
+ * inheritance from <tt>CellAccessor<1></tt> if <tt>dim==1</tt> and from
+ * <tt>TriaObjectAccessor<1,dim></tt> 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.
  *
@@ -585,9 +585,9 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
                                      * cells.
                                      *
                                      * The input vector may be either a
-                                     * Vector@p{<float>},
-                                     * Vector@p{<double>}, or a
-                                     * BlockVector@p{<double>}, or a
+                                     * Vector<tt><float></tt>,
+                                     * Vector<tt><double></tt>, or a
+                                     * BlockVector<tt><double></tt>, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -622,9 +622,9 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
                                      * have the right size beforehand.
                                      *
                                      * The output vector may be either a
-                                     * Vector@p{<float>},
-                                     * Vector@p{<double>}, or a
-                                     * BlockVector@p{<double>}, or a
+                                     * Vector<tt><float></tt>,
+                                     * Vector<tt><double></tt>, or a
+                                     * BlockVector<tt><double></tt>, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -667,7 +667,7 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
                                     /**
                                      * This function does much the same as
                                      * the
-                                     * @p{distribute_local_to_global(Vector,Vector)}
+                                     * <tt>distribute_local_to_global(Vector,Vector)</tt>
                                      * function, but operates on matrices
                                      * instead of vectors. The sparse matrix
                                      * is supposed to have non-zero entry
@@ -779,9 +779,9 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
                                      * cells.
                                      *
                                      * The input vector may be either a
-                                     * Vector@p{<float>},
-                                     * Vector@p{<double>}, or a
-                                     * BlockVector@p{<double>}, or a
+                                     * Vector<tt><float></tt>,
+                                     * Vector<tt><double></tt>, or a
+                                     * BlockVector<tt><double></tt>, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -816,9 +816,9 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
                                      * have the right size beforehand.
                                      *
                                      * The output vector may be either a
-                                     * Vector@p{<float>},
-                                     * Vector@p{<double>}, or a
-                                     * BlockVector@p{<double>}, or a
+                                     * Vector<tt><float></tt>,
+                                     * Vector<tt><double></tt>, or a
+                                     * BlockVector<tt><double></tt>, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -869,7 +869,7 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
                                     /**
                                      * This function does much the same as
                                      * the
-                                     * @p{distribute_local_to_global(Vector,Vector)}
+                                     * <tt>distribute_local_to_global(Vector,Vector)</tt>
                                      * function, but operates on matrices
                                      * instead of vectors. The sparse matrix
                                      * is supposed to have non-zero entry
@@ -981,9 +981,9 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
                                      * cells.
                                      *
                                      * The input vector may be either a
-                                     * Vector@p{<float>},
-                                     * Vector@p{<double>}, or a
-                                     * BlockVector@p{<double>}, or a
+                                     * Vector<tt><float></tt>,
+                                     * Vector<tt><double></tt>, or a
+                                     * BlockVector<tt><double></tt>, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -1018,9 +1018,9 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
                                      * have the right size beforehand.
                                      *
                                      * The output vector may be either a
-                                     * Vector@p{<float>},
-                                     * Vector@p{<double>}, or a
-                                     * BlockVector@p{<double>}, or a
+                                     * Vector<tt><float></tt>,
+                                     * Vector<tt><double></tt>, or a
+                                     * BlockVector<tt><double></tt>, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
@@ -1079,7 +1079,7 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
                                     /**
                                      * This function does much the same as
                                      * the
-                                     * @p{distribute_local_to_global(Vector,Vector)}
+                                     * <tt>distribute_local_to_global(Vector,Vector)</tt>
                                      * function, but operates on matrices
                                      * instead of vectors. The sparse matrix
                                      * is supposed to have non-zero entry
@@ -1102,15 +1102,15 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
 /**
  * Grant access to the degrees of freedom on a cell. In fact, since all
  * access to the degrees of freedom has been enabled by the classes
- * @p{DoFObjectAccessor<1, 1>} and @p{DoFObjectAccessor<2, 2>} for the space dimension
+ * <tt>DoFObjectAccessor<1, 1></tt> and <tt>DoFObjectAccessor<2, 2></tt> for the space dimension
  * 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
+ * together by deriving from the appropriate <tt>DoF*Accessor</tt> and the
+ * right <tt>CellAccessor<dim></tt> and finally adding two functions which give
  * access to the neighbors and children as DoFCellAccessor objects
  * rather than CellAccessor objects (the latter function was inherited
- * from the @p{CellAccessor<dim>} class).
+ * from the <tt>CellAccessor<dim></tt> class).
  *
- * Note that since for the class we derive from, i.e. @p{DoFObjectAccessor<dim,dim>},
+ * Note that since for the class we derive from, i.e. <tt>DoFObjectAccessor<dim,dim></tt>,
  * the two template parameters are equal, the base class is actually derived from
  * CellAccessor, which makes the functions of this class available to the
  * DoFCellAccessor class as well.
@@ -1329,9 +1329,9 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                                      * objects.
                                      *
                                      * The output vector may be either a
-                                     * Vector@p{<float>},
-                                     * Vector@p{<double>}, or a
-                                     * BlockVector@p{<double>}, or a
+                                     * Vector<tt><float></tt>,
+                                     * Vector<tt><double></tt>, or a
+                                     * BlockVector<tt><double></tt>, or a
                                      * PETSc vector if deal.II is compiled to
                                      * support PETSc. It is in the
                                      * responsibility of the caller to assure
index 747c3a68e6119d5d255edbde352981871fa44b5f..6eb8a2864882d8548e76409a8a83c6c08bc38c46 100644 (file)
@@ -566,9 +566,9 @@ class ConstraintMatrix : public Subscriptor
                                      * @p condensed be zero.
                                      *
                                      * The @p VectorType may be a
-                                     * Vector@p{<float>},
-                                     * Vector@p{<double>},
-                                     * BlockVector@p{<...>}, a PETSc
+                                     * Vector<tt><float></tt>,
+                                     * Vector<tt><double></tt>,
+                                     * BlockVector<tt><...></tt>, a PETSc
                                      * vector wrapper class, or any other
                                      * type having the same interface.
                                      */
@@ -579,9 +579,9 @@ class ConstraintMatrix : public Subscriptor
                                     /**
                                      * Condense the given vector
                                      * in-place. The @p VectorType may be a
-                                     * Vector@p{<float>},
-                                     * Vector@p{<double>},
-                                     * BlockVector@p{<...>}, a PETSc
+                                     * Vector<tt><float></tt>,
+                                     * Vector<tt><double></tt>,
+                                     * BlockVector<tt><...></tt>, a PETSc
                                      * vector wrapper class, or any other
                                      * type having the same interface.
                                      */
@@ -603,9 +603,9 @@ class ConstraintMatrix : public Subscriptor
                                      * @p condense.
                                      *
                                      * The @p VectorType may be a
-                                     * Vector@p{<float>},
-                                     * Vector@p{<double>},
-                                     * BlockVector@p{<...>}, a PETSc
+                                     * Vector<tt><float></tt>,
+                                     * Vector<tt><double></tt>,
+                                     * BlockVector<tt><...></tt>, a PETSc
                                      * vector wrapper class, or any other
                                      * type having the same interface.
                                      */
@@ -616,9 +616,9 @@ class ConstraintMatrix : public Subscriptor
                                     /**
                                      * Re-distribute the elements of the
                                      * vector in-place. The @p VectorType
-                                     * may be a Vector@p{<float>},
-                                     * Vector@p{<double>},
-                                     * BlockVector@p{<...>}, a PETSc
+                                     * may be a Vector<tt><float></tt>,
+                                     * Vector<tt><double></tt>,
+                                     * BlockVector<tt><...></tt>, a PETSc
                                      * vector wrapper class, or any other
                                      * type having the same interface.
                                      */
@@ -629,9 +629,9 @@ class ConstraintMatrix : public Subscriptor
                                      * Delete hanging nodes in a vector.
                                      * Sets all hanging node values to
                                      * zero. The @p VectorType may be a
-                                     * Vector@p{<float>},
-                                     * Vector@p{<double>},
-                                     * BlockVector@p{<...>}, a PETSc
+                                     * Vector<tt><float></tt>,
+                                     * Vector<tt><double></tt>,
+                                     * BlockVector<tt><...></tt>, a PETSc
                                      * vector wrapper class, or any other
                                      * type having the same interface.
                                      */
@@ -750,7 +750,7 @@ class ConstraintMatrix : public Subscriptor
                                      * This function writes out all entries
                                      * in the constraint matrix lines with
                                      * their value in the form
-                                     * @p{row col : value}. Unconstrained lines
+                                     * <tt>row col : value</tt>. Unconstrained lines
                                      * containing only one identity entry are
                                      * not stored in this object and are not
                                      * printed.
@@ -891,7 +891,7 @@ class ConstraintMatrix : public Subscriptor
                                      * at the end, so the order is
                                      * unspecified after all entries are
                                      * inserted. Sorting of the entries takes
-                                     * place when calling the @p{close()} function.
+                                     * place when calling the <tt>close()</tt> function.
                                      *
                                      * We could, instead of using a vector, use
                                      * an associative array, like a map to
index 74d0a35827c30edbb0ef21fbfc76bc914666cd48..23cdbc5c09e1051e889edaeb801a7440baf64dff 100644 (file)
@@ -172,12 +172,12 @@ class DoFDimensionInfo<3>
  * 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
+ * by offering <tt>begin()</tt> and <tt>end()</tt> 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 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 <tt>++</tt> and @p -- operators
  * is the same as that for the alike triangulation iterators.
  *
  * This class also provides functions to create the sparsity patterns of
@@ -187,7 +187,7 @@ class DoFDimensionInfo<3>
  * @sect3{Distribution of indices for degrees of freedom}
  *
  * The degrees of freedom (`dofs') are distributed on the given triangulation
- * by the function @p{distribute_dofs()}. It gets passed a finite element object
+ * by the function <tt>distribute_dofs()</tt>. It gets passed a finite element object
  * describing how many degrees of freedom are located on vertices, lines, etc.
  * It traverses the triangulation cell by cell and numbers the dofs of that
  * cell if not yet numbered. For non-multigrid algorithms, only active cells
@@ -212,7 +212,7 @@ class DoFDimensionInfo<3>
  * 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
- * @p{renumber_dofs(vector<unsigned int>)} function is called, which actually
+ * <tt>renumber_dofs(vector<unsigned int>)</tt> function is called, which actually
  * does the change from old DoF indices to the ones given in the
  * array. In some cases, however, a user may want to compute her own
  * renumbering order; in this case, allocate an array with one element
@@ -220,7 +220,7 @@ class DoFDimensionInfo<3>
  * respective degree of freedom shall be assigned. This number may,
  * for example, be obtained by sorting the support points of the
  * degrees of freedom in downwind direction.  Then call the
- * @p{renumber_dofs(vector<unsigned int>)} with the array, which converts old
+ * <tt>renumber_dofs(vector<unsigned int>)</tt> with the array, which converts old
  * into new degree of freedom indices.
  *
  *
@@ -434,7 +434,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return an iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     cell_iterator        end (const unsigned int level) const;
     
@@ -442,7 +442,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return a raw iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_cell_iterator    end_raw (const unsigned int level) const;
 
@@ -450,7 +450,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return an active iterator which is the
                                      * first iterator not on level. If @p level
                                      * is the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     active_cell_iterator end_active (const unsigned int level) const;
 
@@ -559,7 +559,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return an iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     face_iterator        end_face (const unsigned int level) const;
     
@@ -567,7 +567,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return a raw iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_face_iterator    end_raw_face (const unsigned int level) const;
 
@@ -575,7 +575,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return an active iterator which is the
                                      * first iterator not on level. If @p level
                                      * is the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     active_face_iterator end_active_face (const unsigned int level) const;
 
@@ -673,7 +673,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return an iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     line_iterator        end_line (const unsigned int level) const;
     
@@ -681,7 +681,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return a raw iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_line_iterator    end_raw_line (const unsigned int level) const;
 
@@ -689,7 +689,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return an active iterator which is the
                                      * first iterator not on level. If @p level
                                      * is the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     active_line_iterator end_active_line (const unsigned int level) const;
 
@@ -770,7 +770,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return an iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     quad_iterator        end_quad (const unsigned int level) const;
     
@@ -778,7 +778,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return a raw iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_quad_iterator    end_raw_quad (const unsigned int level) const;
 
@@ -786,7 +786,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return an active iterator which is the
                                      * first iterator not on level. If @p level
                                      * is the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     active_quad_iterator end_active_quad (const unsigned int level) const;
 
@@ -871,7 +871,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return an iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     hex_iterator        end_hex (const unsigned int level) const;
     
@@ -879,7 +879,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return a raw iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_hex_iterator    end_raw_hex (const unsigned int level) const;
 
@@ -887,7 +887,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Return an active iterator which is the
                                      * first iterator not on level. If @p level
                                      * is the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     active_hex_iterator end_active_hex (const unsigned int level) const;
 
@@ -1061,7 +1061,7 @@ class DoFHandler  :  public Subscriptor,
                                      * the DoF handler, we subscribe to
                                      * the finite element object. To unlock
                                      * the FE before the end of the lifetime
-                                     * of this DoF handler, use the @p{clear()}
+                                     * of this DoF handler, use the <tt>clear()</tt>
                                      * function (this clears all data of
                                      * this object as well, though).
                                      */
@@ -1093,7 +1093,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      * Reserve enough space in the 
-                                     * @p{levels[]} objects to store the
+                                     * <tt>levels[]</tt> objects to store the
                                      * numbers of the degrees of freedom
                                      * needed for the given element. The
                                      * given element is that one which
@@ -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 Triangulation
+                                     * <tt>levels[]</tt> tree of the Triangulation
                                      * objects.
                                      */
     std::vector<DoFLevel<dim>*>    levels;
index 3ccf4573a4eb5d36039ee5603ddcd74ad4a594ad..80e9e6964ed0e09af03b4442645e20895762ce26 100644 (file)
@@ -45,7 +45,7 @@ class DoFLevel
  *
  * @sect3{Information for all DoFLevel classes}
  *
- * The DoFLevel@p{<N>} classes 
+ * The DoFLevel<tt><N></tt> 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,23 +63,23 @@ 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 DoFHandler@p{::make_hanging_node_constraints ()}
+ * constraint matrix returned by DoFHandler<tt>::make_hanging_node_constraints ()</tt>
  * 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
- * DoFLevel@p{<dim>} classes for the different dimensions which
+ * DoFLevel<tt><dim></tt> 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
- * DoFHandler@p{::distribute_dofs()} to select a finite element)
+ * DoFHandler<tt>::distribute_dofs()</tt> 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 ith
- * line are at the positions @p{N*i...(N+1)*i-1}.
+ * line are at the positions <tt>N*i...(N+1)*i-1</tt>.
  *
  * The DoF indices for vertices are not stored this way, since they
  * need different treatment in multigrid environments. If no multigrid
index 569436f2d8464c2ebd33f6435bb113f73a017627..4dfd3fdc8491b505b30d8ee12756a508bf4340fb 100644 (file)
@@ -604,7 +604,7 @@ class DoFRenumbering
                                      * function.
                                      *
                                      * The algorithm is stable, i.e. if
-                                      * two dofs i,j have @p{i<j} and belong
+                                      * two dofs i,j have <tt>i<j</tt> and belong
                                       * to the same subdomain, then they
                                       * will be in this order also after
                                       * reordering.
index b1edb1c267c862e50eb8a8616fce343606db3abb..24ff517b5cd31396554de0872c4d31ebce0d305c 100644 (file)
@@ -183,11 +183,11 @@ class DoFTools
                                      * of hanging nodes.  They have
                                      * to be taken care of by a call
                                      * to
-                                     * ConstraintMatrix@p{::condense()}
+                                     * ConstraintMatrix<tt>::condense()</tt>
                                      * afterwards.
                                      *
                                      * Remember using
-                                     * SparsityPattern@p{::compress()}
+                                     * SparsityPattern<tt>::compress()</tt>
                                      * after generating the pattern.
                                      *
                                      * The actual type of the
@@ -316,14 +316,14 @@ class DoFTools
                                      * nodes.  The sparsity pattern
                                      * is not compressed, since if
                                      * you want to call
-                                     * ConstraintMatrix@p{::condense(1)}
+                                     * ConstraintMatrix<tt>::condense(1)</tt>
                                      * afterwards, new entries have
                                      * to be added. However, if you
                                      * don't want to call
-                                     * ConstraintMatrix@p{::condense(1)},
+                                     * ConstraintMatrix<tt>::condense(1)</tt>,
                                      * you have to compress the
                                      * matrix yourself, using
-                                     * SparsityPattern@p{::compress()}.
+                                     * SparsityPattern<tt>::compress()</tt>.
                                      *
                                      * The actual type of the
                                      * sparsity pattern may be
@@ -571,7 +571,7 @@ class DoFTools
                                      * It is assumed that the output
                                      * vector @p dof_data already
                                      * has the right size,
-                                     * i.e. @p{n_dofs()} elements.
+                                     * i.e. <tt>n_dofs()</tt> elements.
                                      *
                                      * This function cannot be used
                                      * if the finite element in use
@@ -612,7 +612,7 @@ class DoFTools
                                      * in the finite element used by
                                      * @p dof. The size of
                                      * @p selected_dofs shall equal
-                                     * @p{dof_handler.n_dofs()}. Previous
+                                     * <tt>dof_handler.n_dofs()</tt>. Previous
                                      * contents of this array or
                                      * overwritten.
                                      *
@@ -686,7 +686,7 @@ class DoFTools
                                      * element used by @p dof. The
                                      * size of @p selected_dofs shall
                                      * equal
-                                     * @p{dof_handler.n_dofs()}. Previous
+                                     * <tt>dof_handler.n_dofs()</tt>. Previous
                                      * contents of this array or
                                      * overwritten.
                                      *
@@ -726,7 +726,7 @@ class DoFTools
                                      *
                                      * The size of @p selected_dofs
                                      * shall equal
-                                     * @p{dof_handler.n_dofs()}. Previous
+                                     * <tt>dof_handler.n_dofs()</tt>. Previous
                                      * contents of this array or
                                      * overwritten.
                                      */
@@ -777,7 +777,7 @@ class DoFTools
                                      /**
                                       * For each DoF, return in the output
                                       * array to which subdomain (as given by
-                                      * the @p{cell->subdomain_id()} function)
+                                      * the <tt>cell->subdomain_id()</tt> function)
                                       * it belongs. The output array is
                                       * supposed to have the right size
                                       * already when calling this function.
@@ -1169,7 +1169,7 @@ class DoFTools
                                      * of freedom indices to the
                                      * index of that degree of
                                      * freedom on the boundary. After
-                                     * this operation, @p{mapping[dof]}
+                                     * this operation, <tt>mapping[dof]</tt>
                                      * gives the index of the
                                      * degree of freedom with global
                                      * number @p dof in the list of
@@ -1177,7 +1177,7 @@ class DoFTools
                                      * boundary.  If the degree of
                                      * freedom requested is not on
                                      * the boundary, the value of
-                                     * @p{mapping[dof]} is
+                                     * <tt>mapping[dof]</tt> is
                                      * @p invalid_dof_index. This
                                      * function is mainly used when
                                      * setting up matrices and
index 6dd351d921d90e8b3d00f6a1af83ed2984f86564..19779ee73ab37c74774852d74a9835329d8b88c9 100644 (file)
@@ -114,7 +114,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * Access to base element
                                      * objects. If the element is
                                      * scalar, then
-                                     * @p{base_element(0)} is
+                                     * <tt>base_element(0)</tt> is
                                      * @p this.
                                      */
     virtual
@@ -192,7 +192,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * @p update_each compute which
                                      * values must really be
                                      * computed. Then, the
-                                     * @p{fill_*_values} functions
+                                     * <tt>fill_*_values</tt> functions
                                      * are called with the result of
                                      * these.
                                      *
index 285bd6174529fdd61802e9999b663d9fc93f747e..4edf14c22803e03f3edbc7b67c00cdbd916681c3 100644 (file)
@@ -435,8 +435,8 @@ class FiniteElementBase : public Subscriptor,
                                          * approximate second
                                          * derivatives.
                                          *
-                                         * The ordering is @p{p+hx},
-                                         * @p{p+hy}, @p{p+hz},
+                                         * The ordering is <tt>p+hx</tt>,
+                                         * <tt>p+hy</tt>, <tt>p+hz</tt>,
                                          * @p p-hx, @p p-hy,
                                          * @p p-hz, where unused
                                          * entries in lower dimensions
@@ -473,7 +473,7 @@ class FiniteElementBase : public Subscriptor,
                                      * brackets, and the polynomial
                                      * degree and whatever else is
                                      * necessary in parentheses. For
-                                     * example, @p{FE_Q<2>(3)} is the
+                                     * example, <tt>FE_Q<2>(3)</tt> is the
                                      * value returned for a cubic
                                      * element in 2d.
                                      *
@@ -689,7 +689,7 @@ class FiniteElementBase : public Subscriptor,
                                      * concatenation, not the sum of
                                      * the cell matrices
                                      * @p P_i. That is, if the same
-                                     * non-zero entry @p{j,k} exists
+                                     * non-zero entry <tt>j,k</tt> exists
                                      * in in two different child
                                      * matrices @p P_i, the value
                                      * should be the same in both
@@ -747,7 +747,7 @@ class FiniteElementBase : public Subscriptor,
                                       * and they are not implemented. This
                                       * function could be used to check
                                       * whether a call to
-                                      * @p{get_prolongation_matrix()} will
+                                      * <tt>get_prolongation_matrix()</tt> will
                                       * succeed; however, one then still needs
                                       * to cope with the lack of information
                                       * this just expresses.
@@ -808,7 +808,7 @@ class FiniteElementBase : public Subscriptor,
                                       * node constraints and they are
                                       * not implemented. This function
                                       * could be used to check whether
-                                      * a call to @p{constraints()}
+                                      * a call to <tt>constraints()</tt>
                                       * will succeed; however, one
                                       * then still needs to cope with
                                       * the lack of information this
@@ -822,7 +822,7 @@ class FiniteElementBase : public Subscriptor,
                                      * finite element to the present
                                      * one. The size of the matrix is
                                      * then @p dofs_per_cell times
-                                     * @p{source.dofs_per_cell}.
+                                     * <tt>source.dofs_per_cell</tt>.
                                      *
                                      * Derived elements will have to
                                      * implement this function. They
@@ -1032,7 +1032,7 @@ class FiniteElementBase : public Subscriptor,
                                      * element.  The order of points
                                      * in the array matches that
                                      * returned by the
-                                     * @p{cell->get_dof_indices}
+                                     * <tt>cell->get_dof_indices</tt>
                                      * function.
                                      *
                                      * See the class documentation
@@ -1150,7 +1150,7 @@ class FiniteElementBase : public Subscriptor,
                                      * (@p dofs_per_face). The order
                                      * of points in the array matches
                                      * that returned by the
-                                     * @p{cell->get_dof_indices}
+                                     * <tt>cell->get_dof_indices</tt>
                                      * function.
                                      *
                                      * See the class documentation
@@ -1204,7 +1204,7 @@ class FiniteElementBase : public Subscriptor,
                                      * that case, the component with
                                      * the single zero is also the
                                      * first element of what
-                                     * @p{system_to_component_index(i)}
+                                     * <tt>system_to_component_index(i)</tt>
                                      * returns.
                                      *
                                      * Only for those
@@ -1256,7 +1256,7 @@ class FiniteElementBase : public Subscriptor,
                                      * The result of the function is
                                      * @p true if and only if the
                                      * result of
-                                     * @p{n_nonzero_components(i)} is
+                                     * <tt>n_nonzero_components(i)</tt> is
                                      * equal to one.
                                      */
     bool
@@ -1364,7 +1364,7 @@ class FiniteElementBase : public Subscriptor,
 
                                     /**
                                      * Array of embedding matrices. See
-                                     * @p{get_prolongation_matrix()} above.
+                                     * <tt>get_prolongation_matrix()</tt> above.
                                      *
                                      * Matrices in this array are
                                      * automatically initialized to
index 4048a9385e66259f6d1f61fe8fade3997b10de2f..1abfc53814210ee8d1759c065e9bbfcde02c18e7 100644 (file)
@@ -46,7 +46,7 @@ class FE_DGP : public FE_Poly<PolynomialSpace<dim>,dim>
                                      * Return a string that uniquely
                                      * identifies a finite
                                      * element. This class returns
-                                     * @p{FE_DGP<dim>(degree)}, with
+                                     * <tt>FE_DGP<dim>(degree)</tt>, with
                                      * @p dim and @p degree
                                      * replaced by appropriate
                                      * values.
@@ -90,7 +90,7 @@ class FE_DGP : public FE_Poly<PolynomialSpace<dim>,dim>
                                      * constraint and embedding
                                      * matrices. The definition of
                                      * the various static fields are
-                                     * in the files @p{fe_dgp_[123]d.cc}
+                                     * in the files <tt>fe_dgp_[123]d.cc</tt>
                                      * in the source directory.
                                      */
     struct Matrices
index 53e9be9e0613397ce605bd814a4a0e0788534913..5467583e41465327bf5e173ae54169b6239e06b7 100644 (file)
@@ -61,7 +61,7 @@ class FE_DGPMonomial : public FE_Poly<PolynomialsP<dim>,dim>
                                      * finite element to the present
                                      * one. The size of the matrix is
                                      * then @p dofs_per_cell times
-                                     * @p{source.dofs_per_cell}.
+                                     * <tt>source.dofs_per_cell</tt>.
                                      *
                                      * These matrices are only
                                      * available if the source
index 156eb0b4ac464a5c1b48ba954e697ca694a5b0bc..928f1c2426c9c0062dfb83d8a8d5eab0df4f331f 100644 (file)
@@ -59,7 +59,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                      * Return a string that uniquely
                                      * identifies a finite
                                      * element. This class returns
-                                     * @p{FE_DGPNonparametric<dim>(degree)},
+                                     * <tt>FE_DGPNonparametric<dim>(degree)</tt>,
                                      * with @p dim and @p degree
                                      * replaced by appropriate
                                      * values.
@@ -188,7 +188,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                     /**
                                      * Access to base element
                                      * objects. Since this element is
-                                     * scalar, @p{base_element(0)} is
+                                     * scalar, <tt>base_element(0)</tt> is
                                      * @p this, and all other
                                      * indices throw an error.
                                      */
@@ -199,7 +199,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                       * Multiplicity of base element
                                       * @p index. Since this is a
                                       * scalar element,
-                                      * @p{element_multiplicity(0)}
+                                      * <tt>element_multiplicity(0)</tt>
                                       * returns one, and all other
                                       * indices will throw an error.
                                       */
@@ -242,7 +242,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                      * constraint and embedding
                                      * matrices. The definition of
                                      * the various static fields are
-                                     * in the files @p{fe_dgp_[123]d.cc}
+                                     * in the files <tt>fe_dgp_[123]d.cc</tt>
                                      * in the source directory.
                                      */
     struct Matrices
index 26ae81837eef5fdb53a15a81347b61b793cd41e8..64295bd05b646daa2da7a3735761bc1c823aff82 100644 (file)
@@ -61,7 +61,7 @@ class FE_DGQ : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * finite element to the present
                                      * one. The size of the matrix is
                                      * then @p dofs_per_cell times
-                                     * @p{source.dofs_per_cell}.
+                                     * <tt>source.dofs_per_cell</tt>.
                                      *
                                      * These matrices are only
                                      * available if the source
@@ -112,7 +112,7 @@ class FE_DGQ : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * constraint and embedding
                                      * matrices. The definition of
                                      * the various static fields are
-                                     * in the files @p{fe_dgq_[123]d.cc}
+                                     * in the files <tt>fe_dgq_[123]d.cc</tt>
                                      * in the source directory.
                                      */
     struct Matrices
index 9b28a8a10f3ae6d129af3792fc5d07def0a3df0e..0fd9674dc5d33cab47ba137825f1f774f8134c06 100644 (file)
@@ -30,7 +30,7 @@ template <int dim> class MappingQ;
  *
  * 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
+ * (i.e. <tt>p==1</tt>) are implemented. For a general overview of this
  * element and its properties, see the report by Anna Schneebeli that
  * is linked from the general documentation page of the library.
  *
@@ -192,7 +192,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                      * Return a string that uniquely
                                      * identifies a finite
                                      * element. This class returns
-                                     * @p{FE_Nedelec<dim>(degree)}, with
+                                     * <tt>FE_Nedelec<dim>(degree)</tt>, with
                                      * @p dim and @p degree
                                      * replaced by appropriate
                                      * values.
@@ -263,7 +263,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                     /**
                                      * Access to base element
                                      * objects. Since this element is
-                                     * atomic, @p{base_element(0)} is
+                                     * atomic, <tt>base_element(0)</tt> is
                                      * @p this, and all other
                                      * indices throw an error.
                                      */
@@ -274,7 +274,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                       * Multiplicity of base element
                                       * @p index. Since this is an
                                       * atomic element,
-                                      * @p{element_multiplicity(0)}
+                                      * <tt>element_multiplicity(0)</tt>
                                       * returns one, and all other
                                       * indices will throw an error.
                                       */
@@ -320,7 +320,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                      * constraint and embedding
                                      * matrices. The definition of
                                      * the various static fields are
-                                     * in the files @p{fe_nedelec_[23]d.cc}
+                                     * in the files <tt>fe_nedelec_[23]d.cc</tt>
                                      * in the source directory.
                                      */
     struct Matrices
index 872650069a8a7d67116d2bb116cbf35c531ad4f2..7c6dc5d5ed4128c97ad2ada699664dde978f144f 100644 (file)
  * is listed in the following:
  *
  * <ul>
- * <li> @p{dim==1}
+ * <li> <tt>dim==1</tt>
  *   <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}
+ * <li> <tt>dim==2</tt>
  *   <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}
+ * <li> <tt>dim==3</tt>
  *   <ul>
  *   <li> the @p interface_constraints up to degree 2,
  *   <li> the @p prolongation matrices up to degree 2, and
  *   The respective coordinate values of the support points of the degrees
  *   of freedom are as follows:
  *   <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 0: <tt>[0, 0, 0]</tt>;
+ *   <li> Index 1: <tt>[1, 0, 0]</tt>;
+ *   <li> Index 2: <tt>[1, 0, 1]</tt>;
+ *   <li> Index 3: <tt>[0, 0, 1]</tt>;
+ *   <li> Index 4: <tt>[0, 1, 0]</tt>;
+ *   <li> Index 5: <tt>[1, 1, 0]</tt>;
+ *   <li> Index 6: <tt>[1, 1, 1]</tt>;
+ *   <li> Index 7: <tt>[0, 1, 1]</tt>;
  *   </ul>
  * </ul>
  * @sect4{Q2 elements}
  *   The respective coordinate values of the support points of the degrees
  *   of freedom are as follows:
  *   <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]}
+ *   <li> Index 0: <tt>[0, 0, 0]</tt>;
+ *   <li> Index 1: <tt>[1, 0, 0]</tt>;
+ *   <li> Index 2: <tt>[1, 0, 1]</tt>;
+ *   <li> Index 3: <tt>[0, 0, 1]</tt>;
+ *   <li> Index 4: <tt>[0, 1, 0]</tt>;
+ *   <li> Index 5: <tt>[1, 1, 0]</tt>;
+ *   <li> Index 6: <tt>[1, 1, 1]</tt>;
+ *   <li> Index 7: <tt>[0, 1, 1]</tt>;
+ *   <li> Index 8: <tt>[1/2, 0, 0]</tt>;
+ *   <li> Index 9: <tt>[1, 0, 1/2]</tt>;
+ *   <li> Index 10: <tt>[1/2, 0, 1]</tt>;
+ *   <li> Index 11: <tt>[0, 0, 1/2]</tt>;
+ *   <li> Index 12: <tt>[1/2, 1, 0]</tt>;
+ *   <li> Index 13: <tt>[1, 1, 1/2]</tt>;
+ *   <li> Index 14: <tt>[1/2, 1, 1]</tt>;
+ *   <li> Index 15: <tt>[0, 1, 1/2]</tt>;
+ *   <li> Index 16: <tt>[0, 1/2, 0]</tt>;
+ *   <li> Index 17: <tt>[1, 1/2, 0]</tt>;
+ *   <li> Index 18: <tt>[1, 1/2, 1]</tt>;
+ *   <li> Index 19: <tt>[0, 1/2, 1]</tt>;
+ *   <li> Index 20: <tt>[1/2, 0, 1/2]</tt>;
+ *   <li> Index 21: <tt>[1/2, 1, 1/2]</tt>;
+ *   <li> Index 22: <tt>[1/2, 1/2, 0]</tt>;
+ *   <li> Index 23: <tt>[1, 1/2, 1/2]</tt>;
+ *   <li> Index 24: <tt>[1/2, 1/2, 1]</tt>;
+ *   <li> Index 25: <tt>[0, 1/2, 1/2]</tt>;
+ *   <li> Index 26: <tt>[1/2, 1/2, 1/2]</tt>
  *   </ul>
  * </ul>
  * @sect4{Q3 elements}
@@ -249,7 +249,7 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * Return a string that uniquely
                                      * identifies a finite
                                      * element. This class returns
-                                     * @p{FE_Q<dim>(degree)}, with
+                                     * <tt>FE_Q<dim>(degree)</tt>, with
                                      * @p dim and @p degree
                                      * replaced by appropriate
                                      * values.
@@ -262,7 +262,7 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * finite element to the present
                                      * one. The size of the matrix is
                                      * then @p dofs_per_cell times
-                                     * @p{source.dofs_per_cell}.
+                                     * <tt>source.dofs_per_cell</tt>.
                                      *
                                      * These matrices are only
                                      * available if the source
@@ -312,7 +312,7 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * constraint and embedding
                                      * matrices. The definition of
                                      * the various static fields are
-                                     * in the files @p{fe_q_[123]d.cc}
+                                     * in the files <tt>fe_q_[123]d.cc</tt>
                                      * in the source directory.
                                      */
     struct Matrices
index b12d7c19072c21bfd47b1351f5575dc1c84f80e3..8751157b2b37b381acec98eff5b57ade68c4bfd2 100644 (file)
@@ -28,7 +28,7 @@ template <int dim> class MappingQ;
  * 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 
+ * <tt>[0,1]</tt> 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 
@@ -39,7 +39,7 @@ template <int dim> class MappingQ;
  * 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 <tt>0.5</tt> 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
@@ -101,14 +101,14 @@ template <int dim> class MappingQ;
  *   The respective coordinate values of the support points of the degrees
  *   of freedom are as follows:
  *   <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 0: <tt>[0, 0, 0]</tt>;
+ *   <li> Index 1: <tt>[1, 0, 0]</tt>;
+ *   <li> Index 2: <tt>[1, 0, 1]</tt>;
+ *   <li> Index 3: <tt>[0, 0, 1]</tt>;
+ *   <li> Index 4: <tt>[0, 1, 0]</tt>;
+ *   <li> Index 5: <tt>[1, 1, 0]</tt>;
+ *   <li> Index 6: <tt>[1, 1, 1]</tt>;
+ *   <li> Index 7: <tt>[0, 1, 1]</tt>;
  *   </ul>
  * </ul>
  * @sect4{Q2 elements}
@@ -156,33 +156,33 @@ template <int dim> class MappingQ;
  *   The respective coordinate values of the support points of the degrees
  *   of freedom are as follows:
  *   <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]}
+ *   <li> Index 0: <tt>[0, 0, 0]</tt>;
+ *   <li> Index 1: <tt>[1, 0, 0]</tt>;
+ *   <li> Index 2: <tt>[1, 0, 1]</tt>;
+ *   <li> Index 3: <tt>[0, 0, 1]</tt>;
+ *   <li> Index 4: <tt>[0, 1, 0]</tt>;
+ *   <li> Index 5: <tt>[1, 1, 0]</tt>;
+ *   <li> Index 6: <tt>[1, 1, 1]</tt>;
+ *   <li> Index 7: <tt>[0, 1, 1]</tt>;
+ *   <li> Index 8: <tt>[1/2, 0, 0]</tt>;
+ *   <li> Index 9: <tt>[1, 0, 1/2]</tt>;
+ *   <li> Index 10: <tt>[1/2, 0, 1]</tt>;
+ *   <li> Index 11: <tt>[0, 0, 1/2]</tt>;
+ *   <li> Index 12: <tt>[1/2, 1, 0]</tt>;
+ *   <li> Index 13: <tt>[1, 1, 1/2]</tt>;
+ *   <li> Index 14: <tt>[1/2, 1, 1]</tt>;
+ *   <li> Index 15: <tt>[0, 1, 1/2]</tt>;
+ *   <li> Index 16: <tt>[0, 1/2, 0]</tt>;
+ *   <li> Index 17: <tt>[1, 1/2, 0]</tt>;
+ *   <li> Index 18: <tt>[1, 1/2, 1]</tt>;
+ *   <li> Index 19: <tt>[0, 1/2, 1]</tt>;
+ *   <li> Index 20: <tt>[1/2, 0, 1/2]</tt>;
+ *   <li> Index 21: <tt>[1/2, 1, 1/2]</tt>;
+ *   <li> Index 22: <tt>[1/2, 1/2, 0]</tt>;
+ *   <li> Index 23: <tt>[1, 1/2, 1/2]</tt>;
+ *   <li> Index 24: <tt>[1/2, 1/2, 1]</tt>;
+ *   <li> Index 25: <tt>[0, 1/2, 1/2]</tt>;
+ *   <li> Index 26: <tt>[1/2, 1/2, 1/2]</tt>
  *   </ul>
  * </ul>
  * @sect4{Q3 elements}
@@ -244,7 +244,7 @@ class FE_Q_Hierarchical : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      * Return a string that uniquely
                                      * identifies a finite
                                      * element. This class returns
-                                     * @p{FE_Q_Hierarchical<dim>(degree)},
+                                     * <tt>FE_Q_Hierarchical<dim>(degree)</tt>,
                                      * with @p dim and @p degree
                                      * replaced by appropriate
                                      * values.
index 7b75a775cae6b494f44ffe3c54d150339330c7b2..0f0b72e7b907dc3d588d11d10cdc9c1aec30bf8d 100644 (file)
@@ -148,7 +148,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                      * Return a string that uniquely
                                      * identifies a finite
                                      * element. This class returns
-                                     * @p{FE_RaviartThomas<dim>(degree)}, with
+                                     * <tt>FE_RaviartThomas<dim>(degree)</tt>, with
                                      * @p dim and @p degree
                                      * replaced by appropriate
                                      * values.
@@ -214,7 +214,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                      * finite element to the present
                                      * one. The size of the matrix is
                                      * then @p dofs_per_cell times
-                                     * @p{source.dofs_per_cell}.
+                                     * <tt>source.dofs_per_cell</tt>.
                                      *
                                      * These matrices are only
                                      * available if the source
@@ -239,7 +239,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                     /**
                                      * Access to base element
                                      * objects. Since this element is
-                                     * atomic, @p{base_element(0)} is
+                                     * atomic, <tt>base_element(0)</tt> is
                                      * @p this, and all other
                                      * indices throw an error.
                                      */
@@ -250,7 +250,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                       * Multiplicity of base element
                                       * @p index. Since this is an
                                       * atomic element,
-                                      * @p{element_multiplicity(0)}
+                                      * <tt>element_multiplicity(0)</tt>
                                       * returns one, and all other
                                       * indices will throw an error.
                                       */
index f81ff1eeb43c77b4e45a0a24863e8a630095fa73..417062cb970958ebb47880f2dbfcb0a75b0261bb 100644 (file)
  * subobject. For example, for a element of three components in one
  * space dimension, the first two components being cubic lagrange
  * elements and the third being a quadratic lagrange element, the
- * ordering for the system @p{s=(u,v,p)} is:
+ * ordering for the system <tt>s=(u,v,p)</tt> is:
  *
  * <ul>
- * <li> First vertex: @p{u0, v0, p0 = s0, s1, s2}
- * <li> Second vertex: @p{u1, v1, p1 = s3, s4, s5}
+ * <li> First vertex: <tt>u0, v0, p0 = s0, s1, s2</tt>
+ * <li> Second vertex: <tt>u1, v1, p1 = s3, s4, s5</tt>
  * <li> First component on the line:
- *   @p{u2, u3 = s4, s5}
+ *   <tt>u2, u3 = s4, s5</tt>
  * <li> Second component on the line:
- *   @p{v2, v3 = s6, s7}.
+ *   <tt>v2, v3 = s6, s7</tt>.
  * <li> Third component on the line:
- *   @p{p2 = s8}.
+ *   <tt>p2 = s8</tt>.
  * </ul>
  * Do not rely on this numbering in your application as these
  * internals might change in future. Rather use the functions
@@ -130,7 +130,7 @@ class FESystem : public FiniteElement<dim>
                                      * @p name1...@p nameN returned
                                      * by the basis elements. From
                                      * these, we create a sequence
-                                     * @p{FESystem<dim>[name1^m1-name2^m2-...-nameN^mN]},
+                                     * <tt>FESystem<dim>[name1^m1-name2^m2-...-nameN^mN]</tt>,
                                      * where @p mi are the
                                      * multiplicities of the basis
                                      * elements. If a multiplicity is
@@ -301,7 +301,7 @@ class FESystem : public FiniteElement<dim>
                                      * finite element to the present
                                      * one. The size of the matrix is
                                      * then @p dofs_per_cell times
-                                     * @p{source.dofs_per_cell}.
+                                     * <tt>source.dofs_per_cell</tt>.
                                      *
                                      * These matrices are available
                                      * if source and destination
@@ -443,7 +443,7 @@ class FESystem : public FiniteElement<dim>
                                      * Passes on control to
                                      * @p compute_fill that does the
                                      * work for all three
-                                     * @p{fill_fe*_values}
+                                     * <tt>fill_fe*_values</tt>
                                      * functions.
                                      */
     virtual void
@@ -462,7 +462,7 @@ class FESystem : public FiniteElement<dim>
                                      * Passes on control to
                                      * @p compute_fill that does the
                                      * work for all three
-                                     * @p{fill_fe*_values} functions.
+                                     * <tt>fill_fe*_values</tt> functions.
                                      */    
     virtual void
     fill_fe_face_values (const Mapping<dim>                   &mapping,
@@ -481,7 +481,7 @@ class FESystem : public FiniteElement<dim>
                                      * Passes on control to
                                      * @p compute_fill that does the
                                      * work for all three
-                                     * @p{fill_fe*_values} functions.
+                                     * <tt>fill_fe*_values</tt> functions.
                                      */
     virtual void
     fill_fe_subface_values (const Mapping<dim>                   &mapping,
@@ -496,25 +496,25 @@ class FESystem : public FiniteElement<dim>
 
                                     /**
                                      * Do the work for the three
-                                     * @p{fill_fe*_values} functions.
+                                     * <tt>fill_fe*_values</tt> functions.
                                      * 
                                      * Calls (among other things)
-                                     * @p{fill_fe_([sub]face)_values}
+                                     * <tt>fill_fe_([sub]face)_values</tt>
                                      * of the base elements. Calls
                                      * @p fill_fe_values if
-                                     * @p{face_no==invalid_face_no}
+                                     * <tt>face_no==invalid_face_no</tt>
                                      * and
-                                     * @p{sub_no==invalid_face_no};
+                                     * <tt>sub_no==invalid_face_no</tt>;
                                      * calls @p fill_fe_face_values
                                      * if
-                                     * @p{face_no==invalid_face_no}
+                                     * <tt>face_no==invalid_face_no</tt>
                                      * and
-                                     * @p{sub_no!=invalid_face_no};
+                                     * <tt>sub_no!=invalid_face_no</tt>;
                                      * and calls
                                      * @p fill_fe_subface_values if
-                                     * @p{face_no!=invalid_face_no}
+                                     * <tt>face_no!=invalid_face_no</tt>
                                      * and
-                                     * @p{sub_no!=invalid_face_no}.
+                                     * <tt>sub_no!=invalid_face_no</tt>.
                                      */
     template <int dim_1>
     void compute_fill (const Mapping<dim>                   &mapping,
@@ -813,10 +813,10 @@ class FESystem : public FiniteElement<dim>
                                         /**
                                          * Deletes the
                                          * @p FEValuesData the
-                                         * @p{fe_datas[base_no]}
+                                         * <tt>fe_datas[base_no]</tt>
                                          * pointer is pointing
                                          * to. Sets
-                                         * @p{fe_datas[base_no]} to
+                                         * <tt>fe_datas[base_no]</tt> to
                                          * zero.
                                          *
                                          * This function is used to
index 35564d19935f53ed40ad568dd9b70c3b816c2e26..84c9a09058e380c18cd12aeaafb2b0ef3f1cfc04 100644 (file)
@@ -52,7 +52,7 @@ class FETools
                                      * 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)}.
+                                     * <tt>(fe2.dofs_per_cell, fe1.dofs_per_cell)</tt>.
                                      *
                                      * Note, that if the finite element
                                      * space @p fe1 is a subset of
@@ -73,7 +73,7 @@ class FETools
                                      * @p fe1-function on
                                      * each cell. The interpolation_matrix
                                      * needs to be of size
-                                     * @p{(fe1.dofs_per_cell, fe1.dofs_per_cell)}.
+                                     * <tt>(fe1.dofs_per_cell, fe1.dofs_per_cell)</tt>.
                                      *
                                      * Note, that this function only
                                      * makes sense if the finite element
@@ -93,7 +93,7 @@ class FETools
                                      * back interpolation matrix.
                                      * The @p difference_matrix
                                      * needs to be of size
-                                     * @p{(fe1.dofs_per_cell, fe1.dofs_per_cell)}.
+                                     * <tt>(fe1.dofs_per_cell, fe1.dofs_per_cell)</tt>.
                                      *
                                      * This function gives
                                      * the matrix that transforms a
@@ -525,7 +525,7 @@ class FETools
                                      * space dimension in the form of
                                      * a template argument after the
                                      * name of the class (for example
-                                     * @p{FE_Q<2>}, you can omit the
+                                     * <tt>FE_Q<2></tt>, you can omit the
                                      * dimension argument altogether,
                                      * or replace it with the string
                                      * <tt>@<dim@></tt>. The reason
index 6ba485e8dc8f51bc2aefa692510086d5ae987f11..dc8ac9aa4a18deeb65f5d137fb4442dcc213d9e9 100644 (file)
@@ -203,7 +203,7 @@ class FEValuesData
                                      * follows: we allocate one row
                                      * for each non-zero component as
                                      * indicated by the
-                                     * @p{FiniteElement::get_nonzero_components()}
+                                     * <tt>FiniteElement::get_nonzero_components()</tt>
                                      * function, and the rows are in
                                      * ascending order exactly those
                                      * non-zero components.
@@ -283,7 +283,7 @@ class FEValuesData
  *    and you have to walk over all (or only the non-zero) components of
  *    the shape function using this set of functions.
  *   
- *  <li> @p get_function_values, @p get_function_grads, @p{...}:
+ *  <li> @p get_function_values, @p get_function_grads, <tt>...</tt>:
  *    Compute a finite element function or its derivative
  *    in quadrature points.
  *
@@ -456,8 +456,8 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * correct size. 
                                      *
                                      * The actual data type of the input
-                                     * vector may be either a @p{Vector<T>},
-                                     * @p{BlockVector<T>}, or one of the
+                                     * vector may be either a <tt>Vector<T></tt>,
+                                     * <tt>BlockVector<T></tt>, or one of the
                                      * PETSc vector wrapper classes. It
                                      * represents a global vector of
                                      * DoF values associated with the
@@ -480,8 +480,8 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * elements.
                                      *
                                      * The actual data type of the input
-                                     * vector may be either a @p{Vector<T>},
-                                     * @p{BlockVector<T>}, or one of the
+                                     * vector may be either a <tt>Vector<T></tt>,
+                                     * <tt>BlockVector<T></tt>, or one of the
                                      * PETSc vector wrapper classes. It
                                      * represents a global vector of
                                      * DoF values associated with the
@@ -577,8 +577,8 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * right size.
                                      *
                                      * The actual data type of the input
-                                     * vector may be either a @p{Vector<T>},
-                                     * @p{BlockVector<T>}, or one of the
+                                     * vector may be either a <tt>Vector<T></tt>,
+                                     * <tt>BlockVector<T></tt>, or one of the
                                      * PETSc vector wrapper classes. It
                                      * represents a global vector of
                                      * DoF values associated with the
@@ -616,8 +616,8 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * elements.
                                      *
                                      * The actual data type of the input
-                                     * vector may be either a @p{Vector<T>},
-                                     * @p{BlockVector<T>}, or one of the
+                                     * vector may be either a <tt>Vector<T></tt>,
+                                     * <tt>BlockVector<T></tt>, or one of the
                                      * PETSc vector wrapper classes. It
                                      * represents a global vector of
                                      * DoF values associated with the
@@ -721,8 +721,8 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * function.
                                      * 
                                      * The actual data type of the input
-                                     * vector may be either a @p{Vector<T>},
-                                     * @p{BlockVector<T>}, or one of the
+                                     * vector may be either a <tt>Vector<T></tt>,
+                                     * <tt>BlockVector<T></tt>, or one of the
                                      * PETSc vector wrapper classes..It
                                      * represents a global vector of
                                      * DoF values associated with the
@@ -759,8 +759,8 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * vector-valued finite elements.
                                      *
                                      * The actual data type of the input
-                                     * vector may be either a @p{Vector<T>},
-                                     * @p{BlockVector<T>}, or one of the
+                                     * vector may be either a <tt>Vector<T></tt>,
+                                     * <tt>BlockVector<T></tt>, or one of the
                                      * PETSc vector wrapper classes. It
                                      * represents a global vector of
                                      * DoF values associated with the
@@ -878,7 +878,7 @@ class FEValuesBase : protected FEValuesData<dim>
                                      * Store the cell selected last time
                                      * the @p reinit function was called
                                      * to make access
-                                     * to the @p{get_function_*} functions
+                                     * to the <tt>get_function_*</tt> functions
                                      * safer.
                                      */
     typename DoFHandler<dim>::cell_iterator present_cell;
@@ -1032,9 +1032,9 @@ class FEFaceValuesBase : public FEValuesBase<dim>
                                      * 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
+                                     * @p FEFaceValues it is <tt>2*dim</tt>, while for
                                      * the @p FESubfaceValues class it is
-                                     * @p{2*dim*(1<<(dim-1))}, i.e. the number
+                                     * <tt>2*dim*(1<<(dim-1))</tt>, i.e. the number
                                      * of faces times the number of subfaces
                                      * per face.
                                      */
@@ -1068,7 +1068,7 @@ class FEFaceValuesBase : public FEValuesBase<dim>
                                      * cheaper to compute the
                                      * boundary form immediately, use
                                      * this value to integrate
-                                     * @p{n.ds}.
+                                     * <tt>n.ds</tt>.
                                      */
     const Tensor<1,dim> & boundary_form (const unsigned int i) const;
     
index dd070ee10fdc2b7f76acc2c80a9e91574b24236a..bf9c937d03f902a915a462378e2762fc1cd4ff7f 100644 (file)
@@ -42,11 +42,11 @@ template <int dim> class FESubfaceValues;
  * 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
- * FiniteElement. Then call @p{get_*_data} and with the or'd
+ * FiniteElement. Then call <tt>get_*_data</tt> 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
+ * structures.  On the first cell, call <tt>fill_fe_*_values</tt> 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
+ * <tt>fill_fe_*_values</tt> with the result of @p update_each to compute
  * values for a special cell.
  *
  * A hint to implementators: no function except the two functions
@@ -165,11 +165,11 @@ class Mapping : public Subscriptor
        UpdateFlags          update_each;
 
                                         /**
-                                         * If @p{first_cell==true}
+                                         * If <tt>first_cell==true</tt>
                                          * this function returns
                                          * @p update_flags,
-                                         * i.e. @p{update_once|update_each}.
-                                         * If @p{first_cell==false}
+                                         * i.e. <tt>update_once|update_each</tt>.
+                                         * If <tt>first_cell==false</tt>
                                          * it returns
                                          * @p update_each.
                                          */
@@ -518,8 +518,8 @@ class Mapping : public Subscriptor
 
                                     /**
                                      * Give class @p FEValues access
-                                     * to the private @p{get_...data}
-                                     * and @p{fill_fe_...values}
+                                     * to the private <tt>get_...data</tt>
+                                     * and <tt>fill_fe_...values</tt>
                                      * functions.
                                      */
   friend class FEValues<dim>;
index ea5cbe5917bd4247c1b19ab8c13d455dd2867a79..85cc0f26e19398d10379cf50d5e11b7c94c40aed 100644 (file)
@@ -52,7 +52,7 @@ class MappingC1 : public MappingQ<dim>
 
   protected:
                                     /**
-                                     * For @p{dim=2,3}. Append the
+                                     * For <tt>dim=2,3</tt>. Append the
                                      * support points of all shape
                                      * functions located on bounding
                                      * lines to the vector
@@ -61,8 +61,8 @@ class MappingC1 : public MappingQ<dim>
                                      * included.
                                      *
                                      * Needed by the
-                                     * @p{compute_support_points_simple(laplace)}
-                                     * functions. For @p{dim=1} this
+                                     * <tt>compute_support_points_simple(laplace)</tt>
+                                     * functions. For <tt>dim=1</tt> this
                                      * function is empty.
                                      *
                                      * This function chooses the
@@ -78,7 +78,7 @@ class MappingC1 : public MappingQ<dim>
                             std::vector<Point<dim> > &a) const;
 
                                     /**
-                                     * For @p{dim=3}. Append the
+                                     * For <tt>dim=3</tt>. Append the
                                      * support points of all shape
                                      * functions located on bounding
                                      * faces (quads in 3d) to the
@@ -88,7 +88,7 @@ class MappingC1 : public MappingQ<dim>
                                      *
                                      * Needed by the
                                      * @p compute_support_points_laplace
-                                     * function. For @p{dim=1} and 2
+                                     * function. For <tt>dim=1</tt> and 2
                                      * this function is empty.
                                      *
                                      * This function chooses the
index 0f2a3f73324a3102b0e497740e262b7d8212af25..e5e439ccaa4a3ff57d2ff689a4ff0baa972a1dce 100644 (file)
@@ -30,7 +30,7 @@ template <int dim> class TensorProductPolynomials;
  * equidistant (on the unit cell) support points.
  *
  * For more details about Qp-mappings, see the `mapping' report at
- * @p{deal.II/doc/reports/mapping_q/index.html} in the `Reports'
+ * <tt>deal.II/doc/reports/mapping_q/index.html</tt> in the `Reports'
  * section of `Documentation'.
  *
  * @author Ralf Hartmann, Guido Kanschat 2000, 2001
@@ -160,7 +160,7 @@ class MappingQ : public MappingQ1<dim>
 
                                         /**
                                          * Flag that is set by the
-                                         * @p{fill_fe_[[sub]face]_values}
+                                         * <tt>fill_fe_[[sub]face]_values</tt>
                                          * function.
                                          *
                                          * If this flag is @p true
@@ -220,7 +220,7 @@ class MappingQ : public MappingQ1<dim>
                            typename std::vector<Point<dim> >        &normal_vectors) const ;
 
                                     /**
-                                     * For @p{dim=2,3}. Append the
+                                     * For <tt>dim=2,3</tt>. Append the
                                      * support points of all shape
                                      * functions located on bounding
                                      * lines to the vector
@@ -230,7 +230,7 @@ class MappingQ : public MappingQ1<dim>
                                      *
                                      * Needed by the
                                      * @p compute_support_points_laplace
-                                     * function . For @p{dim=1} this
+                                     * function . For <tt>dim=1</tt> this
                                      * function is empty.
                                      *
                                      * This function is made virtual
@@ -247,7 +247,7 @@ class MappingQ : public MappingQ1<dim>
                             std::vector<Point<dim> > &a) const;
 
                                     /**
-                                     * For @p{dim=3}. Append the
+                                     * For <tt>dim=3</tt>. Append the
                                      * support points of all shape
                                      * functions located on bounding
                                      * faces (quads in 3d) to the
@@ -257,8 +257,8 @@ class MappingQ : public MappingQ1<dim>
                                      *
                                      * Needed by the
                                      * @p compute_support_points_laplace
-                                     * function. For @p{dim=1} and
-                                     * @p{dim=2} this function is
+                                     * function. For <tt>dim=1</tt> and
+                                     * <tt>dim=2</tt> this function is
                                      * empty.
                                      *
                                      * This function is made virtual
@@ -313,14 +313,14 @@ class MappingQ : public MappingQ1<dim>
 
                                     /**
                                      * This function is needed by the
-                                     * constructor of @p{MappingQ<dim>}
-                                     * for @p{dim=} 2 and 3.
+                                     * constructor of <tt>MappingQ<dim></tt>
+                                     * for <tt>dim=</tt> 2 and 3.
                                      *
-                                     * For @p{degree<4} this function
+                                     * For <tt>degree<4</tt> this function
                                      * sets the
                                      * @p laplace_on_quad_vector to
                                      * the hardcoded data. For
-                                     * @p{degree>=4} and MappingQ<2>
+                                     * <tt>degree>=4</tt> and MappingQ<2>
                                      * this vector is computed.
                                      *
                                      * For the definition of the
@@ -333,13 +333,13 @@ class MappingQ : public MappingQ1<dim>
     
                                     /**
                                      * This function is needed by the
-                                     * constructor of @p{MappingQ<3>}.
+                                     * constructor of <tt>MappingQ<3></tt>.
                                      *
-                                     * For @p{degree==2} this function
+                                     * For <tt>degree==2</tt> this function
                                      * sets the
                                      * @p laplace_on_hex_vector to
                                      * the hardcoded data. For
-                                     * @p{degree>2} this vector is
+                                     * <tt>degree>2</tt> this vector is
                                      * computed.
                                      *
                                      * For the definition of the
@@ -351,15 +351,15 @@ class MappingQ : public MappingQ1<dim>
     
                                     /**
                                      * Computes the
-                                     * @p{laplace_on_quad(hex)_vector}.
+                                     * <tt>laplace_on_quad(hex)_vector</tt>.
                                      *
                                      * Called by the
-                                     * @p{set_laplace_on_quad(hex)_vector}
+                                     * <tt>set_laplace_on_quad(hex)_vector</tt>
                                      * functions if the data is not
                                      * yet hardcoded.
                                      *
                                      * For the definition of the
-                                     * @p{laplace_on_quad(hex)_vector}
+                                     * <tt>laplace_on_quad(hex)_vector</tt>
                                      * please refer to equation (8)
                                      * of the `mapping' report.
                                      */
@@ -367,7 +367,7 @@ class MappingQ : public MappingQ1<dim>
 
                                     /**
                                      * Takes a
-                                     * @p{laplace_on_hex(quad)_vector}
+                                     * <tt>laplace_on_hex(quad)_vector</tt>
                                      * and applies it to the vector
                                      * @p a to compute the inner
                                      * support points as a linear
@@ -415,7 +415,7 @@ class MappingQ : public MappingQ1<dim>
                                     /**
                                      * Needed by the
                                      * @p laplace_on_quad function
-                                     * (for @p{dim==2}). Filled by the
+                                     * (for <tt>dim==2</tt>). Filled by the
                                      * constructor.
                                      *
                                      * Sizes:
@@ -437,7 +437,7 @@ class MappingQ : public MappingQ1<dim>
                                     /**
                                      * Needed by the
                                      * @p laplace_on_hex function
-                                     * (for @p{dim==3}). Filled by the
+                                     * (for <tt>dim==3</tt>). Filled by the
                                      * constructor.
                                      *
                                      * For the definition of this
index ad6bb8dfc2a008984c1f246aaef1fa8c065a4383..acc75f0021a28e8caafb016746e7c6dcffbb07df 100644 (file)
@@ -328,7 +328,7 @@ class MappingQ1 : public Mapping<dim>
        
                                         /**
                                          * Default value of this flag
-                                         * is @p true. If @p{*this}
+                                         * is @p true. If <tt>*this</tt>
                                          * is an object of a derived
                                          * class, this flag is set to
                                          * @p false.
@@ -418,7 +418,7 @@ class MappingQ1 : public Mapping<dim>
                                      * this class or that of the
                                      * derived class, depending on
                                      * whether
-                                     * @p{data.is_mapping_q1_data}
+                                     * <tt>data.is_mapping_q1_data</tt>
                                      * equals @p true or @p false.
                                      */
     void compute_shapes (const std::vector<Point<dim> > &unit_points,
@@ -456,7 +456,7 @@ class MappingQ1 : public Mapping<dim>
     
                                     /**
                                      * Do the computation for the
-                                     * @p{fill_*} functions.
+                                     * <tt>fill_*</tt> functions.
                                      */
     void compute_fill (const typename DoFHandler<dim>::cell_iterator &cell,
                       const unsigned int      npts,
@@ -466,7 +466,7 @@ class MappingQ1 : public Mapping<dim>
     
                                     /**
                                      * Do the computation for the
-                                     * @p{fill_*} functions.
+                                     * <tt>fill_*</tt> functions.
                                      */
     void compute_fill_face (const typename DoFHandler<dim>::cell_iterator &cell,
                            const unsigned int      face_no,
index e80c0b82f2e193970290a8ada8fcf5c3e8050d04..12e3530a667d4240e4df8b68f8ee2251937f6697 100644 (file)
@@ -49,7 +49,7 @@
  * In many cases, the shift vector will also be the solution vector of
  * the problem under investigation. If this is not the case (i.e. the
  * number of components of the solution variable is not equal to the
- * space dimension, e.g. for scalar problems in @p{dim>1} where the
+ * space dimension, e.g. for scalar problems in <tt>dim>1</tt> 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 DoFHandler has to be set up on the
@@ -79,7 +79,7 @@ class MappingQ1Eulerian : public MappingQ1<dim>
 
                                     /**
                                      * Constructor. It takes a
-                                     * @p{Vector<double> &} as its
+                                     * <tt>Vector<double> &</tt> as its
                                      * first argument to specify the
                                      * transformation of the whole
                                      * problem from the reference to
@@ -96,7 +96,7 @@ class MappingQ1Eulerian : public MappingQ1<dim>
                                      * of a nonlinear problem.
                                      * Alternatively, the @p Vector
                                      * can be initialized by
-                                     * @p{DoFObjectAccessor::set_dof_values()}.
+                                     * <tt>DoFObjectAccessor::set_dof_values()</tt>.
                                      */
     MappingQ1Eulerian (const Vector<double>  &euler_transform_vectors,
                        const DoFHandler<dim> &shiftmap_dof_handler);
index f5b1f76732b7827aa656a99d0c977dd86cd06f3f..05cd501e7c1d4ff3ee36e717ac4589ea66b992ce 100644 (file)
@@ -199,8 +199,8 @@ namespace IteratorFilters
  *
  * The object that represent the condition an iterator has to satisfy
  * only have to provide an interface that allows to call the
- * evaluation operator, i.e. @p{operator()}. This includes function
- * pointers as well as classes that implement an @p{operator ()}.
+ * evaluation operator, i.e. <tt>operator()</tt>. This includes function
+ * pointers as well as classes that implement an <tt>operator ()</tt>.
  *
  * An example of a simple valid predicate is the following: given the function
  * @verbatim
@@ -263,7 +263,7 @@ namespace IteratorFilters
  *       const unsigned int subdomain_id;
  *   };
  * @endverbatim
- * Objects like @p{SubdomainEqualTo(3)} can then be used as predicates.
+ * Objects like <tt>SubdomainEqualTo(3)</tt> can then be used as predicates.
  *
  * Since whenever a predicate is evaluated it is checked that the
  * iterator checked is actually valid (i.e. not past the end), no
@@ -292,8 +292,8 @@ namespace IteratorFilters
  * however, a value is given to the constructor, that value has either
  * to be past the end, or has to satisfy the predicate. For example,
  * if the predicate only evaluates to true if the level of an object
- * is equal to three, then @p{tria.begin_active(3)} would be a valid
- * choice while @p{tria.begin()} would not since the latter also
+ * is equal to three, then <tt>tria.begin_active(3)</tt> would be a valid
+ * choice while <tt>tria.begin()</tt> would not since the latter also
  * returns iterators to non-active cells which always start at level
  * 0.
  *
@@ -305,7 +305,7 @@ namespace IteratorFilters
  * 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
- * iterator). Like the @p{operator=} they return the resulting value
+ * iterator). Like the <tt>operator=</tt> they return the resulting value
  * of the filtered iterator.
  *
  *
@@ -357,7 +357,7 @@ namespace IteratorFilters
  * Since comparison between filtered and unfiltered iterators is
  * 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
+ * <tt>Triangulation<dim>::active_cell_iterator</tt> since it is unchanged
  * and its value does not depend on the filter.
  *
  * @author Wolfgang Bangerth, 2002
index becba6d22e79808814bd99c2011e36bdb9468055..c6140f4885edf4a3f5e92a7de6e013fffee827f7 100644 (file)
@@ -96,8 +96,8 @@ struct GeometryInfo
                                      * List of numbers which
                                      * denotes which face is opposite
                                      * to a given face. In 1d, this
-                                     * list is @p{{1,0}}, in 2d @p{{2, 3, 0, 1}},
-                                     * in 3d @p{{1, 0, 4, 5, 2, 3}}.
+                                     * list is <tt>{1,0</tt>}, in 2d <tt>{2, 3, 0, 1</tt>},
+                                     * in 3d <tt>{1, 0, 4, 5, 2, 3</tt>}.
                                      */
     static const unsigned int opposite_face[faces_per_cell];
     
@@ -108,7 +108,7 @@ struct GeometryInfo
                                      * written in OpenDX format, each
                                      * entry in this field contains
                                      * the number of a vertex in
-                                     * @p{deal.II} that corresponds
+                                     * <tt>deal.II</tt> that corresponds
                                      * to the DX numbering at this
                                      * location.
                                      *
@@ -174,12 +174,12 @@ struct GeometryInfo
                                      * what you want. You can inquire
                                      * about the face orientation
                                      * using the
-                                     * @p{cell->face_orientation}
+                                     * <tt>cell->face_orientation</tt>
                                      * function, and the function to
                                      * ask for a neighbor's cell
                                      * behind a given face and
                                      * subface is
-                                     * @p{cell->neighbor_child_on_subface}.
+                                     * <tt>cell->neighbor_child_on_subface</tt>.
                                      * The latter function, in
                                      * contrast to the present one,
                                      * also takes into account the
@@ -203,7 +203,7 @@ struct GeometryInfo
     static Point<dimension> unit_cell_vertex (const unsigned int vertex);
 
                                     /**
-                                     * Report, for @p{vertex=0,1} the
+                                     * Report, for <tt>vertex=0,1</tt> the
                                      * indices of the two vertices
                                      * adjacent to the line with
                                      * index @p line among the lines
@@ -239,7 +239,7 @@ struct GeometryInfo
                                      * children, return any one of
                                      * their indices. The result is
                                      * always less than
-                                     * @p{GeometryInfo<dimension>::children_per_cell}.
+                                     * <tt>GeometryInfo<dimension>::children_per_cell</tt>.
                                      *
                                      * The order of child cells is
                                      * described the documentation of
@@ -348,8 +348,8 @@ struct GeometryInfo<0>
                                      * dimension, we provide a useless
                                      * 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}.
+                                     * <tt>for (i=0; i<vertices_per_face; ++i)</tt>,
+                                     * at least if @p i is an <tt>unsigned int</tt>.
                                      */
     static const unsigned int vertices_per_face = 0;
 
@@ -434,8 +434,8 @@ struct GeometryInfo<1>
                                      * dimension, we provide a useless
                                      * 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}.
+                                     * <tt>for (i=0; i<vertices_per_face; ++i)</tt>,
+                                     * at least if @p i is an <tt>unsigned int</tt>.
                                      */
     static const unsigned int vertices_per_face = 1;
 
@@ -470,8 +470,8 @@ struct GeometryInfo<1>
                                      * List of numbers which
                                      * denotes which face is opposite
                                      * to a given face. In 1d, this
-                                     * list is @p{{1,0}}, in 2d @p{{2, 3, 0, 1}},
-                                     * in 3d @p{{1, 0, 4, 5, 2, 3}}.
+                                     * list is <tt>{1,0</tt>}, in 2d <tt>{2, 3, 0, 1</tt>},
+                                     * in 3d <tt>{1, 0, 4, 5, 2, 3</tt>}.
                                      */
     static const unsigned int opposite_face[faces_per_cell];
     
@@ -482,7 +482,7 @@ struct GeometryInfo<1>
                                      * written in OpenDX format, each
                                      * entry in this field contains
                                      * the number of a vertex in
-                                     * @p{deal.II} that corresponds
+                                     * <tt>deal.II</tt> that corresponds
                                      * to the DX numbering at this
                                      * location.
                                      *
@@ -549,12 +549,12 @@ struct GeometryInfo<1>
                                      * you want. You can inquire
                                      * about the face orientation
                                      * using the
-                                     * @p{cell->face_orientation}
+                                     * <tt>cell->face_orientation</tt>
                                      * function, and the function to
                                      * ask for a neighbor's cell
                                      * behind a given face and
                                      * subface is
-                                     * @p{cell->neighbor_child_on_subface}.
+                                     * <tt>cell->neighbor_child_on_subface</tt>.
                                      * The latter function, in
                                      * contrast to the present one,
                                      * also takes into account the
@@ -578,7 +578,7 @@ struct GeometryInfo<1>
     static Point<1> unit_cell_vertex (const unsigned int vertex);
 
                                     /**
-                                     * Report, for @p{vertex=0,1} the
+                                     * Report, for <tt>vertex=0,1</tt> the
                                      * indices of the two vertices
                                      * adjacent to the line with
                                      * index @p line among the lines
@@ -614,7 +614,7 @@ struct GeometryInfo<1>
                                      * children, return any one of
                                      * their indices. The result is
                                      * always less than
-                                     * @p{GeometryInfo<dim>::children_per_cell}.
+                                     * <tt>GeometryInfo<dim>::children_per_cell</tt>.
                                      *
                                      * The order of child cells is
                                      * described the documentation of
@@ -719,8 +719,8 @@ struct GeometryInfo<2>
                                      * dimension, we provide a useless
                                      * 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}.
+                                     * <tt>for (i=0; i<vertices_per_face; ++i)</tt>,
+                                     * at least if @p i is an <tt>unsigned int</tt>.
                                      */
     static const unsigned int vertices_per_face = 2;
 
@@ -755,8 +755,8 @@ struct GeometryInfo<2>
                                      * List of numbers which
                                      * denotes which face is opposite
                                      * to a given face. In 1d, this
-                                     * list is @p{{1,0}}, in 2d @p{{2, 3, 0, 1}},
-                                     * in 3d @p{{1, 0, 4, 5, 2, 3}}.
+                                     * list is <tt>{1,0</tt>}, in 2d <tt>{2, 3, 0, 1</tt>},
+                                     * in 3d <tt>{1, 0, 4, 5, 2, 3</tt>}.
                                      */
     static const unsigned int opposite_face[faces_per_cell];
     
@@ -766,7 +766,7 @@ struct GeometryInfo<2>
                                      * written in OpenDX format, each
                                      * entry in this field contains
                                      * the number of a vertex in
-                                     * @p{deal.II} that corresponds
+                                     * <tt>deal.II</tt> that corresponds
                                      * to the DX numbering at this
                                      * location.
                                      *
@@ -833,12 +833,12 @@ struct GeometryInfo<2>
                                      * you want. You can inquire
                                      * about the face orientation
                                      * using the
-                                     * @p{cell->face_orientation}
+                                     * <tt>cell->face_orientation</tt>
                                      * function, and the function to
                                      * ask for a neighbor's cell
                                      * behind a given face and
                                      * subface is
-                                     * @p{cell->neighbor_child_on_subface}.
+                                     * <tt>cell->neighbor_child_on_subface</tt>.
                                      * The latter function, in
                                      * contrast to the present one,
                                      * also takes into account the
@@ -863,7 +863,7 @@ struct GeometryInfo<2>
     static Point<2> unit_cell_vertex (const unsigned int i);
 
                                     /**
-                                     * Report, for @p{vertex=0,1} the
+                                     * Report, for <tt>vertex=0,1</tt> the
                                      * indices of the two vertices
                                      * adjacent to the line with
                                      * index @p line among the lines
@@ -899,7 +899,7 @@ struct GeometryInfo<2>
                                      * children, return any one of
                                      * their indices. The result is
                                      * always less than
-                                     * @p{GeometryInfo<dim>::children_per_cell}.
+                                     * <tt>GeometryInfo<dim>::children_per_cell</tt>.
                                      *
                                      * The order of child cells is
                                      * described the documentation of
@@ -1005,8 +1005,8 @@ struct GeometryInfo<3>
                                      * dimension, we provide a useless
                                      * 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}.
+                                     * <tt>for (i=0; i<vertices_per_face; ++i)</tt>,
+                                     * at least if @p i is an <tt>unsigned int</tt>.
                                      */
     static const unsigned int vertices_per_face = 4;
 
@@ -1041,8 +1041,8 @@ struct GeometryInfo<3>
                                      * List of numbers which
                                      * denotes which face is opposite
                                      * to a given face. In 1d, this
-                                     * list is @p{{1,0}}, in 2d @p{{2, 3, 0, 1}},
-                                     * in 3d @p{{1, 0, 4, 5, 2, 3}}.
+                                     * list is <tt>{1,0</tt>}, in 2d <tt>{2, 3, 0, 1</tt>},
+                                     * in 3d <tt>{1, 0, 4, 5, 2, 3</tt>}.
                                      */
     static const unsigned int opposite_face[faces_per_cell];
     
@@ -1052,7 +1052,7 @@ struct GeometryInfo<3>
                                      * written in OpenDX format, each
                                      * entry in this field contains
                                      * the number of a vertex in
-                                     * @p{deal.II} that corresponds
+                                     * <tt>deal.II</tt> that corresponds
                                      * to the DX numbering at this
                                      * location.
                                      *
@@ -1119,12 +1119,12 @@ struct GeometryInfo<3>
                                      * you want. You can inquire
                                      * about the face orientation
                                      * using the
-                                     * @p{cell->face_orientation}
+                                     * <tt>cell->face_orientation</tt>
                                      * function, and the function to
                                      * ask for a neighbor's cell
                                      * behind a given face and
                                      * subface is
-                                     * @p{cell->neighbor_child_on_subface}.
+                                     * <tt>cell->neighbor_child_on_subface</tt>.
                                      * The latter function, in contrast
                                      * to the present one, also takes
                                      * into account the actual
@@ -1146,7 +1146,7 @@ struct GeometryInfo<3>
     static Point<3> unit_cell_vertex (const unsigned int i);
 
                                     /**
-                                     * Report, for @p{vertex=0,1} the
+                                     * Report, for <tt>vertex=0,1</tt> the
                                      * indices of the two vertices
                                      * adjacent to the line with
                                      * index @p line among the lines
@@ -1182,7 +1182,7 @@ struct GeometryInfo<3>
                                      * children, return any one of
                                      * their indices. The result is
                                      * always less than
-                                     * @p{GeometryInfo<dim>::children_per_cell}.
+                                     * <tt>GeometryInfo<dim>::children_per_cell</tt>.
                                      *
                                      * The order of child cells is
                                      * described the documentation of
@@ -1292,8 +1292,8 @@ struct GeometryInfo<4>
                                      * dimension, we provide a useless
                                      * 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}.
+                                     * <tt>for (i=0; i<vertices_per_face; ++i)</tt>,
+                                     * at least if @p i is an <tt>unsigned int</tt>.
                                      */
     static const unsigned int vertices_per_face = 8;
 
index d72cbc0968588609b7b1d4a26f6c308b16f882a8..dfffaf7f4e1f9cc837c0da52c79032f793b54976 100644 (file)
@@ -177,7 +177,7 @@ class GridGenerator
                                      * @p repetitions cells. Thus,
                                      * the number of cells filling
                                      * the given volume is
-                                     * @p{repetitions^d}.
+                                     * <tt>repetitions^d</tt>.
                                      */
     template <int dim>
     static void subdivided_hyper_cube (Triangulation<dim> &tria,
@@ -219,7 +219,7 @@ class GridGenerator
                                      * diagonally opposite corner
                                      * points @p p1 and @p p2. In
                                      * dimension @p i,
-                                     * @p{repetitions[i]} cells are
+                                     * <tt>repetitions[i]</tt> cells are
                                      * generated.
                                      * 
                                      * To get cells with an aspect
@@ -354,8 +354,8 @@ class GridGenerator
                                     /**
                                      * Create a cylinder around the
                                      * x-axis.  The cylinder extends
-                                     * from @p{x=-half_length} to
-                                     * @p{x=+half_length} and its
+                                     * from <tt>x=-half_length</tt> to
+                                     * <tt>x=+half_length</tt> and its
                                      * projection into the
                                      * @p yz-plane is a circle of
                                      * radius @p radius.
@@ -396,7 +396,7 @@ class GridGenerator
                                      * Initialize the given
                                      * triangulation with a hyper-L
                                      * consisting of exactly
-                                     * @p{2^dim-1} cells. See the
+                                     * <tt>2^dim-1</tt> cells. See the
                                      * general documentation for a
                                      * description of the
                                      * L-region. The limits default
@@ -436,8 +436,8 @@ class GridGenerator
                                      * Initialize the given
                                      * Triangulation with a hypercube
                                      * with a slit. The slit goes
-                                     * from @p{(x=0,y=-1)} to
-                                     * @p{(0,0)} in 2d.
+                                     * from <tt>(x=0,y=-1)</tt> to
+                                     * <tt>(0,0)</tt> in 2d.
                                      *
                                      * The triangulation needs to be
                                      * void upon calling this
index e27c6d2c5a258937d0e016ca6f750cf59ae62512..9df1a0c7a68bf19fe3b6ca302f8eef7bd965cde3 100644 (file)
@@ -79,7 +79,7 @@ class SubCellData;
  * 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.
  *
- * <li> @p{DB mesh} format: this format is used by the @p BAMG mesh
+ * <li> <tt>DB mesh</tt> 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
@@ -121,16 +121,16 @@ class SubCellData;
  *   |   |   |
  *   0---1---2
  * @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 Triangulation
+ * may be characterised by the vertex numbers <tt>(0 1 4 3)</tt> and
+ * <tt>(1 2 5 4)</tt>, since the middle line would get the direction <tt>1->4</tt>
+ * when viewed from both cells.  The numbering <tt>(0 1 4 3)</tt> and
+ * <tt>(5 4 1 2)</tt> would not be allowed, since the left quad would give the
+ * common line the direction <tt>1->4</tt>, while the right one would want
+ * to use <tt>4->1</tt>, 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
- * indices @p{(4 1 2 5)}, since then it would have to rotate by one
+ * indices <tt>(4 1 2 5)</tt>, since then it would have to rotate by one
  * element or three, the decision which to take is not yet
  * implemented.
  *
@@ -140,7 +140,7 @@ class SubCellData;
  * dimensions, where faces and lines have orientations that need to be
  * taken care of.
  *
- * For this reason, the @p{read_*} functions of this class that read
+ * For this reason, the <tt>read_*</tt> functions of this class that read
  * 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
@@ -242,7 +242,7 @@ class GridIn
                                     /**
                                      * Skip lines of comment that
                                      * start with the indicated
-                                     * character (e.g. @p{#})
+                                     * character (e.g. <tt>#</tt>)
                                      * following the point where the
                                      * given input stream presently
                                      * is. After the call to this
@@ -260,7 +260,7 @@ class GridIn
                                      * Remove vertices that are not
                                      * referenced by any of the
                                      * cells. This function is called
-                                     * by all @p{read_*} functions to
+                                     * by all <tt>read_*</tt> functions to
                                      * eliminate vertices that are
                                      * listed in the input files but
                                      * are not used by the cells in
@@ -274,7 +274,7 @@ class GridIn
                                      * they might be lengthy.
                                      *
                                      * This function is called by all
-                                     * @p{read_*} functions as the
+                                     * <tt>read_*</tt> functions as the
                                      * triangulation class requires
                                      * them to be called with used
                                      * vertices only. This is so,
@@ -290,7 +290,7 @@ class GridIn
                                     /**
                                      * This function can write the
                                      * raw cell data objects created
-                                     * by the @p{read_*} functions in
+                                     * by the <tt>read_*</tt> functions in
                                      * Gnuplot format to a
                                      * stream. This is sometimes
                                      * handy if one would like to see
index afc433efa3b72c6c848fdfa9eb1ba96de07f5890..1cfc342181698b56440bc245bbc4239574f2a70b 100644 (file)
@@ -306,7 +306,7 @@ namespace GridOutFlags
                                        *
                                        * The format of the cell
                                        * number written is
-                                       * @p{level.index}, or simply
+                                       * <tt>level.index</tt>, or simply
                                        * @p index, depending on the
                                        * value of the following flag.
                                        */
@@ -317,7 +317,7 @@ namespace GridOutFlags
                                        * flag, then the value of this
                                        * flag determines whether the
                                        * format shall be
-                                       * @p{level.index}, or simply
+                                       * <tt>level.index</tt>, or simply
                                        * @p index. If @p true, the
                                        * first format is
                                        * taken. Default is @p true.
@@ -482,7 +482,7 @@ namespace GridOutFlags
  * 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_...}
+ * Available output formats can be found in the functions with names <tt>write_...</tt>
  *
  * @sect3{Usage}
  * Usage is simple: either you use the direct form
@@ -498,11 +498,11 @@ namespace GridOutFlags
  *   ofstream output_file("some_filename" + GridOut::default_suffix(output_format));
  *   GridOut().write (tria, output_file, output_format);
  * @endverbatim
- * The function @p{get_output_format_names()} provides a list of possible names of
+ * The function <tt>get_output_format_names()</tt> provides a list of possible names of
  * output formats in a string that is understandable by the ParameterHandler class.
  *
  * 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
+ * one of its <tt>write_*</tt> functions. This looks like as if the respective function
  * 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
@@ -533,7 +533,7 @@ namespace GridOutFlags
  * 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
- * be done by calling @p{grid_out.set_flags (GridOutFlags::Ucd());}, since the
+ * be done by calling <tt>grid_out.set_flags (GridOutFlags::Ucd());</tt>, since the
  * default constructor of each of the flags structures sets the parameters
  * to their initial values.
  *
@@ -666,7 +666,7 @@ class GridOut
                                      * explicitly. This is useful,
                                      * if you want to re-read the
                                      * grid later on, since
-                                     * @p{deal.II} sets the boundary
+                                     * <tt>deal.II</tt> sets the boundary
                                      * indicator to zero by default;
                                      * therefore, to obtain the
                                      * same triangulation as before,
@@ -788,7 +788,7 @@ class GridOut
                                      * Write data and grid to @p out according
                                      * to the given data format. This function
                                      * simply calls the appropriate
-                                     * @p{write_*} function.
+                                     * <tt>write_*</tt> function.
                                      */
     template <int dim>
     void write (const Triangulation<dim> &tria,
@@ -841,10 +841,10 @@ class GridOut
                                      * usually has. At present the following
                                      * formats are defined:
                                      * <ul>
-                                     * <li> @p OpenDX: @p{.dx}
-                                     * <li> @p gnuplot: @p{.gnuplot}
-                                     * <li> @p ucd: @p{.inp}
-                                     * <li> @p eps: @p{.eps}.
+                                     * <li> @p OpenDX: <tt>.dx</tt>
+                                     * <li> @p gnuplot: <tt>.gnuplot</tt>
+                                     * <li> @p ucd: <tt>.inp</tt>
+                                     * <li> @p eps: <tt>.eps</tt>.
                                      * </ul>
                                      *
                                      * Since this function does not need data
@@ -872,14 +872,14 @@ class GridOut
                                      * To get a list of presently available
                                      * format names, e.g. to give it to the
                                      * ParameterHandler class, use the
-                                     * function @p{get_output_format_names ()}.
+                                     * function <tt>get_output_format_names ()</tt>.
                                      */
     static OutputFormat parse_output_format (const std::string &format_name);
 
                                     /**
                                      * Return a list of implemented output
                                      * formats. The different names are
-                                     * separated by vertical bar signs (@p{`|'})
+                                     * separated by vertical bar signs (<tt>`|'</tt>)
                                      * as used by the ParameterHandler
                                      * classes.
                                      */
@@ -962,13 +962,13 @@ class GridOut
                                      * This function unfortunately can not
                                      * be included in the regular @p write_ucd
                                      * function, since it needs special
-                                     * treatment for the case @p{dim==1}, in
+                                     * treatment for the case <tt>dim==1</tt>, in
                                      * which case the face iterators are
-                                     * @p{void*}'s and lack the member functions
+                                     * <tt>void*</tt>'s and lack the member functions
                                      * which are called. We would not actually
                                      * call these functions, but the compiler
                                      * would complain anyway when compiling
-                                     * the function for @p{dim==1}. Bad luck.
+                                     * the function for <tt>dim==1</tt>. Bad luck.
                                      */
     template <int dim>
     void write_ucd_faces (const Triangulation<dim> &tria,
@@ -989,7 +989,7 @@ class GridOut
                                      * triangulation which have a boundary
                                      * indicator not equal to zero. Only
                                      * these faces are explicitly printed
-                                     * in the @p{write_*} functions;
+                                     * in the <tt>write_*</tt> functions;
                                      * all faces with indicator 255 are
                                      * interior ones and an indicator with
                                      * value zero for faces at the boundary
index 4ad51c188e064da84bf83b9289bd2f8a204831f6..b287e5f489337fb89aa639bae748267d381c51d0 100644 (file)
@@ -30,13 +30,13 @@ template <class T> class Vector;
  *   This class provides several function that flag certain cells for
  *   coarsening or refinement based on a vector of ``error''
  *   indicators and some selection algorithm.  The central function is
- *   @p{refine (const Vector &criterion, const double threshold)}:
+ *   <tt>refine (const Vector &criterion, const double threshold)</tt>:
  *   it takes a vector of values, one per active cell,
  *   which denote the criterion according to which the triangulation
  *   is to be refined. It marks all cells for which the criterion is
  *   greater than the threshold being given as the second
  *   argument. Analogously,
- *   @p{coarsen (const Vector &criterion, const double threshold)}
+ *   <tt>coarsen (const Vector &criterion, const double threshold)</tt>
  *   flags those cells for
  *   coarsening for which the criterion is less than the threshold.
  *
@@ -47,7 +47,7 @@ template <class T> class Vector;
  *     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
- *     @p{fraction times n_active_cells} highest criterion. For example, if
+ *     <tt>fraction times n_active_cells</tt> highest criterion. For example, if
  *     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
@@ -57,9 +57,9 @@ template <class T> class Vector;
  *     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 <tt>C++</tt> standard
  *     library, which takes only linear time in the number of elements, rather
- *     than @p{N log N} for sorting all values.
+ *     than <tt>N log N</tt> for sorting all values.
  *
  *     A typical value for the fraction of cells to be refined is 0.3.
  *     However, for singular functions or singular error functionals, you may
@@ -215,7 +215,7 @@ class GridRefinement
                                      * refinement, call
                                      * @p execute_coarsening_and_refinement.
                                      *
-                                     * @p{*_fraction} shall be a
+                                     * <tt>*_fraction</tt> shall be a
                                      * values between zero and one.
                                      *
                                      * Refer to the general doc of
index 2f42d708629d67d4775e80fb9a94706616355f3b..b9a772417e47a0f03b6f65987c41cd087a636c5c 100644 (file)
  *   |   |   |
  *   0---1---2
  * @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.
+ * may be characterised by the vertex numbers <tt>(0 1 4 3)</tt> and
+ * <tt>(1 2 5 4)</tt>, since the middle line would get the direction <tt>1->4</tt>
+ * when viewed from both cells.  The numbering <tt>(0 1 4 3)</tt> and
+ * <tt>(5 4 1 2)</tt> would not be allowed, since the left quad would give the
+ * common line the direction <tt>1->4</tt>, while the right one would want
+ * to use <tt>4->1</tt>, leading to an ambiguity.
  *
  * As a sidenote, we remark that if one adopts the idea that having
  * directions of faces is useful, then the orientation of the four
  *   ^   ^    \ |
  *   0->-1------2
  * @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
+ * (This could for example be done by using the indices <tt>(0 1 4 3)</tt>, <tt>(3 4 7 6)</tt>,
+ * <tt>(6 7 10 9)</tt> for the three cells). Now, you will not find a way of giving
  * indices for the right cells, without introducing either ambiguity for
  * one line or other, or without violating that within each cells, there must be
  * one vertex from which both lines are directed away and the opposite one to
  *
  * 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)}:
+ * the top left cell by <tt>(9 6 7 10)</tt>:
  * @verbatim
  *   9->-10-----11
  *   v   v    / |
  * @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)}
+ * cell (the one which we could order as <tt>(9 6 7 10)</tt>
  * above). However, since opposite lines have to have the same
  * direction, this in turn would force us to rotate the cell left of
  * it, and then the one left to that, and so on until we reach the
  * @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
+ * vertex indices <tt>0 1 2 3</tt> and <tt>6 7 4 5</tt>. Then, if we follow this
  * orientation, the grid after creating the lines for these two cells
  * would look like this:
  * @verbatim
  * where node N has as many children as there are possible
  * orientations of node N+1 (in two space dimensions, there are four
  * orientations in which each cell can be constructed from its four
- * vertices; for example, if the vertex indicaes are @p{(0 1 2 3)},
- * then the four possibilities would be @p{(0 1 2 3)}, @p{(1 2 3 0)},
- * @p{(2 3 0 1)}, and @p{(3 0 1 2)}). When adding one cell after the
+ * vertices; for example, if the vertex indicaes are <tt>(0 1 2 3)</tt>,
+ * then the four possibilities would be <tt>(0 1 2 3)</tt>, <tt>(1 2 3 0)</tt>,
+ * <tt>(2 3 0 1)</tt>, and <tt>(3 0 1 2)</tt>). When adding one cell after the
  * other, we traverse this tree in a depth-first (pre-order)
  * fashion. When we encounter that one path from the root (cell 0) to
  * a leaf (the last cell) is not allowed (i.e. that the orientations
  * stop following all paths below this point and track back
  * immediately.
  *
- * Nevertheless, it is already obvious that the tree has @p{4**N}
+ * Nevertheless, it is already obvious that the tree has <tt>4**N</tt>
  * leaves in two space dimensions, since each of the N cells can be
  * added in four orientations. Most of these nodes can be discarded
  * rapidly, since firstly the orientation of the first cell is
  * that has already been added, then there are already only two
  * possible orientations left, so the total number of checks we have
  * to make until we find a valid way is significantly smaller than
- * @p{4**N}. However, the algorithm is still exponential in time and
+ * <tt>4**N</tt>. However, the algorithm is still exponential in time and
  * linear in memory (we only have to store the information for the
  * present path in form of a stack of orientations of cells that have
  * already been added).
  * 0-----1-----2-----3
  * @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
+ * described the first cell 0 by the vertex numbers <tt>2 3 7 6</tt>, and
+ * cell 5 by <tt>15 14 10 11</tt>, and assume that cells 1, 2, 3, and 4 are
  * numbered such that 5 can be added in initial rotation. All other
  * cells are numbered in the usual way, i.e. starting at the bottom
  * left and counting counterclockwise. Given this description 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
- * Triangulation@p{<dim>::create_triangulation} function.
+ * Triangulation<tt><dim>::create_triangulation</tt> function.
  *
  * @author Wolfgang Bangerth, 2000, Michael Anderson 2003
  */
index 962b7fc1245313b0fbc25d3d697fdd0e940556dd..4863ac90d262c95fa912de10699ce162be88a013 100644 (file)
@@ -78,11 +78,11 @@ class GridTools
                                      * function-like syntax, i.e. the
                                      * predicate is either an object
                                      * of a type that has an
-                                     * @p{operator()}, or it is a
+                                     * <tt>operator()</tt>, or it is a
                                      * pointer to the function. In
                                      * either case, argument and
                                      * return value have to be of
-                                     * type @p{Point<dim>}.
+                                     * type <tt>Point<dim></tt>.
                                      */
     template <int dim, typename Predicate>
     static
@@ -163,7 +163,7 @@ class GridTools
                                       * cell on the coarse grid, and
                                       * then recursively checking its
                                       * sibling cells. The complexity
-                                      * is thus @p{O(M+log N)} where
+                                      * is thus <tt>O(M+log N)</tt> where
                                       * @p M is the number of coarse
                                       * grid cells, and @p N the
                                       * total number of cells.
@@ -243,7 +243,7 @@ class GridTools
                                       * values between zero and
                                       * @p n_partitions-1. You can access the
                                       * subdomain id of a cell by using
-                                      * @p{cell->subdomain_id()}.
+                                      * <tt>cell->subdomain_id()</tt>.
                                       *
                                       * This function will generate an error
                                       * if METIS is not installed unless
@@ -262,7 +262,7 @@ class GridTools
                                      /**
                                       * For each active cell, return in the
                                       * output array to which subdomain (as
-                                      * given by the @p{cell->subdomain_id()}
+                                      * given by the <tt>cell->subdomain_id()</tt>
                                       * function) it belongs. The output array
                                       * is supposed to have the right size
                                       * already when calling this function.
index 8f45b3619e9fcab37b556e2c3cff458e40aba594..f95fb5b40fb3935968788edf89cf7e33a92f6038 100644 (file)
@@ -24,7 +24,7 @@
  * This class provides a map between two grids which are derived from
  * the same coarse grid. For each cell iterator of the source map, it provides
  * the respective cell iterator on the destination map, through its
- * @p{operator []}.
+ * <tt>operator []</tt>.
  *
  * Usually, the two grids will be refined differently. Then, the value
  * returned for an iterator on the source grid will be either:
@@ -69,7 +69,7 @@
  * offering iterator functions and some minor additional requirements is
  * simple.
  *
- * Note that this class could in principle be based on the C++ @p{map<Key,Value>}
+ * Note that this class could in principle be based on the C++ <tt>map<Key,Value></tt>
  * data type. Instead, it uses another data format which is more effective both
  * in terms of computing time for access as well as with regard to memory
  * consumpion.
  * @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
+ * <tt>InterGridMap<DoFHandler,2></tt>, i.e. the dimension is given explicitly and
  * no dimension is attributed to the first parameter, which here is
  * DoFHandler (and could equally well be Triangulation or MGDoFHandler).
  *
index a0e4e6114e5f9c402ec555e9a019a6ae69d78e25..4c9baf73b2e6339dafaf52065b8ca436a58279a6 100644 (file)
  * 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
+ * Triangulation<tt><dim>::clear ()</tt> 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()}.
+ * used withing <tt>restore()</tt>.
  *
  * @author Wolfgang Bangerth, 1999
  */
@@ -156,11 +156,11 @@ class PersistentTriangulation : public Triangulation<dim>
                                      * underlying triangulation is
                                      * not empty, i.e. it will only
                                      * succeed if this object is
-                                     * newly created or @p{clear()}
+                                     * newly created or <tt>clear()</tt>
                                      * was called on it before.
                                      *
                                      * Repeatedly calls the
-                                     * @p{restore(unsigned int)}
+                                     * <tt>restore(unsigned int)</tt>
                                      * function in a loop over all
                                      * refinement steps.
                                      */
@@ -178,7 +178,7 @@ class PersistentTriangulation : public Triangulation<dim>
                                      * is in just the state it were
                                      * if restore would have been
                                      * called from
-                                     * @p{step=0...step_no-1} before.
+                                     * <tt>step=0...step_no-1</tt> before.
                                      */
     void restore (const unsigned int step_no);
 
@@ -227,7 +227,7 @@ class PersistentTriangulation : public Triangulation<dim>
                                     /**
                                      * Reads all refine and coarsen flags
                                      * that previously were written by
-                                     * @p{write_flags(...)}. This is especially
+                                     * <tt>write_flags(...)</tt>. This is especially
                                      * useful for rebuilding the triangulation
                                      * after the end or breakdown of a program
                                      * and its restart.
index 5b60c6420a635b193dadb9b657e84d5d6065e6ee..f39e52fd0d7920637a35c36591a4994727d62b03 100644 (file)
@@ -41,7 +41,7 @@ template <int dim> class MGDoFHandler;
 
 /**
  *  Structure which is passed to the
- *  Triangulation@p{<dim>::create_triangulation} function. It
+ *  Triangulation<tt><dim>::create_triangulation</tt> 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 Triangulation@p{<dim>::create_triangulation}
+ *  Structure to be passed to the Triangulation<tt><dim>::create_triangulation</tt>
  *  function to describe boundary information.
  *
  *  This structure is the same for all dimensions, since we use an input
@@ -144,7 +144,7 @@ struct SubCellData
                                      * This function checks whether the vectors
                                      * which may not be used in a given
                                      * dimension are really empty. I.e.,
-                                     * whether the @p{boundary_*} arrays are
+                                     * whether the <tt>boundary_*</tt> arrays are
                                      * empty when in one space dimension
                                      * and whether the @p boundary_quads
                                      * array is empty when in two dimensions.
@@ -180,7 +180,7 @@ class TriaDimensionInfo
  *  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 lines member variable of a <tt>Triangulation<1></tt> object. An
  *  @p active_line_iterator only operates on the active lines.
  *  @p raw_line_iterator objects operate on all lines, used or not.
  *
@@ -192,8 +192,8 @@ class TriaDimensionInfo
  *  @endverbatim
  *
  *  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
+ *  <tt>Triangulation<1></tt>, the @p quad_iterators are declared as
+ *  <tt>void *</tt>. Thus these types exist, but are useless and will
  *  certainly make any involuntary use visible. The same holds
  *  for hexahedron iterators.
  *
@@ -265,7 +265,7 @@ class TriaDimensionInfo<1>
  *  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 lines member variable of a <tt>Triangulation<2></tt> 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
@@ -277,8 +277,8 @@ class TriaDimensionInfo<1>
  *  @p active_quad_iterator are declared.
  *  
  *  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
+ *  <tt>Triangulation<[12]></tt>, the @p hex_iterators are declared as
+ *  <tt>void *</tt>. 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:
@@ -356,7 +356,7 @@ class TriaDimensionInfo<2>
  *  These are the declararions for the 3D case only.
  *
  *  For the declarations of the data types, more or less the same holds
- *  as for lower dimensions (see @p{TriaDimensionInfo<[12]>}). The
+ *  as for lower dimensions (see <tt>TriaDimensionInfo<[12]></tt>). The
  *  dimension specific data types are here, since we are in three dimensions:
  *  @verbatim
  *    typedef raw_hex_iterator    raw_cell_iterator;
@@ -676,7 +676,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *  dimensions).
  *
  *  <li> @p raw_quad_iterator: loop over all quads, used or not (declared only
- *  for @p{dim>=2}).
+ *  for <tt>dim>=2</tt>).
  *  
  *  <li> @p quad_iterator: loop over all quads (declared only for @p dim>=2).
  *
@@ -819,8 +819,8 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *        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
- *        GridIn@p{<dim>::read_*} functions. The appropriate function to be
- *        called is @p{Triangulation<dim>::create_triangulation ()}.
+ *        GridIn<tt><dim>::read_*</tt> functions. The appropriate function to be
+ *        called is <tt>Triangulation<dim>::create_triangulation ()</tt>.
  *
  *        Creating the hierarchical information needed for this
  *        library from cells storing only vertex information can be
@@ -854,7 +854,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *        the vertex numbering within cells. They do not only hold for
  *        the data read from an UCD or any other input file, but also
  *        for the data passed to the
- *        @p{Triangulation<dim>::create_triangulation ()}
+ *        <tt>Triangulation<dim>::create_triangulation ()</tt>
  *        function. See the documentation for the GridIn class
  *        for more details on this, and above all to the
  *        GridReordering class that explains many of the
@@ -909,7 +909,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   interface between regions of different materials.
  *
  *   Finally, there is a special function for folks who like bad grids:
- *   @p{Triangulation<dim>::distort_random}. It moves all the vertices in the
+ *   <tt>Triangulation<dim>::distort_random</tt>. It moves all the vertices in the
  *   grid a bit around by a random value, leaving behind a distorted mesh.
  *   Note that you should apply this function to the final mesh, since
  *   refinement smoothes the mesh a bit.
@@ -936,7 +936,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   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
  *   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
+ *   function call <tt>i->set_refine_flag()</tt> 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
@@ -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.
+ *   <tt>i->set_coarsen_flag</tt> 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
@@ -984,25 +984,25 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   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.
+ *   <tt>execute_*</tt> stand for @p execute_coarsening_and_refinement.
  *
  *   For the purpose of smoothing, the
  *   Triangulation constructor takes an argument specifying whether a
- *   smoothing step shall be performed on the grid each time @p{execute_*}
+ *   smoothing step shall be performed on the grid each time <tt>execute_*</tt>
  *   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
- *   cases. If switched on, calling @p{execute_*} results in
+ *   cases. If switched on, calling <tt>execute_*</tt> results in
  *   flagging additional cells for refinement to avoid
  *   vertices as the ones mentioned. The algorithms for both regularization
  *   and smoothing of triangulations are described below in the section on
  *   technical issues. The reason why this parameter must be given to the
- *   constructor rather than to @p{execute_*} is that it would result
- *   in algorithmic problems if you called @p{execute_*} once without
+ *   constructor rather than to <tt>execute_*</tt> is that it would result
+ *   in algorithmic problems if you called <tt>execute_*</tt> once without
  *   and once with smoothing, since then in some refinement steps would need
  *   to be refined twice.
  *
  *   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
+ *   bitwise by the constants defined in the <tt>enum MeshSmoothing</tt>. The meaning
  *   of these constants is explained in the following:
  *   <ul>
  *   <li> @p limit_level_difference_at_vertices:
@@ -1068,7 +1068,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     name of the flag may indicate. However, no better name came to mind to
  *     the author by now.
  *
- *   <li> @p{eliminate_refined_*_islands}:
+ *   <li> <tt>eliminate_refined_*_islands</tt>:
  *     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
@@ -1211,10 +1211,10 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   adds additional cells, but their number may be depending on the smoothing
  *   level.
  *
- *   There actually are two sets of @p{save_*_flags} and @p{load_*_flags} functions.
+ *   There actually are two sets of <tt>save_*_flags</tt> and <tt>load_*_flags</tt> functions.
  *   One takes a stream as argument and reads/writes the information from/to the
  *   stream, thus enabling storing flags to files. The other set takes an
- *   argument of type @p{vector<bool>}. This enables the user to temporarily store
+ *   argument of type <tt>vector<bool></tt>. This enables the user to temporarily store
  *   some flags, e.g. if another function needs them, and restore them
  *   afterwards.
  *
@@ -1243,21 +1243,21 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *
  *   As for the refinement and coarsening flags, there exist two versions of these
  *   functions, one which reads/writes from a stream and one which does so from
- *   a @p{vector<bool>}. The latter is used to store flags temporarily, while the
+ *   a <tt>vector<bool></tt>. The latter is used to store flags temporarily, while the
  *   first is used to store them in a file.
  *
  *   It is convention to clear the user flags using the
- *   @p{Triangulation<>::clear_user_flags()} function before usage, since it is
+ *   <tt>Triangulation<>::clear_user_flags()</tt> function before usage, since it is
  *   often necessary to use the flags in more than one function consecutively and
  *   is then error prone to dedicate one of these to clear the flags.
  *
  *   It is recommended that a functions using the flags states so in its
  *   documentation.
  *
- *   There is another set of user data, namely a @p{void *}, for each
+ *   There is another set of user data, namely a <tt>void *</tt>, for each
  *   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
+ *   functions <tt>user_pointer()</tt>, <tt>clear_user_pointer()</tt> and
+ *   <tt>set_user_pointer(p)</tt> in the accessor classes. These pointers are
  *   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
@@ -1280,7 +1280,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   placed. The boundary indicator of the face will be used to
  *   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>}):
+ *   (let @p Ball be a class derived from Boundary<tt><2></tt>):
  * 
  *   @verbatim
  *     void main () {
@@ -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.
  *
- *     <li> @p{eliminate_refined_*_islands}:
+ *     <li> <tt>eliminate_refined_*_islands</tt>:
  *       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
@@ -1428,9 +1428,9 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   preserved upon refinement.
  *
  *   Further we define, that child lines have the same direction as their parent,
- *   i.e. that @p{subline(0).vertex(0)==line.vertex(0)} and
- *   @p{subline(1).vertex(1)==line.vertex(1)}. This also implies, that the
- *   first subline (@p{subline(0)}) is the one at vertex(0) of the old line.
+ *   i.e. that <tt>subline(0).vertex(0)==line.vertex(0)</tt> and
+ *   <tt>subline(1).vertex(1)==line.vertex(1)</tt>. This also implies, that the
+ *   first subline (<tt>subline(0)</tt>) is the one at vertex(0) of the old line.
  *
  *   Similarly we define, that the four children of a quad are adjacent to the
  *   vertex with the same number of the old quad.
@@ -1454,7 +1454,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     *-------------->x
  *   @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)}.
+ *   coordinates <tt>(1,0)</tt>, vertex 2 at <tt>(1,1)</tt> and vertex 3 at <tt>(0,1)</tt>.
  *
  *
  *   @sect3{Implementation conventions for three spatial dimensions}
@@ -1655,7 +1655,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   which case the lines that make up a cell would have reverted
  *   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
+ *   orientation by calling <tt>cell->face_orientation(face_no)</tt>: if
  *   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
@@ -1705,12 +1705,12 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   avoid having to query the standard orientation of the faces of
  *   the two cells every time in such cases, you should use a function
  *   call like
- *   @p{cell->neighbor_child_on_subface(face_no,subface_no)}, which
+ *   <tt>cell->neighbor_child_on_subface(face_no,subface_no)</tt>, which
  *   returns the correct result both in 2d (where face orientations
  *   are immaterial) and 3d (where it is necessary to query the face
  *   orientation and possibly swap the result of
- *   @p{GeometryInfo<3>::child_cell_on_face}). In general, the use of
- *   @p{GeometryInfo<3>::child_cell_on_face} is best avoided due to
+ *   <tt>GeometryInfo<3>::child_cell_on_face</tt>). In general, the use of
+ *   <tt>GeometryInfo<3>::child_cell_on_face</tt> is best avoided due to
  *   these problems.
  *
  *   @sect4{Coordinate systems}
@@ -1730,22 +1730,22 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *    *------>x        0-------1        0-------1
  *   @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)}
+ *   unfortunate, since the vertices 0 through 3 have the coordinates <tt>(x,0,z)</tt>
  *   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.
+ *   <tt>(x,y,0)</tt>. However, the vertex numbering was historically chosen as shown.
  *
  *   By the convention laid down as above, the vertices have the following
  *   coordinates:
  *   <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)}.
+ *      <li> Vertex 0: <tt>(0,0,0)</tt>;
+ *      <li> Vertex 1: <tt>(1,0,0)</tt>;
+ *      <li> Vertex 2: <tt>(1,0,1)</tt>;
+ *      <li> Vertex 3: <tt>(0,0,1)</tt>;
+ *      <li> Vertex 4: <tt>(0,1,0)</tt>;
+ *      <li> Vertex 5: <tt>(1,1,0)</tt>;
+ *      <li> Vertex 6: <tt>(1,1,1)</tt>;
+ *      <li> Vertex 7: <tt>(0,1,1)</tt>.
  *   </ul>
  *
  *
@@ -1931,7 +1931,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * refinement and is dangerous
                                      * afterwards.  Removal of a
                                      * boundary object is done by
-                                     * @p{set_boundary(number)}, which
+                                     * <tt>set_boundary(number)</tt>, which
                                      * uses the default argument of this
                                      * function and replaces the boundary
                                      * approximation by a piecewise
@@ -1988,7 +1988,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Create a triangulation from a
                                      * list of vertices and a list of
                                      * cells, each of the latter
-                                     * being a list of @p{1<<dim}
+                                     * being a list of <tt>1<<dim</tt>
                                      * vertex indices. The
                                      * triangulation must be empty
                                      * upon calling this function and
@@ -2034,7 +2034,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * active lines adjacent to this
                                      * vertex. Note that @p factor
                                      * should obviously be well below
-                                     * @p{0.5}.
+                                     * <tt>0.5</tt>.
                                      *
                                      * If @p keep_boundary is set to
                                      * @p true (which is the
@@ -2067,9 +2067,9 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Refine all cells @p times
                                      *  times, by alternatingly
                                      *  calling
-                                     *  @p{set_all_refine_flags()}
+                                     *  <tt>set_all_refine_flags()</tt>
                                      *  and
-                                     *  @p{execute_coarsening_and_refinement()}.
+                                     *  <tt>execute_coarsening_and_refinement()</tt>.
                                      *  This function actually starts
                                      *  the refinement process, so
                                      *  you have no way to store the
@@ -2109,7 +2109,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Regarding the refinement
                                      * process it fixes the closure
                                      * of the refinement in
-                                     * @p{dim>=2} (make sure that no
+                                     * <tt>dim>=2</tt> (make sure that no
                                      * two cells are adjacent with a
                                      * refinement level differing
                                      * with more than one), etc.  It
@@ -2433,7 +2433,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return an iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     cell_iterator        end (const unsigned int level) const;
     
@@ -2441,7 +2441,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return a raw iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_cell_iterator    end_raw (const unsigned int level) const;
 
@@ -2449,7 +2449,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return an active iterator which is the
                                      * first iterator not on level. If @p level
                                      * is the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     active_cell_iterator end_active (const unsigned int level) const;
 
@@ -2560,7 +2560,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return an iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     face_iterator        end_face (const unsigned int level) const;
     
@@ -2568,7 +2568,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return a raw iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_face_iterator    end_raw_face (const unsigned int level) const;
 
@@ -2576,7 +2576,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return an active iterator which is the
                                      * first iterator not on level. If @p level
                                      * is the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     active_face_iterator end_active_face (const unsigned int level) const;
 
@@ -2678,7 +2678,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return an iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     line_iterator        end_line (const unsigned int level) const;
     
@@ -2686,7 +2686,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return a raw iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_line_iterator    end_raw_line (const unsigned int level) const;
 
@@ -2694,7 +2694,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return an active iterator which is the
                                      * first iterator not on level. If @p level
                                      * is the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     active_line_iterator end_active_line (const unsigned int level) const;
 
@@ -2785,7 +2785,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return an iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     quad_iterator        end_quad (const unsigned int level) const;
     
@@ -2793,7 +2793,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return a raw iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_quad_iterator    end_raw_quad (const unsigned int level) const;
 
@@ -2801,7 +2801,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return an active iterator which is the
                                      * first iterator not on level. If @p level
                                      * is the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     active_quad_iterator end_active_quad (const unsigned int level) const;
 
@@ -2892,7 +2892,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return an iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     hex_iterator        end_hex (const unsigned int level) const;
     
@@ -2900,7 +2900,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return a raw iterator which is the first
                                      * iterator not on level. If @p level is
                                      * the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_hex_iterator    end_raw_hex (const unsigned int level) const;
 
@@ -2908,7 +2908,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * Return an active iterator which is the
                                      * first iterator not on level. If @p level
                                      * is the last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     active_hex_iterator end_active_hex (const unsigned int level) const;
 
@@ -3036,7 +3036,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /**
                                      *  Return total number of used cells,
                                      *  active or not.
-                                     *  Maps to @p{n_lines()} in one space
+                                     *  Maps to <tt>n_lines()</tt> in one space
                                      *  dimension and so on.
                                      */
     unsigned int n_cells () const;
@@ -3044,14 +3044,14 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /**
                                      *  Return total number of used cells,
                                      *  active or not, on level @p level.
-                                     *  Maps to @p{n_lines(level)} in one space
+                                     *  Maps to <tt>n_lines(level)</tt> in one space
                                      *  dimension and so on.
                                      */
     unsigned int n_cells (const unsigned int level) const;
 
                                     /**
                                      *  Return total number of active cells.
-                                     *  Maps to @p{n_active_lines()} in one space
+                                     *  Maps to <tt>n_active_lines()</tt> in one space
                                      *  dimension and so on.
                                      */
     unsigned int n_active_cells () const;
@@ -3059,7 +3059,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /**
                                      * Return total number of active cells
                                      * on level @p level.
-                                     * Maps to @p{n_active_lines(level)} in one
+                                     * Maps to <tt>n_active_lines(level)</tt> in one
                                      * space dimension and so on.
                                      */
     unsigned int n_active_cells (const unsigned int level) const;
@@ -3292,7 +3292,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  The flags are stored in a binary
                                      *  format: for each @p true, a @p 1
                                      *  bit is stored, a @p 0 bit otherwise.
-                                     *  The bits are stored as @p{unsigned char},
+                                     *  The bits are stored as <tt>unsigned char</tt>,
                                      *  thus avoiding endianess. They are
                                      *  written to @p out in plain text, thus
                                      *  amounting to 3.6 bits per active cell
@@ -3403,11 +3403,11 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Array of pointers pointing to the
-                                     *  @p{TriangulationLevel<dim>} objects
+                                     *  <tt>TriangulationLevel<dim></tt> objects
                                      *  storing the data on the different
                                      *  levels.
                                      *
-                                     *  Usage is like @p{levels[3]->quads}.
+                                     *  Usage is like <tt>levels[3]->quads</tt>.
                                      */
     std::vector<TriangulationLevel<dim>*> levels;
 
index 5521b0b7463afe234509685f3073db3b8a2ecb0e..6d4629db2d13bdd1de4d32da355815c32a456ade 100644 (file)
@@ -142,7 +142,7 @@ class TriaAccessor
                                     /**
                                      *  Copy operator. This is normally
                                      *  used in a context like
-                                     *  @p{iterator a,b;  *a=*b;}. Since
+                                     *  <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
@@ -338,7 +338,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                     /**
                                      * Copy the data of a line. Only
                                      * implemented for
-                                     * @p{celldim==1}.
+                                     * <tt>celldim==1</tt>.
                                      */
 
     void set (const Line&) const;
@@ -346,14 +346,14 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                     /**
                                      * Copy the data of the given
                                      * quad. Only implemented for
-                                     * @p{celldim==2}.
+                                     * <tt>celldim==2</tt>.
                                      */
     void set (const Quad&) const;
     
                                     /**
                                      * Copy the data of the given
                                      * hex. Only implemented for
-                                     * @p{celldim==3}.
+                                     * <tt>celldim==3</tt>.
                                      */
     void set (const Hexahedron&) const;
     
@@ -385,7 +385,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      *  Pointer to the @p ith line
                                      *  bounding this object.
                                      *
-                                     * Implemented only for @p{celldim>1}.
+                                     * Implemented only for <tt>celldim>1</tt>.
                                      */
     TriaIterator<dim,TriaObjectAccessor<1, dim> >
     line (const unsigned int i) const;
@@ -396,7 +396,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      * the same as that of the
                                      * object.
                                      *
-                                     * Implemented only for @p{celldim>1}.
+                                     * Implemented only for <tt>celldim>1</tt>.
                                      */
     unsigned int line_index (const unsigned int i) const;
     
@@ -404,7 +404,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      *  Pointer to the @p ith quad
                                      *  bounding this object.
                                      *
-                                     * Implemented only for @p{celldim>2}.
+                                     * Implemented only for <tt>celldim>2</tt>.
                                      */
     TriaIterator<dim,TriaObjectAccessor<2, dim> >
     quad (const unsigned int i) const;
@@ -414,7 +414,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      * quad. The level is naturally
                                      * the same as that of the object.
                                      *
-                                     * Implemented only for @p{celldim>2}.
+                                     * Implemented only for <tt>celldim>2</tt>.
                                      */
     unsigned int quad_index (const unsigned int i) const;
 
@@ -502,7 +502,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      * style cast operator to
                                      * maintain a minimum of
                                      * typesafety, e.g.
-                                     * @p{A *a=static_cast<A*>(cell->user_pointer());}.
+                                     * <tt>A *a=static_cast<A*>(cell->user_pointer());</tt>.
                                      */
     void * user_pointer () const;
 
@@ -613,14 +613,14 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      * dimension less than the
                                      * dimension of a cell, this
                                      * function issues an error if
-                                     * @p{dim<4}.
+                                     * <tt>dim<4</tt>.
                                      */
     unsigned char boundary_indicator () const;
 
                                     /**
                                      * Set the boundary indicator.
                                      * The same applies as for the
-                                     * @p{boundary_indicator()}
+                                     * <tt>boundary_indicator()</tt>
                                      * function.
                                      *
                                      * Caution: Never set the
@@ -645,8 +645,8 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      * the interior of the
                                      * domain. Obviously, the use of
                                      * this function is only possible
-                                     * for @p{dim>celldim}; however,
-                                     * for @p{dim==celldim}, an
+                                     * for <tt>dim>celldim</tt>; however,
+                                     * for <tt>dim==celldim</tt>, an
                                      * object is a cell and the
                                      * CellAccessor class
                                      * offers another possibility to
@@ -744,7 +744,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                     /**
                                      *  Copy operator. This is normally
                                      *  used in a context like
-                                     *  @p{iterator a,b;  *a=*b;}. Since
+                                     *  <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
@@ -783,7 +783,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      *
                                      *  The previous element is
                                      *  previous on this level if
-                                     *  @p{index>0}. If the present
+                                     *  <tt>index>0</tt>. If the present
                                      *  element is the first on this
                                      *  level, the last on the
                                      *  previous level is accessed.
@@ -866,7 +866,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
 
                                     /**
                                      *  Return the index of vertex
-                                     *  @p{i=0,1} of a line.
+                                     *  <tt>i=0,1</tt> of a line.
                                      *
                                      *  Note that the returned value is only
                                      *  the index of the geometrical
@@ -1006,7 +1006,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      * style cast operator to
                                      * maintain a minimum of
                                      * typesafety, e.g.
-                                     * @p{A *a=static_cast<A*>(cell->user_pointer());}.
+                                     * <tt>A *a=static_cast<A*>(cell->user_pointer());</tt>.
                                      */
     void * user_pointer () const;
     
@@ -1074,7 +1074,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      * structures with a dimension
                                      * less than the dimension of a
                                      * cell, this function issues an
-                                     * error if @p{dim<2}.
+                                     * error if <tt>dim<2</tt>.
                                      *
                                      * If the return value is 255,
                                      * then this line is in the
@@ -1086,7 +1086,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      * Set the boundary indicator of
                                      * this line.  The same applies
                                      * as for the
-                                     * @p{boundary_indicator()}
+                                     * <tt>boundary_indicator()</tt>
                                      * function.
                                      *
                                      * You should be careful with
@@ -1111,8 +1111,8 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      * field, which is always 255 if
                                      * the line is in the interior of
                                      * the domain. Obviously, this is
-                                     * only possible for @p{dim>1};
-                                     * however, for @p{dim==1}, a
+                                     * only possible for <tt>dim>1</tt>;
+                                     * however, for <tt>dim==1</tt>, a
                                      * line is a cell and the
                                      * CellAccessor class
                                      * offers another possibility to
@@ -1216,7 +1216,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                     /**
                                      *  Copy operator. This is normally
                                      *  used in a context like
-                                     *  @p{iterator a,b;  *a=*b;}. Since
+                                     *  <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
@@ -1257,7 +1257,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      *
                                      *  The previous element is
                                      *  previous on this level if
-                                     *  @p{index>0}. If the present
+                                     *  <tt>index>0</tt>. If the present
                                      *  element is the first on this
                                      *  level, the last on the
                                      *  previous level is accessed.
@@ -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 <tt>dim>=2</tt>
  *   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.
@@ -1437,7 +1437,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      * style cast operator to
                                      * maintain a minimum of
                                      * typesafety, e.g.
-                                     * @p{A *a=static_cast<A*>(cell->user_pointer());}.
+                                     * <tt>A *a=static_cast<A*>(cell->user_pointer());</tt>.
                                      */
     void * user_pointer () const;
 
@@ -1543,7 +1543,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      * structures with a dimension
                                      * less than the dimension of a
                                      * cell, this function issues an
-                                     * error if @p{dim<3}.
+                                     * error if <tt>dim<3</tt>.
                                      *
                                      * If the return value is 255,
                                      * then this quad is in the
@@ -1555,7 +1555,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      * Set the boundary indicator of
                                      * this quad.  The same applies
                                      * as for the
-                                     * @p{boundary_indicator()}
+                                     * <tt>boundary_indicator()</tt>
                                      * function.
                                      *
                                      * You should be careful with
@@ -1581,8 +1581,8 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      * the quad is in the interior of
                                      * the domain. Obviously, this
                                      * function is only useful for
-                                     * @p{dim>2}; however, for
-                                     * @p{dim==2}, a quad is a cell
+                                     * <tt>dim>2</tt>; however, for
+                                     * <tt>dim==2</tt>, a quad is a cell
                                      * and the CellAccessor
                                      * class offers another
                                      * possibility to determine
@@ -1752,7 +1752,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      *
                                      *  The previous element is
                                      *  previous on this level if
-                                     *  @p{index>0}. If the present
+                                     *  <tt>index>0</tt>. If the present
                                      *  element is the first on this
                                      *  level, the last on the
                                      *  previous level is accessed.
@@ -1771,7 +1771,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
- *   @p{dim>=3} seems reasonable to me). There is a derived class for
+ *   <tt>dim>=3</tt> 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.
  *
@@ -1947,7 +1947,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      * style cast operator to
                                      * maintain a minimum of
                                      * typesafety, e.g.
-                                     * @p{A *a=static_cast<A*>(cell->user_pointer());}.
+                                     * <tt>A *a=static_cast<A*>(cell->user_pointer());</tt>.
                                      */
     void * user_pointer () const;
 
@@ -2054,7 +2054,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      * structures with a dimension
                                      * less than the dimension of a
                                      * cell, this function issues an
-                                     * error if @p{dim<4}.
+                                     * error if <tt>dim<4</tt>.
                                      *
                                      * If the return value is 255,
                                      * then this line is in the
@@ -2066,7 +2066,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      * Set the boundary indicator of
                                      * this hex.  The same applies as
                                      * for the
-                                     * @p{boundary_indicator()}
+                                     * <tt>boundary_indicator()</tt>
                                      * function.
                                      *
                                      * You should be careful with
@@ -2092,8 +2092,8 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      * the hex is in the interior of
                                      * the domain. Obviously, the use
                                      * of this function is only
-                                     * possible for @p{dim>3};
-                                     * however, for @p{dim==3}, a hex
+                                     * possible for <tt>dim>3</tt>;
+                                     * however, for <tt>dim==3</tt>, a hex
                                      * is a cell and the
                                      * CellAccessor class
                                      * offers another possibility to
@@ -2226,7 +2226,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                     /**
                                      *  Copy operator. This is normally
                                      *  used in a context like
-                                     *  @p{iterator a,b;  *a=*b;}. Since
+                                     *  <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
@@ -2267,7 +2267,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      *
                                      *  The previous element is
                                      *  previous on this level if
-                                     *  @p{index>0}. If the present
+                                     *  <tt>index>0</tt>. If the present
                                      *  element is the first on this
                                      *  level, the last on the
                                      *  previous level is accessed.
@@ -2352,10 +2352,10 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                                     /**
                                      * Return the how-many'th
                                      * neighbor this cell is of
-                                     * @p{cell->neighbor(neighbor)},
+                                     * <tt>cell->neighbor(neighbor)</tt>,
                                      * i.e. return the number @p n
                                      * such that
-                                     * @p{cell->neighbor(neighbor)->neighbor(n)==cell}. This
+                                     * <tt>cell->neighbor(neighbor)->neighbor(n)==cell</tt>. This
                                      * function is the right one if
                                      * you want to know how to get
                                      * back from a neighbor to the
@@ -2365,9 +2365,9 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                                      * only useful if the neighbor is
                                      * not on a coarser level than
                                      * the present cell
-                                     * (i.e. @p{cell->neighbor(neighbor)->level()}
+                                     * (i.e. <tt>cell->neighbor(neighbor)->level()</tt>
                                      * needs to be equal to
-                                     * @p{cell->level()}. Use the
+                                     * <tt>cell->level()</tt>. Use the
                                      * @p neighbor_of_coarser_neighbor
                                      * function in that case.
                                      */
@@ -2382,10 +2382,10 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                                      * pair of numbers, face_no and
                                      * subface_no, with the following
                                      * property:
-                                     * @p{cell->neighbor(neighbor)->face(face_no)->child(subface_no)==cell->face(neighbor)}.
+                                     * <tt>cell->neighbor(neighbor)->face(face_no)->child(subface_no)==cell->face(neighbor)</tt>.
                                      *
                                      * This function is impossible
-                                     * for @p{dim==1}.
+                                     * for <tt>dim==1</tt>.
                                      */
     std::pair<unsigned int, unsigned int>
     neighbor_of_coarser_neighbor (const unsigned int neighbor) const;
index 63ec56d09f5c0e78a702c0ef5b376c6220ebade2..5c3ddca030d163c831d43436c976eba5c4b338a3 100644 (file)
@@ -83,7 +83,7 @@ class Boundary : public Subscriptor
                                      * the normals at the vertices of
                                      * a face of a cell. Thus, there
                                      * are
-                                     * @p{GeometryInfo<dim>::vertices_per_face}
+                                     * <tt>GeometryInfo<dim>::vertices_per_face</tt>
                                      * normal vectors, that define
                                      * the tangent spaces of the
                                      * boundary at the vertices. Note
@@ -140,8 +140,8 @@ class Boundary : public Subscriptor
                                      * given @p quad are refined, so
                                      * you may want to use the
                                      * information provided by
-                                     * @p{quad->line(i)->child(j)},
-                                     * @p{i=0...3}, @p{j=0,1}.
+                                     * <tt>quad->line(i)->child(j)</tt>,
+                                     * <tt>i=0...3</tt>, <tt>j=0,1</tt>.
                                      *
                                      * Because in 2D, this function
                                      * is not needed, it is not made
@@ -191,15 +191,15 @@ class Boundary : public Subscriptor
                                      * vector @p points. It is
                                      * required that this number is a
                                      * square of another integer,
-                                     * i.e. @p{n=points.size()=m*m}. It
+                                     * i.e. <tt>n=points.size()=m*m</tt>. It
                                      * is the task of the derived
                                      * classes to arrange the points
                                      * such they split the quad into
-                                     * @p{(m+1)(m+1)} approximately
+                                     * <tt>(m+1)(m+1)</tt> approximately
                                      * equal-sized subquads.
                                      *
                                      * This function is called by the
-                                     * @p{MappingQ<3>} class. This
+                                     * <tt>MappingQ<3></tt> class. This
                                      * happens each face quad of
                                      * cells in 3d that has got at
                                      * least one boundary face quad.
@@ -320,7 +320,7 @@ class StraightBoundary : public Boundary<dim>
     get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &quad) const;
 
                                     /**
-                                     * Gives @p{n=points.size()}
+                                     * Gives <tt>n=points.size()</tt>
                                      * points that splits the
                                      * p{StraightBoundary} line into
                                      * p{n+1} partitions of equal
@@ -336,10 +336,10 @@ class StraightBoundary : public Boundary<dim>
                                     std::vector<Point<dim> > &points) const;
 
                                     /**
-                                     * Gives @p{n=points.size()=m*m}
+                                     * Gives <tt>n=points.size()=m*m</tt>
                                      * points that splits the
                                      * p{StraightBoundary} quad into
-                                     * @p{(m+1)(m+1)} subquads of equal
+                                     * <tt>(m+1)(m+1)</tt> subquads of equal
                                      * size.
                                      *
                                      * Refer to the general
index f308cbab686f34fdea997d224bb14e6741ec118f..8f6a9419f57f8f34ca40d30a2ff042177dacdc7c 100644 (file)
@@ -31,7 +31,7 @@
  *
  *   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.
+ *   StraightBoundary<tt><dim>::in_between(neighbors)</tt> function.
  *
  *   @author Guido Kanschat, 2001
  */
@@ -79,8 +79,8 @@ class CylinderBoundary : public StraightBoundary<dim>
                                      * and the documentation of the
                                      * base class.
                                      *
-                                     * Only implemented for @p{dim=3}
-                                     * and for @p{points.size()==1}.
+                                     * Only implemented for <tt>dim=3</tt>
+                                     * and for <tt>points.size()==1</tt>.
                                      */
     virtual void
     get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
@@ -151,7 +151,7 @@ class CylinderBoundary : public StraightBoundary<dim>
  *
  *   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.
+ *   StraightBoundary<tt><dim>::in_between(neighbors)</tt> function.
  *
  *   @author Wolfgang Bangerth, 1998, Ralf Hartmann, 2001
  */
@@ -200,8 +200,8 @@ class HyperBallBoundary : public StraightBoundary<dim>
                                      * and the documentation of the
                                      * base class.
                                      *
-                                     * Only implemented for @p{dim=3}
-                                     * and for @p{points.size()==1}.
+                                     * Only implemented for <tt>dim=3</tt>
+                                     * and for <tt>points.size()==1</tt>.
                                      */
     virtual void
     get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
@@ -312,7 +312,7 @@ class HalfHyperBallBoundary : public HyperBallBoundary<dim>
                           const double     radius = 1.0);
 
                                     /**
-                                     * Check if on the line @p{x==0},
+                                     * Check if on the line <tt>x==0</tt>,
                                      * otherwise pass to the base
                                      * class.
                                      */
@@ -320,7 +320,7 @@ class HalfHyperBallBoundary : public HyperBallBoundary<dim>
     get_new_point_on_line (const typename Triangulation<dim>::line_iterator &line) const;
 
                                     /**
-                                     * Check if on the line @p{x==0},
+                                     * Check if on the line <tt>x==0</tt>,
                                      * otherwise pass to the base
                                      * class.
                                      */
@@ -346,8 +346,8 @@ class HalfHyperBallBoundary : public HyperBallBoundary<dim>
                                      * and the documentation of the
                                      * base class.
                                      *
-                                     * Only implemented for @p{dim=3}
-                                     * and for @p{points.size()==1}.
+                                     * Only implemented for <tt>dim=3</tt>
+                                     * and for <tt>points.size()==1</tt>.
                                      */
     virtual void
     get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
@@ -450,8 +450,8 @@ class HalfHyperShellBoundary : public HyperShellBoundary<dim>
                                      * and the documentation of the
                                      * base class.
                                      *
-                                     * Only implemented for @p{dim=3}
-                                     * and for @p{points.size()==1}.
+                                     * Only implemented for <tt>dim=3</tt>
+                                     * and for <tt>points.size()==1</tt>.
                                      */
     virtual void
     get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
index 6241e8e7cb45a02392fcd02ef8328485a48b98db..fe2d6a8b342fbc2194282b2789518b756b3da832 100644 (file)
@@ -25,7 +25,7 @@
  *   A heaxhedron itself has one index, as far as the topological part
  *   handled in the triangulation is concerned: the index in the level
  *   it belongs to. The level index is implicitly given by the
- *   position in the @p{hexes.hexes} list attached to the information
+ *   position in the <tt>hexes.hexes</tt> list attached to the information
  *   of each level of the triangulation.
  *
  *   For conventions on the numbering of faces, lines and vertices
index c21598446fe9254e822df354389bfe2647fe0baf..acf1ec2c1c64a8bb276985ae672c5ff9c9bb6b51 100644 (file)
@@ -269,15 +269,15 @@ class TriaRawIterator :
                                     /**
                                      *  Dereferencing operator, returns a
                                      *  reference to an accessor.
-                                     *  Usage is thus like @p{(*i).index ();}
+                                     *  Usage is thus like <tt>(*i).index ();</tt>
                                      *
                                      *  This function has to be specialized
                                      *  explicitly for the different
                                      *  @p Pointees, to allow an
-                                     *  @p{iterator<1,TriangulationLevel<1>::LinesData>}
-                                     *  to point to @p{tria->lines.lines[index]} while
+                                     *  <tt>iterator<1,TriangulationLevel<1>::LinesData></tt>
+                                     *  to point to <tt>tria->lines.lines[index]</tt> while
                                      *  for one dimension higher it has
-                                     *  to point to @p{tria->quads.quads[index]}.
+                                     *  to point to <tt>tria->quads.quads[index]</tt>.
                                      *
                                      *  You must not dereference invalid or
                                      *  past the end iterators.
@@ -293,7 +293,7 @@ class TriaRawIterator :
                                     /**
                                      *  Dereferencing operator, returns a
                                      *  reference of the cell pointed to.
-                                     *  Usage is thus like @p{i->index ();}
+                                     *  Usage is thus like <tt>i->index ();</tt>
                                      *
                                      *  There is a @p const and a non-@p const
                                      *  version.
@@ -344,10 +344,10 @@ class TriaRawIterator :
                                     /**@name Advancement of iterators*/
                                     /*@{*/
                                     /**
-                                     *  Prefix @p{++} operator: @p{++i}. This
+                                     *  Prefix <tt>++</tt> operator: <tt>++i</tt>. This
                                      *  operator advances the iterator to
                                      *  the next element and returns
-                                     *  a reference to @p{*this}.
+                                     *  a reference to <tt>*this</tt>.
                                      *
                                      *  The next element is next on this
                                      *  level if there are more. If the
@@ -358,7 +358,7 @@ class TriaRawIterator :
     TriaRawIterator & operator ++ ();
     
                                     /**
-                                     *  Postfix @p{++} operator: @p{i++}. This
+                                     *  Postfix <tt>++</tt> operator: <tt>i++</tt>. This
                                      *  operator advances the iterator to
                                      *  the next element, but
                                      *  returns an iterator to the element
@@ -367,10 +367,10 @@ class TriaRawIterator :
                                      *  operation and since an
                                      *  @p iterator is quite a large
                                      *  object for a pointer, use the
-                                     *  prefix operator @p{++i} whenever
+                                     *  prefix operator <tt>++i</tt> whenever
                                      *  possible, especially in the head
                                      *  of for loops
-                                     *  (@p{for (; i!=end; ++i)}) since there
+                                     *  (<tt>for (; i!=end; ++i)</tt>) since there
                                      *  you normally never need the
                                      *  returned value.
                                      */
@@ -380,10 +380,10 @@ class TriaRawIterator :
                                      *  Prefix @p -- operator: @p --i. This
                                      *  operator advances the iterator to
                                      *  the previous element and returns
-                                     *  a reference to @p{*this}.
+                                     *  a reference to <tt>*this</tt>.
                                      *
                                      *  The previous element is previous on
-                                     *  this level if @p{index>0}. If the
+                                     *  this level if <tt>index>0</tt>. If the
                                      *  present element is the first on
                                      *  this level, the last on the
                                      *  previous level is accessed.
@@ -403,7 +403,7 @@ class TriaRawIterator :
                                      *  prefix operator @p --i whenever
                                      *  possible, especially in the head
                                      *  of for loops
-                                     *  (@p{for (; i!=end; --i)}) since there
+                                     *  (<tt>for (; i!=end; --i)</tt>) since there
                                      *  you normally never need the
                                      *  returned value.
                                      */
@@ -417,7 +417,7 @@ class TriaRawIterator :
 
                                     /**
                                      * Print the iterator to @p out. The
-                                     * format is like @p{level.index}.
+                                     * format is like <tt>level.index</tt>.
                                      */
     void print (std::ostream &out) const;
 
@@ -598,15 +598,15 @@ class TriaIterator : public TriaRawIterator<dim,Accessor>
                                     /**@name Advancement of iterators*/
                                     /*@{*/
                                     /**
-                                     *  Prefix @p{++} operator: @p{++i}. This
+                                     *  Prefix <tt>++</tt> operator: <tt>++i</tt>. This
                                      *  operator advances the iterator to
                                      *  the next used element and returns
-                                     *  a reference to @p{*this}.
+                                     *  a reference to <tt>*this</tt>.
                                      */
     TriaIterator<dim,Accessor> & operator ++ ();
 
                                     /**
-                                     *  Postfix @p{++} operator: @p{i++}. This
+                                     *  Postfix <tt>++</tt> operator: <tt>i++</tt>. This
                                      *  operator advances the iterator to
                                      *  the next used element, but
                                      *  returns an iterator to the element
@@ -615,10 +615,10 @@ class TriaIterator : public TriaRawIterator<dim,Accessor>
                                      *  operation and since an
                                      *  @p active_iterator is quite a large
                                      *  object for a pointer, use the
-                                     *  prefix operator @p{++i} whenever
+                                     *  prefix operator <tt>++i</tt> whenever
                                      *  possible, especially in the head
                                      *  of for loops
-                                     *  (@p{for (; i!=end; ++i)}) since there
+                                     *  (<tt>for (; i!=end; ++i)</tt>) since there
                                      *  you normally never need the
                                      *  returned value.
                                      */
@@ -628,7 +628,7 @@ class TriaIterator : public TriaRawIterator<dim,Accessor>
                                      *  Prefix @p -- operator: @p --i. This
                                      *  operator advances the iterator to
                                      *  the previous used element and returns
-                                     *  a reference to @p{*this}.
+                                     *  a reference to <tt>*this</tt>.
                                      */
     TriaIterator<dim,Accessor> & operator -- ();
 
@@ -734,7 +734,7 @@ class TriaActiveIterator : public TriaIterator<dim,Accessor>
                                      * raw iterators. Since usual iterators
                                      * are also raw iterators, this constructor
                                      * works also for parameters of type
-                                     * @p{TriaIterator<dim,OtherAccessor>}.
+                                     * <tt>TriaIterator<dim,OtherAccessor></tt>.
                                      */
     template <typename OtherAccessor>
     TriaActiveIterator (const TriaRawIterator<dim,OtherAccessor> &i);
@@ -764,17 +764,17 @@ class TriaActiveIterator : public TriaIterator<dim,Accessor>
     operator = (const TriaIterator<dim,Accessor> &);
 
                                     /**
-                                     *  Prefix @p{++} operator: @p{++i}. This
+                                     *  Prefix <tt>++</tt> operator: <tt>++i</tt>. This
                                      *  operator advances the iterator to
                                      *  the next active element and returns
-                                     *  a reference to @p{*this}.
+                                     *  a reference to <tt>*this</tt>.
                                      */
     TriaActiveIterator<dim,Accessor> & operator ++ ();
 
                                     /**@name Advancement of iterators*/
                                     /*@{*/
                                     /**
-                                     *  Postfix @p{++} operator: @p{i++}. This
+                                     *  Postfix <tt>++</tt> operator: <tt>i++</tt>. This
                                      *  operator advances the iterator to
                                      *  the next active element, but
                                      *  returns an iterator to the element
@@ -783,10 +783,10 @@ class TriaActiveIterator : public TriaIterator<dim,Accessor>
                                      *  operation and since an
                                      *  @p active_iterator is quite a large
                                      *  object for a pointer, use the
-                                     *  prefix operator @p{++i} whenever
+                                     *  prefix operator <tt>++i</tt> whenever
                                      *  possible, especially in the head
                                      *  of for loops
-                                     *  (@p{for (; i!=end; ++i)}) since there
+                                     *  (<tt>for (; i!=end; ++i)</tt>) since there
                                      *  you normally never need the
                                      *  returned value.
                                      */
@@ -796,7 +796,7 @@ class TriaActiveIterator : public TriaIterator<dim,Accessor>
                                      *  Prefix @p -- operator: @p --i. This
                                      *  operator advances the iterator to
                                      *  the previous active element and
-                                     *  returns a reference to @p{*this}.
+                                     *  returns a reference to <tt>*this</tt>.
                                      */
     TriaActiveIterator<dim,Accessor> & operator -- ();
 
@@ -1017,7 +1017,7 @@ 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
+ * address is given by the pair <tt>(level,index)</tt>, where @p index is
  * an index relative to the level in which the object is that is
  * pointed to.
  *
@@ -1036,7 +1036,7 @@ 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
+ * address is given by the pair <tt>(level,index)</tt>, where @p index is
  * an index relative to the level in which the object is that is
  * pointed to.
  *
@@ -1055,7 +1055,7 @@ 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
+ * address is given by the pair <tt>(level,index)</tt>, where @p index is
  * an index relative to the level in which the object is that is
  * pointed to.
  *
index d2d84fcf909f3e96934d04d314e62e2423e66c3a..5ff70654848aed894532310eaababffe05ad41d0 100644 (file)
@@ -83,17 +83,17 @@ class TriangulationLevel<0>
                                      *  are stored in the fields following
                                      *  $i*(2*real_space_dimension)$, e.g. in
                                      *  one spatial dimension, the neighbors
-                                     *  of cell 0 are stored in @p{neighbors[0]}
-                                     *  and @p{neighbors[1]}, the neighbors of
-                                     *  cell 1 are stored in @p{neighbors[2]}
-                                     *  and @p{neighbors[3]}, and so on.
+                                     *  of cell 0 are stored in <tt>neighbors[0]</tt>
+                                     *  and <tt>neighbors[1]</tt>, the neighbors of
+                                     *  cell 1 are stored in <tt>neighbors[2]</tt>
+                                     *  and <tt>neighbors[3]</tt>, and so on.
                                      *
-                                     *  In neighbors, @p{neighbors[i].first} is
-                                     *  the level, while @p{neighbors[i].first}
+                                     *  In neighbors, <tt>neighbors[i].first</tt> is
+                                     *  the level, while <tt>neighbors[i].first</tt>
                                      *  is the index of the neighbor.
                                      *
                                      *  If a neighbor does not exist (cell is
-                                     *  at the boundary), @p{level=index=-1}
+                                     *  at the boundary), <tt>level=index=-1</tt>
                                      *  is set.
                                      *
                                      *  <em>Conventions:</em> The
@@ -146,8 +146,8 @@ class TriangulationLevel<0>
                                      *  level, you have to give to total number
                                      *  of cells, not only the number of newly
                                      *  to accomodate ones, like in the
-                                     *  @p{TriangulationLevel<N>::reserve_space}
-                                     *  functions, with @p{N>0}.
+                                     *  <tt>TriangulationLevel<N>::reserve_space</tt>
+                                     *  functions, with <tt>N>0</tt>.
                                      *
                                      *  Since the
                                      *  number of neighbors per cell depends
@@ -239,7 +239,7 @@ class TriangulationLevel<1> : public TriangulationLevel<0>
                                          *  stored in this list. A line is
                                          *  called active if it has no
                                          *  children. The function
-                                         *  TriaIterator@p{::active()}
+                                         *  TriaIterator<tt>::active()</tt>
                                          *  tests for this.
                                          */
        std::vector<int>  children;
@@ -267,7 +267,7 @@ class TriangulationLevel<1> : public TriangulationLevel<0>
                                          *  already been processed.
                                          *
                                          *  You can clear all used flags using
-                                         *  Triangulation@p{::clear_user_flags()}.
+                                         *  Triangulation<tt>::clear_user_flags()</tt>.
                                          */
        std::vector<bool> user_flags;
 
@@ -313,7 +313,7 @@ class TriangulationLevel<1> : public TriangulationLevel<0>
                                      *  Assert that enough space is allocated
                                      *  to accomodate @p new_lines new lines.
                                      *  This function does not only call
-                                     *  @p{vector::reserve()}, but does really
+                                     *  <tt>vector::reserve()</tt>, but does really
                                      *  append the needed elements.
                                      *  There are pendants for higher
                                      *  dimensions, which you have to call
@@ -369,7 +369,7 @@ class TriangulationLevel<2> :  public TriangulationLevel<1>
                                      *
                                      *  It is fully analogous to the
                                      *  @ref{TriangulationLevel<1>::LinesData} structure inherited from
-                                     *  Triangulation@p{<1>}.
+                                     *  Triangulation<tt><1></tt>.
                                      */
     struct QuadsData
     {
@@ -606,7 +606,7 @@ class TriangulationLevel<3> :  public TriangulationLevel<2>
                                           * a @p false value.
                                           *
                                           * In effect, this field has
-                                          * @p{6*n_cells} elements,
+                                          * <tt>6*n_cells</tt> elements,
                                           * being the number of cells
                                           * times the six faces each
                                           * has.
index e544a8e999fc8f43946fb565418f46b47a88bfd1..6646c8cc722ff04aef0f9ee5f627b4ff1b76d6a1 100644 (file)
@@ -25,7 +25,7 @@
  *   A line itself has one index, as far as the topological part handled in
  *   the triangulation is concerned: the index in the level
  *   it belongs to. The level index is implicitly given by the position
- *   in the @p{lines.lines} list attached to the information of each level.
+ *   in the <tt>lines.lines</tt> list attached to the information of each level.
  *
  *   @author Wolfgang Bangerth, 1998
  */
index 8f2f272d3bcd000cd440200f5460e9a6fd5caa47..42a7077a3e4d4661a83ab9941b447a03776b43d2 100644 (file)
@@ -26,7 +26,7 @@
  *   A quad itself has one index, as far as the topological part handled in
  *   the triangulation is concerned: the index in the level
  *   it belongs to. The level index is implicitly given by the position
- *   in the @p{quads.quads} list attached to the information of each level
+ *   in the <tt>quads.quads</tt> list attached to the information of each level
  *   of the triangulation.
  *
  *   @author Wolfgang Bangerth, 1998
index a9da3d12a1e3c3c48ad0f551e522072014f70869..912df745573728faf7d4149fe37f8b1dcad4fb81 100644 (file)
@@ -109,11 +109,11 @@ 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
- * from. By default, @p{MGDoFObjectAccessor<celldim,dim>} derives from
- * 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,
+ * from. By default, <tt>MGDoFObjectAccessor<celldim,dim></tt> derives from
+ * the @p typedef in the general <tt>MGDoFObjectAccessor_Inheritance<celldim,dim></tt>
+ * class, which is <tt>DoFObjectAccessor<celldim,dim></tt>,
+ * but if <tt>celldim==dim</tt>, then the specialization <tt>MGDoFObjectAccessor_Inheritance<dim,dim></tt>
+ * is used which declares its local type to be <tt>DoFCellAccessor<dim></tt>. Therefore,
  * the inheritance is automatically chosen to be from @p DoFCellAccessor if the
  * object under consideration has full dimension, i.e. constitutes a cell.
  *
@@ -135,11 +135,11 @@ 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
- * from. By default, @p{DoFObjectAccessor<celldim,dim>} derives from
- * 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,
+ * from. By default, <tt>DoFObjectAccessor<celldim,dim></tt> derives from
+ * the @p typedef in the general <tt>DoFObjectAccessor_Inheritance<celldim,dim></tt>
+ * class, which is <tt>TriaObjectAccessor<celldim,dim></tt>,
+ * but if <tt>celldim==dim</tt>, then the specialization <tt>TriaObjectAccessor<dim,dim></tt>
+ * is used which declares its local type to be <tt>CellAccessor<dim></tt>. Therefore,
  * the inheritance is automatically chosen to be from @p CellAccessor if the
  * object under consideration has full dimension, i.e. constitutes a cell.
  *
@@ -219,9 +219,9 @@ class MGDoFObjectAccessor<0, dim>
  * 
  * @sect3{Notes about the class hierarchy structure}
  *
- * 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
+ * Inheritance from <tt>MGDoFObjectAccessor_Inheritance<1,dim>::BaseClass</tt> yields
+ * inheritance from <tt>DoFCellAccessor<1></tt> if <tt>dim==1</tt> and from
+ * <tt>TriaObjectAccessor<1,dim></tt> 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.
  *
@@ -248,7 +248,7 @@ class MGDoFObjectAccessor<1, dim> :  public MGDoFAccessor<dim>,
                                     /**
                                      * Constructor. The @p local_data
                                      * argument is assumed to be a pointer
-                                     * to a @p{MGDoFHandler<dim>} object.
+                                     * to a <tt>MGDoFHandler<dim></tt> object.
                                      */
     MGDoFObjectAccessor (const Triangulation<dim> *tria,
                         const int                 level,
@@ -597,13 +597,13 @@ class MGDoFObjectAccessor<3, dim> :  public MGDoFAccessor<dim>,
 /**
  * Grant access to the degrees of freedom on a cell. In fact, since all
  * access to the degrees of freedom has been enabled by the classes
- * @p{DoFObjectAccessor<1, 1>} and @p{DoFObjectAccessor<2, 2>} for the space dimension
+ * <tt>DoFObjectAccessor<1, 1></tt> and <tt>DoFObjectAccessor<2, 2></tt> for the space dimension
  * 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
+ * together by deriving from the appropriate <tt>DoF*Accessor</tt> and the
+ * right <tt>CellAccessor<dim></tt> 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
- * from the @p{CellAccessor<dim>} class).
+ * from the <tt>CellAccessor<dim></tt> class).
  *
  * @author Wolfgang Bangerth, 1998
  */
index 465be0c3a697e6dc8c0754058d226a7d61e7db3c..39d1f090643cb1016ae6e48386390788d5637c0a 100644 (file)
@@ -350,7 +350,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the first iterator not on
                                      * level. If @p level is the
                                      * last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     cell_iterator        end (const unsigned int level) const;
     
@@ -359,7 +359,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the first iterator not on
                                      * level. If @p level is the
                                      * last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_cell_iterator    end_raw (const unsigned int level) const;
 
@@ -368,7 +368,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * which is the first iterator
                                      * not on level. If @p level is
                                      * the last level, then this
-                                     * returns @p{end()}.
+                                     * returns <tt>end()</tt>.
                                      */
     active_cell_iterator end_active (const unsigned int level) const;
 
@@ -494,7 +494,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the first iterator not on
                                      * level. If @p level is the
                                      * last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     face_iterator        end_face (const unsigned int level) const;
     
@@ -503,7 +503,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the first iterator not on
                                      * level. If @p level is the
                                      * last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_face_iterator    end_raw_face (const unsigned int level) const;
 
@@ -512,7 +512,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * which is the first iterator
                                      * not on level. If @p level is
                                      * the last level, then this
-                                     * returns @p{end()}.
+                                     * returns <tt>end()</tt>.
                                      */
     active_face_iterator end_active_face (const unsigned int level) const;
 
@@ -622,7 +622,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the first iterator not on
                                      * level. If @p level is the
                                      * last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     line_iterator        end_line (const unsigned int level) const;
     
@@ -631,7 +631,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the first iterator not on
                                      * level. If @p level is the
                                      * last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_line_iterator    end_raw_line (const unsigned int level) const;
 
@@ -640,7 +640,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * which is the first iterator
                                      * not on level. If @p level is
                                      * the last level, then this
-                                     * returns @p{end()}.
+                                     * returns <tt>end()</tt>.
                                      */
     active_line_iterator end_active_line (const unsigned int level) const;
 
@@ -726,7 +726,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the first iterator not on
                                      * level. If @p level is the
                                      * last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     quad_iterator        end_quad (const unsigned int level) const;
     
@@ -735,7 +735,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the first iterator not on
                                      * level. If @p level is the
                                      * last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_quad_iterator    end_raw_quad (const unsigned int level) const;
 
@@ -744,7 +744,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * which is the first iterator
                                      * not on level. If @p level is
                                      * the last level, then this
-                                     * returns @p{end()}.
+                                     * returns <tt>end()</tt>.
                                      */
     active_quad_iterator end_active_quad (const unsigned int level) const;
 
@@ -830,7 +830,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the first iterator not on
                                      * level. If @p level is the
                                      * last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     hex_iterator        end_hex (const unsigned int level) const;
     
@@ -839,7 +839,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * the first iterator not on
                                      * level. If @p level is the
                                      * last level, then this returns
-                                     * @p{end()}.
+                                     * <tt>end()</tt>.
                                      */
     raw_hex_iterator    end_raw_hex (const unsigned int level) const;
 
@@ -848,7 +848,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * which is the first iterator
                                      * not on level. If @p level is
                                      * the last level, then this
-                                     * returns @p{end()}.
+                                     * returns <tt>end()</tt>.
                                      */
     active_hex_iterator end_active_hex (const unsigned int level) const;
 
index e729bf9411674fd663a43ff55dea81d749ba7b53..b11b6954f0c9cce66456d54fd7a3a7555f861c14 100644 (file)
@@ -49,7 +49,7 @@ class MGTools
                                      * creating the actual matrix
                                      * you have to compress the
                                      * matrix yourself, using
-                                     * @p{SparseMatrixStruct::compress()}.
+                                     * <tt>SparseMatrixStruct::compress()</tt>.
                                      *
                                      * There is no need to consider
                                      * hanging nodes here, since only
@@ -122,7 +122,7 @@ class MGTools
                                      * for each level a vector
                                      * containing the number of dofs
                                      * for each component (access is
-                                     * @p{result[level][component]}).
+                                     * <tt>result[level][component]</tt>).
                                      */
     template <int dim>
       static void count_dofs_per_component (const MGDoFHandler<dim>& mg_dof,
index 3c574f0f9f29829b6bc998e4d91305fde11bd31f..a5c3b127ed58cf29135fc3296dc933b9e748efb4 100644 (file)
@@ -126,7 +126,7 @@ class MGSmootherContinuous : public MGSmootherBase<VECTOR>
                                      * different levels to zero in the given
                                      * data vector @p u.
                                      *
-                                     * Since the coarsest level (@p{level==0})
+                                     * Since the coarsest level (<tt>level==0</tt>)
                                      * has no interior boundaries, this
                                      * function does nothing in this case.
                                      */
@@ -193,8 +193,8 @@ class MGSmootherContinuous : public MGSmootherBase<VECTOR>
  * 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
+ * The library contains instantiation for <tt>SparseMatrix<.></tt> and
+ * <tt>Vector<.></tt>, where the template arguments are all combinations of
  * @p float and @p double. Additional instantiations may be created
  * by including the file mg_smoother.templates.h.
  * 
@@ -219,9 +219,9 @@ class MGSmootherRelaxation : public MGSmootherBase<VECTOR>
                                      * Initialize for matrices. The
                                      * parameter @p matrices can be
                                      * any object having functions
-                                     * @p{get_minlevel()} and
-                                     * @p{get_maxlevel()} as well as
-                                     * an @p{operator[]} returning a
+                                     * <tt>get_minlevel()</tt> and
+                                     * <tt>get_maxlevel()</tt> as well as
+                                     * an <tt>operator[]</tt> returning a
                                      * reference to @p MATRIX. This
                                      * function stores pointers to
                                      * the level matrices and
@@ -244,9 +244,9 @@ class MGSmootherRelaxation : public MGSmootherBase<VECTOR>
                                      * of matrices. The parameter
                                      * @p matrices can be any object
                                      * having functions
-                                     * @p{get_minlevel()} and
-                                     * @p{get_maxlevel()} as well as
-                                     * an @p{operator[]} returning a
+                                     * <tt>get_minlevel()</tt> and
+                                     * <tt>get_maxlevel()</tt> as well as
+                                     * an <tt>operator[]</tt> returning a
                                      * reference to a block matrix
                                      * where each block is of type
                                      * @p MATRIX. Of this block
index d7715cfd65ba7ab790aaaea3e790ce989ad183e6..c047b60f7ff2a89fb2e37ea4f607e308bdee66bd 100644 (file)
@@ -90,7 +90,7 @@ class MGTransferPrebuilt : public MGTransferBase<VECTOR>
                                      * Copies data from active
                                      * portions of an MGVector into
                                      * the respective positions of a
-                                     * @p{Vector<number>}. In order to
+                                     * <tt>Vector<number></tt>. In order to
                                      * keep the result consistent,
                                      * constrained degrees of freedom
                                      * are set to zero.
@@ -176,8 +176,8 @@ class MGTransferPrebuilt : public MGTransferBase<VECTOR>
                                      * functions of @p copy_to_mg,
                                      * where the 1d function takes an
                                      * argument of type
-                                     * @p{is_1d<true>} and the other
-                                     * one of type @p{is_1d<false>}.
+                                     * <tt>is_1d<true></tt> and the other
+                                     * one of type <tt>is_1d<false></tt>.
                                      */
     template <bool> struct is_1d {};
     
@@ -505,8 +505,8 @@ class MGTransferBlock : public MGTransferBase<BlockVector<number> >,
                                      * functions of @p copy_to_mg,
                                      * where the 1d function takes an
                                      * argument of type
-                                     * @p{is_1d<true>} and the other
-                                     * one of type @p{is_1d<false>}.
+                                     * <tt>is_1d<true></tt> and the other
+                                     * one of type <tt>is_1d<false></tt>.
                                      */
     template <bool> struct is_1d {};
 
index e8590281dfe0c03e2c4af6f586ca72b254a82dcd..2510b504f4ad6810552d3b0a9a128e62d43bfba3 100644 (file)
@@ -63,7 +63,7 @@
  * @code
  *   void COARSE::operator() (VECTOR& x, const VECTOR& b)
  * @endcode
- * returning the solution to the system @p{Ax=b} on the coarsest level
+ * returning the solution to the system <tt>Ax=b</tt> on the coarsest level
  * in <i>x</i>.
  * 
  * @author Guido Kanschat, 1999 - 2004
@@ -124,10 +124,10 @@ class Multigrid : public Subscriptor
                                      * the outer defect correction
                                      * scheme (usually performed by
                                      * PreconditionMG). After
-                                     * execution of @p{vcycle()}, the
+                                     * execution of <tt>vcycle()</tt>, the
                                      * result is in the vector
                                      * @p solution. See
-                                     * @p{copy_*_mg} in class
+                                     * <tt>copy_*_mg</tt> in class
                                      * @p MGTools if you want to use
                                      * these vectors yourself.
                                      *
@@ -245,9 +245,9 @@ class Multigrid : public Subscriptor
  * and provide the standard interface for LAC iterative methods.
  *
  * The template parameter class @p MG is required to inherit @p MGBase.
- * Furthermore, it needs functions @p{void copy_to_mg(const VECTOR&)}
+ * Furthermore, it needs functions <tt>void copy_to_mg(const VECTOR&)</tt>
  * 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.
+ * <tt>void copy_from_mg(VECTOR&)</tt> to store the result of the v-cycle in @p dst.
  *
  * @author Guido Kanschat, 1999, 2000, 2001, 2002
  */
index 0abac4f45e5e6e87be5528d22536942a5cc10eac..5205853b53f8007da609198d93681bb3d8146834 100644 (file)
@@ -72,11 +72,11 @@ template <int>      class FEValuesBase;
  * components ("x-displacement" and "y-displacement") while the error estimator
  * probably is a vector holding cell data. When attaching a data vector, you have
  * 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
+ * of type <tt>vector<string></tt> 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 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>}.
+ * of the <tt>vector<string></tt>.
  *
  * 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
@@ -101,7 +101,7 @@ template <int>      class FEValuesBase;
  * 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
  * example, but you can select it by a run-time parameter without having
- * to write the @p{if () ... else ...} clauses yourself), and also functions
+ * to write the <tt>if () ... else ...</tt> clauses yourself), and also functions
  * and classes offering ways to control the appearance of the output by
  * setting flags for each output format.
  * 
@@ -212,7 +212,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                      * stored, so you have to make
                                      * sure the vector exists at that
                                      * address at least as long as
-                                     * you call the @p{write_*}
+                                     * you call the <tt>write_*</tt>
                                      * functions.
                                      *
                                      * It is assumed that the vector
@@ -751,7 +751,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
  * and so on.
  *
  * 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
+ * more of the <tt>write_*</tt> functions of the base classes. You can therefore
  * output the same data in more than one format without having to rebuild
  * the patches.
  *
@@ -811,7 +811,7 @@ class DataOut : public DataOut_DoFData<dim,dim>
                                      * mode. The default number of
                                      * threads to be used to build
                                      * the patches is set to
-                                     * @p{multithread_info.n_default_threads}.
+                                     * <tt>multithread_info.n_default_threads</tt>.
                                      */
     virtual void build_patches (const unsigned int n_subdivisions = 1,
                                const unsigned int n_threads      = multithread_info.n_default_threads);
@@ -831,7 +831,7 @@ class DataOut : public DataOut_DoFData<dim,dim>
                                      * Return the next cell after
                                      * @p cell which we want output
                                      * for.  If there are no more
-                                     * cells, @p{dofs->end()} shall
+                                     * cells, <tt>dofs->end()</tt> shall
                                      * be returned.
                                      *
                                      * The default implementation
@@ -869,7 +869,7 @@ class DataOut : public DataOut_DoFData<dim,dim>
                                      *
                                      * The @p index_to_patch_map is
                                      * an array that stores for index
-                                     * @p{[i][j]} the number of the
+                                     * <tt>[i][j]</tt> the number of the
                                      * patch that associated with the
                                      * cell with index @p j on level
                                      * @p i. This information is set
index 752d1f7434c9baecb7a9c1c86c3b1eb0a7057bb6..72790424bff45aecf85804ffc4877ef373ae9f5a 100644 (file)
@@ -97,7 +97,7 @@ class DataOutFaces : public DataOut_DoFData<dim,dim-1,dim>
                                      * mode. The default number of
                                      * threads to be used to build
                                      * the patches is set to
-                                     * @p{multithread_info.n_default_threads}.
+                                     * <tt>multithread_info.n_default_threads</tt>.
                                      */
     virtual void
     build_patches (const unsigned int n_subdivisions = 1,
@@ -109,7 +109,7 @@ 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
-                                     * DoFHandler@p{<dim>::fec_iterator},
+                                     * DoFHandler<tt><dim>::fec_iterator</tt>,
                                      * but since we have to describe
                                      * faces to objects of type
                                      * FEValues, we can only
@@ -137,7 +137,7 @@ class DataOutFaces : public DataOut_DoFData<dim,dim-1,dim>
                                      * Return the next face after
                                      * @p face which we want output
                                      * for.  If there are no more
-                                     * face, @p{dofs->end()} shall be
+                                     * face, <tt>dofs->end()</tt> shall be
                                      * returned as the first
                                      * component of the return value.
                                      *
index 40f210789538e8772e7dc93571fd82db8931897d..d2b28f528b7e756a072b8727760b95cc8b7a236f 100644 (file)
@@ -108,7 +108,7 @@ class DataOutRotation : public DataOut_DoFData<dim,dim+1>
                                      * mode. The default number of
                                      * threads to be used to build
                                      * the patches is set to
-                                     * @p{multithread_info.n_default_threads}.
+                                     * <tt>multithread_info.n_default_threads</tt>.
                                      */
     virtual void build_patches (const unsigned int n_patches_per_circle,
                                const unsigned int n_subdivisions = 1,
@@ -130,7 +130,7 @@ class DataOutRotation : public DataOut_DoFData<dim,dim+1>
                                      * Return the next cell after @p cell which
                                      * we want output for.
                                      * If there are no more cells,
-                                     * @p{dofs->end()} shall be returned.
+                                     * <tt>dofs->end()</tt> shall be returned.
                                      *
                                      * The default
                                      * implementation returns the next
index d1e2140e7da809cd107e11d8666d47e01be21192..2eec27b49bd4052e0ecdfffaf72dc50ab018b381 100644 (file)
@@ -171,7 +171,7 @@ class DataOutStack : public DataOutInterface<dim+1>
                                      * component and therefore more than one
                                      * name needs to be given. However, you
                                      * can also call this function with a
-                                     * @p{vector<string>} containing only one
+                                     * <tt>vector<string></tt> containing only one
                                      * element if the finite element has
                                      * only one component.
                                      */
@@ -218,7 +218,7 @@ class DataOutStack : public DataOutInterface<dim+1>
                                      * component and therefore more than one
                                      * name needs to be given. However, you
                                      * can also call this function with a
-                                     * @p{vector<string>} containing only one
+                                     * <tt>vector<string></tt> containing only one
                                      * element if the finite element has
                                      * only one component.
                                      *
index d3ba08ec8926b00533d34448eeae095481c9b08d..9f58efb16092dc2d0af12dffd3efa7a17cd19eeb 100644 (file)
@@ -44,7 +44,7 @@
  * Objects of this class are provided with a solver class through a
  * 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
+ * <tt>basename.[step].[suffix]</tt>) and into which the solution is
  * written as a finite element field using the DataOut class.
  * Please note that this class may produce enormous amounts of data!
  *
@@ -62,7 +62,7 @@ class DoFPrintSolverStep : public SOLVER
                                      * finite element function.
                                      *
                                      * One output file with the name
-                                     * @p{basename.[step].[suffix]}
+                                     * <tt>basename.[step].[suffix]</tt>
                                      * will be produced for each
                                      * iteration step.
                                      */
index e0cd6f62c00fe5ca8b088e204965300a39727db0..5d6ba134a91162c67f883db8b38416b1091399e0 100644 (file)
@@ -49,7 +49,7 @@ 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 Triangulation@p{<dim>::refine_*} functions. This
+ *  can be used to feed the Triangulation<tt><dim>::refine_*</tt> 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.
@@ -249,7 +249,7 @@ class KellyErrorEstimator
                                      * The estimator supports
                                      * multithreading and splits the
                                      * cells to
-                                     * @p{multithread_info.n_default_threads}
+                                     * <tt>multithread_info.n_default_threads</tt>
                                      * (default) threads. The number
                                      * of threads to be used in
                                      * multithreaded mode can be set
@@ -502,7 +502,7 @@ class KellyErrorEstimator
                                          * on one cell
                                          *
                                          * Let psi be a short name
-                                         * for @p{a grad u_h}, where
+                                         * for <tt>a grad u_h</tt>, where
                                          * the third index be the
                                          * component of the finite
                                          * element, and the second
@@ -562,7 +562,7 @@ class KellyErrorEstimator
                                      * Computates the error on all cells
                                      * of the domain with the number n,
                                      * satisfying
-                                     * @p{n=this_thread (mod n_threads)}
+                                     * <tt>n=this_thread (mod n_threads)</tt>
                                      * This enumeration is chosen to
                                      * generate a random distribution
                                      * of all cells.
@@ -719,7 +719,7 @@ class KellyErrorEstimator<1>
                                      *
                                      * The estimator supports multithreading
                                      * and splits the cells to
-                                     * @p{multithread_info.n_default_threads}
+                                     * <tt>multithread_info.n_default_threads</tt>
                                      * (default) threads. The number of
                                      * threads to be used in multithreaded
                                      * mode can be set with the last
@@ -745,7 +745,7 @@ class KellyErrorEstimator<1>
                                     /**
                                      * Calls the @p estimate
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1<1>()}.
+                                     * <tt>mapping=MappingQ1<1>()</tt>.
                                      */    
     template <typename InputVector>
     static void estimate (const DoFHandler<1>   &dof,
@@ -800,7 +800,7 @@ class KellyErrorEstimator<1>
                                     /**
                                      * Calls the @p estimate
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1<1>()}.
+                                     * <tt>mapping=MappingQ1<1>()</tt>.
                                      */
     template <typename InputVector>
     static void estimate (const DoFHandler<1>       &dof,
index d5961bf1bcd4456c795eb297c6344ec1e98e9110..59a9b0758a05554ec6fd37d2305fa5413433b419 100644 (file)
@@ -85,7 +85,7 @@ class Histogram
                                      *
                                      * The histograms will be arranged such
                                      * that the computed intervals of the
-                                     * @p{values[i][j]} form the x-range,
+                                     * <tt>values[i][j]</tt> form the x-range,
                                      * and the number of values in each
                                      * interval will be the y-range (for
                                      * 2d plots) or the z-range (for 3d
@@ -97,7 +97,7 @@ class Histogram
                                      * the @p y_values are ignored.
                                      *
                                      * If you give only one data set, i.e.
-                                     * @p{values.size()==1}, then the
+                                     * <tt>values.size()==1</tt>, then the
                                      * resulting histogram will be a 2d
                                      * one.
                                      *
@@ -233,8 +233,8 @@ class Histogram
                                      * logarithmic case interval spacing
                                      * scheme.
                                      *
-                                     * Return @p true, if (@p{n1<n2},
-                                     * and (@p{n1>0} or @p{n2<0})), or
+                                     * Return @p true, if (<tt>n1<n2</tt>,
+                                     * and (<tt>n1>0</tt> or <tt>n2<0</tt>)), or
                                      * (n2<n1 and n1>0 and n2<=0). This
                                      * in effect sorts all negativ
                                      * numbers to be larger than the
index 1a0147d38480ebe6eadf22de32e17940543a45a4..5229c350c79921fb1184a130cab003c1f8b4e97c 100644 (file)
@@ -74,7 +74,7 @@ namespace PETScWrappers
  * created. The functions assume that the matrix is initialized with a
  * 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 DoFHandler@p{<dim>::make_sparsity_pattern}
+ * You can do this by calling the DoFHandler<tt><dim>::make_sparsity_pattern</tt>
  * function.
  *
  * Furthermore it is assumed that no relevant data is in the matrix. All
@@ -95,7 +95,7 @@ namespace PETScWrappers
  *
  * If you want to use boundary conditions with the matrices generated
  * by the functions of this class, you have to use a function like
- * @p{ProblemBase<>::apply_dirichlet_bc} to matrix and right hand
+ * <tt>ProblemBase<>::apply_dirichlet_bc</tt> to matrix and right hand
  * side.
  *
  *
@@ -147,7 +147,7 @@ namespace PETScWrappers
  * 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
+ * <tt>unsigned char</tt>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
@@ -403,7 +403,7 @@ class MatrixCreator
                                      * pairs of DoF handler cell
                                      * iterators. This type works
                                      * just like a
-                                     * @p{std::pair<iterator,iterator>}
+                                     * <tt>std::pair<iterator,iterator></tt>
                                      * but is templatized on the
                                      * space dimension.
                                      */
@@ -619,17 +619,17 @@ class MatrixCreator
  * 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
  * 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
+ * an <tt>O(N*log(m))</tt> operation, since searching in each row takes
+ * <tt>log(m)</tt> operations). If your sparsity pattern is symmetric, but
  * 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
+ * <tt>O(m*log(m))</tt>, 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
- * would be @p{O(N*sqrt(N)*log(m))} for the general case; the latter
+ * number of boundary nodes is <tt>sqrt(N)</tt> in 2d, the algorithm for
+ * symmetric sparsity patterns is <tt>O(sqrt(N)*m*log(m))</tt>, while it
+ * would be <tt>O(N*sqrt(N)*log(m))</tt> for the general case; the latter
  * is too expensive to be performed.
  *
  * It seems as if we had to make clear not to overwrite the lines of
index 05a2396b8f25be4af90fd9d1ef14352820c16abc..893648602b170838cfb9874388c2cf85ed95bbee 100644 (file)
  * @endverbatim
  *
  * Multiple calls to the function 
- * @p{interpolate (const Vector<number> &in, Vector<number> &out)}
+ * <tt>interpolate (const Vector<number> &in, Vector<number> &out)</tt>
  * 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},
+ * <tt>void interpolate (const vector<Vector<number> >&all_in, vector<Vector<number> >&all_out) const</tt>,
  * 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).
  * </ul>
  *
  * For deleting all stored data in @p SolutionTransfer and reinitializing it
- * use the @p{clear()} function.
+ * use the <tt>clear()</tt> function.
  *
  * Note that the @p user_pointer of some cells are used. 
  * Be sure that you don't need them otherwise.
  * 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
- * DoFHandler@p{::distribute_dofs(...)} will change at least some of the
+ * DoFHandler<tt>::distribute_dofs(...)</tt> 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
  * is used to point to the vector of these DoF indices of that cell, all other
  * @p user_pointers are cleared. All this is
- * done by @p{prepare_for_pure_refinement()}.
+ * done by <tt>prepare_for_pure_refinement()</tt>.
  *
- * In the function @p{refine_interpolate(in,out)} and on each cell where the
+ * In the function <tt>refine_interpolate(in,out)</tt> 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
  * 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.
  *
- * The @p{refine_interpolate(in,out)} function can be called multiply for
+ * The <tt>refine_interpolate(in,out)</tt> function can be called multiply for
  * arbitrary many discrete functions (solution vectors) on the original grid. 
  *
  * <li> Solution transfer while coarsening and refinement. After 
  * Additionally the DoF indices of the cells
  * that will not be coarsened need to be stored according to the solution
  * transfer while pure refinement (cf there). All this is performed by
- * @p{prepare_for_coarsening_and_refinement(all_in)} where the 
- * @p{vector<Vector<number> >vector all_in} includes
+ * <tt>prepare_for_coarsening_and_refinement(all_in)</tt> where the 
+ * <tt>vector<Vector<number> >vector all_in</tt> includes
  * all discrete functions to be interpolated onto the new grid.
  *
- * 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)
+ * As we need two different kinds of pointers (<tt>vector<unsigned int> *</tt> for the Dof
+ * indices and <tt>vector<Vector<number> > *</tt> 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. 
  * 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
+ * <tt>void * user_pointer</tt> as <tt>vector<unsigned int> *</tt> at one time and as 
+ * <tt>vector<Vector<number> > *</tt> 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.
  * 
- * In @p{interpolate(all_in, all_out)} the refined cells are treated according
+ * In <tt>interpolate(all_in, all_out)</tt> the refined cells are treated according
  * 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 
  * 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.
- * 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.
+ * It is clear that <tt>interpolate(all_in, all_out)</tt> only can be called with
+ * the <tt>vector<Vector<number> > all_in</tt> that previously was the parameter
+ * of the <tt>prepare_for_coarsening_and_refinement(all_in)</tt> function. Hence 
+ * <tt>interpolate(all_in, all_out)</tt> can (in contrast to 
+ * <tt>refine_interpolate(in, out)</tt>) only be called once.
  * </ul>
  *
  * @author Ralf Hartmann, 1999
@@ -262,8 +262,8 @@ class SolutionTransfer
                                      * 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})
+                                     * right sizes (i.e. <tt>in.size()==n_dofs_old</tt>,
+                                     * <tt>out.size()==n_dofs_refined</tt>)
                                              *
                                      * Calling this function is allowed only
                                      * if @p prepare_for_pure_refinement is called
@@ -277,7 +277,7 @@ class SolutionTransfer
                             Vector<number> &out) const;
     
                                     /**
-                                     * Same as @p{interpolate(in,out)}
+                                     * Same as <tt>interpolate(in,out)</tt>
                                      * but it interpolates
                                      * just 'in-place'. Therefore @p vec will be
                                      * reinitialized to the new needed vector
@@ -293,7 +293,7 @@ class SolutionTransfer
                                      * It assumes the vectors in @p all_in
                                      * denote the same vectors
                                      * as in @p all_in as parameter of
-                                     * @p{prepare_for_refinement_and_coarsening(all_in)}.
+                                     * <tt>prepare_for_refinement_and_coarsening(all_in)</tt>.
                                      * However, there is no way of verifying
                                      * this internally, so be careful here.
                                      *
@@ -326,14 +326,14 @@ class SolutionTransfer
                                      * Same as the previous function.
                                      * It interpolates only one function.
                                      * It assumes the vectors having the
-                                     * right sizes (i.e. @p{in.size()==n_dofs_old},
-                                     * @p{out.size()==n_dofs_refined})
+                                     * right sizes (i.e. <tt>in.size()==n_dofs_old</tt>,
+                                     * <tt>out.size()==n_dofs_refined</tt>)
                                      * 
                                      * Multiple calling of this function is
                                      * NOT allowed. Interpolating
                                      * several functions can be performed
                                      * in one step by using
-                                     * @p{interpolate (all_in, all_out)}
+                                     * <tt>interpolate (all_in, all_out)</tt>
                                      */
     void interpolate (const Vector<number> &in,
                      Vector<number>       &out) const;
@@ -436,9 +436,9 @@ class SolutionTransfer
                                      * data need to be packetized in a structure.
                                      * Note that in our case on each cell
                                      * either the
-                                     * @p{vector<unsigned int> indices} (if the cell
+                                     * <tt>vector<unsigned int> indices</tt> (if the cell
                                      * will be refined) or the
-                                     * @p{vector<double> dof_values} (if the
+                                     * <tt>vector<double> dof_values</tt> (if the
                                      * children of this cell will be deleted)
                                      * is needed, hence one @p user_pointer should
                                      * be sufficient, but to allow some errorchecks
@@ -457,7 +457,7 @@ class SolutionTransfer
                                      * Vector of all @p Pointerstructs (cf. there).
                                      * It makes it
                                      * easier to delete all these structs
-                                     * (without going over all @p{cell->user_pointer})
+                                     * (without going over all <tt>cell->user_pointer</tt>)
                                      * after they are not used any more, and
                                      * collecting all these structures in a vector
                                      * helps avoiding fraqmentation of the memory.
index 5c8ddb9d2e2b27835331b9a0d6d28f6b02d3d923..095ccfb7074467d06fa08755f77061604ae8623f 100644 (file)
@@ -140,7 +140,7 @@ template <int dim> class Triangulation;
  * management, data reload and storage into one set of functions and
  * computations into another.
  *
- * In the example above, possible actions might be: timestep @p{n+1} rebuilds
+ * In the example above, possible actions might be: timestep <tt>n+1</tt> 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
  * size, maybe using an initial guess; then it does the computations; then
@@ -271,7 +271,7 @@ template <int dim> class Triangulation;
  * to be run.
  *
  * 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 <tt>C++</tt> 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:
  * @verbatim
@@ -297,7 +297,7 @@ template <int dim> class Triangulation;
  * 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}.
+ * outside <tt>0..n_timesteps-1</tt>.
  * @verbatim
  *   template <typename InitFunctionObject, typename LoopFunctionObject>
  *   void TimeDependent::do_loop (InitFunctionObject      init_function,
@@ -442,7 +442,7 @@ class TimeDependent
                                     /**
                                      * Destructor. This will delete the
                                      * objects pointed to by the pointers
-                                     * given to the @p{insert_*} and
+                                     * given to the <tt>insert_*</tt> and
                                      * @p add_timestep functions, i.e.
                                      * it will delete the objects doing
                                      * the computations on each time step.
@@ -593,7 +593,7 @@ class TimeDependent
                                      *
                                      * Instead of using the above form, you can
                                      * equally well use
-                                     * @p{bind2nd(mem_fun1(&X::unary_function), arg)} 
+                                     * <tt>bind2nd(mem_fun1(&X::unary_function), arg)</tt> 
                                      * which lets the @p do_loop
                                      * function call teh given function with
                                      * the specified parameter. Note that you
@@ -733,7 +733,7 @@ class TimeDependent
   private:
 
                                     /**
-                                     * Do the work of @p{end_sweep()}
+                                     * Do the work of <tt>end_sweep()</tt>
                                      * for some timesteps only. This
                                      * is useful in multithread mode.
                                      */
@@ -1052,7 +1052,7 @@ class TimeStepBase : public Subscriptor
                                      * problem is actual, or any of
                                      * the other actions
                                      * specified. This variable is
-                                     * set by the @p{init_for_*}
+                                     * set by the <tt>init_for_*</tt>
                                      * functions.
                                      */
     unsigned int next_action;
@@ -1297,9 +1297,9 @@ namespace TimeStepBase_Tria_Flags
  *   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
- *   certain factor. For example, if this list was @p{((100 5) (200 3) (500 2))},
+ *   certain factor. For example, if this list was <tt>((100 5) (200 3) (500 2))</tt>,
  *   this would mean that for grids with a cell number below 100, the
- *   @p{cell_number_corridor_*} variables are to be multiplied by 5 before they
+ *   <tt>cell_number_corridor_*</tt> variables are to be multiplied by 5 before they
  *   are applied, for cell numbers below 200 they are to be multiplied by 3,
  *   and so on.
  *
@@ -1660,7 +1660,7 @@ class TimeStepBase_Tria : public TimeStepBase
                                      * destroy it in the @p sleep function.
                                      * It does so also the first time we
                                      * hit this function and @p wakeup_level
-                                     * equals @p{flags.wakeup_level_to_build_grid},
+                                     * equals <tt>flags.wakeup_level_to_build_grid</tt>,
                                      * independently of the value of the
                                      * mentioned flag. (Actually, it does so
                                      * whenever the triangulation pointer
index fc75dee92b409c66c391e44f37a59b60305d74f5..86e78e04020472fd6bc38feab5e9593f5632328c 100644 (file)
@@ -153,7 +153,7 @@ class ConstraintMatrix;
  * <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
- *   MatrixCreator@p{::create_*} functions which take a right hand side do,
+ *   MatrixCreator<tt>::create_*</tt> functions which take a right hand side do,
  *   but without assembling a matrix.
  *
  * <li> Creation of boundary right hand side vectors: The
@@ -170,7 +170,7 @@ class ConstraintMatrix;
  *   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.
  *   To use it, you have to
- *   specify a list of pairs of boundary indicators (of type @p{unsigned char};
+ *   specify a list of pairs of boundary indicators (of type <tt>unsigned char</tt>;
  *   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.
@@ -227,7 +227,7 @@ class ConstraintMatrix;
  *   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
- *   promoted with the @p{++} operator.
+ *   promoted with the <tt>++</tt> operator.
  * 
  *   You can use the @p distribute_cell_to_dof_vector function of the
  *   DoFHandler class to convert cell based data to a data
@@ -268,17 +268,17 @@ class ConstraintMatrix;
  * 
  *   To get the global <i>L<sup>1</sup></i> error, you have to sum up the
  *   entries in @p difference, e.g. using
- *   Vector@p{<double>::l1_norm} function.  For the global <i>L<sup>2</sup></i>
+ *   Vector<tt><double>::l1_norm</tt> 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
- *   Vector@p{<double>::l2_norm}.  These two operations
+ *   Vector<tt><double>::l2_norm</tt>.  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 Vector@p{<double>::linfty_norm} function.
+ *   using the Vector<tt><double>::linfty_norm</tt> 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.
@@ -374,7 +374,7 @@ class VectorTools
                                      * @p dof.
                                      *
                                      * Note that you may have to call
-                                     * @p{hanging_nodes.distribute(vec)}
+                                     * <tt>hanging_nodes.distribute(vec)</tt>
                                      * with the hanging nodes from
                                      * space @p dof afterwards, to
                                      * make the result continuous
@@ -414,7 +414,7 @@ class VectorTools
                                      * are neglected so far.
                                      *
                                      * Note that you may have to call
-                                     * @p{hanging_nodes.distribute(data_2)}
+                                     * <tt>hanging_nodes.distribute(data_2)</tt>
                                      * with the hanging nodes from
                                      * space @p dof_2 afterwards, to
                                      * make the result continuous
@@ -494,7 +494,7 @@ class VectorTools
                                     /**
                                      * Calls the @p project
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1@<dim@>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim>
     static void project (const DoFHandler<dim>    &dof,
@@ -525,7 +525,7 @@ class VectorTools
                                     /**
                                      * Calls the @p create_right_hand_side
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1@<dim@>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim>
     static void create_right_hand_side (const DoFHandler<dim> &dof,
@@ -569,7 +569,7 @@ class VectorTools
                                      * Calls the
                                      * @p create_boundary_right_hand_side
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1@<dim@>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim>
     static void create_boundary_right_hand_side (const DoFHandler<dim>   &dof,
@@ -700,7 +700,7 @@ class VectorTools
                                      * Calls the other
                                      * @p interpolate_boundary_values
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1@<dim@>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim>
     static void interpolate_boundary_values (const DoFHandler<dim>         &dof,
@@ -713,7 +713,7 @@ class VectorTools
                                      * Calls the other
                                      * @p interpolate_boundary_values
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1@<dim@>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim>
     static void interpolate_boundary_values (const DoFHandler<dim>         &dof,
@@ -765,7 +765,7 @@ class VectorTools
                                     /**
                                      * Calls the @p project_boundary_values
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1@<dim@>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim>
     static void project_boundary_values (const DoFHandler<dim>    &dof,
@@ -832,7 +832,7 @@ class VectorTools
                                     /**
                                      * Calls the @p integrate_difference
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1@<dim@>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim, class InVector, class OutVector>
     static void integrate_difference (const DoFHandler<dim> &dof,
@@ -929,7 +929,7 @@ class VectorTools
                                     /**
                                      * Calls the @p compute_mean_value
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1@<dim@>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim, class InVector>
     static double compute_mean_value (const DoFHandler<dim> &dof,
index b8736360f35b5d01db9e83bdf34d13a85dbdb042..431f35b4d8ceec3dcca0675c2d73c75336681005 100644 (file)
@@ -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 <tt>n[i]</tt>. The
                                      * number of blocks will be the
                                      * size of the vector
                                      */
@@ -65,7 +65,7 @@ class BlockIndices
                                      * of blocks will be adjusted to
                                      * the size of @p n and the size
                                      * of block @p i is set to
-                                     * @p{n[i]}.
+                                     * <tt>n[i]</tt>.
                                      */
     inline void reinit (const std::vector<unsigned int> &n);
     
index 10b86238469d8054cd2371f6403de5c2c572d120..829d06af593593701d00d7061792a8a7d5541a53 100644 (file)
@@ -42,12 +42,12 @@ template <typename> class Vector;
  * Block matrix composed of different single matrices.
  *
  * 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}.
+ * block matrix with block entries of the form <tt>M_{jk</tt> = s_{jk}A_i}.
  * 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
- * location @p{(i,j)} several times will add the corresponding
+ * location <tt>(i,j)</tt> several times will add the corresponding
  * matrices in matrix-vector multiplications.
  *
  * @sect3{Requirements}
@@ -55,7 +55,7 @@ template <typename> class Vector;
  * 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
+ * <tt>BlockVector<VECTOR></tt>. SparseMatrix is a possible entry
  * type.
  *
  * @author Guido Kanschat, 2000, 2001
index 17b6dfdca5eade977a61a93c1c1a47a227a61733..0d8ea22f7b9e2293f366ca9bf967ce035528ae12 100644 (file)
@@ -195,7 +195,7 @@ class BlockSparseMatrixEZ : public Subscriptor
     unsigned int n () const;
 
                                     /**
-                                     * Set the element @p{(i,j)} to
+                                     * Set the element <tt>(i,j)</tt> to
                                      * @p value.  Throws an error if
                                      * the entry does not
                                      * exist. Still, it is allowed to
@@ -208,7 +208,7 @@ class BlockSparseMatrixEZ : public Subscriptor
     
                                     /**
                                      * Add @p value to the element
-                                     * @p{(i,j)}.  Throws an error if
+                                     * <tt>(i,j)</tt>.  Throws an error if
                                      * the entry does not
                                      * exist. Still, it is allowed to
                                      * store zero values in
index c1d1e1ca0735d8f6847cc5687f6f0daad0b379ca..c584da7f48964d20a886e563409fa37f32989f12 100644 (file)
@@ -48,12 +48,12 @@ class CompressedBlockSparsityPattern;
  * 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
- * @p{block(row,col)} function.
+ * <tt>block(row,col)</tt> function.
  *
  * Attention: this object is not automatically notified if the size of
  * one of its subobjects' size is changed. After you initialize the
  * sizes of the subobjects, you will therefore have to call the
- * @p{collect_sizes()} function of this class! Note that, of course, all
+ * <tt>collect_sizes()</tt> function of this class! Note that, of course, all
  * sub-matrices in a (block-)row have to have the same number of rows, and
  * that all sub-matrices in a (block-)column have to have the same number of
  * columns.
@@ -264,7 +264,7 @@ class BlockSparsityPatternBase : public Subscriptor
                                      * bad happens.
                                      *
                                      * This function simply finds out
-                                     * to which block @p{(i,j)} belongs
+                                     * to which block <tt>(i,j)</tt> belongs
                                      * and then relays to that block.
                                      */
     void add (const unsigned int i, const unsigned int j);
@@ -571,7 +571,7 @@ BlockSparsityPatternBase<SparsityPatternBase>::add (const unsigned int i,
 {
                                   // if you get an error here, are
                                   // you sure you called
-                                  // @p{collect_sizes()} before?
+                                  // <tt>collect_sizes()</tt> before?
   const std::pair<unsigned int,unsigned int>
     row_index = row_indices.global_to_local (i),
     col_index = column_indices.global_to_local (j);
@@ -589,7 +589,7 @@ BlockSparsityPatternBase<SparsityPatternBase>::exists (const unsigned int i,
 {
                                   // if you get an error here, are
                                   // you sure you called
-                                  // @p{collect_sizes()} before?
+                                  // <tt>collect_sizes()</tt> before?
   const std::pair<unsigned int,unsigned int>
     row_index = row_indices.global_to_local (i),
     col_index = column_indices.global_to_local (j);
index 87bad9a88cde7c4bf43b6c83c08b42433dbf7a4a..acace609fff9bfb1e857549cc4a7de95ff0aa27b 100644 (file)
@@ -131,7 +131,7 @@ class CompressedSparsityPattern : public Subscriptor
                                      * if yo want to use the STL data types
                                      * on classes like this, e.g. to write
                                      * such statements like
-                                     * @p{v.push_back (CompressedSparsityPattern());},
+                                     * <tt>v.push_back (CompressedSparsityPattern());</tt>,
                                      * with @p v a vector of @p CompressedSparsityPattern
                                      * objects.
                                      *
@@ -246,7 +246,7 @@ class CompressedSparsityPattern : public Subscriptor
                                      * and which can be used to plot the
                                      * sparsity pattern in a graphical
                                      * way. The format consists of pairs
-                                     * @p{i j} of nonzero elements, each
+                                     * <tt>i j</tt> of nonzero elements, each
                                      * representing one entry of this
                                      * matrix, one per line of the output
                                      * file. Indices are counted from
@@ -255,7 +255,7 @@ class CompressedSparsityPattern : public Subscriptor
                                      * way as matrices are displayed, we
                                      * print the negative of the column
                                      * index, which means that the
-                                     * @p{(0,0)} element is in the top left
+                                     * <tt>(0,0)</tt> element is in the top left
                                      * rather than in the bottom left
                                      * corner.
                                      *
index 0b9c60f0c607bbdea105563eb6d958fd6bb1bdfd..bee82cab5bfdcdf1adf53dec52e668cb26e4cfd0 100644 (file)
@@ -172,8 +172,8 @@ template <typename number> class Vector;
  * 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=}.
+ * provide access to indivual elements through <tt>operator()</tt>,
+ * assignment through <tt>operator=</tt>.
  *
  *
  * @sect3{Thread-safety}
@@ -273,7 +273,7 @@ class FilteredMatrix : public Subscriptor
                                      * @p std::vector of
                                      * IndexValuePair objects,
                                      * but also a
-                                     * @p{std::map<unsigned,value_type>}.
+                                     * <tt>std::map<unsigned,value_type></tt>.
                                      *
                                      * It is an error if the argument
                                      * contains an entry for a degree
@@ -283,7 +283,7 @@ class FilteredMatrix : public Subscriptor
                                      * assumed that the list of
                                      * constraints is sorted. If the
                                      * input argument is a
-                                     * @p{std::map<unsigned,value_type>},
+                                     * <tt>std::map<unsigned,value_type></tt>,
                                      * this is automatically the
                                      * case.
                                      *
@@ -400,9 +400,9 @@ class FilteredMatrix : public Subscriptor
 
                                     /**
                                      * Compute the residual of an
-                                     * equation @p{Mx=b}, where the
+                                     * equation <tt>Mx=b</tt>, where the
                                      * residual is defined to be
-                                     * @p{r=b-Mx} with @p x
+                                     * <tt>r=b-Mx</tt> with @p x
                                      * typically being an approximate
                                      * of the true solution of the
                                      * equation. Write the residual
index d42ef8345a9b9a10aa0dbdbae53af2ba6d575b5c..e7f2aa8b611ea72cc244a237d45a2d6fbeff6e5f 100644 (file)
@@ -182,7 +182,7 @@ class MatrixOut : public DataOutInterface<2,2>
                                      * size of the matrix, for which
                                      * we assume that the matrix type
                                      * offers member functions
-                                     * @p{m()} and @p{n()}, which
+                                     * <tt>m()</tt> and <tt>n()</tt>, which
                                      * return the number of rows and
                                      * columns, respectively.
                                      */
@@ -272,7 +272,7 @@ class MatrixOut : public DataOutInterface<2,2>
                                      * for which no specialization of
                                      * this function was declared
                                      * above. This will call
-                                     * @p{operator()} on the matrix.
+                                     * <tt>operator()</tt> on the matrix.
                                      */
     template <class Matrix>
     static double get_element (const Matrix       &matrix,
@@ -281,7 +281,7 @@ class MatrixOut : public DataOutInterface<2,2>
 
                                     /**
                                      * Get the value of the matrix at
-                                     * gridpoint @p{(i,j)}. Depending
+                                     * gridpoint <tt>(i,j)</tt>. Depending
                                      * on the given flags, this can
                                      * mean different things, for
                                      * example if only absolute
index 4c86b80da2e93d0bc3d1d89292d64d2cb5939fd4..e4c12249af761426448f92e7131010b3131b3a0b 100644 (file)
@@ -368,7 +368,7 @@ namespace PETScWrappers
                                         * does not transmit this information.
                                         *
                                         * This function is therefore exactly
-                                        * equivalent to the @p{el()} function.
+                                        * equivalent to the <tt>el()</tt> function.
                                         */
       PetscScalar operator () (const unsigned int i,
                                const unsigned int j) const;
index 3f719d502080a823ee5f8d19e7ef3cd80cf498fc..93e05d0d3c903f94800f6bc828b73bea50e7a09d 100644 (file)
@@ -75,7 +75,7 @@ namespace PETScWrappers
                                           * whether we should tell PETSc that
                                           * the matrix is going to be symmetric
                                           * (as indicated by the call
-                                          * @p{MatSetOption(mat,MAT_SYMMETRIC)}. Note
+                                          * <tt>MatSetOption(mat,MAT_SYMMETRIC)</tt>. Note
                                           * that the PETSc documentation states
                                           * that one cannot form an ILU
                                           * decomposition of a matrix for which
@@ -108,7 +108,7 @@ namespace PETScWrappers
                                           * whether we should tell PETSc that
                                           * the matrix is going to be symmetric
                                           * (as indicated by the call
-                                          * @p{MatSetOption(mat,MAT_SYMMETRIC)}. Note
+                                          * <tt>MatSetOption(mat,MAT_SYMMETRIC)</tt>. Note
                                           * that the PETSc documentation states
                                           * that one cannot form an ILU
                                           * decomposition of a matrix for which
index 5f70be46a0ea9402f867cad7c2e8d51bdf4e4b31..411f1bb8b043c8f716d07e4a949a0d78362b4b48 100644 (file)
@@ -165,11 +165,11 @@ namespace PETScWrappers
                                           * 
                                           * The constructor is made explicit
                                           * to avoid accidents like this:
-                                          * @p{v=0;}. Presumably, the user
+                                          * <tt>v=0;</tt>. Presumably, the user
                                           * wants to set every element of the
                                           * vector to zero, but instead, what
                                           * happens is this call:
-                                          * @p{v=Vector<number>(0);}, i.e. the
+                                          * <tt>v=Vector<number>(0);</tt>, i.e. the
                                           * vector is replaced by one of
                                           * length zero.
                                           */
index 80ab0021a7f180fdcf81a81aa68af5acf3629173..629400148d623cf0208016a0a145ccb2c7410225 100644 (file)
@@ -66,7 +66,7 @@ namespace PETScWrappers
                                         * whether we should tell PETSc that
                                         * the matrix is going to be symmetric
                                         * (as indicated by the call
-                                        * @p{MatSetOption(mat,MAT_SYMMETRIC)}. Note
+                                        * <tt>MatSetOption(mat,MAT_SYMMETRIC)</tt>. Note
                                         * that the PETSc documentation states
                                         * that one cannot form an ILU
                                         * decomposition of a matrix for which
@@ -97,7 +97,7 @@ namespace PETScWrappers
                                         * whether we should tell PETSc that
                                         * the matrix is going to be symmetric
                                         * (as indicated by the call
-                                        * @p{MatSetOption(mat,MAT_SYMMETRIC)}. Note
+                                        * <tt>MatSetOption(mat,MAT_SYMMETRIC)</tt>. Note
                                         * that the PETSc documentation states
                                         * that one cannot form an ILU
                                         * decomposition of a matrix for which
index c72d3800ee3a712c20fd5a57859afbeb70dd42fa..cf568b382fffd6ec1467a20f208ddceb206c8122 100644 (file)
@@ -58,10 +58,10 @@ namespace PETScWrappers
                                         *
                                         * The constructor is made explicit to
                                         * avoid accidents like this:
-                                        * @p{v=0;}. Presumably, the user wants
+                                        * <tt>v=0;</tt>. Presumably, the user wants
                                         * to set every element of the vector to
                                         * zero, but instead, what happens is
-                                        * this call: @p{v=Vector<number>(0);},
+                                        * this call: <tt>v=Vector<number>(0);</tt>,
                                         * i.e. the vector is replaced by one of
                                         * length zero.
                                         */
index 9bc1a9b0e38fb653ff5eaa7418b368968a41c9d3..7b7625827f91832f8d37bbdc66c86319b6f2f3b5 100644 (file)
@@ -206,8 +206,8 @@ namespace PETScWrappers
                                        /**
                                         * Declare some of the standard types
                                         * used in all containers. These types
-                                        * parallel those in the @p{C++}
-                                        * standard libraries @p{vector<...>}
+                                        * parallel those in the <tt>C++</tt>
+                                        * standard libraries <tt>vector<...></tt>
                                         * class.
                                         */
       typedef PetscScalar       value_type;
@@ -245,11 +245,11 @@ namespace PETScWrappers
 
                                        /**
                                         * Set all entries to zero. Equivalent
-                                        * to @p{v = 0}, but more obvious and
+                                        * to <tt>v = 0</tt>, but more obvious and
                                         * faster.  Note that this function
                                         * does not change the size of the
                                         * vector, unlike the STL's
-                                        * @p{vector<>::clear} function.
+                                        * <tt>vector<>::clear</tt> function.
                                         */
       void clear ();    
       
@@ -430,19 +430,19 @@ namespace PETScWrappers
     
                                        /**
                                         * Simple vector addition, equal to the
-                                        * @p{operator +=}.
+                                        * <tt>operator +=</tt>.
                                         */
       void add (const VectorBase &V);
     
                                        /**
                                         * Simple addition of a multiple of a
-                                        * vector, i.e. @p{*this += a*V}.
+                                        * vector, i.e. <tt>*this += a*V</tt>.
                                         */
       void add (const PetscScalar a, const VectorBase &V);
     
                                        /**
                                         * Multiple addition of scaled vectors,
-                                        * i.e. @p{*this += a*V+b*W}.
+                                        * i.e. <tt>*this += a*V+b*W</tt>.
                                         */
       void add (const PetscScalar a, const VectorBase &V,
                 const PetscScalar b, const VectorBase &W);
@@ -450,14 +450,14 @@ namespace PETScWrappers
                                        /**
                                         * Scaling and simple vector addition,
                                         * i.e.
-                                        * @p{*this = s*(*this)+V}.
+                                        * <tt>*this = s*(*this)+V</tt>.
                                         */
       void sadd (const PetscScalar s,
                  const VectorBase     &V);
     
                                        /**
                                         * Scaling and simple addition, i.e.
-                                        * @p{*this = s*(*this)+a*V}.
+                                        * <tt>*this = s*(*this)+a*V</tt>.
                                         */
       void sadd (const PetscScalar s,
                  const PetscScalar a,
@@ -474,7 +474,7 @@ namespace PETScWrappers
     
                                        /**
                                         * Scaling and multiple addition.
-                                        * @p{*this = s*(*this)+a*V + b*W + c*X}.
+                                        * <tt>*this = s*(*this)+a*V + b*W + c*X</tt>.
                                         */
       void sadd (const PetscScalar s,
                  const PetscScalar a,
@@ -496,12 +496,12 @@ namespace PETScWrappers
       void scale (const VectorBase &scaling_factors);
     
                                        /**
-                                        * Assignment @p{*this = a*V}.
+                                        * Assignment <tt>*this = a*V</tt>.
                                         */
       void equ (const PetscScalar a, const VectorBase &V);
     
                                        /**
-                                        * Assignment @p{*this = a*V + b*W}.
+                                        * Assignment <tt>*this = a*V + b*W</tt>.
                                         */
       void equ (const PetscScalar a, const VectorBase &V,
                 const PetscScalar b, const VectorBase &W);
@@ -509,7 +509,7 @@ namespace PETScWrappers
                                        /**
                                         * Compute the elementwise ratio of the
                                         * two given vectors, that is let
-                                        * @p{this[i] = a[i]/b[i]}. This is
+                                        * <tt>this[i] = a[i]/b[i]</tt>. This is
                                         * useful for example if you want to
                                         * compute the cellwise ratio of true to
                                         * estimated error.
@@ -517,7 +517,7 @@ namespace PETScWrappers
                                         * This vector is appropriately
                                         * scaled to hold the result.
                                         *
-                                        * If any of the @p{b[i]} is
+                                        * If any of the <tt>b[i]</tt> is
                                         * zero, the result is
                                         * undefined. No attempt is made
                                         * to catch such situations.
@@ -563,8 +563,8 @@ namespace PETScWrappers
                                         * the @p swap function of all C++
                                         * standard containers. Also,
                                         * there is a global function
-                                        * @p{swap(u,v)} that simply calls
-                                        * @p{u.swap(v)}, again in analogy
+                                        * <tt>swap(u,v)</tt> that simply calls
+                                        * <tt>u.swap(v)</tt>, again in analogy
                                         * to standard functions.
                                         */
       void swap (VectorBase &v);
index 573c80ec7e4eb0377b1cad73a1e6c96b91e77b91..f0d41a75fb0801cd8b6b1e1ec8ec86831410bff1 100644 (file)
@@ -92,7 +92,7 @@ public:
                                    * Constructor.  The pointer in the
                                    * argument is stored in this
                                    * class. As usual, the lifetime of
-                                   * @p{*M} must be longer than the
+                                   * <tt>*M</tt> must be longer than the
                                    * one of the @p PointerMatrix.
                                    *
                                    * If @p M is zero, no matrix is stored.
index 1775647d9845aaee483070c99a9fd2e5743345ba..40ef7b6daac259c4176b4e56c3da0d98eab4edac 100644 (file)
@@ -35,7 +35,7 @@ class PreconditionBlockJacobi;
 /**
  * Base class for @p PreconditionBlockJacobi,
  * @p PreconditionBlockSOR, ...  This class assumes the
- * @p{SparseMatrix<number>} consisting of invertible blocks of
+ * <tt>SparseMatrix<number></tt> consisting of invertible blocks of
  * @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
@@ -60,11 +60,11 @@ class PreconditionBlockJacobi;
  * The first template parameter denotes the type of number
  * representation in the sparse matrix, the second denotes the type of
  * number representation in which the inverted diagonal block matrices
- * are stored within this class by @p{invert_diagblocks()}. If you
+ * are stored within this class by <tt>invert_diagblocks()</tt>. If you
  * don't want to use the block inversion as an exact solver, but
  * rather as a preconditioner, you may probably want to store the
  * inverted blocks with less accuracy than the original matrix; for
- * example, @p{number==double, inverse_type=float} might be a viable
+ * example, <tt>number==double, inverse_type=float</tt> might be a viable
  * choice.
  *
  *
@@ -221,7 +221,7 @@ class PreconditionBlock : public virtual Subscriptor
                                      * It is not allowed to call this
                                      * function twice (will produce
                                      * an error) before a call of
-                                     * @p{clear(...)}  because at the
+                                     * <tt>clear(...)</tt>  because at the
                                      * second time there already
                                      * exist the inverse matrices.
                                      *
@@ -349,11 +349,11 @@ class PreconditionBlock : public virtual Subscriptor
                                      * Storage of the inverse
                                      * matrices of the diagonal
                                      * blocks matrices as
-                                     * @p{FullMatrix<inverse_type>}
+                                     * <tt>FullMatrix<inverse_type></tt>
                                      * matrices. Using
-                                     * @p{inverse_type=float} saves
+                                     * <tt>inverse_type=float</tt> saves
                                      * memory in comparison with
-                                     * @p{inverse_type=double}.
+                                     * <tt>inverse_type=double</tt>.
                                      */
     std::vector<FullMatrix<inverse_type> > var_inverse;
 
@@ -500,7 +500,7 @@ class PreconditionBlockJacobi : public virtual Subscriptor,
                                           */
        bool operator == (const const_iterator&) const;
                                          /**
-                                          * Inverse of @p{==}.
+                                          * Inverse of <tt>==</tt>.
                                           */
        bool operator != (const const_iterator&) const;
 
index cbdcffa61f3a614d8b9ef40dab84647aefe8fcbc..b158b3dcc3fda4279e2e1adab02a8c179228db88 100644 (file)
@@ -31,7 +31,7 @@ template <class number> class SparseMatrix;
  * the name of the preconditioning and the damping parameter 
  * @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
+ * by the matrix-builtin precondition functions. Each time, the <tt>operator()</tt> function
  * is called, this preselected preconditioner, this matrix and
  * this @p omega is used
  * for the preconditioning. This class is designed for being used as
@@ -110,7 +110,7 @@ class PreconditionSelector : public Subscriptor
                                      * Takes the matrix that is needed
                                      * for preconditionings that involves a
                                      * matrix. e.g. for @p precondition_jacobi,
-                                     * @p{~_sor}, @p{~_ssor}.
+                                     * <tt>~_sor</tt>, <tt>~_ssor</tt>.
                                      */
     void use_matrix(const Matrix &M);
 
index bdc8929e63badf86632dda75cd5e06ca26fe420b..2bab4e84fb4618e90c39acb5568c9b78c3500411 100644 (file)
@@ -99,7 +99,7 @@ class SolverControl;
  * @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.
+ * <tt>swap(VECTOR &a, VECTOR &b)</tt> 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
@@ -111,7 +111,7 @@ class SolverControl;
  * 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
+ * each solver class the <tt>struct AdditionalData</tt> 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
  * empty and calling the constructor may be done without giving the additional
index 80e1e49341cfac3533eb4b37bb41bb93b5149693..21d6095e99785cb62a033a1edd248c5bd38088f5 100644 (file)
  * 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
- * file if @p{AdditionalData::log_coefficients = true}, the matrix
+ * file if <tt>AdditionalData::log_coefficients = true</tt>, the matrix
  * @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}}.
+ * elements <tt>1/alpha_0</tt>, <tt>1/alpha_1 + beta_0/alpha_0</tt>, ...,
+ * <tt>1/alpha_{m-1</tt>+beta_{m-2}/alpha_{m-2}} and off-diagonal elements
+ * <tt>sqrt(beta_0)/alpha_0</tt>, ..., <tt>sqrt(beta_{m-2</tt>)/alpha_{m-2}}.
  * The eigenvalues of this matrix can be computed by postprocessing.
  *
  * This version of CG is taken from Braess: "Finite Elements". It
index 9ec9e6224d9c4f1cae2d1642134a0ef648fb95df..da5f2d7ba42ea2bba49fd254ed43df07876a2295 100644 (file)
@@ -27,7 +27,7 @@ class ParameterHandler;
  * Control class for iterative solvers.
  *
  * Used by iterative methods to determine whether the iteration should
- * be continued. To this respect, the virtual function @p{check()} is
+ * be continued. To this respect, the virtual function <tt>check()</tt> is
  * called in each iteration with the current iteration step and the
  * value indicating convergence (usually the residual).
  *
@@ -35,7 +35,7 @@ class ParameterHandler;
  * @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
+ * <tt>check()</tt> can be replaced in derived classes to allow for more
  * sophisticated tests.
  *
  *
@@ -46,7 +46,7 @@ class ParameterHandler;
  *
  * The possible values of State are
  * <ul>
- * <li> @p{iterate = 0}: continue the iteration.
+ * <li> <tt>iterate = 0</tt>: continue the iteration.
  * <li> @p success: the goal is reached, the iterative method can terminate
  *       successfully.
  * <li> @p failure: the iterative method should stop because convergence 
@@ -185,15 +185,15 @@ class SolverControl : public Subscriptor
                                      * scripts checks for this and
                                      * sets the flag @p HAVE_ISNAN
                                      * in the file
-                                     * @p{Make.global_options} if
+                                     * <tt>Make.global_options</tt> if
                                      * this function was found.
                                      *
-                                     * @p{check()} additionally
+                                     * <tt>check()</tt> additionally
                                      * preserves @p step and
                                      * @p check_value. These
                                      * values are accessible by
-                                     * @p{last_value()} and
-                                     * @p{last_step()}.
+                                     * <tt>last_value()</tt> and
+                                     * <tt>last_step()</tt>.
                                      *
                                      * Derived classes may overload
                                      * this function, e.g. to log the
@@ -235,8 +235,8 @@ class SolverControl : public Subscriptor
                                      * Enables the failure
                                      * check. Solving is stopped with
                                      * @p ReturnState @p failure if
-                                     * @p{residual>failure_residual} with
-                                     * @p{failure_residual:=rel_failure_residual*first_residual}.
+                                     * <tt>residual>failure_residual</tt> with
+                                     * <tt>failure_residual:=rel_failure_residual*first_residual</tt>.
                                      */
     void set_failure_criterion (const double rel_failure_residual);
 
@@ -408,7 +408,7 @@ class ReductionControl : public SolverControl
                                      * of an iteration.  This function
                                      * calls the one in the base
                                      * class, but sets the tolerance
-                                     * to @p{reduction * initial value}
+                                     * to <tt>reduction * initial value</tt>
                                      * upon the first iteration.
                                      */
     virtual State check (const unsigned int step,
index 55d8175a2ef55a15bf5e9b6cbd712d3fd59f7b6c..89bb249ccd803b0b761588eb2d85846ff2807c29 100644 (file)
@@ -168,7 +168,7 @@ namespace internal
  * computed by the GMRes method but need to be computed in addition. This
  * (especially for the left preconditioned GMRes) might lead to a significant
  * loss in the solver performance. Therefore, the user should set
- * @p{use_default_residual=false} only for debugging/testing purposes.
+ * <tt>use_default_residual=false</tt> only for debugging/testing purposes.
  *
  * For the requirements on matrices and vectors in order to work with
  * this class, see the documentation of the Solver base class.
@@ -293,7 +293,7 @@ class SolverGMRES : public Solver<VECTOR>
  * Krylov space method inside the preconditioner.
  *
  * FGMRES needs two vectors in each iteration steps yielding a total
- * of @p{2*AdditionalData::max_basis_size+1} auxiliary vectors.
+ * of <tt>2*AdditionalData::max_basis_size+1</tt> auxiliary vectors.
  *
  * Caveat: documentation of this class is not up to date. There are
  * also a few parameters of GMRES we would like to introduce here.
index 2c4aa53c04de78a58471f4560ca1f173b6ad6e7d..fe4a7bbbce9f3c18a94bfcde9c501aa5adaa19a9 100644 (file)
@@ -50,7 +50,7 @@
  * The algorithm is taken from the Master thesis of Astrid Batterman
  * with some changes.
  * The full text can be found at
- * @p{http://scholar.lib.vt.edu/theses/public/etd-12164379662151/etd-title.html}
+ * <tt>http://scholar.lib.vt.edu/theses/public/etd-12164379662151/etd-title.html</tt>
  *
  * @author Thomas Richter, 2000
  */
index b12bb0864b60c90c67ca2ffb0ded7737581a2cb6..319729babe09a1332c7049d4ec57c744c1fab701 100644 (file)
@@ -258,14 +258,14 @@ class SparseMatrixEZ : public Subscriptor
                                          /**
                                           * Prefix increment. This
                                           * always returns a valid
-                                          * entry or @p{end()}.
+                                          * entry or <tt>end()</tt>.
                                           */
        const_iterator& operator++ ();
 
                                          /**
                                           * Postfix increment. This
                                           * always returns a valid
-                                          * entry or @p{end()}.
+                                          * entry or <tt>end()</tt>.
                                           */
        const_iterator& operator++ (int);
 
@@ -287,7 +287,7 @@ class SparseMatrixEZ : public Subscriptor
                                           */
        bool operator == (const const_iterator&) const;
                                          /**
-                                          * Inverse of @p{==}.
+                                          * Inverse of <tt>==</tt>.
                                           */
        bool operator != (const const_iterator&) const;
 
@@ -440,7 +440,7 @@ class SparseMatrixEZ : public Subscriptor
     unsigned int n () const;
 
                                     /**
-                                     * Set the element @p{(i,j)} to
+                                     * Set the element <tt>(i,j)</tt> to
                                      * @p value. Allocates the entry,
                                      * if it does not exist and
                                      * @p value is non-zero.
@@ -450,7 +450,7 @@ class SparseMatrixEZ : public Subscriptor
     
                                     /**
                                      * Add @p value to the element
-                                     * @p{(i,j)}. Allocates the entry
+                                     * <tt>(i,j)</tt>. Allocates the entry
                                      * if it does not exist. Filters
                                      * out zeroes automatically.
                                      */
@@ -496,7 +496,7 @@ class SparseMatrixEZ : public Subscriptor
                                      * cheaper. Since this operation
                                      * is notheless not for free, we
                                      * do not make it available
-                                     * through @p{operator =}, since
+                                     * through <tt>operator =</tt>, since
                                      * this may lead to unwanted
                                      * usage, e.g. in copy arguments
                                      * to functions, which should
@@ -532,7 +532,7 @@ class SparseMatrixEZ : public Subscriptor
                                      * cited function is that the
                                      * objects which the inner
                                      * iterator points to need to be
-                                     * of type @p{std::pair<unsigned int, value},
+                                     * of type <tt>std::pair<unsigned int, value</tt>,
                                      * where @p value
                                      * needs to be convertible to the
                                      * element type of this class, as
@@ -614,7 +614,7 @@ class SparseMatrixEZ : public Subscriptor
                                      * error if the matrix is not square.
                                      *
                                      * This function is considerably
-                                     * faster than the @p{operator()},
+                                     * faster than the <tt>operator()</tt>,
                                      * since for square matrices, the
                                      * diagonal entry is always the
                                      * first to be stored in each row
@@ -790,7 +790,7 @@ class SparseMatrixEZ : public Subscriptor
                                      * @p B has a @p const_iterator
                                      * traversing all matrix entries
                                      * and that @p A has a function
-                                     * @p{el(i,j)} for access to a
+                                     * <tt>el(i,j)</tt> for access to a
                                      * specific entry.
                                      */
     template <class MATRIXA, class MATRIXB>
@@ -813,7 +813,7 @@ class SparseMatrixEZ : public Subscriptor
                                      * STL-like iterator with the
                                      * first entry of row @p r. If
                                      * this row is empty, the result
-                                     * is @p{end(r)}, which does NOT
+                                     * is <tt>end(r)</tt>, which does NOT
                                      * point into row @p r..
                                      */
     const_iterator begin (const unsigned int r) const;
@@ -821,7 +821,7 @@ class SparseMatrixEZ : public Subscriptor
                                     /**
                                      * Final iterator of row
                                      * @p r. The result may be
-                                     * different from @p{end()}!
+                                     * different from <tt>end()</tt>!
                                      */
     const_iterator end (const unsigned int r) const;
     
@@ -842,7 +842,7 @@ class SparseMatrixEZ : public Subscriptor
                                     /**
                                      * Print the matrix to the given
                                      * stream, using the format
-                                     * @p{(line,col) value}, i.e. one
+                                     * <tt>(line,col) value</tt>, i.e. one
                                      * nonzero entry of the matrix
                                      * per line.
                                      */
@@ -1014,7 +1014,7 @@ class SparseMatrixEZ : public Subscriptor
                                      * Version of @p vmult which only
                                      * performs its actions on the
                                      * region defined by
-                                     * @p{[begin_row,end_row)}. This
+                                     * <tt>[begin_row,end_row)</tt>. This
                                      * function is called by @p vmult
                                      * in the case of enabled
                                      * multithreading.
@@ -1030,7 +1030,7 @@ class SparseMatrixEZ : public Subscriptor
                                      * @p matrix_norm_square which
                                      * only performs its actions on
                                      * the region defined by
-                                     * @p{[begin_row,end_row)}. This
+                                     * <tt>[begin_row,end_row)</tt>. This
                                      * function is called by
                                      * @p matrix_norm_square in the
                                      * case of enabled
@@ -1047,7 +1047,7 @@ class SparseMatrixEZ : public Subscriptor
                                      * @p matrix_scalar_product which
                                      * only performs its actions on
                                      * the region defined by
-                                     * @p{[begin_row,end_row)}. This
+                                     * <tt>[begin_row,end_row)</tt>. This
                                      * function is called by
                                      * @p matrix_scalar_product in the
                                      * case of enabled
index 1b4549995947c279f04173cfe56b396c1f72eaa7..2cb07593dee0f84feaffb353960595c5bac149ea 100644 (file)
@@ -58,8 +58,8 @@ template <typename number> class SparseBlockVanka;
  * 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
- * 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
+ * the element <tt>(i,j)</tt> is a nonzero entry in the sparse matrix under 
+ * consideration. The elements <tt>(j,i)</tt> are not considered. We now pick all
  * matrix entries from rows and columns out of the set of degrees of freedom
  * just described out of the global matrix and put it into a local matrix,
  * which is subsequently inverted. This system may be of different size for
@@ -189,7 +189,7 @@ class SparseVanka
                                      * multithreaded mode. By
                                      * default, this variable is set
                                      * to the value of
-                                     * @p{multithread_info.n_default_threads}.
+                                     * <tt>multithread_info.n_default_threads</tt>.
                                      */
     SparseVanka(const SparseMatrix<number> &M,
                const std::vector<bool>    &selected,
@@ -260,7 +260,7 @@ class SparseVanka
                                      * degrees of freedom. This is
                                      * then equivalent to calling the
                                      * function with a
-                                     * @p{vector<bool>(n_dofs,true)}.
+                                     * <tt>vector<bool>(n_dofs,true)</tt>.
                                      *
                                      * The @p vmult of this class
                                      * of course calls this function
@@ -320,9 +320,9 @@ class SparseVanka
                                     /**
                                      * Compute the inverses at
                                      * positions in the range
-                                     * @p{[begin,end)}. In
+                                     * <tt>[begin,end)</tt>. In
                                      * non-multithreaded mode,
-                                     * @p{compute_inverses()} calls
+                                     * <tt>compute_inverses()</tt> calls
                                      * this function with the whole
                                      * range, but in multithreaded
                                      * mode, several copies of this
@@ -359,7 +359,7 @@ class SparseVanka
                                       * 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
+                                      * <tt>x.f()</tt>, where @p x is an
                                       * object of the base class, and
                                       * @p f one of it's non-public
                                       * member functions).
@@ -406,7 +406,7 @@ class SparseVanka
  * want to set the number of blocks equal to the number of processors
  * you have.
  *
- * Note that the parallelization is done if @p{deal.II} was configured
+ * Note that the parallelization is done if <tt>deal.II</tt> was configured
  * for multithread use and that the number of threads which is spawned
  * equals the number of blocks. This is reasonable since you will not
  * want to set the number of blocks unnecessarily large, since, as
@@ -431,12 +431,12 @@ 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 <tt>[0,N)</tt>, where @p N is the number of
  * degrees of freedom of the system of equations.
  *
  * <ul>
  * <li> @p index_intervals:
- *    Here, we chose the blocks to be intervals @p{[a_i,a_{i+1})},
+ *    Here, we chose the blocks to be intervals <tt>[a_i,a_{i+1</tt>)},
  *    i.e. consecutive degrees of freedom are usually also within the
  *    same block. This is a reasonable strategy, if the degrees of
  *    freedom have, for example, be re-numbered using the
@@ -495,7 +495,7 @@ class SparseVanka
  * 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
+ * @p SparseBlockVanka with <tt>n_blocks==1</tt>), the following numbers of
  * iterations is needed to solver the linear system in each nonlinear
  * step:
  * @verbatim
@@ -575,11 +575,11 @@ class SparseBlockVanka : public SparseVanka<number>
                                      * In this field, we precompute
                                      * for each block which degrees
                                      * of freedom belong to it. Thus,
-                                     * if @p{dof_masks[i][j]==true},
+                                     * if <tt>dof_masks[i][j]==true</tt>,
                                      * 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
+                                     * <tt>dof_masks[l][j]</tt> may be
+                                     * @p true for <tt>l!=i</tt>. This
                                      * computation is done in the
                                      * constructor, to avoid
                                      * recomputing each time the
index e1c45e7b16949321aa69292cbe320bcea480d128..79f53b60d4021c949cd8d351a3315c06ad213f90 100644 (file)
@@ -513,7 +513,7 @@ SparseBlockVanka<number>::compute_dof_masks (const SparseMatrix<number> &M,
                                         // now we know that block @p i
                                         // wants to write to DoF @p j
                                         // as often as
-                                        // @p{access_count[i][j]}
+                                        // <tt>access_count[i][j]</tt>
                                         // times. Let @p j be allotted
                                         // to the block which
                                         // accesses it most often.
index 8407729c6c4895087f8aa812220451e28c1ab2ba..06865ba8dcc940021d475cf735700527b9479dbc 100644 (file)
@@ -76,7 +76,7 @@ class SwappableVector : public Vector<number>
                                      * about that. In particular do
                                      * not take over ownership of any
                                      * files that @p v might own (as,
-                                     * for example, @p{C++}'s
+                                     * for example, <tt>C++</tt>'s
                                      * @p auto_ptr objects would do).
                                      */
     SwappableVector (const SwappableVector &v);
index 21e3ef9465a1aaf987fffdf5fb2cc039c59c61bf..5b0471cebecdfac2af0fac43d0fed65864722930 100644 (file)
@@ -69,8 +69,8 @@ class Vector
                                     /**
                                      * Declare standard types used in all
                                      * containers. These types parallel
-                                     * those in the @p{C++} standard libraries
-                                     * @p{vector<...>} class.
+                                     * those in the <tt>C++</tt> standard libraries
+                                     * <tt>vector<...></tt> class.
                                      */
     typedef Number            value_type;
     typedef value_type       *pointer;
@@ -158,7 +158,7 @@ class Vector
                                      * The constructor is made
                                      * explicit to avoid accidents
                                      * like this:
-                                     * @p{v=0;}. Presumably, the user
+                                     * <tt>v=0;</tt>. Presumably, the user
                                      * wants to set every element of
                                      * the vector to zero, but
                                      * instead, what happens is this
@@ -211,10 +211,10 @@ class Vector
 
                                     /**
                                      * Set all entries to zero. Equivalent to
-                                     * @p{v = 0}, but more obvious and
+                                     * <tt>v = 0</tt>, but more obvious and
                                      * faster.  Note that this function does
                                      * not change the size of the vector,
-                                     * unlike the STL's @p{vector<>::clear}
+                                     * unlike the STL's <tt>vector<>::clear</tt>
                                      * function.
                                      */
     void clear ();    
@@ -225,12 +225,12 @@ class Vector
                                      * vector remains unchanged if possible,
                                      * to make things faster; this may waste
                                      * some memory, so keep this in mind.
-                                     * However, if @p{N==0} all memory is
+                                     * However, if <tt>N==0</tt> all memory is
                                      * freed, i.e. if you want to resize the
                                      * vector and release the memory not
                                      * needed, you have to first call
-                                     * @p{reinit(0)} and then
-                                     * @p{reinit(N)}. This cited behaviour is
+                                     * <tt>reinit(0)</tt> and then
+                                     * <tt>reinit(N)</tt>. This cited behaviour is
                                      * analogous to that of the STL
                                      * containers.
                                      *
@@ -249,7 +249,7 @@ class Vector
                                      *
                                      * The elements of @p V are not copied,
                                      * i.e.  this function is the same as
-                                     * calling @p{reinit (V.size(), fast)}.
+                                     * calling <tt>reinit (V.size(), fast)</tt>.
                                      */
     template <typename Number2>
     void reinit (const Vector<Number2> &V,
@@ -274,8 +274,8 @@ class Vector
                                      * the @p swap function of all C++
                                      * standard containers. Also,
                                      * there is a global function
-                                     * @p{swap(u,v)} that simply calls
-                                     * @p{u.swap(v)}, again in analogy
+                                     * <tt>swap(u,v)</tt> that simply calls
+                                     * <tt>u.swap(v)</tt>, again in analogy
                                      * to standard functions.
                                      */
     void swap (Vector<Number> &v);
@@ -431,7 +431,7 @@ class Vector
     
                                     /**
                                      * Make the @p Vector class a bit like the
-                                     * @p{vector<>} class of the C++ standard
+                                     * <tt>vector<></tt> class of the C++ standard
                                      * library by returning iterators to
                                      * the start and end of the elements of this
                                      * vector.
@@ -502,19 +502,19 @@ class Vector
     
                                     /**
                                      * Simple vector addition, equal to the
-                                     * @p{operator +=}.
+                                     * <tt>operator +=</tt>.
                                      */
     void add (const Vector<Number> &V);
     
                                     /**
                                      * Simple addition of a multiple of a
-                                     * vector, i.e. @p{*this += a*V}.
+                                     * vector, i.e. <tt>*this += a*V</tt>.
                                      */
     void add (const Number a, const Vector<Number> &V);
     
                                     /**
                                      * Multiple addition of scaled vectors,
-                                     * i.e. @p{*this += a*V+b*W}.
+                                     * i.e. <tt>*this += a*V+b*W</tt>.
                                      */
     void add (const Number a, const Vector<Number> &V,
              const Number b, const Vector<Number> &W);
@@ -522,14 +522,14 @@ class Vector
                                     /**
                                      * Scaling and simple vector addition,
                                      * i.e.
-                                     * @p{*this = s*(*this)+V}.
+                                     * <tt>*this = s*(*this)+V</tt>.
                                      */
     void sadd (const Number          s,
                const Vector<Number> &V);
     
                                     /**
                                      * Scaling and simple addition, i.e.
-                                     * @p{*this = s*(*this)+a*V}.
+                                     * <tt>*this = s*(*this)+a*V</tt>.
                                      */
     void sadd (const Number          s,
                const Number          a,
@@ -546,7 +546,7 @@ class Vector
     
                                     /**
                                      * Scaling and multiple addition.
-                                     * @p{*this = s*(*this)+a*V + b*W + c*X}.
+                                     * <tt>*this = s*(*this)+a*V + b*W + c*X</tt>.
                                      */
     void sadd (const Number          s,
                const Number          a,
@@ -563,8 +563,8 @@ class Vector
                                      * This function is deprecated
                                      * and will be removed in a
                                      * future version. Use
-                                     * @p{operator *=} and
-                                     * @p{operator /=} instead.
+                                     * <tt>operator *=</tt> and
+                                     * <tt>operator /=</tt> instead.
                                      */
     void scale (const Number factor);
 
@@ -596,13 +596,13 @@ class Vector
     void scale (const Vector<Number2> &scaling_factors);
     
                                     /**
-                                     * Assignment @p{*this = a*V}.
+                                     * Assignment <tt>*this = a*V</tt>.
                                      */
     template <typename Number2>
     void equ (const Number a, const Vector<Number2>& V);
     
                                     /**
-                                     * Assignment @p{*this = a*V + b*W}.
+                                     * Assignment <tt>*this = a*V + b*W</tt>.
                                      */
     void equ (const Number a, const Vector<Number>& V,
              const Number b, const Vector<Number>& W);
@@ -610,7 +610,7 @@ class Vector
                                     /**
                                      * Compute the elementwise ratio of the
                                      * two given vectors, that is let
-                                     * @p{this[i] = a[i]/b[i]}. This is
+                                     * <tt>this[i] = a[i]/b[i]</tt>. This is
                                      * useful for example if you want to
                                      * compute the cellwise ratio of true to
                                      * estimated error.
@@ -618,7 +618,7 @@ class Vector
                                      * This vector is appropriately
                                      * scaled to hold the result.
                                      *
-                                     * If any of the @p{b[i]} is
+                                     * If any of the <tt>b[i]</tt> is
                                      * zero, the result is
                                      * undefined. No attempt is made
                                      * to catch such situations.
@@ -707,7 +707,7 @@ class Vector
                                      * Dimension. Actual number of
                                      * components contained in the
                                      * vector.  Get this number by
-                                     * calling @p{size()}.
+                                     * calling <tt>size()</tt>.
                                      */
     unsigned int dim;
 

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.